evie/android_kernel_oneplus_msm8998
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge "diag: Synchronize msg mask read and write on a peripheral"

Browse source
This commit is contained in:
Linux Build Service Account 2017-07-23 10:48:40 -07:00 • committed by Gerrit - the friendly Code Review server
commit 9023a992a8
1 changed files with 31 additions and 23 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

54
drivers/char/diag/diag_masks.c
View file

@ -320,6 +320,7 @@ static void diag_send_msg_mask_update(uint8_t peripheral, int first, int last)
struct diag_mask_info *mask_info = NULL; struct diag_mask_info *mask_info = NULL;
struct diag_msg_mask_t *mask = NULL; struct diag_msg_mask_t *mask = NULL;
struct diag_ctrl_msg_mask header; struct diag_ctrl_msg_mask header;
uint8_t msg_mask_tbl_count_local;
if (peripheral >= NUM_PERIPHERALS) if (peripheral >= NUM_PERIPHERALS)
return; return;
@ -360,6 +361,8 @@ static void diag_send_msg_mask_update(uint8_t peripheral, int first, int last)
return; return;
} }
buf = mask_info->update_buf; buf = mask_info->update_buf;
msg_mask_tbl_count_local = driver->msg_mask_tbl_count;
mutex_unlock(&driver->msg_mask_lock);
mutex_lock(&mask_info->lock); mutex_lock(&mask_info->lock);
switch (mask_info->status) { switch (mask_info->status) {
case DIAG_CTRL_MASK_ALL_DISABLED: case DIAG_CTRL_MASK_ALL_DISABLED:
@ -376,9 +379,11 @@ static void diag_send_msg_mask_update(uint8_t peripheral, int first, int last)
goto err; goto err;
} }
for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) { for (i = 0; i < msg_mask_tbl_count_local; i++, mask++) {
if (((first < mask->ssid_first) || mutex_lock(&driver->msg_mask_lock);
(last > mask->ssid_last_tools)) && first != ALL_SSID) { if (((mask->ssid_first > first) ||
(mask->ssid_last_tools < last)) && first != ALL_SSID) {
mutex_unlock(&driver->msg_mask_lock);
continue; continue;
} }
@ -419,19 +424,19 @@ proceed:
if (mask_size > 0) if (mask_size > 0)
memcpy(buf + header_len, mask->ptr, mask_size); memcpy(buf + header_len, mask->ptr, mask_size);
mutex_unlock(&mask->lock); mutex_unlock(&mask->lock);
mutex_unlock(&driver->msg_mask_lock);
err = diagfwd_write(peripheral, TYPE_CNTL, buf, err = diagfwd_write(peripheral, TYPE_CNTL, buf,
header_len + mask_size); header_len + mask_size);
if (err && err != -ENODEV) if (err && err != -ENODEV)
pr_err_ratelimited("diag: Unable to send msg masks to peripheral %d\n", pr_err_ratelimited("diag: Unable to send msg masks to peripheral %d, error = %d\n",
peripheral); peripheral, err);
if (first != ALL_SSID) if (first != ALL_SSID)
break; break;
} }
err: err:
mutex_unlock(&mask_info->lock); mutex_unlock(&mask_info->lock);
mutex_unlock(&driver->msg_mask_lock);
} }
static void diag_send_time_sync_update(uint8_t peripheral) static void diag_send_time_sync_update(uint8_t peripheral)
@ -711,8 +716,8 @@ static int diag_cmd_set_msg_mask(unsigned char *src_buf, int src_len,
} }
req = (struct diag_msg_build_mask_t *)src_buf; req = (struct diag_msg_build_mask_t *)src_buf;
mutex_lock(&driver->msg_mask_lock);
mutex_lock(&mask_info->lock); mutex_lock(&mask_info->lock);
mutex_lock(&driver->msg_mask_lock);
mask = (struct diag_msg_mask_t *)mask_info->ptr; mask = (struct diag_msg_mask_t *)mask_info->ptr;
for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) { for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) {
if (i < (driver->msg_mask_tbl_count - 1)) { if (i < (driver->msg_mask_tbl_count - 1)) {
@ -752,6 +757,8 @@ static int diag_cmd_set_msg_mask(unsigned char *src_buf, int src_len,
pr_err_ratelimited("diag: In %s, unable to allocate memory for msg mask ptr, mask_size: %d\n", pr_err_ratelimited("diag: In %s, unable to allocate memory for msg mask ptr, mask_size: %d\n",
__func__, mask_size); __func__, mask_size);
mutex_unlock(&mask->lock); mutex_unlock(&mask->lock);
mutex_unlock(&driver->msg_mask_lock);
mutex_unlock(&mask_info->lock);
return -ENOMEM; return -ENOMEM;
} }
mask->ptr = temp; mask->ptr = temp;
@ -770,8 +777,8 @@ static int diag_cmd_set_msg_mask(unsigned char *src_buf, int src_len,
mask_info->status = DIAG_CTRL_MASK_VALID; mask_info->status = DIAG_CTRL_MASK_VALID;
break; break;
} }
mutex_unlock(&mask_info->lock);
mutex_unlock(&driver->msg_mask_lock); mutex_unlock(&driver->msg_mask_lock);
mutex_unlock(&mask_info->lock);
if (diag_check_update(APPS_DATA)) if (diag_check_update(APPS_DATA))
diag_update_userspace_clients(MSG_MASKS_TYPE); diag_update_userspace_clients(MSG_MASKS_TYPE);
@ -826,9 +833,11 @@ static int diag_cmd_set_all_msg_mask(unsigned char *src_buf, int src_len,
} }
req = (struct diag_msg_config_rsp_t *)src_buf; req = (struct diag_msg_config_rsp_t *)src_buf;
mutex_lock(&driver->msg_mask_lock);
mask = (struct diag_msg_mask_t *)mask_info->ptr;
mutex_lock(&mask_info->lock); mutex_lock(&mask_info->lock);
mutex_lock(&driver->msg_mask_lock);
mask = (struct diag_msg_mask_t *)mask_info->ptr;
mask_info->status = (req->rt_mask) ? DIAG_CTRL_MASK_ALL_ENABLED : mask_info->status = (req->rt_mask) ? DIAG_CTRL_MASK_ALL_ENABLED :
DIAG_CTRL_MASK_ALL_DISABLED; DIAG_CTRL_MASK_ALL_DISABLED;
for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) { for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) {
@ -837,8 +846,8 @@ static int diag_cmd_set_all_msg_mask(unsigned char *src_buf, int src_len,
mask->range * sizeof(uint32_t)); mask->range * sizeof(uint32_t));
mutex_unlock(&mask->lock); mutex_unlock(&mask->lock);
} }
mutex_unlock(&mask_info->lock);
mutex_unlock(&driver->msg_mask_lock); mutex_unlock(&driver->msg_mask_lock);
mutex_unlock(&mask_info->lock);
if (diag_check_update(APPS_DATA)) if (diag_check_update(APPS_DATA))
diag_update_userspace_clients(MSG_MASKS_TYPE); diag_update_userspace_clients(MSG_MASKS_TYPE);
@ -1352,8 +1361,8 @@ static int diag_create_msg_mask_table(void)
struct diag_msg_mask_t *mask = (struct diag_msg_mask_t *)msg_mask.ptr; struct diag_msg_mask_t *mask = (struct diag_msg_mask_t *)msg_mask.ptr;
struct diag_ssid_range_t range; struct diag_ssid_range_t range;
mutex_lock(&driver->msg_mask_lock);
mutex_lock(&msg_mask.lock); mutex_lock(&msg_mask.lock);
mutex_lock(&driver->msg_mask_lock);
driver->msg_mask_tbl_count = MSG_MASK_TBL_CNT; driver->msg_mask_tbl_count = MSG_MASK_TBL_CNT;
for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) { for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) {
range.ssid_first = msg_mask_tbl[i].ssid_first; range.ssid_first = msg_mask_tbl[i].ssid_first;
@ -1362,8 +1371,8 @@ static int diag_create_msg_mask_table(void)
if (err) if (err)
break; break;
} }
mutex_unlock(&msg_mask.lock);
mutex_unlock(&driver->msg_mask_lock); mutex_unlock(&driver->msg_mask_lock);
mutex_unlock(&msg_mask.lock);
return err; return err;
} }
@ -1376,8 +1385,8 @@ static int diag_create_build_time_mask(void)
struct diag_msg_mask_t *build_mask = NULL; struct diag_msg_mask_t *build_mask = NULL;
struct diag_ssid_range_t range; struct diag_ssid_range_t range;
mutex_lock(&driver->msg_mask_lock);
mutex_lock(&msg_bt_mask.lock); mutex_lock(&msg_bt_mask.lock);
mutex_lock(&driver->msg_mask_lock);
driver->bt_msg_mask_tbl_count = MSG_MASK_TBL_CNT; driver->bt_msg_mask_tbl_count = MSG_MASK_TBL_CNT;
build_mask = (struct diag_msg_mask_t *)msg_bt_mask.ptr; build_mask = (struct diag_msg_mask_t *)msg_bt_mask.ptr;
for (i = 0; i < driver->bt_msg_mask_tbl_count; i++, build_mask++) { for (i = 0; i < driver->bt_msg_mask_tbl_count; i++, build_mask++) {
@ -1490,9 +1499,8 @@ static int diag_create_build_time_mask(void)
} }
memcpy(build_mask->ptr, tbl, tbl_size); memcpy(build_mask->ptr, tbl, tbl_size);
} }
mutex_unlock(&msg_bt_mask.lock);
mutex_unlock(&driver->msg_mask_lock); mutex_unlock(&driver->msg_mask_lock);
mutex_unlock(&msg_bt_mask.lock);
return err; return err;
} }
@ -1662,8 +1670,8 @@ int diag_msg_mask_copy(struct diag_mask_info *dest, struct diag_mask_info *src)
err = __diag_mask_init(dest, MSG_MASK_SIZE, APPS_BUF_SIZE); err = __diag_mask_init(dest, MSG_MASK_SIZE, APPS_BUF_SIZE);
if (err) if (err)
return err; return err;
mutex_lock(&driver->msg_mask_lock);
mutex_lock(&dest->lock); mutex_lock(&dest->lock);
mutex_lock(&driver->msg_mask_lock);
src_mask = (struct diag_msg_mask_t *)src->ptr; src_mask = (struct diag_msg_mask_t *)src->ptr;
dest_mask = (struct diag_msg_mask_t *)dest->ptr; dest_mask = (struct diag_msg_mask_t *)dest->ptr;
@ -1680,9 +1688,8 @@ int diag_msg_mask_copy(struct diag_mask_info *dest, struct diag_mask_info *src)
src_mask++; src_mask++;
dest_mask++; dest_mask++;
} }
mutex_unlock(&dest->lock);
mutex_unlock(&driver->msg_mask_lock); mutex_unlock(&driver->msg_mask_lock);
mutex_unlock(&dest->lock);
return err; return err;
} }
@ -1693,15 +1700,15 @@ void diag_msg_mask_free(struct diag_mask_info *mask_info)
if (!mask_info) if (!mask_info)
return; return;
mutex_lock(&driver->msg_mask_lock);
mutex_lock(&mask_info->lock); mutex_lock(&mask_info->lock);
mutex_lock(&driver->msg_mask_lock);
mask = (struct diag_msg_mask_t *)mask_info->ptr; mask = (struct diag_msg_mask_t *)mask_info->ptr;
for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) { for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) {
kfree(mask->ptr); kfree(mask->ptr);
mask->ptr = NULL; mask->ptr = NULL;
} }
mutex_unlock(&mask_info->lock);
mutex_unlock(&driver->msg_mask_lock); mutex_unlock(&driver->msg_mask_lock);
mutex_unlock(&mask_info->lock);
__diag_mask_exit(mask_info); __diag_mask_exit(mask_info);
} }
@ -1870,8 +1877,9 @@ int diag_copy_to_user_msg_mask(char __user *buf, size_t count,
return -EIO; return -EIO;
} }
mutex_unlock(&driver->diag_maskclear_mutex); mutex_unlock(&driver->diag_maskclear_mutex);
mutex_lock(&driver->msg_mask_lock);
mutex_lock(&mask_info->lock); mutex_lock(&mask_info->lock);
mutex_lock(&driver->msg_mask_lock);
mask = (struct diag_msg_mask_t *)(mask_info->ptr); mask = (struct diag_msg_mask_t *)(mask_info->ptr);
for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) { for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) {
ptr = mask_info->update_buf; ptr = mask_info->update_buf;
@ -1908,8 +1916,8 @@ int diag_copy_to_user_msg_mask(char __user *buf, size_t count,
} }
total_len += len; total_len += len;
} }
mutex_unlock(&mask_info->lock);
mutex_unlock(&driver->msg_mask_lock); mutex_unlock(&driver->msg_mask_lock);
mutex_unlock(&mask_info->lock);
return err ? err : total_len; return err ? err : total_len;
} }