Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 20a957fb authored by Linux Build Service Account's avatar Linux Build Service Account
Browse files

Merge 624fcb29 on remote branch 

Change-Id: I40c2cd9fdf7a24e05a07cab01af07b539e313bc4
parents a6229295 624fcb29

arch/arm/boot/dts/qcom/sdm636.dtsi

+7 −1
Original line number Diff line number Diff line 
/* Copyright (c) 2017, The Linux Foundation. All rights reserved.

/* Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and
@@ -71,3 +71,9 @@ 
		};

	};

};



/* GPU overrides */

&msm_gpu {

		/* Update GPU chip ID*/

		qcom,chipid = <0x05000900>;

};

drivers/char/diag/diag_dci.c

+69 −26
Original line number Diff line number Diff line
@@ -1162,18 +1162,31 @@ void extract_dci_events(unsigned char *buf, int len, int data_source, 
	struct list_head *start, *temp;

	struct diag_dci_client_tbl *entry = NULL;



	length = *(uint16_t *)(buf + 1); /* total length of event series */

	if (length == 0) {

		pr_err("diag: Incoming dci event length is invalid\n");

	if (!buf) {

		pr_err("diag: In %s buffer is NULL\n", __func__);

		return;

	}

	/*

	 * Move directly to the start of the event series. 1 byte for

	 * event code and 2 bytes for the length field.

	 * 1 byte for event code and 2 bytes for the length field.

	 * The length field indicates the total length removing the cmd_code

	 * and the lenght field. The event parsing in that case should happen

	 * till the end.

	 */

	if (len < 3) {

		pr_err("diag: In %s invalid len: %d\n", __func__, len);

		return;

	}

	length = *(uint16_t *)(buf + 1); /* total length of event series */

	if ((length == 0) || (len != (length + 3))) {

		pr_err("diag: Incoming dci event length: %d is invalid\n",

			length);

		return;

	}

	/*

	 * Move directly to the start of the event series.

	 * The event parsing should happen from start of event

	 * series till the end.

	 */

	temp_len = 3;

	while (temp_len < length) {

		event_id_packet = *(uint16_t *)(buf + temp_len);
@@ -1190,30 +1203,60 @@ void extract_dci_events(unsigned char *buf, int len, int data_source, 
			 * necessary.

			 */

			timestamp_len = 8;

			memcpy(timestamp, buf + temp_len + 2, timestamp_len);

			if ((temp_len + timestamp_len + 2) <= len)

				memcpy(timestamp, buf + temp_len + 2,

					timestamp_len);

			else {

				pr_err("diag: Invalid length in %s, len: %d, temp_len: %d",

						__func__, len, temp_len);

				return;

			}

		}

		/* 13th and 14th bit represent the payload length */

		if (((event_id_packet & 0x6000) >> 13) == 3) {

			payload_len_field = 1;

			if ((temp_len + timestamp_len + 3) <= len) {

				payload_len = *(uint8_t *)

					(buf + temp_len + 2 + timestamp_len);

			if (payload_len < (MAX_EVENT_SIZE - 13)) {

				/* copy the payload length and the payload */

			} else {

				pr_err("diag: Invalid length in %s, len: %d, temp_len: %d",

						__func__, len, temp_len);

				return;

			}

			if ((payload_len < (MAX_EVENT_SIZE - 13)) &&

			((temp_len + timestamp_len + payload_len + 3) <= len)) {

				/*

				 * Copy the payload length and the payload

				 * after skipping temp_len bytes for already

				 * parsed packet, timestamp_len for timestamp

				 * buffer, 2 bytes for event_id_packet.

				 */

				memcpy(event_data + 12, buf + temp_len + 2 +

							timestamp_len, 1);

				memcpy(event_data + 13, buf + temp_len + 2 +

					timestamp_len + 1, payload_len);

			} else {

				pr_err("diag: event > %d, payload_len = %d\n",

					(MAX_EVENT_SIZE - 13), payload_len);

				pr_err("diag: event > %d, payload_len = %d, temp_len = %d\n",

				(MAX_EVENT_SIZE - 13), payload_len, temp_len);

				return;

			}

		} else {

			payload_len_field = 0;

			payload_len = (event_id_packet & 0x6000) >> 13;

			/* copy the payload */

			/*

			 * Copy the payload after skipping temp_len bytes

			 * for already parsed packet, timestamp_len for

			 * timestamp buffer, 2 bytes for event_id_packet.

			 */

			if ((payload_len < (MAX_EVENT_SIZE - 12)) &&

			((temp_len + timestamp_len + payload_len + 2) <= len))

				memcpy(event_data + 12, buf + temp_len + 2 +

						timestamp_len, payload_len);

			else {

				pr_err("diag: event > %d, payload_len = %d, temp_len = %d\n",

				(MAX_EVENT_SIZE - 12), payload_len, temp_len);

				return;

			}

		}



		/* Before copying the data to userspace, check if we are still
@@ -1337,19 +1380,19 @@ void extract_dci_log(unsigned char *buf, int len, int data_source, int token, 
		pr_err("diag: In %s buffer is NULL\n", __func__);

		return;

	}



	/* The first six bytes for the incoming log packet contains

	 * Command code (2), the length of the packet (2) and the length

	 * of the log (2)

	/*

	 * The first eight bytes for the incoming log packet contains

	 * Command code (2), the length of the packet (2), the length

	 * of the log (2) and log code (2)

	 */

	log_code = *(uint16_t *)(buf + 6);

	read_bytes += sizeof(uint16_t) + 6;

	if (read_bytes > len) {

		pr_err("diag: Invalid length in %s, len: %d, read: %d",

						__func__, len, read_bytes);

	if (len < 8) {

		pr_err("diag: In %s invalid len: %d\n", __func__, len);

		return;

	}



	log_code = *(uint16_t *)(buf + 6);

	read_bytes += sizeof(uint16_t) + 6;



	/* parse through log mask table of each client and check mask */

	mutex_lock(&driver->dci_mutex);

	list_for_each_safe(start, temp, &driver->dci_client_list) {
@@ -1376,6 +1419,10 @@ void extract_dci_ext_pkt(unsigned char *buf, int len, int data_source, 
		pr_err("diag: In %s buffer is NULL\n", __func__);

		return;

	}

	if (len < (EXT_HDR_LEN + sizeof(uint8_t))) {

		pr_err("diag: In %s invalid len: %d\n", __func__, len);

		return;

	}



	version = *(uint8_t *)buf + 1;

	if (version < EXT_HDR_VERSION)  {
@@ -1387,10 +1434,6 @@ void extract_dci_ext_pkt(unsigned char *buf, int len, int data_source, 
	pkt = buf + EXT_HDR_LEN;

	pkt_cmd_code = *(uint8_t *)pkt;

	len -= EXT_HDR_LEN;

	if (len < 0) {

		pr_err("diag: %s, Invalid length len: %d\n", __func__, len);

		return;

	}



	switch (pkt_cmd_code) {

	case LOG_CMD_CODE:

drivers/char/diag/diag_masks.c

+100 −42
Original line number Diff line number Diff line 
/* Copyright (c) 2008-2017, The Linux Foundation. All rights reserved.

/* Copyright (c) 2008-2018, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and
@@ -537,8 +537,7 @@ static void diag_send_feature_mask_update(uint8_t peripheral) 
}



static int diag_cmd_get_ssid_range(unsigned char *src_buf, int src_len,

				   unsigned char *dest_buf, int dest_len,

				   struct diag_md_session_t *info)

			unsigned char *dest_buf, int dest_len, int pid)

{

	int i;

	int write_len = 0;
@@ -546,23 +545,30 @@ static int diag_cmd_get_ssid_range(unsigned char *src_buf, int src_len, 
	struct diag_msg_ssid_query_t rsp;

	struct diag_ssid_range_t ssid_range;

	struct diag_mask_info *mask_info = NULL;

	struct diag_md_session_t *info = NULL;



	mutex_lock(&driver->md_session_lock);

	info = diag_md_session_get_pid(pid);

	mask_info = (!info) ? &msg_mask : info->msg_mask;

	if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||

	    !mask_info) {

		pr_err("diag: Invalid input in %s, src_buf: %pK, src_len: %d, dest_buf: %pK, dest_len: %d, mask_info: %pK\n",

		       __func__, src_buf, src_len, dest_buf, dest_len,

		       mask_info);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	if (!mask_info->ptr) {

		pr_err("diag: In %s, invalid input mask_info->ptr: %pK\n",

			__func__, mask_info->ptr);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}



	if (!diag_apps_responds())

	if (!diag_apps_responds()) {

		mutex_unlock(&driver->md_session_lock);

		return 0;

	}

	mutex_lock(&driver->msg_mask_lock);

	rsp.cmd_code = DIAG_CMD_MSG_CONFIG;

	rsp.sub_cmd = DIAG_CMD_OP_GET_SSID_RANGE;
@@ -584,12 +590,12 @@ static int diag_cmd_get_ssid_range(unsigned char *src_buf, int src_len, 
		write_len += sizeof(ssid_range);

	}

	mutex_unlock(&driver->msg_mask_lock);

	mutex_unlock(&driver->md_session_lock);

	return write_len;

}



static int diag_cmd_get_build_mask(unsigned char *src_buf, int src_len,

				   unsigned char *dest_buf, int dest_len,

				   struct diag_md_session_t *info)

			unsigned char *dest_buf, int dest_len, int pid)

{

	int i = 0;

	int write_len = 0;
@@ -642,8 +648,7 @@ static int diag_cmd_get_build_mask(unsigned char *src_buf, int src_len, 
}



static int diag_cmd_get_msg_mask(unsigned char *src_buf, int src_len,

				 unsigned char *dest_buf, int dest_len,

				 struct diag_md_session_t *info)

			unsigned char *dest_buf, int dest_len, int pid)

{

	int i;

	int write_len = 0;
@@ -652,6 +657,10 @@ static int diag_cmd_get_msg_mask(unsigned char *src_buf, int src_len, 
	struct diag_build_mask_req_t *req = NULL;

	struct diag_msg_build_mask_t rsp;

	struct diag_mask_info *mask_info = NULL;

	struct diag_md_session_t *info = NULL;



	mutex_lock(&driver->md_session_lock);

	info = diag_md_session_get_pid(pid);



	mask_info = (!info) ? &msg_mask : info->msg_mask;

	if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||
@@ -659,15 +668,19 @@ static int diag_cmd_get_msg_mask(unsigned char *src_buf, int src_len, 
		pr_err("diag: Invalid input in %s, src_buf: %pK, src_len: %d, dest_buf: %pK, dest_len: %d, mask_info: %pK\n",

		       __func__, src_buf, src_len, dest_buf, dest_len,

		       mask_info);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	if (!mask_info->ptr) {

		pr_err("diag: In %s, invalid input mask_info->ptr: %pK\n",

			__func__, mask_info->ptr);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	if (!diag_apps_responds())

	if (!diag_apps_responds()) {

		mutex_unlock(&driver->md_session_lock);

		return 0;

	}



	mutex_lock(&driver->msg_mask_lock);

	req = (struct diag_build_mask_req_t *)src_buf;
@@ -682,6 +695,7 @@ static int diag_cmd_get_msg_mask(unsigned char *src_buf, int src_len, 
		pr_err("diag: Invalid input in %s, mask->ptr: %pK\n",

			__func__, mask->ptr);

		mutex_unlock(&driver->msg_mask_lock);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) {
@@ -701,12 +715,12 @@ static int diag_cmd_get_msg_mask(unsigned char *src_buf, int src_len, 
	memcpy(dest_buf, &rsp, sizeof(rsp));

	write_len += sizeof(rsp);

	mutex_unlock(&driver->msg_mask_lock);

	mutex_unlock(&driver->md_session_lock);

	return write_len;

}



static int diag_cmd_set_msg_mask(unsigned char *src_buf, int src_len,

				 unsigned char *dest_buf, int dest_len,

				 struct diag_md_session_t *info)

			unsigned char *dest_buf, int dest_len, int pid)

{

	int i;

	int write_len = 0;
@@ -720,6 +734,10 @@ static int diag_cmd_set_msg_mask(unsigned char *src_buf, int src_len, 
	struct diag_mask_info *mask_info = NULL;

	struct diag_msg_mask_t *mask_next = NULL;

	uint32_t *temp = NULL;

	struct diag_md_session_t *info = NULL;



	mutex_lock(&driver->md_session_lock);

	info = diag_md_session_get_pid(pid);



	mask_info = (!info) ? &msg_mask : info->msg_mask;

	if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||
@@ -727,11 +745,13 @@ static int diag_cmd_set_msg_mask(unsigned char *src_buf, int src_len, 
		pr_err("diag: Invalid input in %s, src_buf: %pK, src_len: %d, dest_buf: %pK, dest_len: %d, mask_info: %pK\n",

		       __func__, src_buf, src_len, dest_buf, dest_len,

		       mask_info);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	if (!mask_info->ptr) {

		pr_err("diag: In %s, invalid input mask_info->ptr: %pK\n",

			__func__, mask_info->ptr);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}
@@ -744,6 +764,7 @@ static int diag_cmd_set_msg_mask(unsigned char *src_buf, int src_len, 
			__func__, mask->ptr);

		mutex_unlock(&driver->msg_mask_lock);

		mutex_unlock(&mask_info->lock);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	for (i = 0; i < driver->msg_mask_tbl_count; i++, mask++) {
@@ -786,6 +807,7 @@ static int diag_cmd_set_msg_mask(unsigned char *src_buf, int src_len, 
				mutex_unlock(&mask->lock);

				mutex_unlock(&driver->msg_mask_lock);

				mutex_unlock(&mask_info->lock);

				mutex_unlock(&driver->md_session_lock);

				return -ENOMEM;

			}

			mask->ptr = temp;
@@ -806,6 +828,7 @@ static int diag_cmd_set_msg_mask(unsigned char *src_buf, int src_len, 
	}

	mutex_unlock(&driver->msg_mask_lock);

	mutex_unlock(&mask_info->lock);

	mutex_unlock(&driver->md_session_lock);

	if (diag_check_update(APPS_DATA))

		diag_update_userspace_clients(MSG_MASKS_TYPE);
@@ -839,8 +862,7 @@ end: 
}



static int diag_cmd_set_all_msg_mask(unsigned char *src_buf, int src_len,

				     unsigned char *dest_buf, int dest_len,

				     struct diag_md_session_t *info)

			unsigned char *dest_buf, int dest_len, int pid)

{

	int i;

	int write_len = 0;
@@ -849,6 +871,10 @@ static int diag_cmd_set_all_msg_mask(unsigned char *src_buf, int src_len, 
	struct diag_msg_config_rsp_t *req = NULL;

	struct diag_msg_mask_t *mask = NULL;

	struct diag_mask_info *mask_info = NULL;

	struct diag_md_session_t *info = NULL;



	mutex_lock(&driver->md_session_lock);

	info = diag_md_session_get_pid(pid);



	mask_info = (!info) ? &msg_mask : info->msg_mask;

	if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||
@@ -856,11 +882,13 @@ static int diag_cmd_set_all_msg_mask(unsigned char *src_buf, int src_len, 
		pr_err("diag: Invalid input in %s, src_buf: %pK, src_len: %d, dest_buf: %pK, dest_len: %d, mask_info: %pK\n",

		       __func__, src_buf, src_len, dest_buf, dest_len,

		       mask_info);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	if (!mask_info->ptr) {

		pr_err("diag: In %s, invalid input mask_info->ptr: %pK\n",

			__func__, mask_info->ptr);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}
@@ -875,6 +903,7 @@ static int diag_cmd_set_all_msg_mask(unsigned char *src_buf, int src_len, 
			__func__, mask->ptr);

		mutex_unlock(&driver->msg_mask_lock);

		mutex_unlock(&mask_info->lock);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	mask_info->status = (req->rt_mask) ? DIAG_CTRL_MASK_ALL_ENABLED :
@@ -887,7 +916,7 @@ static int diag_cmd_set_all_msg_mask(unsigned char *src_buf, int src_len, 
	}

	mutex_unlock(&driver->msg_mask_lock);

	mutex_unlock(&mask_info->lock);



	mutex_unlock(&driver->md_session_lock);

	if (diag_check_update(APPS_DATA))

		diag_update_userspace_clients(MSG_MASKS_TYPE);
@@ -915,8 +944,7 @@ static int diag_cmd_set_all_msg_mask(unsigned char *src_buf, int src_len, 
}



static int diag_cmd_get_event_mask(unsigned char *src_buf, int src_len,

				   unsigned char *dest_buf, int dest_len,

				   struct diag_md_session_t *info)

			unsigned char *dest_buf, int dest_len, int pid)

{

	int write_len = 0;

	uint32_t mask_size;
@@ -951,8 +979,7 @@ static int diag_cmd_get_event_mask(unsigned char *src_buf, int src_len, 
}



static int diag_cmd_update_event_mask(unsigned char *src_buf, int src_len,

				      unsigned char *dest_buf, int dest_len,

				      struct diag_md_session_t *info)

			unsigned char *dest_buf, int dest_len, int pid)

{

	int i;

	int write_len = 0;
@@ -961,18 +988,23 @@ static int diag_cmd_update_event_mask(unsigned char *src_buf, int src_len, 
	struct diag_event_mask_config_t rsp;

	struct diag_event_mask_config_t *req;

	struct diag_mask_info *mask_info = NULL;

	struct diag_md_session_t *info = NULL;



	mutex_lock(&driver->md_session_lock);

	info = diag_md_session_get_pid(pid);

	mask_info = (!info) ? &event_mask : info->event_mask;

	if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||

	    !mask_info) {

		pr_err("diag: Invalid input in %s, src_buf: %pK, src_len: %d, dest_buf: %pK, dest_len: %d, mask_info: %pK\n",

		       __func__, src_buf, src_len, dest_buf, dest_len,

		       mask_info);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	if (!mask_info->ptr) {

		pr_err("diag: In %s, invalid input mask_info->ptr: %pK\n",

			__func__, mask_info->ptr);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	req = (struct diag_event_mask_config_t *)src_buf;
@@ -980,6 +1012,7 @@ static int diag_cmd_update_event_mask(unsigned char *src_buf, int src_len, 
	if (mask_len <= 0 || mask_len > event_mask.mask_len) {

		pr_err("diag: In %s, invalid event mask len: %d\n", __func__,

		       mask_len);

		mutex_unlock(&driver->md_session_lock);

		return -EIO;

	}
@@ -987,6 +1020,7 @@ static int diag_cmd_update_event_mask(unsigned char *src_buf, int src_len, 
	memcpy(mask_info->ptr, src_buf + header_len, mask_len);

	mask_info->status = DIAG_CTRL_MASK_VALID;

	mutex_unlock(&mask_info->lock);

	mutex_unlock(&driver->md_session_lock);

	if (diag_check_update(APPS_DATA))

		diag_update_userspace_clients(EVENT_MASKS_TYPE);
@@ -1015,26 +1049,30 @@ static int diag_cmd_update_event_mask(unsigned char *src_buf, int src_len, 
}



static int diag_cmd_toggle_events(unsigned char *src_buf, int src_len,

				  unsigned char *dest_buf, int dest_len,

				  struct diag_md_session_t *info)

			unsigned char *dest_buf, int dest_len, int pid)

{

	int i;

	int write_len = 0;

	uint8_t toggle = 0;

	struct diag_event_report_t header;

	struct diag_mask_info *mask_info = NULL;

	struct diag_md_session_t *info = NULL;



	mutex_lock(&driver->md_session_lock);

	info = diag_md_session_get_pid(pid);

	mask_info = (!info) ? &event_mask : info->event_mask;

	if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||

	    !mask_info) {

		pr_err("diag: Invalid input in %s, src_buf: %pK, src_len: %d, dest_buf: %pK, dest_len: %d, mask_info: %pK\n",

		       __func__, src_buf, src_len, dest_buf, dest_len,

		       mask_info);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	if (!mask_info->ptr) {

		pr_err("diag: In %s, invalid input mask_info->ptr: %pK\n",

			__func__, mask_info->ptr);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}
@@ -1048,6 +1086,7 @@ static int diag_cmd_toggle_events(unsigned char *src_buf, int src_len, 
		memset(mask_info->ptr, 0, mask_info->mask_len);

	}

	mutex_unlock(&mask_info->lock);

	mutex_unlock(&driver->md_session_lock);

	if (diag_check_update(APPS_DATA))

		diag_update_userspace_clients(EVENT_MASKS_TYPE);
@@ -1071,8 +1110,7 @@ static int diag_cmd_toggle_events(unsigned char *src_buf, int src_len, 
}



static int diag_cmd_get_log_mask(unsigned char *src_buf, int src_len,

				 unsigned char *dest_buf, int dest_len,

				 struct diag_md_session_t *info)

			unsigned char *dest_buf, int dest_len, int pid)

{

	int i;

	int status = LOG_STATUS_INVALID;
@@ -1085,6 +1123,10 @@ static int diag_cmd_get_log_mask(unsigned char *src_buf, int src_len, 
	struct diag_log_config_req_t *req;

	struct diag_log_config_rsp_t rsp;

	struct diag_mask_info *mask_info = NULL;

	struct diag_md_session_t *info = NULL;



	mutex_lock(&driver->md_session_lock);

	info = diag_md_session_get_pid(pid);



	mask_info = (!info) ? &log_mask : info->log_mask;

	if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||
@@ -1092,16 +1134,20 @@ static int diag_cmd_get_log_mask(unsigned char *src_buf, int src_len, 
		pr_err("diag: Invalid input in %s, src_buf: %pK, src_len: %d, dest_buf: %pK, dest_len: %d, mask_info: %pK\n",

		       __func__, src_buf, src_len, dest_buf, dest_len,

		       mask_info);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	if (!mask_info->ptr) {

		pr_err("diag: In %s, invalid input mask_info->ptr: %pK\n",

			__func__, mask_info->ptr);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}



	if (!diag_apps_responds())

	if (!diag_apps_responds()) {

		mutex_unlock(&driver->md_session_lock);

		return 0;

	}



	req = (struct diag_log_config_req_t *)src_buf;

	read_len += req_header_len;
@@ -1121,6 +1167,7 @@ static int diag_cmd_get_log_mask(unsigned char *src_buf, int src_len, 
	if (!log_item->ptr) {

		pr_err("diag: Invalid input in %s, mask: %pK\n",

			__func__, log_item);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	for (i = 0; i < MAX_EQUIP_ID; i++, log_item++) {
@@ -1162,28 +1209,27 @@ static int diag_cmd_get_log_mask(unsigned char *src_buf, int src_len, 
	rsp.status = status;

	memcpy(dest_buf, &rsp, rsp_header_len);



	mutex_unlock(&driver->md_session_lock);

	return write_len;

}



static int diag_cmd_get_log_range(unsigned char *src_buf, int src_len,

				  unsigned char *dest_buf, int dest_len,

				  struct diag_md_session_t *info)

			unsigned char *dest_buf, int dest_len, int pid)

{

	int i;

	int write_len = 0;

	struct diag_log_config_rsp_t rsp;

	struct diag_mask_info *mask_info = NULL;

	struct diag_log_mask_t *mask = (struct diag_log_mask_t *)log_mask.ptr;



	if (!mask)

		return -EINVAL;



	if (!diag_apps_responds())

		return 0;



	mask_info = (!info) ? &log_mask : info->log_mask;

	if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||

	    !mask_info) {

		pr_err("diag: Invalid input in %s, src_buf: %pK, src_len: %d, dest_buf: %pK, dest_len: %d, mask_info: %pK\n",

		       __func__, src_buf, src_len, dest_buf, dest_len,

		       mask_info);

	if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0) {

		pr_err("diag: Invalid input in %s, src_buf: %pK, src_len: %d, dest_buf: %pK, dest_len: %d\n",

		       __func__, src_buf, src_len, dest_buf, dest_len);

		return -EINVAL;

	}
@@ -1206,7 +1252,7 @@ static int diag_cmd_get_log_range(unsigned char *src_buf, int src_len, 


static int diag_cmd_set_log_mask(unsigned char *src_buf, int src_len,

				 unsigned char *dest_buf, int dest_len,

				 struct diag_md_session_t *info)

				 int pid)

{

	int i;

	int write_len = 0;
@@ -1221,6 +1267,10 @@ static int diag_cmd_set_log_mask(unsigned char *src_buf, int src_len, 
	struct diag_log_mask_t *mask = NULL;

	unsigned char *temp_buf = NULL;

	struct diag_mask_info *mask_info = NULL;

	struct diag_md_session_t *info = NULL;



	mutex_lock(&driver->md_session_lock);

	info = diag_md_session_get_pid(pid);



	mask_info = (!info) ? &log_mask : info->log_mask;

	if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||
@@ -1228,11 +1278,13 @@ static int diag_cmd_set_log_mask(unsigned char *src_buf, int src_len, 
		pr_err("diag: Invalid input in %s, src_buf: %pK, src_len: %d, dest_buf: %pK, dest_len: %d, mask_info: %pK\n",

		       __func__, src_buf, src_len, dest_buf, dest_len,

		       mask_info);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	if (!mask_info->ptr) {

		pr_err("diag: In %s, invalid input mask_info->ptr: %pK\n",

			__func__, mask_info->ptr);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}
@@ -1242,6 +1294,7 @@ static int diag_cmd_set_log_mask(unsigned char *src_buf, int src_len, 
	if (!mask->ptr) {

		pr_err("diag: Invalid input in %s, mask->ptr: %pK\n",

			__func__, mask->ptr);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	if (req->equip_id >= MAX_EQUIP_ID) {
@@ -1304,6 +1357,7 @@ static int diag_cmd_set_log_mask(unsigned char *src_buf, int src_len, 
		break;

	}

	mutex_unlock(&mask_info->lock);

	mutex_unlock(&driver->md_session_lock);

	if (diag_check_update(APPS_DATA))

		diag_update_userspace_clients(LOG_MASKS_TYPE);
@@ -1344,14 +1398,16 @@ end: 
}



static int diag_cmd_disable_log_mask(unsigned char *src_buf, int src_len,

				     unsigned char *dest_buf, int dest_len,

				     struct diag_md_session_t *info)

			unsigned char *dest_buf, int dest_len, int pid)

{

	struct diag_mask_info *mask_info = NULL;

	struct diag_log_mask_t *mask = NULL;

	struct diag_log_config_rsp_t header;

	int write_len = 0;

	int i;

	int write_len = 0, i;

	struct diag_md_session_t *info = NULL;



	mutex_lock(&driver->md_session_lock);

	info = diag_md_session_get_pid(pid);



	mask_info = (!info) ? &log_mask : info->log_mask;

	if (!src_buf || !dest_buf || src_len <= 0 || dest_len <= 0 ||
@@ -1359,17 +1415,20 @@ static int diag_cmd_disable_log_mask(unsigned char *src_buf, int src_len, 
		pr_err("diag: Invalid input in %s, src_buf: %pK, src_len: %d, dest_buf: %pK, dest_len: %d, mask_info: %pK\n",

		       __func__, src_buf, src_len, dest_buf, dest_len,

		       mask_info);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	if (!mask_info->ptr) {

		pr_err("diag: In %s, invalid input mask_info->ptr: %pK\n",

			__func__, mask_info->ptr);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	mask = (struct diag_log_mask_t *)mask_info->ptr;

	if (!mask->ptr) {

		pr_err("diag: Invalid input in %s, mask->ptr: %pK\n",

			__func__, mask->ptr);

		mutex_unlock(&driver->md_session_lock);

		return -EINVAL;

	}

	for (i = 0; i < MAX_EQUIP_ID; i++, mask++) {
@@ -1378,6 +1437,7 @@ static int diag_cmd_disable_log_mask(unsigned char *src_buf, int src_len, 
		mutex_unlock(&mask->lock);

	}

	mask_info->status = DIAG_CTRL_MASK_ALL_DISABLED;

	mutex_unlock(&driver->md_session_lock);

	if (diag_check_update(APPS_DATA))

		diag_update_userspace_clients(LOG_MASKS_TYPE);
@@ -2109,14 +2169,12 @@ void diag_send_updates_peripheral(uint8_t peripheral) 
				&driver->buffering_mode[peripheral]);

}



int diag_process_apps_masks(unsigned char *buf, int len,

			    struct diag_md_session_t *info)

int diag_process_apps_masks(unsigned char *buf, int len, int pid)

{

	int size = 0;

	int sub_cmd = 0;

	int (*hdlr)(unsigned char *src_buf, int src_len,

		    unsigned char *dest_buf, int dest_len,

		    struct diag_md_session_t *info) = NULL;

		    unsigned char *dest_buf, int dest_len, int pid) = NULL;



	if (!buf || len <= 0)

		return -EINVAL;
@@ -2166,7 +2224,7 @@ int diag_process_apps_masks(unsigned char *buf, int len, 


	if (hdlr)

		size = hdlr(buf, len, driver->apps_rsp_buf,

			    DIAG_MAX_RSP_SIZE, info);

			    DIAG_MAX_RSP_SIZE, pid);



	return (size > 0) ? size : 0;

}

drivers/char/diag/diag_masks.h

+2 −3
Original line number Diff line number Diff line 
/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.

/* Copyright (c) 2013-2015, 2018 The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and
@@ -167,8 +167,7 @@ int diag_event_mask_copy(struct diag_mask_info *dest, 
void diag_log_mask_free(struct diag_mask_info *mask_info);

void diag_msg_mask_free(struct diag_mask_info *mask_info);

void diag_event_mask_free(struct diag_mask_info *mask_info);

int diag_process_apps_masks(unsigned char *buf, int len,

			    struct diag_md_session_t *info);

int diag_process_apps_masks(unsigned char *buf, int len, int pid);

void diag_send_updates_peripheral(uint8_t peripheral);



extern int diag_create_msg_mask_table_entry(struct diag_msg_mask_t *msg_mask,

drivers/char/diag/diag_memorydevice.c

+11 −7
Original line number Diff line number Diff line 
/* Copyright (c) 2014-2017, The Linux Foundation. All rights reserved.

/* Copyright (c) 2014-2018, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and
@@ -131,7 +131,7 @@ void diag_md_close_all() 


int diag_md_write(int id, unsigned char *buf, int len, int ctx)

{

	int i;

	int i, pid = 0;

	uint8_t found = 0;

	unsigned long flags;

	struct diag_md_info *ch = NULL;
@@ -149,10 +149,14 @@ int diag_md_write(int id, unsigned char *buf, int len, int ctx) 
	if (peripheral < 0)

		return -EINVAL;



	session_info =

		diag_md_session_get_peripheral(peripheral);

	if (!session_info)

	mutex_lock(&driver->md_session_lock);

	session_info = diag_md_session_get_peripheral(peripheral);

	if (!session_info) {

		mutex_unlock(&driver->md_session_lock);

		return -EIO;

	}

	pid = session_info->pid;

	mutex_unlock(&driver->md_session_lock);



	ch = &diag_md[id];

	if (!ch)
@@ -195,13 +199,13 @@ int diag_md_write(int id, unsigned char *buf, int len, int ctx) 


	found = 0;

	for (i = 0; i < driver->num_clients && !found; i++) {

		if ((driver->client_map[i].pid !=

		     session_info->pid) ||

		if ((driver->client_map[i].pid != pid) ||

		    (driver->client_map[i].pid == 0))

			continue;



		found = 1;

		driver->data_ready[i] |= USER_SPACE_DATA_TYPE;

		atomic_inc(&driver->data_ready_notif[i]);

		pr_debug("diag: wake up logging process\n");

		wake_up_interruptible(&driver->wait_q);

	}