Merge "diag: Streamline diag memory pool" (38cbc36d) · Commits · e / devices / android_kernel_sony_msm8994

drivers/char/diag/diag_dci.c

+5 −5

Original line number	Diff line number	Diff line
		@@ -1290,8 +1290,8 @@ unsigned char *dci_get_buffer_from_bridge(int index)
		unsigned char *buf = NULL;

		do {
		buf = diagmem_alloc(driver, WRITE_HSIC_BUF_SIZE_DCI,
		POOL_TYPE_HSIC_DCI_WRITE + index);
		buf = diagmem_alloc(driver, DIAG_MDM_DCI_BUF_SIZE,
		POOL_TYPE_MDM_DCI_WRITE + index);
		if (!buf) {
		usleep_range(5000, 5100);
		retries++;
		@@ -1376,7 +1376,7 @@ static int diag_send_dci_pkt_remote(unsigned char *data, int len, int tag,
		if (ret != write_len) {
		pr_err("diag: In %s, unable to write to DCI HSIC channel, err: %d\n",
		__func__, ret);
		diagmem_free(driver, buf, POOL_TYPE_HSIC_DCI_WRITE + b_index);
		diagmem_free(driver, buf, POOL_TYPE_MDM_DCI_WRITE + b_index);
		} else {
		ret = DIAG_DCI_NO_ERROR;
		}
		@@ -2004,7 +2004,7 @@ int diag_send_dci_event_mask_remote(int token)
		err = diag_dci_write_bridge(b_index, buf, write_len);
		if (err != write_len) {
		pr_err("diag: error writing to hsic channel, err: %d\n", err);
		diagmem_free(driver, buf, POOL_TYPE_HSIC_DCI_WRITE + b_index);
		diagmem_free(driver, buf, POOL_TYPE_MDM_DCI_WRITE + b_index);
		ret = err;
		} else {
		ret = DIAG_DCI_NO_ERROR;
		@@ -2182,7 +2182,7 @@ int diag_send_dci_log_mask_remote(int token)
		pr_err("diag: error writing log mask to MDM hsic channel, equip_id: %d, err: %d\n",
		i, err);
		diagmem_free(driver, buf,
		POOL_TYPE_HSIC_DCI_WRITE + b_index);
		POOL_TYPE_MDM_DCI_WRITE + b_index);
		updated = 0;
		}
		if (updated)

drivers/char/diag/diag_debugfs.c

+46 −102

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@
		#define DEBUG_BUF_SIZE 4096
		static struct dentry *diag_dbgfs_dent;
		static int diag_dbgfs_table_index;
		static int diag_dbgfs_mempool_index;
		static int diag_dbgfs_finished;
		static int diag_dbgfs_dci_data_index;
		static int diag_dbgfs_dci_finished;
		@@ -476,76 +477,23 @@ static ssize_t diag_dbgfs_read_table(struct file file, char __user ubuf,
		return ret;
		}

		#ifdef CONFIG_DIAGFWD_BRIDGE_CODE
		static ssize_t diag_dbgfs_read_mempool(struct file file, char __user ubuf,
		size_t count, loff_t *ppos)
		{
		char *buf = NULL;
		int ret = 0, i = 0;
		int ret = 0;
		int i = 0;
		unsigned int buf_size;
		buf = kzalloc(sizeof(char) * DEBUG_BUF_SIZE, GFP_KERNEL);
		if (ZERO_OR_NULL_PTR(buf)) {
		pr_err("diag: %s, Error allocating memory\n", __func__);
		return -ENOMEM;
		}
		buf_size = ksize(buf);

		ret = scnprintf(buf, buf_size,
		"POOL_TYPE_COPY: [0x%p : 0x%p] count = %d\n"
		"POOL_TYPE_HDLC: [0x%p : 0x%p] count = %d\n"
		"POOL_TYPE_USER: [0x%p : 0x%p] count = %d\n"
		"POOL_TYPE_WRITE_STRUCT: [0x%p : 0x%p] count = %d\n"
		"POOL_TYPE_DCI: [0x%p : 0x%p] count = %d\n",
		driver->diagpool,
		diag_pools_array[POOL_COPY_IDX],
		driver->count,
		driver->diag_hdlc_pool,
		diag_pools_array[POOL_HDLC_IDX],
		driver->count_hdlc_pool,
		driver->diag_user_pool,
		diag_pools_array[POOL_USER_IDX],
		driver->count_user_pool,
		driver->diag_write_struct_pool,
		diag_pools_array[POOL_WRITE_STRUCT_IDX],
		driver->count_write_struct_pool,
		driver->diag_dci_pool,
		diag_pools_array[POOL_DCI_IDX],
		driver->count_dci_pool);

		for (i = 0; i < MAX_HSIC_DATA_CH; i++) {
		if (!diag_hsic[i].hsic_inited)
		continue;
		ret += scnprintf(buf+ret, buf_size-ret,
		"POOL_TYPE_HSIC_%d: [0x%p : 0x%p] count = %d\n",
		i+1,
		diag_hsic[i].diag_hsic_pool,
		diag_pools_array[POOL_HSIC_IDX + i],
		diag_hsic[i].count_hsic_pool);
		}

		for (i = 0; i < MAX_HSIC_DATA_CH; i++) {
		if (!diag_hsic[i].hsic_inited)
		continue;
		ret += scnprintf(buf+ret, buf_size-ret,
		"POOL_TYPE_HSIC_%d_WRITE: [0x%p : 0x%p] count = %d\n",
		i+1,
		diag_hsic[i].diag_hsic_write_pool,
		diag_pools_array[POOL_HSIC_WRITE_IDX + i],
		diag_hsic[i].count_hsic_write_pool);
		}

		ret = simple_read_from_buffer(ubuf, count, ppos, buf, ret);
		unsigned int bytes_remaining = 0;
		unsigned int bytes_written = 0;
		unsigned int bytes_in_buffer = 0;
		struct diag_mempool_t *mempool = NULL;

		kfree(buf);
		return ret;
		if (diag_dbgfs_mempool_index >= NUM_MEMORY_POOLS) {
		/* Done. Reset to prepare for future requests */
		diag_dbgfs_mempool_index = 0;
		return 0;
		}
		#else
		static ssize_t diag_dbgfs_read_mempool(struct file file, char __user ubuf,
		size_t count, loff_t *ppos)
		{
		char *buf = NULL;
		int ret = 0;
		unsigned int buf_size;

		buf = kzalloc(sizeof(char) * DEBUG_BUF_SIZE, GFP_KERNEL);
		if (ZERO_OR_NULL_PTR(buf)) {
		@@ -554,34 +502,45 @@ static ssize_t diag_dbgfs_read_mempool(struct file file, char __user ubuf,
		}

		buf_size = ksize(buf);
		ret = scnprintf(buf, buf_size,
		"POOL_TYPE_COPY: [0x%p : 0x%p] count = %d\n"
		"POOL_TYPE_HDLC: [0x%p : 0x%p] count = %d\n"
		"POOL_TYPE_USER: [0x%p : 0x%p] count = %d\n"
		"POOL_TYPE_WRITE_STRUCT: [0x%p : 0x%p] count = %d\n"
		"POOL_TYPE_DCI: [0x%p : 0x%p] count = %d\n",
		driver->diagpool,
		diag_pools_array[POOL_COPY_IDX],
		driver->count,
		driver->diag_hdlc_pool,
		diag_pools_array[POOL_HDLC_IDX],
		driver->count_hdlc_pool,
		driver->diag_user_pool,
		diag_pools_array[POOL_USER_IDX],
		driver->count_user_pool,
		driver->diag_write_struct_pool,
		diag_pools_array[POOL_WRITE_STRUCT_IDX],
		driver->count_write_struct_pool,
		driver->diag_dci_pool,
		diag_pools_array[POOL_DCI_IDX],
		driver->count_dci_pool);
		bytes_remaining = buf_size;
		bytes_written = scnprintf(buf+bytes_in_buffer, bytes_remaining,
		"%-24s\t"
		"%-10s\t"
		"%-5s\t"
		"%-5s\t"
		"%-5s\n",
		"POOL", "HANDLE", "COUNT", "SIZE", "ITEMSIZE");
		bytes_in_buffer += bytes_written;
		bytes_remaining = buf_size - bytes_in_buffer;

		ret = simple_read_from_buffer(ubuf, count, ppos, buf, ret);
		for (i = diag_dbgfs_mempool_index; i < NUM_MEMORY_POOLS; i++) {
		mempool = &diag_mempools[i];
		bytes_written = scnprintf(buf+bytes_in_buffer, bytes_remaining,
		"%-24s\t"
		"%-10p\t"
		"%-5d\t"
		"%-5d\t"
		"%-5d\n",
		mempool->name,
		mempool->pool,
		mempool->count,
		mempool->poolsize,
		mempool->itemsize);
		bytes_in_buffer += bytes_written;

		/* Check if there is room to add another table entry */
		bytes_remaining = buf_size - bytes_in_buffer;

		if (bytes_remaining < bytes_written)
		break;
		}
		diag_dbgfs_mempool_index = i+1;
		*ppos = 0;
		ret = simple_read_from_buffer(ubuf, count, ppos, buf, bytes_in_buffer);

		kfree(buf);
		return ret;
		}
		#endif

		#ifdef CONFIG_DIAGFWD_BRIDGE_CODE
		static ssize_t diag_dbgfs_read_bridge(struct file file, char __user ubuf,
		@@ -650,10 +609,6 @@ static ssize_t diag_dbgfs_read_bridge(struct file file, char __user ubuf,
		"hsic_suspend: %d\n"
		"in_busy_hsic_read_on_device: %d\n"
		"in_busy_hsic_write: %d\n"
		"count_hsic_pool: %d\n"
		"count_hsic_write_pool: %d\n"
		"diag_hsic_pool: %p\n"
		"diag_hsic_write_pool: %p\n"
		"HSIC write_len: %d\n"
		"num_hsic_buf_tbl_entries: %d\n"
		"HSIC usb_connected: %d\n"
		@@ -668,10 +623,6 @@ static ssize_t diag_dbgfs_read_bridge(struct file file, char __user ubuf,
		diag_hsic[i].hsic_suspend,
		diag_hsic[i].in_busy_hsic_read_on_device,
		diag_hsic[i].in_busy_hsic_write,
		diag_hsic[i].count_hsic_pool,
		diag_hsic[i].count_hsic_write_pool,
		diag_hsic[i].diag_hsic_pool,
		diag_hsic[i].diag_hsic_write_pool,
		diag_bridge[i].write_len,
		diag_hsic[i].num_hsic_buf_tbl_entries,
		diag_bridge[i].usb_connected,
		@@ -748,10 +699,6 @@ static ssize_t diag_dbgfs_read_bridge_dci(struct file file, char __user ubuf,
		"hsic_opened: %d\n"
		"hsic_suspend: %d\n"
		"in_busy_hsic_write: %d\n"
		"count_hsic_pool: %d\n"
		"count_hsic_write_pool: %d\n"
		"diag_hsic_pool: %p\n"
		"diag_hsic_write_pool: %p\n"
		"data: %p\n"
		"data_buf: %p\n"
		"data_len: %d\n"
		@@ -764,10 +711,6 @@ static ssize_t diag_dbgfs_read_bridge_dci(struct file file, char __user ubuf,
		diag_hsic_dci[i].hsic_device_opened,
		diag_hsic_dci[i].hsic_suspend,
		diag_hsic_dci[i].in_busy_hsic_write,
		diag_hsic_dci[i].count_hsic_pool,
		diag_hsic_dci[i].count_hsic_write_pool,
		diag_hsic_dci[i].diag_hsic_pool,
		diag_hsic_dci[i].diag_hsic_write_pool,
		diag_hsic_dci[i].data,
		diag_hsic_dci[i].data_buf,
		diag_hsic_dci[i].data_len,
		@@ -885,6 +828,7 @@ int diag_debugfs_init(void)
		#endif

		diag_dbgfs_table_index = 0;
		diag_dbgfs_mempool_index = 0;
		diag_dbgfs_finished = 0;
		diag_dbgfs_dci_data_index = 0;
		diag_dbgfs_dci_finished = 0;

drivers/char/diag/diagchar.h

+7 −53

Original line number	Diff line number	Diff line
		@@ -34,42 +34,8 @@
		/* Size of the buffer used for deframing a packet
		reveived from the PC tool*/
		#define HDLC_MAX 4096
		#define HDLC_OUT_BUF_SIZE 8192
		#define POOL_TYPE_COPY 1
		#define POOL_TYPE_HDLC 2
		#define POOL_TYPE_USER 3
		#define POOL_TYPE_WRITE_STRUCT 4
		#define POOL_TYPE_HSIC 5
		#define POOL_TYPE_HSIC_2 6
		#define POOL_TYPE_HSIC_DCI 7
		#define POOL_TYPE_HSIC_DCI_2 8
		#define POOL_TYPE_HSIC_WRITE 11
		#define POOL_TYPE_HSIC_2_WRITE 12
		#define POOL_TYPE_HSIC_DCI_WRITE 13
		#define POOL_TYPE_HSIC_DCI_2_WRITE 14
		#define POOL_TYPE_ALL 10
		#define POOL_TYPE_DCI 20

		#define POOL_COPY_IDX 0
		#define POOL_HDLC_IDX 1
		#define POOL_USER_IDX 2
		#define POOL_WRITE_STRUCT_IDX 3
		#define POOL_DCI_IDX 4
		#define POOL_BRIDGE_BASE POOL_DCI_IDX
		#define POOL_HSIC_IDX (POOL_BRIDGE_BASE + 1)
		#define POOL_HSIC_DCI_IDX (POOL_BRIDGE_BASE + 2)
		#define POOL_HSIC_3_IDX (POOL_BRIDGE_BASE + 3)
		#define POOL_HSIC_4_IDX (POOL_BRIDGE_BASE + 4)
		#define POOL_HSIC_WRITE_IDX (POOL_BRIDGE_BASE + 5)
		#define POOL_HSIC_DCI_WRITE_IDX (POOL_BRIDGE_BASE + 6)
		#define POOL_HSIC_3_WRITE_IDX (POOL_BRIDGE_BASE + 7)
		#define POOL_HSIC_4_WRITE_IDX (POOL_BRIDGE_BASE + 8)

		#ifdef CONFIG_DIAGFWD_BRIDGE_CODE
		#define NUM_MEMORY_POOLS 13
		#else
		#define NUM_MEMORY_POOLS 5
		#endif
		#define HDLC_OUT_BUF_SIZE (driver->itemsize_hdlc)
		#define DIAG_HDLC_BUF_SIZE 8195

		#define MAX_SSID_PER_RANGE 200

		@@ -185,6 +151,10 @@

		#define DIAG_TS_SIZE 50

		#define DIAG_MDM_BUF_SIZE 2048
		/* The Maximum request size is 2k + DCI header + footer (6 bytes) */
		#define DIAG_MDM_DCI_BUF_SIZE (2048 + 6)

		#define MAX_HSIC_DATA_CH 2
		#define MAX_HSIC_DCI_CH 2
		#define MAX_HSIC_CH (MAX_HSIC_DATA_CH + MAX_HSIC_DCI_CH)
		@@ -401,30 +371,14 @@ struct diagchar_dev {
		unsigned char *apps_dci_buf;
		int dci_state;
		struct workqueue_struct *diag_dci_wq;
		/* Memory pool parameters */
		/* Sizes that reflect memory pool sizes */
		unsigned int itemsize;
		unsigned int poolsize;
		unsigned int itemsize_hdlc;
		unsigned int poolsize_hdlc;
		unsigned int itemsize_user;
		unsigned int poolsize_user;
		unsigned int itemsize_write_struct;
		unsigned int poolsize_write_struct;
		unsigned int itemsize_dci;
		unsigned int poolsize_dci;
		unsigned int debug_flag;
		/* State for the mempool for the char driver */
		mempool_t *diagpool;
		mempool_t *diag_hdlc_pool;
		mempool_t *diag_user_pool;
		mempool_t *diag_write_struct_pool;
		mempool_t *diag_dci_pool;
		spinlock_t diag_mem_lock;
		int count;
		int count_hdlc_pool;
		int count_user_pool;
		int count_write_struct_pool;
		int count_dci_pool;
		int used;
		/* Buffers for masks */
		struct mutex diag_cntl_mutex;

drivers/char/diag/diagchar_core.c

+121 −36

Original line number	Diff line number	Diff line
		@@ -58,26 +58,86 @@ struct diagchar_dev *driver;
		struct diagchar_priv {
		int pid;
		};
		/* The following variables can be specified by module options */
		/* for copy buffer */
		static unsigned int itemsize = 4096; /Size of item in the mempool /
		static unsigned int poolsize = 12; /Number of items in the mempool /
		/* for hdlc buffer */
		static unsigned int itemsize_hdlc = 8192; /Size of item in the mempool /
		static unsigned int poolsize_hdlc = 10; /Number of items in the mempool /
		/* for user buffer */
		static unsigned int itemsize_user = 8192; /Size of item in the mempool /
		static unsigned int poolsize_user = 8; /Number of items in the mempool /
		/* for write structure buffer */
		/Size of item in the mempool /
		static unsigned int itemsize_write_struct = sizeof(struct diag_request);
		static unsigned int poolsize_write_struct = 10;/* Num of items in the mempool */
		/* For the dci memory pool */
		static unsigned int itemsize_dci = IN_BUF_SIZE; /Size of item in the mempool /
		static unsigned int poolsize_dci = 10; /Number of items in the mempool /

		/* Memory pool variables */
		/* Used for copying any incoming packet from user space clients. */
		static unsigned int itemsize = 4096;
		static unsigned int poolsize = 12;
		module_param(itemsize, uint, 0);
		module_param(poolsize, uint, 0);

		/*
		* Used for HDLC encoding packets coming from the user
		* space. Itemsize is defined in diagchar_init. HDLC
		* Buffer can be at most twice as long as the itemsize.
		* Add 3 bytes for CRC bytes and delimiter. Don't expose
		* itemsize_hdlc as it is dependent on itemsize.By
		* default it is set to DIAG_HDLC_BUF_SIZE (8K)
		*/
		static unsigned int itemsize_hdlc = DIAG_HDLC_BUF_SIZE;
		static unsigned int poolsize_hdlc = 10;
		module_param(poolsize_hdlc, uint, 0);

		/*
		* This is used for incoming DCI requests from the user space clients.
		* Don't expose itemsize as it is internal.
		*/
		static unsigned int itemsize_user = 8192;
		static unsigned int poolsize_user = 8;
		module_param(poolsize_user, uint, 0);

		/*
		* USB structures allocated for writing Diag data generated on the Apps to USB.
		* Don't expose itemsize as it is constant.
		*/
		static unsigned int itemsize_usb_apps = sizeof(struct diag_request);
		static unsigned int poolsize_usb_apps = 10;
		module_param(poolsize_usb_apps, uint, 0);

		/* Used for DCI client buffers. Don't expose itemsize as it is constant. */
		static unsigned int itemsize_dci = IN_BUF_SIZE;
		static unsigned int poolsize_dci = 10;
		module_param(poolsize_dci, uint, 0);

		#ifdef CONFIG_DIAGFWD_BRIDGE_CODE
		/* Used for reading data from the remote device. */
		static unsigned int itemsize_mdm = DIAG_MDM_BUF_SIZE;
		static unsigned int poolsize_mdm = 8;
		module_param(itemsize_mdm, uint, 0);
		module_param(poolsize_mdm, uint, 0);

		/*
		* Used for reading DCI data from the remote device.
		* Don't expose poolsize for DCI data. There is only one read buffer
		*/
		static unsigned int itemsize_mdm_dci = DIAG_MDM_BUF_SIZE;
		static unsigned int poolsize_mdm_dci = 1;
		module_param(itemsize_mdm_dci, uint, 0);

		/*
		* Used for USB structues associated with a remote device.
		* Don't expose the itemsize since it is constant.
		*/
		static unsigned int itemsize_mdm_usb = sizeof(struct diag_request);
		static unsigned int poolsize_mdm_usb = 8;
		module_param(poolsize_mdm_usb, uint, 0);

		/*
		* Used for writing read DCI data to remote peripherals. Don't
		* expose poolsize for DCI data. There is only one read
		* buffer. Add 6 bytes for DCI header information: Start (1),
		* Version (1), Length (2), Tag (2)
		*/
		static unsigned int itemsize_mdm_dci_write = DIAG_MDM_DCI_BUF_SIZE;
		static unsigned int poolsize_mdm_dci_write = 1;
		module_param(itemsize_mdm_dci_write, uint, 0);
		#endif

		/* This is the max number of user-space clients supported at initialization*/
		static unsigned int max_clients = 15;
		static unsigned int threshold_client_limit = 30;
		module_param(max_clients, uint, 0);

		/* This is the maximum number of pkt registrations supported at initialization*/
		int diag_max_reg = 600;
		int diag_threshold_reg = 750;
		@@ -86,9 +146,6 @@ int diag_threshold_reg = 750;
		static struct timer_list drain_timer;
		static int timer_in_progress;
		void *buf_hdlc;
		module_param(itemsize, uint, 0);
		module_param(poolsize, uint, 0);
		module_param(max_clients, uint, 0);

		#define DIAGPKT_MAX_DELAYED_RSP 0xFFFF

		@@ -194,7 +251,7 @@ void diag_clear_hsic_tbl(void)
		/* Return the buffer to the pool */
		diagmem_free(driver, (unsigned char *)
		(diag_hsic[j].hsic_buf_tbl[i].
		buf), j+POOL_TYPE_HSIC);
		buf), j+POOL_TYPE_MDM);
		diag_hsic[j].hsic_buf_tbl[i].buf = 0;
		}
		diag_hsic[j].hsic_buf_tbl[i].length = 0;
		@@ -220,6 +277,20 @@ void diag_add_client(int i, struct file *file)
		driver->client_map[i].name[19] = '\0';
		}

		static void diag_mempool_init(void)
		{
		int i = 0;
		for (i = 0; i < POOL_TYPE_LOCAL_LAST; i++)
		diagmem_init(driver, i);
		}

		static void diag_mempool_exit(void)
		{
		int i = 0;
		for (i = 0; i < POOL_TYPE_LOCAL_LAST; i++)
		diagmem_exit(driver, i);
		}

		static int diagchar_open(struct inode inode, struct file file)
		{
		int i = 0;
		@@ -272,7 +343,7 @@ static int diagchar_open(struct inode inode, struct file file)
		driver->data_ready[i] \|= DCI_EVENT_MASKS_TYPE;

		if (driver->ref_count == 0)
		diagmem_init(driver);
		diag_mempool_init();
		driver->ref_count++;
		mutex_unlock(&driver->diagchar_mutex);
		return 0;
		@@ -354,12 +425,9 @@ static int diagchar_close(struct inode inode, struct file file)

		mutex_lock(&driver->diagchar_mutex);
		driver->ref_count--;
		/* On Client exit, try to destroy all 5 pools */
		diagmem_exit(driver, POOL_TYPE_COPY);
		diagmem_exit(driver, POOL_TYPE_HDLC);
		diagmem_exit(driver, POOL_TYPE_USER);
		diagmem_exit(driver, POOL_TYPE_WRITE_STRUCT);
		diagmem_exit(driver, POOL_TYPE_DCI);
		if (driver->ref_count == 0)
		diag_mempool_exit();

		for (i = 0; i < driver->num_clients; i++) {
		if (NULL != diagpriv_data && diagpriv_data->pid ==
		driver->client_map[i].pid) {
		@@ -572,7 +640,7 @@ drop_hsic:
		/* Return the buffer to the pool */
		diagmem_free(driver,
		(unsigned char *)(hsic_buf_tbl[i].buf),
		index+POOL_TYPE_HSIC);
		index+POOL_TYPE_MDM);

		/* Call the write complete function */
		diagfwd_write_complete_hsic(NULL, index);
		@@ -2533,14 +2601,21 @@ static int __init diagchar_init(void)
		setup_timer(&drain_timer, drain_timer_func, 1234);
		driver->itemsize = itemsize;
		driver->poolsize = poolsize;
		/*
		* HDLC buffer can be at most twice as much as itemsize. Add 3 for
		* 16-bit CRC and delimiter.
		*/
		itemsize_hdlc = (itemsize * 2) + 3;
		driver->itemsize_hdlc = itemsize_hdlc;
		driver->poolsize_hdlc = poolsize_hdlc;
		driver->itemsize_user = itemsize_user;
		driver->poolsize_user = poolsize_user;
		driver->itemsize_write_struct = itemsize_write_struct;
		driver->poolsize_write_struct = poolsize_write_struct;
		driver->itemsize_dci = itemsize_dci;
		driver->poolsize_dci = poolsize_dci;
		diagmem_setsize(POOL_TYPE_COPY, itemsize, poolsize);
		diagmem_setsize(POOL_TYPE_HDLC, itemsize_hdlc, poolsize_hdlc);
		diagmem_setsize(POOL_TYPE_USER, itemsize_user, poolsize_user);
		diagmem_setsize(POOL_TYPE_USB_APPS, itemsize_usb_apps,
		poolsize_usb_apps);
		diagmem_setsize(POOL_TYPE_DCI, itemsize_dci, poolsize_dci);
		driver->num_clients = max_clients;
		driver->logging_mode = USB_MODE;
		driver->socket_process = NULL;
		@@ -2567,6 +2642,18 @@ static int __init diagchar_init(void)
		if (ret)
		goto fail;
		#ifdef CONFIG_DIAGFWD_BRIDGE_CODE
		diagmem_setsize(POOL_TYPE_MDM, itemsize_mdm, poolsize_mdm);
		diagmem_setsize(POOL_TYPE_MDM2, itemsize_mdm, poolsize_mdm);
		diagmem_setsize(POOL_TYPE_MDM_DCI, itemsize_mdm_dci, poolsize_mdm_dci);
		diagmem_setsize(POOL_TYPE_MDM2_DCI, itemsize_mdm_dci,
		poolsize_mdm_dci);
		diagmem_setsize(POOL_TYPE_MDM_USB, itemsize_mdm_usb, poolsize_mdm_usb);
		diagmem_setsize(POOL_TYPE_MDM2_USB, itemsize_mdm_usb, poolsize_mdm_usb);
		diagmem_setsize(POOL_TYPE_MDM_DCI_WRITE, itemsize_mdm_dci_write,
		poolsize_mdm_dci_write);
		diagmem_setsize(POOL_TYPE_MDM2_DCI_WRITE, itemsize_mdm_dci_write,
		poolsize_mdm_dci_write);

		ret = diagfwd_bridge_init(HSIC_DATA_CH);
		if (ret)
		goto fail;
		@@ -2633,9 +2720,7 @@ fail:
		static void diagchar_exit(void)
		{
		printk(KERN_INFO "diagchar exiting ..\n");
		/* On Driver exit, send special pool type to
		ensure no memory leaks */
		diagmem_exit(driver, POOL_TYPE_ALL);
		diag_mempool_exit();
		diagfwd_exit();
		diagfwd_cntl_exit();
		diag_dci_exit();

drivers/char/diag/diagfwd.c

+5 −5

Original line number	Diff line number	Diff line
		@@ -919,7 +919,7 @@ int diag_device_write(void buf, int data_type, struct diag_request write_ptr)
		if (data_type == APPS_DATA) {
		driver->write_ptr_svc = (struct diag_request *)
		(diagmem_alloc(driver, sizeof(struct diag_request),
		POOL_TYPE_WRITE_STRUCT));
		POOL_TYPE_USB_APPS));
		if (driver->write_ptr_svc) {
		driver->write_ptr_svc->length = driver->used;
		driver->write_ptr_svc->buf = buf;
		@@ -930,7 +930,7 @@ int diag_device_write(void buf, int data_type, struct diag_request write_ptr)
		diagmem_free(driver,
		(unsigned char *)driver->
		write_ptr_svc,
		POOL_TYPE_WRITE_STRUCT);
		POOL_TYPE_USB_APPS);
		}
		} else {
		err = -ENOMEM;
		@@ -957,7 +957,7 @@ int diag_device_write(void buf, int data_type, struct diag_request write_ptr)
		diagmem_alloc(driver,
		sizeof(struct diag_request),
		index +
		POOL_TYPE_HSIC_WRITE);
		POOL_TYPE_MDM_USB);
		if (write_ptr_mdm) {
		write_ptr_mdm->buf = buf;
		write_ptr_mdm->length =
		@@ -970,7 +970,7 @@ int diag_device_write(void buf, int data_type, struct diag_request write_ptr)
		diagmem_free(driver,
		write_ptr_mdm,
		index +
		POOL_TYPE_HSIC_WRITE);
		POOL_TYPE_MDM_USB);
		pr_err_ratelimited("diag: HSIC write failure, err: %d, ch %d\n",
		err, index);
		}
		@@ -1684,7 +1684,7 @@ int diagfwd_write_complete(struct diag_request *diag_write_ptr)
		diagmem_free(driver, (unsigned char *)buf,
		POOL_TYPE_HDLC);
		diagmem_free(driver, (unsigned char *)diag_write_ptr,
		POOL_TYPE_WRITE_STRUCT);
		POOL_TYPE_USB_APPS);
		}
		return 0;
		}