TRACE_MEM() cleanups
authorvlnb <vlnb@d57e44dd-8a1f-0410-8b47-8ef2f437770f>
Thu, 2 Nov 2006 11:20:46 +0000 (11:20 +0000)
committervlnb <vlnb@d57e44dd-8a1f-0410-8b47-8ef2f437770f>
Thu, 2 Nov 2006 11:20:46 +0000 (11:20 +0000)
git-svn-id: https://scst.svn.sourceforge.net/svnroot/scst/trunk@23 d57e44dd-8a1f-0410-8b47-8ef2f437770f

qla2x00t/qla2x00-target/qla2x00t.c
scst/src/dev_handlers/scst_cdrom.c
scst/src/dev_handlers/scst_disk.c
scst/src/dev_handlers/scst_fileio.c
scst/src/dev_handlers/scst_modisk.c
scst/src/dev_handlers/scst_tape.c
scst/src/scst.c
scst/src/scst_lib.c
scst/src/scst_priv.h
scst/src/scst_proc.c

index b6dbebb..773b23b 100644 (file)
 #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;
                }
index bf3f989..d0f84af 100644 (file)
@@ -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;
 
index 090ec10..3f173f1 100644 (file)
@@ -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;
 
index f948c71..f5388e1 100644 (file)
@@ -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);
index 40fc637..be46264 100644 (file)
@@ -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;
 
index 48ab98f..9ea1d2c 100644 (file)
@@ -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;
 
index 55f191d..ec4699d 100644 (file)
@@ -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();
index 8bf9088..43497c3 100644 (file)
@@ -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);
index 01b544d..224a261 100644 (file)
@@ -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;
 }
index d068c94..8ada240 100644 (file)
@@ -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;