[SCSI] Remove ->pid field from scsi_cmnd

The pid field is a duplicate of the serial_number field and has been
scheduled for removal for a long time.  A few drivers were still using
it, so just change them to use serial_number instead.

Signed-off-by: Matthew Wilcox <willy@linux.intel.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>

1 files changed, 55 insertions, 55 deletions

diff --git a/drivers/scsi/dc395x.c b/drivers/scsi/dc395x.c
index 7b8a3457b696..1591824cf4b3 100644
--- a/drivers/scsi/dc395x.c
+++ b/drivers/scsi/dc395x.c
@@ -778,7 +778,7 @@ static void srb_waiting_insert(struct DeviceCtlBlk *dcb,
                 struct ScsiReqBlk *srb)
 {
         dprintkdbg(DBG_0, "srb_waiting_insert: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->pid, dcb->target_id, dcb->target_lun, srb);
+                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
         list_add(&srb->list, &dcb->srb_waiting_list);
 }
 
@@ -787,7 +787,7 @@ static void srb_waiting_append(struct DeviceCtlBlk *dcb,
                 struct ScsiReqBlk *srb)
 {
         dprintkdbg(DBG_0, "srb_waiting_append: (pid#%li) <%02i-%i> srb=%p\n",
-                 srb->cmd->pid, dcb->target_id, dcb->target_lun, srb);
+                 srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
         list_add_tail(&srb->list, &dcb->srb_waiting_list);
 }
 
@@ -795,7 +795,7 @@ static void srb_waiting_append(struct DeviceCtlBlk *dcb,
 static void srb_going_append(struct DeviceCtlBlk *dcb, struct ScsiReqBlk *srb)
 {
         dprintkdbg(DBG_0, "srb_going_append: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->pid, dcb->target_id, dcb->target_lun, srb);
+                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
         list_add_tail(&srb->list, &dcb->srb_going_list);
 }
 
@@ -805,7 +805,7 @@ static void srb_going_remove(struct DeviceCtlBlk *dcb, struct ScsiReqBlk *srb)
         struct ScsiReqBlk *i;
         struct ScsiReqBlk *tmp;
         dprintkdbg(DBG_0, "srb_going_remove: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->pid, dcb->target_id, dcb->target_lun, srb);
+                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
 
         list_for_each_entry_safe(i, tmp, &dcb->srb_going_list, list)
                 if (i == srb) {
@@ -821,7 +821,7 @@ static void srb_waiting_remove(struct DeviceCtlBlk *dcb,
         struct ScsiReqBlk *i;
         struct ScsiReqBlk *tmp;
         dprintkdbg(DBG_0, "srb_waiting_remove: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->pid, dcb->target_id, dcb->target_lun, srb);
+                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
 
         list_for_each_entry_safe(i, tmp, &dcb->srb_waiting_list, list)
                 if (i == srb) {
@@ -836,7 +836,7 @@ static void srb_going_to_waiting_move(struct DeviceCtlBlk *dcb,
 {
         dprintkdbg(DBG_0,
                 "srb_going_to_waiting_move: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->pid, dcb->target_id, dcb->target_lun, srb);
+                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
         list_move(&srb->list, &dcb->srb_waiting_list);
 }
 
@@ -846,7 +846,7 @@ static void srb_waiting_to_going_move(struct DeviceCtlBlk *dcb,
 {
         dprintkdbg(DBG_0,
                 "srb_waiting_to_going_move: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->pid, dcb->target_id, dcb->target_lun, srb);
+                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
         list_move(&srb->list, &dcb->srb_going_list);
 }
 
@@ -982,7 +982,7 @@ static void build_srb(struct scsi_cmnd *cmd, struct DeviceCtlBlk *dcb,
         int nseg;
         enum dma_data_direction dir = cmd->sc_data_direction;
         dprintkdbg(DBG_0, "build_srb: (pid#%li) <%02i-%i>\n",
-                cmd->pid, dcb->target_id, dcb->target_lun);
+                cmd->serial_number, dcb->target_id, dcb->target_lun);
 
         srb->dcb = dcb;
         srb->cmd = cmd;
@@ -1086,7 +1086,7 @@ static int dc395x_queue_command(struct scsi_cmnd *cmd, void (*done)(struct scsi_
         struct AdapterCtlBlk *acb =
             (struct AdapterCtlBlk *)cmd->device->host->hostdata;
         dprintkdbg(DBG_0, "queue_command: (pid#%li) <%02i-%i> cmnd=0x%02x\n",
-                cmd->pid, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
+                cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
 
         /* Assume BAD_TARGET; will be cleared later */
         cmd->result = DID_BAD_TARGET << 16;
@@ -1139,7 +1139,7 @@ static int dc395x_queue_command(struct scsi_cmnd *cmd, void (*done)(struct scsi_
                 /* process immediately */
                 send_srb(acb, srb);
         }
-        dprintkdbg(DBG_1, "queue_command: (pid#%li) done\n", cmd->pid);
+        dprintkdbg(DBG_1, "queue_command: (pid#%li) done\n", cmd->serial_number);
         return 0;
 
 complete:
@@ -1203,7 +1203,7 @@ static void dump_register_info(struct AdapterCtlBlk *acb,
                 else
                         dprintkl(KERN_INFO, "dump: srb=%p cmd=%p (pid#%li) "
                                  "cmnd=0x%02x <%02i-%i>\n",
-                                srb, srb->cmd, srb->cmd->pid,
+                                srb, srb->cmd, srb->cmd->serial_number,
                                 srb->cmd->cmnd[0], srb->cmd->device->id,
                                 srb->cmd->device->lun);
                 printk("  sglist=%p cnt=%i idx=%i len=%zu\n",
@@ -1300,7 +1300,7 @@ static int __dc395x_eh_bus_reset(struct scsi_cmnd *cmd)
                 (struct AdapterCtlBlk *)cmd->device->host->hostdata;
         dprintkl(KERN_INFO,
                 "eh_bus_reset: (pid#%li) target=<%02i-%i> cmd=%p\n",
-                cmd->pid, cmd->device->id, cmd->device->lun, cmd);
+                cmd->serial_number, cmd->device->id, cmd->device->lun, cmd);
 
         if (timer_pending(&acb->waiting_timer))
                 del_timer(&acb->waiting_timer);
@@ -1367,7 +1367,7 @@ static int dc395x_eh_abort(struct scsi_cmnd *cmd)
         struct DeviceCtlBlk *dcb;
         struct ScsiReqBlk *srb;
         dprintkl(KERN_INFO, "eh_abort: (pid#%li) target=<%02i-%i> cmd=%p\n",
-                cmd->pid, cmd->device->id, cmd->device->lun, cmd);
+                cmd->serial_number, cmd->device->id, cmd->device->lun, cmd);
 
         dcb = find_dcb(acb, cmd->device->id, cmd->device->lun);
         if (!dcb) {
@@ -1494,7 +1494,7 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
         u8 s_stat, scsicommand, i, identify_message;
         u8 *ptr;
         dprintkdbg(DBG_0, "start_scsi: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->pid, dcb->target_id, dcb->target_lun, srb);
+                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
 
         srb->tag_number = TAG_NONE;     /* acb->tag_max_num: had error read in eeprom */
 
@@ -1504,7 +1504,7 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
 #if 1
         if (s_stat & 0x20 /* s_stat2 & 0x02000 */ ) {
                 dprintkdbg(DBG_KG, "start_scsi: (pid#%li) BUSY %02x %04x\n",
-                        srb->cmd->pid, s_stat, s_stat2);
+                        srb->cmd->serial_number, s_stat, s_stat2);
                 /*
                  * Try anyway?
                  *
@@ -1522,14 +1522,14 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
         if (acb->active_dcb) {
                 dprintkl(KERN_DEBUG, "start_scsi: (pid#%li) Attempt to start a"
                         "command while another command (pid#%li) is active.",
-                        srb->cmd->pid,
+                        srb->cmd->serial_number,
                         acb->active_dcb->active_srb ?
-                            acb->active_dcb->active_srb->cmd->pid : 0);
+                            acb->active_dcb->active_srb->cmd->serial_number : 0);
                 return 1;
         }
         if (DC395x_read16(acb, TRM_S1040_SCSI_STATUS) & SCSIINTERRUPT) {
                 dprintkdbg(DBG_KG, "start_scsi: (pid#%li) Failed (busy)\n",
-                        srb->cmd->pid);
+                        srb->cmd->serial_number);
                 return 1;
         }
         /* Allow starting of SCSI commands half a second before we allow the mid-level
@@ -1603,7 +1603,7 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
                 if (tag_number >= dcb->max_command) {
                         dprintkl(KERN_WARNING, "start_scsi: (pid#%li) "
                                 "Out of tags target=<%02i-%i>)\n",
-                                srb->cmd->pid, srb->cmd->device->id,
+                                srb->cmd->serial_number, srb->cmd->device->id,
                                 srb->cmd->device->lun);
                         srb->state = SRB_READY;
                         DC395x_write16(acb, TRM_S1040_SCSI_CONTROL,
@@ -1622,7 +1622,7 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
 /*polling:*/
         /* Send CDB ..command block ......... */
         dprintkdbg(DBG_KG, "start_scsi: (pid#%li) <%02i-%i> cmnd=0x%02x tag=%i\n",
-                srb->cmd->pid, srb->cmd->device->id, srb->cmd->device->lun,
+                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun,
                 srb->cmd->cmnd[0], srb->tag_number);
         if (srb->flag & AUTO_REQSENSE) {
                 DC395x_write8(acb, TRM_S1040_SCSI_FIFO, REQUEST_SENSE);
@@ -1647,7 +1647,7 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
                  * : Let's process it first!
                  */
                 dprintkdbg(DBG_0, "start_scsi: (pid#%li) <%02i-%i> Failed - busy\n",
-                        srb->cmd->pid, dcb->target_id, dcb->target_lun);
+                        srb->cmd->serial_number, dcb->target_id, dcb->target_lun);
                 srb->state = SRB_READY;
                 free_tag(dcb, srb);
                 srb->msg_count = 0;
@@ -1842,7 +1842,7 @@ static irqreturn_t dc395x_interrupt(int irq, void *dev_id)
 static void msgout_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "msgout_phase0: (pid#%li)\n", srb->cmd->pid);
+        dprintkdbg(DBG_0, "msgout_phase0: (pid#%li)\n", srb->cmd->serial_number);
         if (srb->state & (SRB_UNEXPECT_RESEL + SRB_ABORT_SENT))
                 *pscsi_status = PH_BUS_FREE;    /*.. initial phase */
 
@@ -1856,18 +1856,18 @@ static void msgout_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 {
         u16 i;
         u8 *ptr;
-        dprintkdbg(DBG_0, "msgout_phase1: (pid#%li)\n", srb->cmd->pid);
+        dprintkdbg(DBG_0, "msgout_phase1: (pid#%li)\n", srb->cmd->serial_number);
 
         clear_fifo(acb, "msgout_phase1");
         if (!(srb->state & SRB_MSGOUT)) {
                 srb->state |= SRB_MSGOUT;
                 dprintkl(KERN_DEBUG,
                         "msgout_phase1: (pid#%li) Phase unexpected\n",
-                        srb->cmd->pid); /* So what ? */
+                        srb->cmd->serial_number);       /* So what ? */
         }
         if (!srb->msg_count) {
                 dprintkdbg(DBG_0, "msgout_phase1: (pid#%li) NOP msg\n",
-                        srb->cmd->pid);
+                        srb->cmd->serial_number);
                 DC395x_write8(acb, TRM_S1040_SCSI_FIFO, MSG_NOP);
                 DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH);      /* it's important for atn stop */
                 DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, SCMD_FIFO_OUT);
@@ -1887,7 +1887,7 @@ static void msgout_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 static void command_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "command_phase0: (pid#%li)\n", srb->cmd->pid);
+        dprintkdbg(DBG_0, "command_phase0: (pid#%li)\n", srb->cmd->serial_number);
         DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH);
 }
 
@@ -1898,7 +1898,7 @@ static void command_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
         struct DeviceCtlBlk *dcb;
         u8 *ptr;
         u16 i;
-        dprintkdbg(DBG_0, "command_phase1: (pid#%li)\n", srb->cmd->pid);
+        dprintkdbg(DBG_0, "command_phase1: (pid#%li)\n", srb->cmd->serial_number);
 
         clear_fifo(acb, "command_phase1");
         DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_CLRATN);
@@ -2042,7 +2042,7 @@ static void data_out_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
         u16 scsi_status = *pscsi_status;
         u32 d_left_counter = 0;
         dprintkdbg(DBG_0, "data_out_phase0: (pid#%li) <%02i-%i>\n",
-                srb->cmd->pid, srb->cmd->device->id, srb->cmd->device->lun);
+                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
 
         /*
          * KG: We need to drain the buffers before we draw any conclusions!
@@ -2172,7 +2172,7 @@ static void data_out_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
         dprintkdbg(DBG_0, "data_out_phase1: (pid#%li) <%02i-%i>\n",
-                srb->cmd->pid, srb->cmd->device->id, srb->cmd->device->lun);
+                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
         clear_fifo(acb, "data_out_phase1");
         /* do prepare before transfer when data out phase */
         data_io_transfer(acb, srb, XFERDATAOUT);
@@ -2184,7 +2184,7 @@ static void data_in_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
         u16 scsi_status = *pscsi_status;
 
         dprintkdbg(DBG_0, "data_in_phase0: (pid#%li) <%02i-%i>\n",
-                srb->cmd->pid, srb->cmd->device->id, srb->cmd->device->lun);
+                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
 
         /*
          * KG: DataIn is much more tricky than DataOut. When the device is finished
@@ -2205,7 +2205,7 @@ static void data_in_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 
                 if (scsi_status & PARITYERROR) {
                         dprintkl(KERN_INFO, "data_in_phase0: (pid#%li) "
-                                "Parity Error\n", srb->cmd->pid);
+                                "Parity Error\n", srb->cmd->serial_number);
                         srb->status |= PARITY_ERROR;
                 }
                 /*
@@ -2395,7 +2395,7 @@ static void data_in_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
         dprintkdbg(DBG_0, "data_in_phase1: (pid#%li) <%02i-%i>\n",
-                srb->cmd->pid, srb->cmd->device->id, srb->cmd->device->lun);
+                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
         data_io_transfer(acb, srb, XFERDATAIN);
 }
 
@@ -2407,7 +2407,7 @@ static void data_io_transfer(struct AdapterCtlBlk *acb,
         u8 bval;
         dprintkdbg(DBG_0,
                 "data_io_transfer: (pid#%li) <%02i-%i> %c len=%i, sg=(%i/%i)\n",
-                srb->cmd->pid, srb->cmd->device->id, srb->cmd->device->lun,
+                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun,
                 ((io_dir & DMACMD_DIR) ? 'r' : 'w'),
                 srb->total_xfer_length, srb->sg_index, srb->sg_count);
         if (srb == acb->tmp_srb)
@@ -2580,7 +2580,7 @@ static void status_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
         dprintkdbg(DBG_0, "status_phase0: (pid#%li) <%02i-%i>\n",
-                srb->cmd->pid, srb->cmd->device->id, srb->cmd->device->lun);
+                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
         srb->target_status = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
         srb->end_message = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);      /* get message */
         srb->state = SRB_COMPLETED;
@@ -2594,7 +2594,7 @@ static void status_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
         dprintkdbg(DBG_0, "status_phase1: (pid#%li) <%02i-%i>\n",
-                srb->cmd->pid, srb->cmd->device->id, srb->cmd->device->lun);
+                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
         srb->state = SRB_STATUS;
         DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH);      /* it's important for atn stop */
         DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, SCMD_COMP);
@@ -2636,7 +2636,7 @@ static struct ScsiReqBlk *msgin_qtag(struct AdapterCtlBlk *acb,
         struct ScsiReqBlk *srb = NULL;
         struct ScsiReqBlk *i;
         dprintkdbg(DBG_0, "msgin_qtag: (pid#%li) tag=%i srb=%p\n",
-                   srb->cmd->pid, tag, srb);
+                   srb->cmd->serial_number, tag, srb);
 
         if (!(dcb->tag_mask & (1 << tag)))
                 dprintkl(KERN_DEBUG,
@@ -2655,7 +2655,7 @@ static struct ScsiReqBlk *msgin_qtag(struct AdapterCtlBlk *acb,
                 goto mingx0;
 
         dprintkdbg(DBG_0, "msgin_qtag: (pid#%li) <%02i-%i>\n",
-                srb->cmd->pid, srb->dcb->target_id, srb->dcb->target_lun);
+                srb->cmd->serial_number, srb->dcb->target_id, srb->dcb->target_lun);
         if (dcb->flag & ABORT_DEV_) {
                 /*srb->state = SRB_ABORT_SENT; */
                 enable_msgout_abort(acb, srb);
@@ -2865,7 +2865,7 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
         struct DeviceCtlBlk *dcb = acb->active_dcb;
-        dprintkdbg(DBG_0, "msgin_phase0: (pid#%li)\n", srb->cmd->pid);
+        dprintkdbg(DBG_0, "msgin_phase0: (pid#%li)\n", srb->cmd->serial_number);
 
         srb->msgin_buf[acb->msg_len++] = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
         if (msgin_completed(srb->msgin_buf, acb->msg_len)) {
@@ -2933,7 +2933,7 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                          */
                         dprintkdbg(DBG_0, "msgin_phase0: (pid#%li) "
                                 "SAVE POINTER rem=%i Ignore\n",
-                                srb->cmd->pid, srb->total_xfer_length);
+                                srb->cmd->serial_number, srb->total_xfer_length);
                         break;
 
                 case RESTORE_POINTERS:
@@ -2943,7 +2943,7 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 case ABORT:
                         dprintkdbg(DBG_0, "msgin_phase0: (pid#%li) "
                                 "<%02i-%i> ABORT msg\n",
-                                srb->cmd->pid, dcb->target_id,
+                                srb->cmd->serial_number, dcb->target_id,
                                 dcb->target_lun);
                         dcb->flag |= ABORT_DEV_;
                         enable_msgout_abort(acb, srb);
@@ -2975,7 +2975,7 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 static void msgin_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "msgin_phase1: (pid#%li)\n", srb->cmd->pid);
+        dprintkdbg(DBG_0, "msgin_phase1: (pid#%li)\n", srb->cmd->serial_number);
         clear_fifo(acb, "msgin_phase1");
         DC395x_write32(acb, TRM_S1040_SCSI_COUNTER, 1);
         if (!(srb->state & SRB_MSGIN)) {
@@ -3041,7 +3041,7 @@ static void disconnect(struct AdapterCtlBlk *acb)
         }
         srb = dcb->active_srb;
         acb->active_dcb = NULL;
-        dprintkdbg(DBG_0, "disconnect: (pid#%li)\n", srb->cmd->pid);
+        dprintkdbg(DBG_0, "disconnect: (pid#%li)\n", srb->cmd->serial_number);
 
         srb->scsi_phase = PH_BUS_FREE;  /* initial phase */
         clear_fifo(acb, "disconnect");
@@ -3072,13 +3072,13 @@ static void disconnect(struct AdapterCtlBlk *acb)
                                 srb->state = SRB_READY;
                                 dprintkl(KERN_DEBUG,
                                         "disconnect: (pid#%li) Unexpected\n",
-                                        srb->cmd->pid);
+                                        srb->cmd->serial_number);
                                 srb->target_status = SCSI_STAT_SEL_TIMEOUT;
                                 goto disc1;
                         } else {
                                 /* Normal selection timeout */
                                 dprintkdbg(DBG_KG, "disconnect: (pid#%li) "
-                                        "<%02i-%i> SelTO\n", srb->cmd->pid,
+                                        "<%02i-%i> SelTO\n", srb->cmd->serial_number,
                                         dcb->target_id, dcb->target_lun);
                                 if (srb->retry_count++ > DC395x_MAX_RETRIES
                                     || acb->scan_devices) {
@@ -3090,7 +3090,7 @@ static void disconnect(struct AdapterCtlBlk *acb)
                                 srb_going_to_waiting_move(dcb, srb);
                                 dprintkdbg(DBG_KG,
                                         "disconnect: (pid#%li) Retry\n",
-                                        srb->cmd->pid);
+                                        srb->cmd->serial_number);
                                 waiting_set_timer(acb, HZ / 20);
                         }
                 } else if (srb->state & SRB_DISCONNECT) {
@@ -3144,7 +3144,7 @@ static void reselect(struct AdapterCtlBlk *acb)
                 if (!acb->scan_devices) {
                         dprintkdbg(DBG_KG, "reselect: (pid#%li) <%02i-%i> "
                                 "Arb lost but Resel win rsel=%i stat=0x%04x\n",
-                                srb->cmd->pid, dcb->target_id,
+                                srb->cmd->serial_number, dcb->target_id,
                                 dcb->target_lun, rsel_tar_lun_id,
                                 DC395x_read16(acb, TRM_S1040_SCSI_STATUS));
                         arblostflag = 1;
@@ -3318,7 +3318,7 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
         enum dma_data_direction dir = cmd->sc_data_direction;
         int ckc_only = 1;
 
-        dprintkdbg(DBG_1, "srb_done: (pid#%li) <%02i-%i>\n", srb->cmd->pid,
+        dprintkdbg(DBG_1, "srb_done: (pid#%li) <%02i-%i>\n", srb->cmd->serial_number,
                 srb->cmd->device->id, srb->cmd->device->lun);
         dprintkdbg(DBG_SG, "srb_done: srb=%p sg=%i(%i/%i) buf=%p\n",
                    srb, scsi_sg_count(cmd), srb->sg_index, srb->sg_count,
@@ -3499,7 +3499,7 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
                 if (srb->total_xfer_length)
                         dprintkdbg(DBG_KG, "srb_done: (pid#%li) <%02i-%i> "
                                 "cmnd=0x%02x Missed %i bytes\n",
-                                cmd->pid, cmd->device->id, cmd->device->lun,
+                                cmd->serial_number, cmd->device->id, cmd->device->lun,
                                 cmd->cmnd[0], srb->total_xfer_length);
         }
 
@@ -3509,7 +3509,7 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
                 dprintkl(KERN_ERR, "srb_done: ERROR! Completed cmd with tmp_srb\n");
         else {
                 dprintkdbg(DBG_0, "srb_done: (pid#%li) done result=0x%08x\n",
-                        cmd->pid, cmd->result);
+                        cmd->serial_number, cmd->result);
                 srb_free_insert(acb, srb);
         }
         pci_unmap_srb(acb, srb);
@@ -3538,7 +3538,7 @@ static void doing_srb_done(struct AdapterCtlBlk *acb, u8 did_flag,
                         p = srb->cmd;
                         dir = p->sc_data_direction;
                         result = MK_RES(0, did_flag, 0, 0);
-                        printk("G:%li(%02i-%i) ", p->pid,
+                        printk("G:%li(%02i-%i) ", p->serial_number,
                                p->device->id, p->device->lun);
                         srb_going_remove(dcb, srb);
                         free_tag(dcb, srb);
@@ -3568,7 +3568,7 @@ static void doing_srb_done(struct AdapterCtlBlk *acb, u8 did_flag,
                         p = srb->cmd;
 
                         result = MK_RES(0, did_flag, 0, 0);
-                        printk("W:%li<%02i-%i>", p->pid, p->device->id,
+                        printk("W:%li<%02i-%i>", p->serial_number, p->device->id,
                                p->device->lun);
                         srb_waiting_remove(dcb, srb);
                         srb_free_insert(acb, srb);
@@ -3678,7 +3678,7 @@ static void request_sense(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
 {
         struct scsi_cmnd *cmd = srb->cmd;
         dprintkdbg(DBG_1, "request_sense: (pid#%li) <%02i-%i>\n",
-                cmd->pid, cmd->device->id, cmd->device->lun);
+                cmd->serial_number, cmd->device->id, cmd->device->lun);
 
         srb->flag |= AUTO_REQSENSE;
         srb->adapter_status = 0;
@@ -3709,7 +3709,7 @@ static void request_sense(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
         if (start_scsi(acb, dcb, srb)) {        /* Should only happen, if sb. else grabs the bus */
                 dprintkl(KERN_DEBUG,
                         "request_sense: (pid#%li) failed <%02i-%i>\n",
-                        srb->cmd->pid, dcb->target_id, dcb->target_lun);
+                        srb->cmd->serial_number, dcb->target_id, dcb->target_lun);
                 srb_going_to_waiting_move(dcb, srb);
                 waiting_set_timer(acb, HZ / 100);
         }
@@ -4717,13 +4717,13 @@ static int dc395x_proc_info(struct Scsi_Host *host, char *buffer,
                                 dcb->target_id, dcb->target_lun,
                                 list_size(&dcb->srb_waiting_list));
                 list_for_each_entry(srb, &dcb->srb_waiting_list, list)
-                        SPRINTF(" %li", srb->cmd->pid);
+                        SPRINTF(" %li", srb->cmd->serial_number);
                 if (!list_empty(&dcb->srb_going_list))
                         SPRINTF("\nDCB (%02i-%i): Going  : %i:",
                                 dcb->target_id, dcb->target_lun,
                                 list_size(&dcb->srb_going_list));
                 list_for_each_entry(srb, &dcb->srb_going_list, list)
-                        SPRINTF(" %li", srb->cmd->pid);
+                        SPRINTF(" %li", srb->cmd->serial_number);
                 if (!list_empty(&dcb->srb_waiting_list) || !list_empty(&dcb->srb_going_list))
                         SPRINTF("\n");
         }