TRACE_MEM() cleanups

git-svn-id: http://svn.code.sf.net/p/scst/svn/trunk@23 d57e44dd-8a1f-0410-8b47-8ef2f437770f

qla2x00t/qla2x00-target/qla2x00t.c

@@ -53,21 +53,6 @@
 #include <scst_debug.h>
 #include <scst_debug.c>
 
-#ifndef MEMCPY
-/* Debugging to see how many memcopys/memsets happen */
-#define MEMCPY(d, s, l) do {                                    \
-                TRACE_MEM("memcpy to %p size %zd", d, (size_t)l); \
-                memcpy(d, s, l);                                \
-        } while (0)
-#endif
-
-#ifndef MEMSET
-#define MEMSET(d, c, l) do {                                    \
-                TRACE_MEM("memset of %p size %zd", d, (size_t)l); \
-                memset(d, c, l);                                \
-        } while (0)
-#endif
-
 #ifndef FC_TARGET_SUPPORT
 #error "FC_TARGET_SUPPORT is NOT DEFINED"
 #endif
@@ -217,7 +202,7 @@ static void __q2t_send_notify_ack(scsi_qla_host_t *ha,
 	if (ha->tgt != NULL)
 		ha->tgt->notify_ack_expected++;
 
-	MEMSET(ntfy, 0, sizeof(*ntfy));
+	memset(ntfy, 0, sizeof(*ntfy));
 	ntfy->entry_type = NOTIFY_ACK_TYPE;
 	ntfy->entry_count = 1;
 	SET_TARGET_ID(ha, ntfy->target, target_id);
@@ -302,7 +287,6 @@ static void q2t_free_session_done(struct scst_session *scst_sess)
 	BUG_ON(sess == NULL);
 	tgt = sess->tgt;
 
-	TRACE_MEM("kfree for sess %p (tgt %p)", sess, tgt);
 	kfree(sess);
 
 	if (tgt == NULL)
@@ -414,7 +398,6 @@ static int q2t_target_release(struct scst_tgt *scst_tgt)
 
 	scst_tgt_set_tgt_priv(scst_tgt, NULL);
 
-	TRACE_MEM("kfree for tgt %p", tgt);
 	kfree(tgt);
 
 	TRACE_EXIT_RES(res);
@@ -598,7 +581,7 @@ static void q2t_load_data_segments(struct q2t_prm *prm)
 		 * that.
 		 */
 
-		MEMSET(cont_pkt64, 0, sizeof(*cont_pkt64));
+		memset(cont_pkt64, 0, sizeof(*cont_pkt64));
 
 		cont_pkt64->entry_count = 1;
 		cont_pkt64->sys_define = 0;
@@ -665,10 +648,10 @@ static void q2t_init_ctio_ret_entry(ctio_ret_entry_t *ctio_m1,
 		ctio_m1->scsi_status |=
 				__constant_cpu_to_le16(SS_SENSE_LEN_VALID);
 		ctio_m1->sense_length = cpu_to_le16(prm->sense_buffer_len);
-		MEMCPY(ctio_m1->sense_data, prm->sense_buffer,
+		memcpy(ctio_m1->sense_data, prm->sense_buffer,
 		       prm->sense_buffer_len);
 	} else {
-		MEMSET(ctio_m1->sense_data, 0, sizeof(ctio_m1->sense_data));
+		memset(ctio_m1->sense_data, 0, sizeof(ctio_m1->sense_data));
 		ctio_m1->sense_length = 0;
 	}
 
@@ -800,7 +783,7 @@ static int q2t_xmit_response(struct scst_cmd *scst_cmd)
 				TRACE_DBG("%s", "Building additional status "
 					"packet");
 
-				MEMCPY(ctio_m1, prm.pkt, sizeof(*ctio_m1));
+				memcpy(ctio_m1, prm.pkt, sizeof(*ctio_m1));
 				ctio_m1->entry_count = 1;
 
 				/* Real finish is ctio_m1's finish */
@@ -965,7 +948,6 @@ out_unlock:
 
 static inline void q2t_free_cmd(struct q2t_cmd *cmd)
 {
-	TRACE_MEM("kfree for cmd (q2t_cmd) %p", cmd);
 	kmem_cache_free(q2t_cmd_cachep, cmd);
 }
 
@@ -1367,7 +1349,6 @@ static int q2t_send_cmd_to_scst(scsi_qla_host_t *ha, atio_entry_t *atio)
 	}
 
 	cmd =  kmem_cache_alloc(q2t_cmd_cachep, GFP_ATOMIC);
-	TRACE_MEM("kmem_cache_alloc(GFP_ATOMIC) for cmd (%zd): %p", sizeof(*cmd), cmd);
 	if (cmd == NULL) {
 		TRACE(TRACE_OUT_OF_MEM, "%s", "Allocation of cmd failed");
 		res = -ENOMEM;
@@ -1375,15 +1356,13 @@ static int q2t_send_cmd_to_scst(scsi_qla_host_t *ha, atio_entry_t *atio)
 	}
 
 	TRACE_BUFFER("ATIO Coming Up", atio, sizeof(*atio));
-	MEMSET(cmd, 0, sizeof(*cmd));
-	MEMCPY(&cmd->atio, atio, sizeof(*atio));
+	memset(cmd, 0, sizeof(*cmd));
+	memcpy(&cmd->atio, atio, sizeof(*atio));
 	cmd->state = Q2T_STATE_NEW;
 
 	sess = q2t_find_sess_by_lid(tgt, loop_id);
 	if (unlikely(sess == NULL)) {
 		sess = kzalloc(sizeof(*sess), GFP_ATOMIC);
-		TRACE_MEM("kzalloc(GFP_ATOMIC) for sess (%zd): %p",
-		      sizeof(*sess), sess);
 		if (sess == NULL) {
 			TRACE(TRACE_OUT_OF_MEM, "%s",
 			      "Allocation of sess failed");
@@ -1431,7 +1410,6 @@ out:
 	return res;
 
 out_free_sess:
-	TRACE_MEM("kfree for sess %p", sess);
 	kfree(sess);
 	smp_mb__before_atomic_dec();
 	if (atomic_dec_and_test(&tgt->sess_count))
@@ -1470,8 +1448,6 @@ static int q2t_handle_task_mgmt(scsi_qla_host_t *ha, notify_entry_t *iocb)
 	}
 
 	mcmd = kzalloc(sizeof(*mcmd), GFP_ATOMIC);
-	TRACE_MEM("kzalloc(GFP_ATOMIC) for mcmd (%zd): %p",
-		  sizeof(*mcmd), mcmd);
 	if (mcmd == NULL) {
 		TRACE(TRACE_OUT_OF_MEM, "%s", "Allocation of mgmt cmd failed");
 		res = -ENOMEM;
@@ -1535,7 +1511,6 @@ out:
 	return res;
 
 out_free:
-	TRACE_MEM("kfree for mcmd %p", mcmd);
 	kfree(mcmd);
 	goto out;
 }
@@ -1563,7 +1538,6 @@ static int q2t_abort_task(scsi_qla_host_t *ha, notify_entry_t *iocb)
 	}
 	
 	mcmd = kzalloc(sizeof(*mcmd), GFP_ATOMIC);
-	TRACE_MEM("kzalloc(GFP_ATOMIC) for mcmd (%zd): %p", sizeof(*mcmd), mcmd);
 	if (mcmd == NULL) {
 		TRACE(TRACE_OUT_OF_MEM, "%s", "Allocation of mgmt cmd failed");
 		res = -ENOMEM;
@@ -1587,7 +1561,6 @@ out:
 	return res;
 
 out_free:
-	TRACE_MEM("kfree for mcmd %p", mcmd);
 	kfree(mcmd);
 	goto out;
 }
@@ -1617,7 +1590,6 @@ static void q2t_task_mgmt_fn_done(struct scst_mgmt_cmd *scst_mcmd)
 
 	/* scst_mgmt_cmd_set_tgt_priv(scst_mcmd, NULL); */
 	scst_mcmd->tgt_priv = NULL;
-	TRACE_MEM("kfree for mcmd %p", mcmd);
 	kfree(mcmd);
 
 out:
@@ -1982,8 +1954,6 @@ static void q2t_host_action(scsi_qla_host_t *ha,
 	switch (action) {
 	case ENABLE_TARGET_MODE :
 		tgt = kzalloc(sizeof(*tgt), GFP_KERNEL);
-		TRACE_MEM("kzalloc(GFP_KERNEL) for tgt (%zd): %p",
-			  sizeof(*tgt), tgt);
 		if (tgt == NULL) {
 			TRACE(TRACE_OUT_OF_MEM, "%s",
 			      "Allocation of tgt failed");
@@ -2021,7 +1991,6 @@ static void q2t_host_action(scsi_qla_host_t *ha,
 			PRINT_ERROR("qla2x00tgt(%ld): scst_register() "
 				    "failed for host %ld(%p)", ha->instance, 
 				    ha->host_no, ha);
-			TRACE_MEM("kfree for tgt %p", tgt);
 			kfree(tgt);
 			goto out;
 		}

scst/src/dev_handlers/scst_cdrom.c

@@ -95,8 +95,6 @@ int cdrom_attach(struct scst_device *dev)
 	}
 
 	cdrom = kzalloc(sizeof(*cdrom), GFP_KERNEL);
-	TRACE_MEM("kzalloc(GFP_KERNEL) for struct cdrom_params (%zu): %p",
-	      sizeof(*cdrom), cdrom);
 	if (cdrom == NULL) {
 		TRACE(TRACE_OUT_OF_MEM, "%s",
 		      "Unable to allocate struct cdrom_params");
@@ -105,7 +103,6 @@ int cdrom_attach(struct scst_device *dev)
 	}
 
 	buffer = kzalloc(buffer_size, GFP_KERNEL);
-	TRACE_MEM("kzalloc(GFP_KERNEL) for %d: %p", buffer_size, buffer);
 	if (!buffer) {
 		TRACE(TRACE_OUT_OF_MEM, "%s", "Memory allocation failure");
 		res = -ENOMEM;
@@ -158,16 +155,13 @@ int cdrom_attach(struct scst_device *dev)
 	}
 
 out_free_buf:
-	TRACE_MEM("kfree for buffer: %p", buffer);
 	kfree(buffer);
 
 out_free_cdrom:
 	if (res == 0)
 		dev->dh_priv = cdrom;
-	else {
-		TRACE_MEM("kfree for cdrom: %p", cdrom);
+	else
 		kfree(cdrom);
-	}
 
 out:
 	TRACE_EXIT();
@@ -189,7 +183,6 @@ void cdrom_detach(struct scst_device *dev)
 
 	TRACE_ENTRY();
 
-	TRACE_MEM("kfree for cdrom: %p", cdrom);
 	kfree(cdrom);
 	dev->dh_priv = NULL;
 

scst/src/dev_handlers/scst_disk.c

@@ -171,8 +171,6 @@ int disk_attach(struct scst_device *dev)
 	}
 
 	disk = kzalloc(sizeof(*disk), GFP_KERNEL);
-	TRACE_MEM("kzalloc(GFP_KERNEL) for struct disk_params (%zu): %p",
-	      sizeof(*disk), disk);
 	if (disk == NULL) {
 		TRACE(TRACE_OUT_OF_MEM, "%s",
 		      "Unable to allocate struct disk_params");
@@ -181,7 +179,6 @@ int disk_attach(struct scst_device *dev)
 	}
 
 	buffer = kzalloc(buffer_size, GFP_KERNEL);
-	TRACE_MEM("kzalloc(GFP_KERNEL) for %d: %p", buffer_size, buffer);
 	if (!buffer) {
 		TRACE(TRACE_OUT_OF_MEM, "%s", "Memory allocation failure");
 		res = -ENOMEM;
@@ -231,16 +228,13 @@ int disk_attach(struct scst_device *dev)
 	}
 
 out_free_buf:
-	TRACE_MEM("kfree for buffer: %p", buffer);
 	kfree(buffer);
 
 out_free_disk:
 	if (res == 0)
 		dev->dh_priv = disk;
-	else {
-		TRACE_MEM("kfree for disk: %p", disk);
+	else
 		kfree(disk);
-	}
 
 out:
 	TRACE_EXIT_RES(res);
@@ -262,7 +256,6 @@ void disk_detach(struct scst_device *dev)
 
 	TRACE_ENTRY();
 
-	TRACE_MEM("kfree for disk: %p", disk);
 	kfree(disk);
 	dev->dh_priv = NULL;
 

scst/src/dev_handlers/scst_fileio.c

@@ -700,8 +700,6 @@ static int fileio_attach_tgt(struct scst_tgt_dev *tgt_dev)
 	TRACE_ENTRY();
 
 	ftgt_dev = kzalloc(sizeof(*ftgt_dev), GFP_KERNEL);
-	TRACE_MEM("kzalloc(GFP_KERNEL) for ftgt_dev (%zd): %p", 
-		sizeof(*ftgt_dev), ftgt_dev);
 	if (ftgt_dev == NULL) {
 		TRACE(TRACE_OUT_OF_MEM, "%s", "Allocation of per-session "
 			"virtual device failed");
@@ -755,7 +753,6 @@ out_free_close:
 		filp_close(ftgt_dev->fd, NULL);
 
 out_free:
-	TRACE_MEM("kfree ftgt_dev: %p", ftgt_dev);
 	kfree(ftgt_dev);
 	goto out;
 }
@@ -780,12 +777,9 @@ static void fileio_detach_tgt(struct scst_tgt_dev *tgt_dev)
 	if (ftgt_dev->fd)
 		filp_close(ftgt_dev->fd, NULL);
 
-	if (ftgt_dev->iv != NULL) {
-		TRACE_MEM("kfree ftgt_dev->iv: %p", ftgt_dev->iv);
+	if (ftgt_dev->iv != NULL)
 		kfree(ftgt_dev->iv);
-	}
 
-	TRACE_MEM("kfree ftgt_dev: %p", ftgt_dev);
 	kfree(ftgt_dev);
 
 	tgt_dev->dh_priv = NULL;
@@ -1892,13 +1886,9 @@ static struct iovec *fileio_alloc_iv(struct scst_cmd *cmd,
 	
 	iv_count = scst_get_buf_count(cmd);
 	if (iv_count > ftgt_dev->iv_count) {
-		if (ftgt_dev->iv != NULL) {
-			TRACE_MEM("kfree ftgt_dev->iv: %p", ftgt_dev->iv);
+		if (ftgt_dev->iv != NULL)
 			kfree(ftgt_dev->iv);
-		}
 		ftgt_dev->iv = kmalloc(sizeof(*ftgt_dev->iv) * iv_count, GFP_KERNEL);
-		TRACE_MEM("kmalloc(GFP_KERNEL) for iv (%zd): %p",
-		    sizeof(*ftgt_dev->iv) * iv_count, ftgt_dev->iv);
 		if (ftgt_dev->iv == NULL) {
 			PRINT_ERROR_PR("Unable to allocate iv (%d)", iv_count);
 			scst_set_busy(cmd);
@@ -2260,7 +2250,6 @@ static inline struct scst_fileio_dev *fileio_alloc_dev(void)
 {
 	struct scst_fileio_dev *dev;
 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
-	TRACE_MEM("kzalloc(GFP_KERNEL) for dev (%zd): %p", sizeof(*dev), dev);
 	if (dev == NULL) {
 		TRACE(TRACE_OUT_OF_MEM, "%s", "Allocation of virtual "
 			"device failed");
@@ -2551,8 +2540,6 @@ static int disk_fileio_proc(char *buffer, char **start, off_t offset,
 
 			len = strlen(file_name) + 1;
 			virt_dev->file_name = kmalloc(len, GFP_KERNEL);
-			TRACE_MEM("kmalloc(GFP_KERNEL) for file_name (%d): %p",
-				  len, virt_dev->file_name);
 			if (virt_dev->file_name == NULL) {
 				TRACE(TRACE_OUT_OF_MEM, "%s",
 				      "Allocation of file_name failed");
@@ -2598,9 +2585,7 @@ static int disk_fileio_proc(char *buffer, char **start, off_t offset,
 
 			list_del(&virt_dev->fileio_dev_list_entry);
 
-			TRACE_MEM("kfree for file_name: %p", virt_dev->file_name);
 			kfree(virt_dev->file_name);
-			TRACE_MEM("kfree for virt_dev: %p", virt_dev);
 			kfree(virt_dev);
 		}
 		res = length;
@@ -2615,12 +2600,9 @@ out:
 
 out_free_vpath:
 	list_del(&virt_dev->fileio_dev_list_entry);
-
-	TRACE_MEM("kfree for file_name: %p", virt_dev->file_name);
 	kfree(virt_dev->file_name);
 
 out_free_vdev:
-	TRACE_MEM("kfree for virt_dev: %p", virt_dev);
 	kfree(virt_dev);
 	goto out_up;
 }
@@ -2681,8 +2663,6 @@ static int cdrom_fileio_open(char *p, char *name)
 	if (!virt_dev->cdrom_empty) {
 		len = strlen(file_name) + 1;
 		virt_dev->file_name = kmalloc(len, GFP_KERNEL);
-		TRACE_MEM("kmalloc(GFP_KERNEL) for file_name (%d): %p",
-			  len, virt_dev->file_name);
 		if (virt_dev->file_name == NULL) {
 			TRACE(TRACE_OUT_OF_MEM, "%s",
 			      "Allocation of file_name failed");
@@ -2711,12 +2691,9 @@ out:
 
 out_free_vpath:
 	list_del(&virt_dev->fileio_dev_list_entry);
-
-	TRACE_MEM("kfree for file_name: %p", virt_dev->file_name);
 	kfree(virt_dev->file_name);
 
 out_free_vdev:
-	TRACE_MEM("kfree for virt_dev: %p", virt_dev);
 	kfree(virt_dev);
 	goto out;
 }
@@ -2749,11 +2726,8 @@ static int cdrom_fileio_close(char *name)
 
 	list_del(&virt_dev->fileio_dev_list_entry);
 
-	if (virt_dev->file_name) {
-		TRACE_MEM("kfree for file_name: %p", virt_dev->file_name);
+	if (virt_dev->file_name)
 		kfree(virt_dev->file_name);
-	}
-	TRACE_MEM("kfree for virt_dev: %p", virt_dev);
 	kfree(virt_dev);
 
 out:
@@ -2810,8 +2784,6 @@ static int cdrom_fileio_change(char *p, char *name)
 	if (!virt_dev->cdrom_empty) {
 		len = strlen(file_name) + 1;
 		fn = kmalloc(len, GFP_KERNEL);
-		TRACE_MEM("kmalloc(GFP_KERNEL) for file_name (%d): %p",
-			len, fn);
 		if (fn == NULL) {
 			TRACE(TRACE_OUT_OF_MEM, "%s",
 				"Allocation of file_name failed");
@@ -2908,10 +2880,8 @@ static int cdrom_fileio_change(char *p, char *name)
 			virt_dev->name);
 	}
 
-	if (old_fn) {
-		TRACE_MEM("kfree for old_fn: %p", old_fn);
+	if (old_fn)
 		kfree(old_fn);
-	}
 
 out_resume:
 	scst_resume_activity();
@@ -2921,19 +2891,16 @@ out:
 
 out_free:
 	virt_dev->file_name = old_fn;
-	TRACE_MEM("kfree for fn: %p", fn);
 	kfree(fn);
 	goto out;
 
 out_free_resume:
 	virt_dev->file_name = old_fn;
-	TRACE_MEM("kfree for fn: %p", fn);
 	kfree(fn);
 	goto out_resume;
 
 out_err_resume:
 	virt_dev->file_name = old_fn;
-	TRACE_MEM("kfree for fn: %p", fn);
 	kfree(fn);
 	scst_resume_activity();
 	cdrom_fileio_close(name);
@@ -3161,9 +3128,7 @@ static void __exit exit_scst_fileio(struct scst_dev_type *devtype,
 
 		PRINT_INFO_PR("Virtual device %s unregistered", virt_dev->name);
 		TRACE_DBG("virt_id %d", virt_dev->virt_id);
-		TRACE_MEM("kfree for file_name: %p", virt_dev->file_name);
 		kfree(virt_dev->file_name);
-		TRACE_MEM("kfree for virt_dev: %p", virt_dev);
 		kfree(virt_dev);
 	}
 	up(&scst_fileio_mutex);

scst/src/dev_handlers/scst_modisk.c

@@ -171,8 +171,6 @@ int modisk_attach(struct scst_device *dev)
 	}
 
 	modisk = kzalloc(sizeof(*modisk), GFP_KERNEL);
-	TRACE_MEM("kzalloc(GFP_KERNEL) for struct modisk_params (%zu): %p",
-	      sizeof(*modisk), modisk);
 	if (modisk == NULL) {
 		TRACE(TRACE_OUT_OF_MEM, "%s",
 		      "Unable to allocate struct modisk_params");
@@ -193,7 +191,6 @@ int modisk_attach(struct scst_device *dev)
 	}
 
 	buffer = kzalloc(buffer_size, GFP_KERNEL);
-	TRACE_MEM("kzalloc(GFP_KERNEL) for %d: %p", buffer_size, buffer);
 	if (!buffer) {
 		TRACE(TRACE_OUT_OF_MEM, "%s", "Memory allocation failure");
 		res = -ENOMEM;
@@ -245,16 +242,13 @@ int modisk_attach(struct scst_device *dev)
 	}
 
 out_free_buf:
-	TRACE_MEM("kfree for buffer: %p", buffer);
 	kfree(buffer);
 
 out_free_modisk:
 	if (res == 0)
 		dev->dh_priv = modisk;
-	else {
-		TRACE_MEM("kfree for modisk: %p", modisk);
+	else
 		kfree(modisk);
-	}
 
 out:
 	TRACE_EXIT_RES(res);
@@ -276,7 +270,6 @@ void modisk_detach(struct scst_device *dev)
 
 	TRACE_ENTRY();
 
-	TRACE_MEM("kfree for modisk: %p", modisk);
 	kfree(modisk);
 	dev->dh_priv = NULL;
 

scst/src/dev_handlers/scst_tape.c

@@ -181,8 +181,6 @@ int tape_attach(struct scst_device *dev)
 	}
 
 	tape = kzalloc(sizeof(*tape), GFP_KERNEL);
-	TRACE_MEM("kzalloc(GFP_KERNEL) for struct tape_params (%zu): %p",
-	      sizeof(*tape), tape);
 	if (tape == NULL) {
 		TRACE(TRACE_OUT_OF_MEM, "%s",
 		      "Unable to allocate struct tape_params");
@@ -192,7 +190,6 @@ int tape_attach(struct scst_device *dev)
 	spin_lock_init(&tape->tp_lock);
 
 	buffer = kmalloc(buffer_size, GFP_KERNEL);
-	TRACE_MEM("kmalloc(GFP_KERNEL) for %d: %p", buffer_size, buffer);
 	if (!buffer) {
 		TRACE(TRACE_OUT_OF_MEM, "%s", "Memory allocation failure");
 		res = -ENOMEM;
@@ -243,16 +240,13 @@ int tape_attach(struct scst_device *dev)
 	}
 
 out_free_buf:
-	TRACE_MEM("kfree for buffer: %p", buffer);
 	kfree(buffer);
 
 out_free_req:
 	if (res == 0)
 		dev->dh_priv = tape;
-	else {
-		TRACE_MEM("kfree for tape: %p", tape);
+	else
 		kfree(tape);
-	}
 
 out:
 	TRACE_EXIT_RES(res);
@@ -274,7 +268,6 @@ void tape_detach(struct scst_device *dev)
 
 	TRACE_ENTRY();
 
-	TRACE_MEM("kfree for tape: %p", tape);
 	kfree(tape);
 	dev->dh_priv = NULL;
 

scst/src/scst.c

@@ -238,8 +238,6 @@ struct scst_tgt *scst_register(struct scst_tgt_template *vtt)
 	TRACE_ENTRY();
 
 	tgt = kzalloc(sizeof(*tgt), GFP_KERNEL);
-	TRACE_MEM("kzalloc(GFP_KERNEL) for tgt (%zd): %p",
-	      sizeof(*tgt), tgt);
 	if (tgt == NULL) {
 		TRACE(TRACE_OUT_OF_MEM, "%s", "kzalloc() failed");
 		goto out;
@@ -272,7 +270,6 @@ out:
 	return tgt;
 
 out_free:
-	TRACE_MEM("kfree() for tgt %p", tgt);
 	kfree(tgt);
 	goto out;
 }
@@ -314,7 +311,6 @@ void scst_unregister(struct scst_tgt *tgt)
 
 	del_timer_sync(&tgt->retry_timer);
 
-	TRACE_MEM("kfree for tgt: %p", tgt);
 	kfree(tgt);
 
 	TRACE_EXIT();

scst/src/scst_lib.c

@@ -150,7 +150,6 @@ struct scst_device *scst_alloc_device(int gfp_mask)
 	TRACE_ENTRY();
 
 	dev = kzalloc(sizeof(*dev), gfp_mask);
-	TRACE_MEM("kzalloc() for dev (%zd): %p", sizeof(*dev), dev);
 	if (dev == NULL) {
 		TRACE(TRACE_OUT_OF_MEM, "%s",
 		      "Allocation of scst_device failed");
@@ -185,7 +184,6 @@ void scst_free_device(struct scst_device *dev)
 	}
 #endif
 
-	TRACE_MEM("kfree for dev: %p", dev);
 	kfree(dev);
 
 	TRACE_EXIT();
@@ -200,7 +198,6 @@ struct scst_acg_dev *scst_alloc_acg_dev(struct scst_acg *acg,
 	TRACE_ENTRY();
 	
 	res = kmem_cache_alloc(scst_acgd_cachep, GFP_KERNEL);
-	TRACE_MEM("kmem_cache_alloc() for acg_dev (%zd): %p", sizeof(*res), res);
 	if (res == NULL) {
 		TRACE(TRACE_OUT_OF_MEM, "%s", "Allocation of scst_acg_dev failed");
 		goto out;
@@ -226,7 +223,6 @@ void scst_free_acg_dev(struct scst_acg_dev *acg_dev)
 	list_del(&acg_dev->acg_dev_list_entry);
 	list_del(&acg_dev->dev_acg_dev_list_entry);
 	
-	TRACE_MEM("kfree for acg_dev: %p", acg_dev);
 	kmem_cache_free(scst_acgd_cachep, acg_dev);
 	
 	TRACE_EXIT();
@@ -241,7 +237,6 @@ struct scst_acg *scst_alloc_add_acg(const char *acg_name)
 	TRACE_ENTRY();
 
 	acg = kzalloc(sizeof(*acg), GFP_KERNEL);
-	TRACE_MEM("kzalloc() for acg (%zd): %p", sizeof(*acg), acg);
 	if (acg == NULL) {
 		TRACE(TRACE_OUT_OF_MEM, "%s", "Allocation of acg failed");
 		goto out;
@@ -302,16 +297,12 @@ int scst_destroy_acg(struct scst_acg *acg)
 		acn_list_entry)
 	{
 		list_del(&n->acn_list_entry);
-		TRACE_MEM("kfree() for scst_acn->name: %p", n->name);
 		kfree(n->name);
-		TRACE_MEM("kfree() for scst_acn: %p", n);
 		kfree(n);
 	}
 	INIT_LIST_HEAD(&acg->acn_list);
 
-	TRACE_MEM("kfree for acg: %p", acg);
 	kfree(acg);
-
 out:
 	TRACE_EXIT_RES(res);
 	return res;
@@ -331,8 +322,6 @@ static struct scst_tgt_dev *scst_alloc_add_tgt_dev(struct scst_session *sess,
 	TRACE_ENTRY();
 
 	tgt_dev = kmem_cache_alloc(scst_tgtd_cachep, GFP_KERNEL);
-	TRACE_MEM("kmem_cache_alloc(GFP_KERNEL) for tgt_dev (%zd): %p",
-	      sizeof(*tgt_dev), tgt_dev);
 	if (tgt_dev != NULL)
 		memset(tgt_dev, 0, sizeof(*tgt_dev));
 	else {
@@ -394,7 +383,6 @@ out:
 	return tgt_dev;
 
 out_free:
-	TRACE_MEM("kfree for tgt_dev: %p", tgt_dev);
 	kmem_cache_free(scst_tgtd_cachep, tgt_dev);
 	tgt_dev = NULL;
 	goto out;
@@ -463,7 +451,6 @@ static void scst_free_tgt_dev(struct scst_tgt_dev *tgt_dev)
 		TRACE_DBG("%s", "Dev handler's detach_tgt() returned");
 	}
 
-	TRACE_MEM("kfree for tgt_dev: %p", tgt_dev);
 	kmem_cache_free(scst_tgtd_cachep, tgt_dev);
 
 	TRACE_EXIT();
@@ -649,7 +636,6 @@ int scst_acg_add_name(struct scst_acg *acg, const char *name)
 	}
 	
 	n = kmalloc(sizeof(*n), GFP_KERNEL);
-	TRACE_MEM("kmalloc(GFP_KERNEL) for scst_acn (%zd): %p", sizeof(*n), n);
 	if (n == NULL) {
 		PRINT_ERROR_PR("%s", "Unable to allocate scst_acn");
 		res = -ENOMEM;
@@ -658,8 +644,6 @@ int scst_acg_add_name(struct scst_acg *acg, const char *name)
 	
 	len = strlen(name);
 	nm = kmalloc(len + 1, GFP_KERNEL);
-	TRACE_MEM("kmalloc(GFP_KERNEL) for scst_acn->name (%d): %p",
-		  len + 1, nm);
 	if (nm == NULL) {
 		PRINT_ERROR_PR("%s", "Unable to allocate scst_acn->name");
 		res = -ENOMEM;
@@ -676,7 +660,6 @@ out:
 	return res;
 
 out_free:
-	TRACE_MEM("kfree() for scst_acn: %p", n);
 	kfree(n);
 	goto out;
 }
@@ -693,9 +676,7 @@ int scst_acg_remove_name(struct scst_acg *acg, const char *name)
 	{
 		if (strcmp(n->name, name) == 0) {
 			list_del(&n->acn_list_entry);
-			TRACE_MEM("kfree() for scst_acn->name: %p", n->name);
 		        kfree(n->name);
-			TRACE_MEM("kfree() for scst_acn: %p", n);
 		        kfree(n);
 			res = 0;
 			break;
@@ -720,11 +701,8 @@ static void scst_req_done(struct scsi_cmnd *scsi_cmd)
 
 	if (scsi_cmd && (req = scsi_cmd->sc_request)) {
 		if (req) {
-			if (req->sr_bufflen) {
-				TRACE_MEM("kfree for req->sr_buffer: %p",
-				      req->sr_buffer);
+			if (req->sr_bufflen)
 				kfree(req->sr_buffer);
-			}
 			scsi_release_request(req);
 		}
 	}
@@ -823,7 +801,6 @@ struct scst_session *scst_alloc_session(struct scst_tgt *tgt, int gfp_mask,
 	TRACE_ENTRY();
 
 	sess = kmem_cache_alloc(scst_sess_cachep, gfp_mask);
-	TRACE_MEM("kmem_cache_alloc() for sess (%zd): %p", sizeof(*sess), sess);
 	if (sess != NULL)
 		memset(sess, 0, sizeof(*sess));
 	else {
@@ -842,8 +819,6 @@ struct scst_session *scst_alloc_session(struct scst_tgt *tgt, int gfp_mask,
 	
 	len = strlen(initiator_name);
 	nm = kmalloc(len + 1, gfp_mask);
-	TRACE_MEM("kmalloc(GFP_KERNEL) for sess->initiator_name (%d): %p",
-		  len + 1, nm);
 	if (nm == NULL) {
 		PRINT_ERROR_PR("%s", "Unable to allocate sess->initiator_name");
 		goto out_free;
@@ -857,7 +832,6 @@ out:
 	return sess;
 
 out_free:
-	TRACE_MEM("kfree() for sess: %p", sess);
 	kmem_cache_free(scst_sess_cachep, sess);
 	sess = NULL;
 	goto out;
@@ -881,10 +855,7 @@ void scst_free_session(struct scst_session *sess)
 
 	up(&scst_mutex);
 
-	TRACE_MEM("kfree for sess->initiator_name: %p", sess->initiator_name);
 	kfree(sess->initiator_name);
-
-	TRACE_MEM("kfree for sess: %p", sess);
 	kmem_cache_free(scst_sess_cachep, sess);
 
 	TRACE_EXIT();
@@ -939,7 +910,6 @@ struct scst_cmd *scst_alloc_cmd(int gfp_mask)
 	TRACE_ENTRY();
 
 	cmd = kmem_cache_alloc(scst_cmd_cachep, gfp_mask);
-	TRACE_MEM("kmem_cache_alloc() for cmd (%zd): %p", sizeof(*cmd), cmd);
 	if (cmd != NULL)
 		memset(cmd, 0, sizeof(*cmd));
 	else {
@@ -1112,8 +1082,6 @@ struct scst_mgmt_cmd *scst_alloc_mgmt_cmd(int gfp_mask)
 	TRACE_ENTRY();
 
 	mcmd = mempool_alloc(scst_mgmt_mempool, gfp_mask);
-	TRACE_MEM("mempool_alloc() for mgmt cmd (%zd): %p", sizeof(*mcmd),
-		mcmd);
 	if (mcmd == NULL) {
 		PRINT_ERROR("%s", "Allocation of management command "
 			"failed, some commands and their data could leak");
@@ -1143,7 +1111,6 @@ void scst_free_mgmt_cmd(struct scst_mgmt_cmd *mcmd, int del)
 	if (mcmd->mcmd_tgt_dev != NULL)
 		scst_dec_cmd_count();
 
-	TRACE_MEM("mempool_free for mgmt cmd: %p", mcmd);
 	mempool_free(mcmd, scst_mgmt_mempool);
 
 	TRACE_EXIT();
@@ -1755,8 +1722,6 @@ int scst_set_pending_UA(struct scst_cmd *cmd)
 
 	list_del(&UA_entry->UA_list_entry);
 
-
-	TRACE_MEM("mempool_free for UA_entry: %p", UA_entry);
 	mempool_free(UA_entry, scst_ua_mempool);
 
 	if (list_empty(&cmd->tgt_dev->UA_list)) {
@@ -1784,8 +1749,6 @@ void scst_alloc_set_UA(struct scst_tgt_dev *tgt_dev,
 	TRACE_ENTRY();
 
 	UA_entry = mempool_alloc(scst_ua_mempool, GFP_ATOMIC);
-	TRACE_MEM("mempool_alloc(GFP_ATOMIC) for UA_entry (%zd): %p",
-		sizeof(*UA_entry), UA_entry);
 	if (UA_entry == NULL) {
 		PRINT_ERROR_PR("%s", "UNIT ATTENTION memory "
 		     "allocation failed. The UNIT ATTENTION "
@@ -1876,7 +1839,6 @@ void scst_free_all_UA(struct scst_tgt_dev *tgt_dev)
 		TRACE_MGMT_DBG("Clearing UA for tgt_dev lun %d", 
 			tgt_dev->acg_dev->lun);
 		list_del(&UA_entry->UA_list_entry);
-		TRACE_MEM("kfree for UA_entry: %p", UA_entry);
 		kfree(UA_entry);
 	}
 	INIT_LIST_HEAD(&tgt_dev->UA_list);

scst/src/scst_priv.h

@@ -251,7 +251,6 @@ struct scst_cmd *scst_alloc_cmd(int gfp_mask);
 void scst_free_cmd(struct scst_cmd *cmd);
 static inline void scst_destroy_cmd(struct scst_cmd *cmd)
 {
-	TRACE_MEM("kfree for cmd: %p", cmd);
 	kmem_cache_free(scst_cmd_cachep, cmd);
 	return;
 }

scst/src/scst_proc.c

@@ -619,7 +619,6 @@ static int scst_proc_group_add(const char *p)
 	TRACE_ENTRY();
 
 	name = kmalloc(len, GFP_KERNEL);
-	TRACE_MEM("kmalloc() for acg_dev (%d): %p", len, name);
 	if (name == NULL) {
 		TRACE(TRACE_OUT_OF_MEM, "%s", "Allocation of name failed");
 		goto out_nomem;
@@ -644,7 +643,6 @@ out_free_acg:
 	scst_proc_del_free_acg(acg, 0);
 
 out_free:
-	TRACE_MEM("kfree for name: %p", name);
 	kfree(name);
 
 out_nomem:
@@ -666,7 +664,6 @@ static int scst_proc_del_free_acg(struct scst_acg *acg, int remove_proc)
 		if (res == 0) {
 			if (remove_proc)
 				scst_proc_del_acg_tree(acg_proc_root, name);
-			TRACE_MEM("kfree for name: %p", name);
 			kfree(name);
 		}
 	}
@@ -2231,9 +2228,7 @@ static int scst_proc_groups_names_write(struct file *file, const char *buf,
 		list_for_each_entry_safe(n, nn, &acg->acn_list, 
 					 acn_list_entry) {
 			list_del(&n->acn_list_entry);
-			TRACE_MEM("kfree() for scst_acn->name: %p", n->name);
 			kfree(n->name);
-			TRACE_MEM("kfree() for scst_acn: %p", n);
 			kfree(n);
 		}
 		break;