5 files changed, 235 insertions, 279 deletions

diff --git a/drivers/scsi/libfc/fc_disc.c b/drivers/scsi/libfc/fc_disc.c
index 4c880656990b..6fabf66972b9 100644
--- a/drivers/scsi/libfc/fc_disc.c
+++ b/drivers/scsi/libfc/fc_disc.c
@@ -45,14 +45,6 @@
 
 #define FC_DISC_DELAY           3
 
-static int fc_disc_debug;
-
-#define FC_DEBUG_DISC(fmt...)                   \
-        do {                                    \
-                if (fc_disc_debug)              \
-                        FC_DBG(fmt);            \
-        } while (0)
-
 static void fc_disc_gpn_ft_req(struct fc_disc *);
 static void fc_disc_gpn_ft_resp(struct fc_seq *, struct fc_frame *, void *);
 static int fc_disc_new_target(struct fc_disc *, struct fc_rport *,
@@ -137,8 +129,8 @@ static void fc_disc_rport_callback(struct fc_lport *lport,
         struct fc_rport_libfc_priv *rdata = rport->dd_data;
         struct fc_disc *disc = &lport->disc;
 
-        FC_DEBUG_DISC("Received a %d event for port (%6x)\n", event,
-                      rport->port_id);
+        FC_DISC_DBG(disc, "Received a %d event for port (%6x)\n", event,
+                    rport->port_id);
 
         switch (event) {
         case RPORT_EV_CREATED:
@@ -191,8 +183,7 @@ static void fc_disc_recv_rscn_req(struct fc_seq *sp, struct fc_frame *fp,
 
         lport = disc->lport;
 
-        FC_DEBUG_DISC("Received an RSCN event on port (%6x)\n",
-                      fc_host_port_id(lport->host));
+        FC_DISC_DBG(disc, "Received an RSCN event\n");
 
         /* make sure the frame contains an RSCN message */
         rp = fc_frame_payload_get(fp, sizeof(*rp));
@@ -225,8 +216,8 @@ static void fc_disc_recv_rscn_req(struct fc_seq *sp, struct fc_frame *fp,
                  */
                 switch (fmt) {
                 case ELS_ADDR_FMT_PORT:
-                        FC_DEBUG_DISC("Port address format for port (%6x)\n",
-                                      ntoh24(pp->rscn_fid));
+                        FC_DISC_DBG(disc, "Port address format for port "
+                                    "(%6x)\n", ntoh24(pp->rscn_fid));
                         dp = kzalloc(sizeof(*dp), GFP_KERNEL);
                         if (!dp) {
                                 redisc = 1;
@@ -243,19 +234,19 @@ static void fc_disc_recv_rscn_req(struct fc_seq *sp, struct fc_frame *fp,
                 case ELS_ADDR_FMT_DOM:
                 case ELS_ADDR_FMT_FAB:
                 default:
-                        FC_DEBUG_DISC("Address format is (%d)\n", fmt);
+                        FC_DISC_DBG(disc, "Address format is (%d)\n", fmt);
                         redisc = 1;
                         break;
                 }
         }
         lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
         if (redisc) {
-                FC_DEBUG_DISC("RSCN received: rediscovering\n");
+                FC_DISC_DBG(disc, "RSCN received: rediscovering\n");
                 fc_disc_restart(disc);
         } else {
-                FC_DEBUG_DISC("RSCN received: not rediscovering. "
-                              "redisc %d state %d in_prog %d\n",
-                              redisc, lport->state, disc->pending);
+                FC_DISC_DBG(disc, "RSCN received: not rediscovering. "
+                            "redisc %d state %d in_prog %d\n",
+                            redisc, lport->state, disc->pending);
                 list_for_each_entry_safe(dp, next, &disc_ports, peers) {
                         list_del(&dp->peers);
                         rport = lport->tt.rport_lookup(lport, dp->ids.port_id);
@@ -270,7 +261,7 @@ static void fc_disc_recv_rscn_req(struct fc_seq *sp, struct fc_frame *fp,
         fc_frame_free(fp);
         return;
 reject:
-        FC_DEBUG_DISC("Received a bad RSCN frame\n");
+        FC_DISC_DBG(disc, "Received a bad RSCN frame\n");
         rjt_data.fp = NULL;
         rjt_data.reason = ELS_RJT_LOGIC;
         rjt_data.explan = ELS_EXPL_NONE;
@@ -302,7 +293,8 @@ static void fc_disc_recv_req(struct fc_seq *sp, struct fc_frame *fp,
                 mutex_unlock(&disc->disc_mutex);
                 break;
         default:
-                FC_DBG("Received an unsupported request. opcode (%x)\n", op);
+                FC_DISC_DBG(disc, "Received an unsupported request, "
+                            "the opcode is (%x)\n", op);
                 break;
         }
 }
@@ -320,12 +312,10 @@ static void fc_disc_restart(struct fc_disc *disc)
         struct fc_rport_libfc_priv *rdata, *next;
         struct fc_lport *lport = disc->lport;
 
-        FC_DEBUG_DISC("Restarting discovery for port (%6x)\n",
-                      fc_host_port_id(lport->host));
+        FC_DISC_DBG(disc, "Restarting discovery\n");
 
         list_for_each_entry_safe(rdata, next, &disc->rports, peers) {
                 rport = PRIV_TO_RPORT(rdata);
-                FC_DEBUG_DISC("list_del(%6x)\n", rport->port_id);
                 list_del(&rdata->peers);
                 lport->tt.rport_logoff(rport);
         }
@@ -485,8 +475,7 @@ static void fc_disc_done(struct fc_disc *disc)
         struct fc_lport *lport = disc->lport;
         enum fc_disc_event event;
 
-        FC_DEBUG_DISC("Discovery complete for port (%6x)\n",
-                      fc_host_port_id(lport->host));
+        FC_DISC_DBG(disc, "Discovery complete\n");
 
         event = disc->event;
         disc->event = DISC_EV_NONE;
@@ -510,10 +499,10 @@ static void fc_disc_error(struct fc_disc *disc, struct fc_frame *fp)
 {
         struct fc_lport *lport = disc->lport;
         unsigned long delay = 0;
-        if (fc_disc_debug)
-                FC_DBG("Error %ld, retries %d/%d\n",
-                       PTR_ERR(fp), disc->retry_count,
-                       FC_DISC_RETRY_LIMIT);
+
+        FC_DISC_DBG(disc, "Error %ld, retries %d/%d\n",
+                    PTR_ERR(fp), disc->retry_count,
+                    FC_DISC_RETRY_LIMIT);
 
         if (!fp || PTR_ERR(fp) == -FC_EX_TIMEOUT) {
                 /*
@@ -649,9 +638,9 @@ static int fc_disc_gpn_ft_parse(struct fc_disc *disc, void *buf, size_t len)
                                               &disc->rogue_rports);
                                 lport->tt.rport_login(rport);
                         } else
-                                FC_DBG("Failed to allocate memory for "
-                                       "the newly discovered port (%6x)\n",
-                                       dp.ids.port_id);
+                                printk(KERN_WARNING "libfc: Failed to allocate "
+                                       "memory for the newly discovered port "
+                                       "(%6x)\n", dp.ids.port_id);
                 }
 
                 if (np->fp_flags & FC_NS_FID_LAST) {
@@ -671,9 +660,8 @@ static int fc_disc_gpn_ft_parse(struct fc_disc *disc, void *buf, size_t len)
          */
         if (error == 0 && len > 0 && len < sizeof(*np)) {
                 if (np != &disc->partial_buf) {
-                        FC_DEBUG_DISC("Partial buffer remains "
-                                      "for discovery by (%6x)\n",
-                                      fc_host_port_id(lport->host));
+                        FC_DISC_DBG(disc, "Partial buffer remains "
+                                    "for discovery\n");
                         memcpy(&disc->partial_buf, np, len);
                 }
                 disc->buf_len = (unsigned char) len;
@@ -721,8 +709,7 @@ static void fc_disc_gpn_ft_resp(struct fc_seq *sp, struct fc_frame *fp,
         int error;
 
         mutex_lock(&disc->disc_mutex);
-        FC_DEBUG_DISC("Received a GPN_FT response on port (%6x)\n",
-                      fc_host_port_id(disc->lport->host));
+        FC_DISC_DBG(disc, "Received a GPN_FT response\n");
 
         if (IS_ERR(fp)) {
                 fc_disc_error(disc, fp);
@@ -738,30 +725,30 @@ static void fc_disc_gpn_ft_resp(struct fc_seq *sp, struct fc_frame *fp,
             disc->seq_count == 0) {
                 cp = fc_frame_payload_get(fp, sizeof(*cp));
                 if (!cp) {
-                        FC_DBG("GPN_FT response too short, len %d\n",
-                               fr_len(fp));
+                        FC_DISC_DBG(disc, "GPN_FT response too short, len %d\n",
+                                    fr_len(fp));
                 } else if (ntohs(cp->ct_cmd) == FC_FS_ACC) {
 
                         /* Accepted, parse the response. */
                         buf = cp + 1;
                         len -= sizeof(*cp);
                 } else if (ntohs(cp->ct_cmd) == FC_FS_RJT) {
-                        FC_DBG("GPN_FT rejected reason %x exp %x "
-                               "(check zoning)\n", cp->ct_reason,
-                               cp->ct_explan);
+                        FC_DISC_DBG(disc, "GPN_FT rejected reason %x exp %x "
+                                    "(check zoning)\n", cp->ct_reason,
+                                    cp->ct_explan);
                         disc->event = DISC_EV_FAILED;
                         fc_disc_done(disc);
                 } else {
-                        FC_DBG("GPN_FT unexpected response code %x\n",
-                               ntohs(cp->ct_cmd));
+                        FC_DISC_DBG(disc, "GPN_FT unexpected response code "
+                                    "%x\n", ntohs(cp->ct_cmd));
                 }
         } else if (fr_sof(fp) == FC_SOF_N3 &&
                    seq_cnt == disc->seq_count) {
                 buf = fh + 1;
         } else {
-                FC_DBG("GPN_FT unexpected frame - out of sequence? "
-                       "seq_cnt %x expected %x sof %x eof %x\n",
-                       seq_cnt, disc->seq_count, fr_sof(fp), fr_eof(fp));
+                FC_DISC_DBG(disc, "GPN_FT unexpected frame - out of sequence? "
+                            "seq_cnt %x expected %x sof %x eof %x\n",
+                            seq_cnt, disc->seq_count, fr_sof(fp), fr_eof(fp));
         }
         if (buf) {
                 error = fc_disc_gpn_ft_parse(disc, buf, len);
diff --git a/drivers/scsi/libfc/fc_exch.c b/drivers/scsi/libfc/fc_exch.c
index 7af9bceb8aa9..2bc22be5f849 100644
--- a/drivers/scsi/libfc/fc_exch.c
+++ b/drivers/scsi/libfc/fc_exch.c
@@ -32,18 +32,7 @@
 #include <scsi/libfc.h>
 #include <scsi/fc_encode.h>
 
-/*
- * fc_exch_debug can be set in debugger or at compile time to get more logs.
- */
-static int fc_exch_debug;
-
-#define FC_DEBUG_EXCH(fmt...)                   \
-        do {                                    \
-                if (fc_exch_debug)              \
-                        FC_DBG(fmt);            \
-        } while (0)
-
-static struct kmem_cache *fc_em_cachep; /* cache for exchanges */
+static struct kmem_cache *fc_em_cachep;        /* cache for exchanges */
 
 /*
  * Structure and function definitions for managing Fibre Channel Exchanges
@@ -333,8 +322,8 @@ static inline void fc_exch_timer_set_locked(struct fc_exch *ep,
         if (ep->state & (FC_EX_RST_CLEANUP | FC_EX_DONE))
                 return;
 
-        FC_DEBUG_EXCH("Exchange (%4x) timed out, notifying the upper layer\n",
-                      ep->xid);
+        FC_EXCH_DBG(ep, "Exchange timed out, notifying the upper layer\n");
+
         if (schedule_delayed_work(&ep->timeout_work,
                                   msecs_to_jiffies(timer_msec)))
                 fc_exch_hold(ep);               /* hold for timer */
@@ -545,7 +534,7 @@ struct fc_exch *fc_exch_alloc(struct fc_exch_mgr *mp,
                 /* alloc a new xid */
                 xid = fc_em_alloc_xid(mp, fp);
                 if (!xid) {
-                        printk(KERN_ERR "fc_em_alloc_xid() failed\n");
+                        printk(KERN_WARNING "libfc: Failed to allocate an exhange\n");
                         goto err;
                 }
         }
@@ -820,8 +809,8 @@ static struct fc_seq *fc_seq_start_next_locked(struct fc_seq *sp)
         struct fc_exch *ep = fc_seq_exch(sp);
 
         sp = fc_seq_alloc(ep, ep->seq_id++);
-        FC_DEBUG_EXCH("exch %4x f_ctl %6x seq %2x\n",
-                      ep->xid, ep->f_ctl, sp->id);
+        FC_EXCH_DBG(ep, "f_ctl %6x seq %2x\n",
+                    ep->f_ctl, sp->id);
         return sp;
 }
 /*
@@ -901,7 +890,7 @@ void fc_seq_els_rsp_send(struct fc_seq *sp, enum fc_els_cmd els_cmd,
                 fc_exch_els_rec(sp, els_data->fp);
                 break;
         default:
-                FC_DBG("Invalid ELS CMD:%x\n", els_cmd);
+                FC_EXCH_DBG(fc_seq_exch(sp), "Invalid ELS CMD:%x\n", els_cmd);
         }
 }
 EXPORT_SYMBOL(fc_seq_els_rsp_send);
@@ -1134,7 +1123,7 @@ static void fc_exch_recv_req(struct fc_lport *lp, struct fc_exch_mgr *mp,
                         lp->tt.lport_recv(lp, sp, fp);
                 fc_exch_release(ep);    /* release from lookup */
         } else {
-                FC_DEBUG_EXCH("exch/seq lookup failed: reject %x\n", reject);
+                FC_EM_DBG(mp, "exch/seq lookup failed: reject %x\n", reject);
                 fc_frame_free(fp);
         }
 }
@@ -1242,10 +1231,10 @@ static void fc_exch_recv_resp(struct fc_exch_mgr *mp, struct fc_frame *fp)
         sp = fc_seq_lookup_orig(mp, fp);        /* doesn't hold sequence */
         if (!sp) {
                 atomic_inc(&mp->stats.xid_not_found);
-                FC_DEBUG_EXCH("seq lookup failed\n");
+                FC_EM_DBG(mp, "seq lookup failed\n");
         } else {
                 atomic_inc(&mp->stats.non_bls_resp);
-                FC_DEBUG_EXCH("non-BLS response to sequence");
+                FC_EM_DBG(mp, "non-BLS response to sequence");
         }
         fc_frame_free(fp);
 }
@@ -1266,8 +1255,8 @@ static void fc_exch_abts_resp(struct fc_exch *ep, struct fc_frame *fp)
         int rc = 1, has_rec = 0;
 
         fh = fc_frame_header_get(fp);
-        FC_DEBUG_EXCH("exch: BLS rctl %x - %s\n",
-                      fh->fh_r_ctl, fc_exch_rctl_name(fh->fh_r_ctl));
+        FC_EXCH_DBG(ep, "exch: BLS rctl %x - %s\n", fh->fh_r_ctl,
+                    fc_exch_rctl_name(fh->fh_r_ctl));
 
         if (cancel_delayed_work_sync(&ep->timeout_work))
                 fc_exch_release(ep);    /* release from pending timer hold */
@@ -1359,9 +1348,9 @@ static void fc_exch_recv_bls(struct fc_exch_mgr *mp, struct fc_frame *fp)
                 case FC_RCTL_ACK_0:
                         break;
                 default:
-                        FC_DEBUG_EXCH("BLS rctl %x - %s received",
-                                      fh->fh_r_ctl,
-                                      fc_exch_rctl_name(fh->fh_r_ctl));
+                        FC_EXCH_DBG(ep, "BLS rctl %x - %s received",
+                                    fh->fh_r_ctl,
+                                    fc_exch_rctl_name(fh->fh_r_ctl));
                         break;
                 }
                 fc_frame_free(fp);
@@ -1599,7 +1588,8 @@ static void fc_exch_rrq_resp(struct fc_seq *sp, struct fc_frame *fp, void *arg)
 
                 if (err == -FC_EX_CLOSED || err == -FC_EX_TIMEOUT)
                         goto cleanup;
-                FC_DBG("Cannot process RRQ, because of frame error %d\n", err);
+                FC_EXCH_DBG(aborted_ep, "Cannot process RRQ, "
+                            "frame error %d\n", err);
                 return;
         }
 
@@ -1608,12 +1598,13 @@ static void fc_exch_rrq_resp(struct fc_seq *sp, struct fc_frame *fp, void *arg)
 
         switch (op) {
         case ELS_LS_RJT:
-                FC_DBG("LS_RJT for RRQ");
+                FC_EXCH_DBG(aborted_ep, "LS_RJT for RRQ");
                 /* fall through */
         case ELS_LS_ACC:
                 goto cleanup;
         default:
-                FC_DBG("unexpected response op %x for RRQ", op);
+                FC_EXCH_DBG(aborted_ep, "unexpected response op %x "
+                            "for RRQ", op);
                 return;
         }
 
@@ -1740,8 +1731,8 @@ struct fc_exch_mgr *fc_exch_mgr_alloc(struct fc_lport *lp,
         size_t len;
 
         if (max_xid <= min_xid || min_xid == 0 || max_xid == FC_XID_UNKNOWN) {
-                FC_DBG("Invalid min_xid 0x:%x and max_xid 0x:%x\n",
-                       min_xid, max_xid);
+                FC_LPORT_DBG(lp, "Invalid min_xid 0x:%x and max_xid 0x:%x\n",
+                             min_xid, max_xid);
                 return NULL;
         }
 
@@ -1878,7 +1869,8 @@ void fc_exch_recv(struct fc_lport *lp, struct fc_exch_mgr *mp,
 
         /* lport lock ? */
         if (!lp || !mp || (lp->state == LPORT_ST_NONE)) {
-                FC_DBG("fc_lport or EM is not allocated and configured");
+                FC_LPORT_DBG(lp, "Receiving frames for an lport that "
+                             "has not been initialized correctly\n");
                 fc_frame_free(fp);
                 return;
         }
@@ -1904,7 +1896,7 @@ void fc_exch_recv(struct fc_lport *lp, struct fc_exch_mgr *mp,
                         fc_exch_recv_req(lp, mp, fp);
                 break;
         default:
-                FC_DBG("dropping invalid frame (eof %x)", fr_eof(fp));
+                FC_EM_DBG(mp, "dropping invalid frame (eof %x)", fr_eof(fp));
                 fc_frame_free(fp);
                 break;
         }
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index ad8b747837b0..e303e0d12c4b 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -43,13 +43,9 @@ MODULE_AUTHOR("Open-FCoE.org");
 MODULE_DESCRIPTION("libfc");
 MODULE_LICENSE("GPL v2");
 
-static int fc_fcp_debug;
-
-#define FC_DEBUG_FCP(fmt...)                    \
-        do {                                    \
-                if (fc_fcp_debug)               \
-                        FC_DBG(fmt);            \
-        } while (0)
+unsigned int fc_debug_logging;
+module_param_named(debug_logging, fc_debug_logging, int, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");
 
 static struct kmem_cache *scsi_pkt_cachep;
 
@@ -347,8 +343,8 @@ static void fc_fcp_recv_data(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
                 if ((fr_flags(fp) & FCPHF_CRC_UNCHECKED) &&
                     fc_frame_crc_check(fp))
                         goto crc_err;
-                FC_DEBUG_FCP("data received past end. len %zx offset %zx "
-                             "data_len %x\n", len, offset, fsp->data_len);
+                FC_FCP_DBG(fsp, "data received past end. len %zx offset %zx "
+                           "data_len %x\n", len, offset, fsp->data_len);
                 fc_fcp_retry_cmd(fsp);
                 return;
         }
@@ -411,7 +407,8 @@ crc_err:
                         stats->ErrorFrames++;
                         /* FIXME - per cpu count, not total count! */
                         if (stats->InvalidCRCCount++ < 5)
-                                printk(KERN_WARNING "CRC error on data frame for port (%6x)\n",
+                                printk(KERN_WARNING "libfc: CRC error on data "
+                                       "frame for port (%6x)\n",
                                        fc_host_port_id(lp->host));
                         /*
                          * Assume the frame is total garbage.
@@ -475,14 +472,14 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
         WARN_ON(seq_blen <= 0);
         if (unlikely(offset + seq_blen > fsp->data_len)) {
                 /* this should never happen */
-                FC_DEBUG_FCP("xfer-ready past end. seq_blen %zx offset %zx\n",
-                             seq_blen, offset);
+                FC_FCP_DBG(fsp, "xfer-ready past end. seq_blen %zx "
+                           "offset %zx\n", seq_blen, offset);
                 fc_fcp_send_abort(fsp);
                 return 0;
         } else if (offset != fsp->xfer_len) {
                 /* Out of Order Data Request - no problem, but unexpected. */
-                FC_DEBUG_FCP("xfer-ready non-contiguous. "
-                             "seq_blen %zx offset %zx\n", seq_blen, offset);
+                FC_FCP_DBG(fsp, "xfer-ready non-contiguous. "
+                           "seq_blen %zx offset %zx\n", seq_blen, offset);
         }
 
         /*
@@ -493,7 +490,7 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
         t_blen = fsp->max_payload;
         if (lp->seq_offload) {
                 t_blen = min(seq_blen, (size_t)lp->lso_max);
-                FC_DEBUG_FCP("fsp=%p:lso:blen=%zx lso_max=0x%x t_blen=%zx\n",
+                FC_FCP_DBG(fsp, "fsp=%p:lso:blen=%zx lso_max=0x%x t_blen=%zx\n",
                            fsp, seq_blen, lp->lso_max, t_blen);
         }
 
@@ -694,7 +691,7 @@ static void fc_fcp_reduce_can_queue(struct fc_lport *lp)
         if (!can_queue)
                 can_queue = 1;
         lp->host->can_queue = can_queue;
-        shost_printk(KERN_ERR, lp->host, "Could not allocate frame.\n"
+        shost_printk(KERN_ERR, lp->host, "libfc: Could not allocate frame.\n"
                      "Reducing can_queue to %d.\n", can_queue);
 done:
         spin_unlock_irqrestore(lp->host->host_lock, flags);
@@ -768,7 +765,7 @@ static void fc_fcp_recv(struct fc_seq *seq, struct fc_frame *fp, void *arg)
 
                 fc_fcp_resp(fsp, fp);
         } else {
-                FC_DBG("unexpected frame.  r_ctl %x\n", r_ctl);
+                FC_FCP_DBG(fsp, "unexpected frame.  r_ctl %x\n", r_ctl);
         }
 unlock:
         fc_fcp_unlock_pkt(fsp);
@@ -877,17 +874,17 @@ static void fc_fcp_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
                         return;
                 }
                 fsp->status_code = FC_DATA_OVRRUN;
-                FC_DBG("tgt %6x xfer len %zx greater than expected len %x. "
-                       "data len %x\n",
-                       fsp->rport->port_id,
-                       fsp->xfer_len, expected_len, fsp->data_len);
+                FC_FCP_DBG(fsp, "tgt %6x xfer len %zx greater than expected, "
+                           "len %x, data len %x\n",
+                           fsp->rport->port_id,
+                           fsp->xfer_len, expected_len, fsp->data_len);
         }
         fc_fcp_complete_locked(fsp);
         return;
 
 len_err:
-        FC_DBG("short FCP response. flags 0x%x len %u respl %u snsl %u\n",
-               flags, fr_len(fp), respl, snsl);
+        FC_FCP_DBG(fsp, "short FCP response. flags 0x%x len %u respl %u "
+                   "snsl %u\n", flags, fr_len(fp), respl, snsl);
 err:
         fsp->status_code = FC_ERROR;
         fc_fcp_complete_locked(fsp);
@@ -1107,13 +1104,11 @@ static void fc_fcp_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
         if (fc_fcp_lock_pkt(fsp))
                 return;
 
-        switch (error) {
-        case -FC_EX_CLOSED:
+        if (error == -FC_EX_CLOSED) {
                 fc_fcp_retry_cmd(fsp);
                 goto unlock;
-        default:
-                FC_DBG("unknown error %ld\n", PTR_ERR(fp));
         }
+
         /*
          * clear abort pending, because the lower layer
          * decided to force completion.
@@ -1145,10 +1140,10 @@ static int fc_fcp_pkt_abort(struct fc_lport *lp, struct fc_fcp_pkt *fsp)
         fsp->wait_for_comp = 0;
 
         if (!rc) {
-                FC_DBG("target abort cmd  failed\n");
+                FC_FCP_DBG(fsp, "target abort cmd  failed\n");
                 rc = FAILED;
         } else if (fsp->state & FC_SRB_ABORTED) {
-                FC_DBG("target abort cmd  passed\n");
+                FC_FCP_DBG(fsp, "target abort cmd  passed\n");
                 rc = SUCCESS;
                 fc_fcp_complete_locked(fsp);
         }
@@ -1213,7 +1208,7 @@ static int fc_lun_reset(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
         spin_unlock_bh(&fsp->scsi_pkt_lock);
 
         if (!rc) {
-                FC_DBG("lun reset failed\n");
+                FC_SCSI_DBG(lp, "lun reset failed\n");
                 return FAILED;
         }
 
@@ -1221,7 +1216,7 @@ static int fc_lun_reset(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
         if (fsp->cdb_status != FCP_TMF_CMPL)
                 return FAILED;
 
-        FC_DBG("lun reset to lun %u completed\n", lun);
+        FC_SCSI_DBG(lp, "lun reset to lun %u completed\n", lun);
         fc_fcp_cleanup_each_cmd(lp, id, lun, FC_CMD_ABORTED);
         return SUCCESS;
 }
@@ -1388,13 +1383,13 @@ static void fc_fcp_rec_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
                 rjt = fc_frame_payload_get(fp, sizeof(*rjt));
                 switch (rjt->er_reason) {
                 default:
-                        FC_DEBUG_FCP("device %x unexpected REC reject "
-                                     "reason %d expl %d\n",
-                                     fsp->rport->port_id, rjt->er_reason,
-                                     rjt->er_explan);
+                        FC_FCP_DBG(fsp, "device %x unexpected REC reject "
+                                   "reason %d expl %d\n",
+                                   fsp->rport->port_id, rjt->er_reason,
+                                   rjt->er_explan);
                         /* fall through */
                 case ELS_RJT_UNSUP:
-                        FC_DEBUG_FCP("device does not support REC\n");
+                        FC_FCP_DBG(fsp, "device does not support REC\n");
                         rp = fsp->rport->dd_data;
                         /*
                          * if we do not spport RECs or got some bogus
@@ -1514,8 +1509,8 @@ static void fc_fcp_rec_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
                 break;
 
         default:
-                FC_DBG("REC %p fid %x error unexpected error %d\n",
-                       fsp, fsp->rport->port_id, error);
+                FC_FCP_DBG(fsp, "REC %p fid %x error unexpected error %d\n",
+                           fsp, fsp->rport->port_id, error);
                 fsp->status_code = FC_CMD_PLOGO;
                 /* fall through */
 
@@ -1524,9 +1519,9 @@ static void fc_fcp_rec_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
                  * Assume REC or LS_ACC was lost.
                  * The exchange manager will have aborted REC, so retry.
                  */
-                FC_DBG("REC fid %x error error %d retry %d/%d\n",
-                       fsp->rport->port_id, error, fsp->recov_retry,
-                       FC_MAX_RECOV_RETRY);
+                FC_FCP_DBG(fsp, "REC fid %x error error %d retry %d/%d\n",
+                           fsp->rport->port_id, error, fsp->recov_retry,
+                           FC_MAX_RECOV_RETRY);
                 if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
                         fc_fcp_rec(fsp);
                 else
@@ -2011,9 +2006,11 @@ int fc_eh_device_reset(struct scsi_cmnd *sc_cmd)
         if (lp->state != LPORT_ST_READY)
                 return rc;
 
+        FC_SCSI_DBG(lp, "Resetting rport (%6x)\n", rport->port_id);
+
         fsp = fc_fcp_pkt_alloc(lp, GFP_NOIO);
         if (fsp == NULL) {
-                FC_DBG("could not allocate scsi_pkt\n");
+                printk(KERN_WARNING "libfc: could not allocate scsi_pkt\n");
                 sc_cmd->result = DID_NO_CONNECT << 16;
                 goto out;
         }
@@ -2048,17 +2045,21 @@ int fc_eh_host_reset(struct scsi_cmnd *sc_cmd)
         struct fc_lport *lp = shost_priv(shost);
         unsigned long wait_tmo;
 
+        FC_SCSI_DBG(lp, "Resetting host\n");
+
         lp->tt.lport_reset(lp);
         wait_tmo = jiffies + FC_HOST_RESET_TIMEOUT;
         while (!fc_fcp_lport_queue_ready(lp) && time_before(jiffies, wait_tmo))
                 msleep(1000);
 
         if (fc_fcp_lport_queue_ready(lp)) {
-                shost_printk(KERN_INFO, shost, "Host reset succeeded.\n");
+                shost_printk(KERN_INFO, shost, "libfc: Host reset succeeded "
+                             "on port (%6x)\n", fc_host_port_id(lp->host));
                 return SUCCESS;
         } else {
-                shost_printk(KERN_INFO, shost, "Host reset failed. "
-                             "lport not ready.\n");
+                shost_printk(KERN_INFO, shost, "libfc: Host reset failed, "
+                             "port (%6x) is not ready.\n",
+                             fc_host_port_id(lp->host));
                 return FAILED;
         }
 }
@@ -2117,7 +2118,8 @@ void fc_fcp_destroy(struct fc_lport *lp)
         struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
 
         if (!list_empty(&si->scsi_pkt_queue))
-                printk(KERN_ERR "Leaked scsi packets.\n");
+                printk(KERN_ERR "libfc: Leaked SCSI packets when destroying "
+                       "port (%6x)\n", fc_host_port_id(lp->host));
 
         mempool_destroy(si->scsi_pkt_pool);
         kfree(si);
@@ -2166,7 +2168,8 @@ static int __init libfc_init(void)
                                             sizeof(struct fc_fcp_pkt),
                                             0, SLAB_HWCACHE_ALIGN, NULL);
         if (scsi_pkt_cachep == NULL) {
-                FC_DBG("Unable to allocate SRB cache...module load failed!");
+                printk(KERN_ERR "libfc: Unable to allocate SRB cache, "
+                       "module load failed!");
                 return -ENOMEM;
         }
 
diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
index e0c247724d2b..745fa5555d6a 100644
--- a/drivers/scsi/libfc/fc_lport.c
+++ b/drivers/scsi/libfc/fc_lport.c
@@ -101,14 +101,6 @@
 
 #define DNS_DELAY             3 /* Discovery delay after RSCN (in seconds)*/
 
-static int fc_lport_debug;
-
-#define FC_DEBUG_LPORT(fmt...)                  \
-        do {                                    \
-                if (fc_lport_debug)             \
-                        FC_DBG(fmt);            \
-        } while (0)
-
 static void fc_lport_error(struct fc_lport *, struct fc_frame *);
 
 static void fc_lport_enter_reset(struct fc_lport *);
@@ -151,8 +143,8 @@ static void fc_lport_rport_callback(struct fc_lport *lport,
                                     struct fc_rport *rport,
                                     enum fc_rport_event event)
 {
-        FC_DEBUG_LPORT("Received a %d event for port (%6x)\n", event,
-                       rport->port_id);
+        FC_LPORT_DBG(lport, "Received a %d event for port (%6x)\n", event,
+                     rport->port_id);
 
         switch (event) {
         case RPORT_EV_CREATED:
@@ -162,19 +154,19 @@ static void fc_lport_rport_callback(struct fc_lport *lport,
                                 lport->dns_rp = rport;
                                 fc_lport_enter_rpn_id(lport);
                         } else {
-                                FC_DEBUG_LPORT("Received an CREATED event on "
-                                               "port (%6x) for the directory "
-                                               "server, but the lport is not "
-                                               "in the DNS state, it's in the "
-                                               "%d state", rport->port_id,
-                                               lport->state);
+                                FC_LPORT_DBG(lport, "Received an CREATED event "
+                                             "on port (%6x) for the directory "
+                                             "server, but the lport is not "
+                                             "in the DNS state, it's in the "
+                                             "%d state", rport->port_id,
+                                             lport->state);
                                 lport->tt.rport_logoff(rport);
                         }
                         mutex_unlock(&lport->lp_mutex);
                 } else
-                        FC_DEBUG_LPORT("Received an event for port (%6x) "
-                                       "which is not the directory server\n",
-                                       rport->port_id);
+                        FC_LPORT_DBG(lport, "Received an event for port (%6x) "
+                                     "which is not the directory server\n",
+                                     rport->port_id);
                 break;
         case RPORT_EV_LOGO:
         case RPORT_EV_FAILED:
@@ -185,9 +177,9 @@ static void fc_lport_rport_callback(struct fc_lport *lport,
                         mutex_unlock(&lport->lp_mutex);
 
                 } else
-                        FC_DEBUG_LPORT("Received an event for port (%6x) "
-                                       "which is not the directory server\n",
-                                       rport->port_id);
+                        FC_LPORT_DBG(lport, "Received an event for port (%6x) "
+                                     "which is not the directory server\n",
+                                     rport->port_id);
                 break;
         case RPORT_EV_NONE:
                 break;
@@ -363,8 +355,8 @@ static void fc_lport_add_fc4_type(struct fc_lport *lport, enum fc_fh_type type)
 static void fc_lport_recv_rlir_req(struct fc_seq *sp, struct fc_frame *fp,
                                    struct fc_lport *lport)
 {
-        FC_DEBUG_LPORT("Received RLIR request while in state %s\n",
-                       fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Received RLIR request while in state %s\n",
+                     fc_lport_state(lport));
 
         lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
         fc_frame_free(fp);
@@ -389,8 +381,8 @@ static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
         void *dp;
         u32 f_ctl;
 
-        FC_DEBUG_LPORT("Received RLIR request while in state %s\n",
-                       fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Received RLIR request while in state %s\n",
+                     fc_lport_state(lport));
 
         len = fr_len(in_fp) - sizeof(struct fc_frame_header);
         pp = fc_frame_payload_get(in_fp, len);
@@ -437,8 +429,8 @@ static void fc_lport_recv_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp,
         size_t len;
         u32 f_ctl;
 
-        FC_DEBUG_LPORT("Received RNID request while in state %s\n",
-                       fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Received RNID request while in state %s\n",
+                     fc_lport_state(lport));
 
         req = fc_frame_payload_get(in_fp, sizeof(*req));
         if (!req) {
@@ -498,8 +490,8 @@ static void fc_lport_recv_adisc_req(struct fc_seq *sp, struct fc_frame *in_fp,
         size_t len;
         u32 f_ctl;
 
-        FC_DEBUG_LPORT("Received ADISC request while in state %s\n",
-                       fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Received ADISC request while in state %s\n",
+                     fc_lport_state(lport));
 
         req = fc_frame_payload_get(in_fp, sizeof(*req));
         if (!req) {
@@ -574,8 +566,8 @@ EXPORT_SYMBOL(fc_fabric_login);
  */
 void fc_linkup(struct fc_lport *lport)
 {
-        FC_DEBUG_LPORT("Link is up for port (%6x)\n",
-                       fc_host_port_id(lport->host));
+        printk(KERN_INFO "libfc: Link up on port (%6x)\n",
+               fc_host_port_id(lport->host));
 
         mutex_lock(&lport->lp_mutex);
         if (!lport->link_up) {
@@ -595,8 +587,8 @@ EXPORT_SYMBOL(fc_linkup);
 void fc_linkdown(struct fc_lport *lport)
 {
         mutex_lock(&lport->lp_mutex);
-        FC_DEBUG_LPORT("Link is down for port (%6x)\n",
-                       fc_host_port_id(lport->host));
+        printk(KERN_INFO "libfc: Link down on port (%6x)\n",
+               fc_host_port_id(lport->host));
 
         if (lport->link_up) {
                 lport->link_up = 0;
@@ -701,12 +693,11 @@ void fc_lport_disc_callback(struct fc_lport *lport, enum fc_disc_event event)
 {
         switch (event) {
         case DISC_EV_SUCCESS:
-                FC_DEBUG_LPORT("Got a SUCCESS event for port (%6x)\n",
-                               fc_host_port_id(lport->host));
+                FC_LPORT_DBG(lport, "Discovery succeeded\n");
                 break;
         case DISC_EV_FAILED:
-                FC_DEBUG_LPORT("Got a FAILED event for port (%6x)\n",
-                               fc_host_port_id(lport->host));
+                printk(KERN_ERR "libfc: Discovery failed for port (%6x)\n",
+                       fc_host_port_id(lport->host));
                 mutex_lock(&lport->lp_mutex);
                 fc_lport_enter_reset(lport);
                 mutex_unlock(&lport->lp_mutex);
@@ -726,8 +717,8 @@ void fc_lport_disc_callback(struct fc_lport *lport, enum fc_disc_event event)
  */
 static void fc_lport_enter_ready(struct fc_lport *lport)
 {
-        FC_DEBUG_LPORT("Port (%6x) entered Ready from state %s\n",
-                       fc_host_port_id(lport->host), fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Entered READY from state %s\n",
+                     fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_READY);
 
@@ -762,8 +753,8 @@ static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
         u32 local_fid;
         u32 f_ctl;
 
-        FC_DEBUG_LPORT("Received FLOGI request while in state %s\n",
-                       fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Received FLOGI request while in state %s\n",
+                     fc_lport_state(lport));
 
         fh = fc_frame_header_get(rx_fp);
         remote_fid = ntoh24(fh->fh_s_id);
@@ -772,12 +763,11 @@ static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
                 goto out;
         remote_wwpn = get_unaligned_be64(&flp->fl_wwpn);
         if (remote_wwpn == lport->wwpn) {
-                FC_DBG("FLOGI from port with same WWPN %llx "
-                       "possible configuration error\n",
-                       (unsigned long long)remote_wwpn);
+                printk(KERN_WARNING "libfc: Received FLOGI from port "
+                       "with same WWPN %llx\n", remote_wwpn);
                 goto out;
         }
-        FC_DBG("FLOGI from port WWPN %llx\n", (unsigned long long)remote_wwpn);
+        FC_LPORT_DBG(lport, "FLOGI from port WWPN %llx\n", remote_wwpn);
 
         /*
          * XXX what is the right thing to do for FIDs?
@@ -909,7 +899,8 @@ static void fc_lport_recv_req(struct fc_lport *lport, struct fc_seq *sp,
                         }
                 }
         } else {
-                FC_DBG("dropping invalid frame (eof %x)\n", fr_eof(fp));
+                FC_LPORT_DBG(lport, "dropping invalid frame (eof %x)\n",
+                             fr_eof(fp));
                 fc_frame_free(fp);
         }
         mutex_unlock(&lport->lp_mutex);
@@ -947,8 +938,8 @@ EXPORT_SYMBOL(fc_lport_reset);
  */
 static void fc_lport_enter_reset(struct fc_lport *lport)
 {
-        FC_DEBUG_LPORT("Port (%6x) entered RESET state from %s state\n",
-                       fc_host_port_id(lport->host), fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Entered RESET state from %s state\n",
+                     fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_RESET);
 
@@ -982,9 +973,9 @@ static void fc_lport_enter_reset(struct fc_lport *lport)
 static void fc_lport_error(struct fc_lport *lport, struct fc_frame *fp)
 {
         unsigned long delay = 0;
-        FC_DEBUG_LPORT("Error %ld in state %s, retries %d\n",
-                       PTR_ERR(fp), fc_lport_state(lport),
-                       lport->retry_count);
+        FC_LPORT_DBG(lport, "Error %ld in state %s, retries %d\n",
+                     PTR_ERR(fp), fc_lport_state(lport),
+                     lport->retry_count);
 
         if (!fp || PTR_ERR(fp) == -FC_EX_TIMEOUT) {
                 /*
@@ -1040,11 +1031,11 @@ static void fc_lport_rft_id_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&lport->lp_mutex);
 
-        FC_DEBUG_LPORT("Received a RFT_ID response\n");
+        FC_LPORT_DBG(lport, "Received a RFT_ID response\n");
 
         if (lport->state != LPORT_ST_RFT_ID) {
-                FC_DBG("Received a RFT_ID response, but in state %s\n",
-                       fc_lport_state(lport));
+                FC_LPORT_DBG(lport, "Received a RFT_ID response, but in state "
+                             "%s\n", fc_lport_state(lport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -1094,11 +1085,11 @@ static void fc_lport_rpn_id_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&lport->lp_mutex);
 
-        FC_DEBUG_LPORT("Received a RPN_ID response\n");
+        FC_LPORT_DBG(lport, "Received a RPN_ID response\n");
 
         if (lport->state != LPORT_ST_RPN_ID) {
-                FC_DBG("Received a RPN_ID response, but in state %s\n",
-                       fc_lport_state(lport));
+                FC_LPORT_DBG(lport, "Received a RPN_ID response, but in state "
+                             "%s\n", fc_lport_state(lport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -1146,11 +1137,11 @@ static void fc_lport_scr_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&lport->lp_mutex);
 
-        FC_DEBUG_LPORT("Received a SCR response\n");
+        FC_LPORT_DBG(lport, "Received a SCR response\n");
 
         if (lport->state != LPORT_ST_SCR) {
-                FC_DBG("Received a SCR response, but in state %s\n",
-                       fc_lport_state(lport));
+                FC_LPORT_DBG(lport, "Received a SCR response, but in state "
+                             "%s\n", fc_lport_state(lport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -1184,8 +1175,8 @@ static void fc_lport_enter_scr(struct fc_lport *lport)
 {
         struct fc_frame *fp;
 
-        FC_DEBUG_LPORT("Port (%6x) entered SCR state from %s state\n",
-                       fc_host_port_id(lport->host), fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Entered SCR state from %s state\n",
+                     fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_SCR);
 
@@ -1213,8 +1204,8 @@ static void fc_lport_enter_rft_id(struct fc_lport *lport)
         struct fc_ns_fts *lps;
         int i;
 
-        FC_DEBUG_LPORT("Port (%6x) entered RFT_ID state from %s state\n",
-                       fc_host_port_id(lport->host), fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Entered RFT_ID state from %s state\n",
+                     fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_RFT_ID);
 
@@ -1253,8 +1244,8 @@ static void fc_lport_enter_rpn_id(struct fc_lport *lport)
 {
         struct fc_frame *fp;
 
-        FC_DEBUG_LPORT("Port (%6x) entered RPN_ID state from %s state\n",
-                       fc_host_port_id(lport->host), fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Entered RPN_ID state from %s state\n",
+                     fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_RPN_ID);
 
@@ -1294,8 +1285,8 @@ static void fc_lport_enter_dns(struct fc_lport *lport)
         dp.ids.roles = FC_RPORT_ROLE_UNKNOWN;
         dp.lp = lport;
 
-        FC_DEBUG_LPORT("Port (%6x) entered DNS state from %s state\n",
-                       fc_host_port_id(lport->host), fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Entered DNS state from %s state\n",
+                     fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_DNS);
 
@@ -1374,11 +1365,11 @@ static void fc_lport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&lport->lp_mutex);
 
-        FC_DEBUG_LPORT("Received a LOGO response\n");
+        FC_LPORT_DBG(lport, "Received a LOGO response\n");
 
         if (lport->state != LPORT_ST_LOGO) {
-                FC_DBG("Received a LOGO response, but in state %s\n",
-                       fc_lport_state(lport));
+                FC_LPORT_DBG(lport, "Received a LOGO response, but in state "
+                             "%s\n", fc_lport_state(lport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -1413,8 +1404,8 @@ static void fc_lport_enter_logo(struct fc_lport *lport)
         struct fc_frame *fp;
         struct fc_els_logo *logo;
 
-        FC_DEBUG_LPORT("Port (%6x) entered LOGO state from %s state\n",
-                       fc_host_port_id(lport->host), fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Entered LOGO state from %s state\n",
+                     fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_LOGO);
 
@@ -1456,11 +1447,11 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&lport->lp_mutex);
 
-        FC_DEBUG_LPORT("Received a FLOGI response\n");
+        FC_LPORT_DBG(lport, "Received a FLOGI response\n");
 
         if (lport->state != LPORT_ST_FLOGI) {
-                FC_DBG("Received a FLOGI response, but in state %s\n",
-                       fc_lport_state(lport));
+                FC_LPORT_DBG(lport, "Received a FLOGI response, but in state "
+                             "%s\n", fc_lport_state(lport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -1475,7 +1466,8 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
         did = ntoh24(fh->fh_d_id);
         if (fc_frame_payload_op(fp) == ELS_LS_ACC && did != 0) {
 
-                FC_DEBUG_LPORT("Assigned fid %x\n", did);
+                printk(KERN_INFO "libfc: Assigned FID (%6x) in FLOGI response\n",
+                       did);
                 fc_host_port_id(lport->host) = did;
 
                 flp = fc_frame_payload_get(fp, sizeof(*flp));
@@ -1494,7 +1486,8 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
                                 if (e_d_tov > lport->e_d_tov)
                                         lport->e_d_tov = e_d_tov;
                                 lport->r_a_tov = 2 * e_d_tov;
-                                FC_DBG("Point-to-Point mode\n");
+                                printk(KERN_INFO "libfc: Port (%6x) entered "
+                                       "point to point mode\n", did);
                                 fc_lport_ptp_setup(lport, ntoh24(fh->fh_s_id),
                                                    get_unaligned_be64(
                                                            &flp->fl_wwpn),
@@ -1517,7 +1510,7 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
                         }
                 }
         } else {
-                FC_DBG("bad FLOGI response\n");
+                FC_LPORT_DBG(lport, "Bad FLOGI response\n");
         }
 
 out:
@@ -1537,7 +1530,8 @@ void fc_lport_enter_flogi(struct fc_lport *lport)
 {
         struct fc_frame *fp;
 
-        FC_DEBUG_LPORT("Processing FLOGI state\n");
+        FC_LPORT_DBG(lport, "Entered FLOGI state from %s state\n",
+                     fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_FLOGI);
 
diff --git a/drivers/scsi/libfc/fc_rport.c b/drivers/scsi/libfc/fc_rport.c
index 7bfbff7e0efb..7162385f52eb 100644
--- a/drivers/scsi/libfc/fc_rport.c
+++ b/drivers/scsi/libfc/fc_rport.c
@@ -55,14 +55,6 @@
 #include <scsi/libfc.h>
 #include <scsi/fc_encode.h>
 
-static int fc_rport_debug;
-
-#define FC_DEBUG_RPORT(fmt...)                  \
-        do {                                    \
-                if (fc_rport_debug)             \
-                        FC_DBG(fmt);            \
-        } while (0)
-
 struct workqueue_struct *rport_event_queue;
 
 static void fc_rport_enter_plogi(struct fc_rport *);
@@ -97,7 +89,7 @@ static const char *fc_rport_state_names[] = {
 static void fc_rport_rogue_destroy(struct device *dev)
 {
         struct fc_rport *rport = dev_to_rport(dev);
-        FC_DEBUG_RPORT("Destroying rogue rport (%6x)\n", rport->port_id);
+        FC_RPORT_DBG(rport, "Destroying rogue rport\n");
         kfree(rport);
 }
 
@@ -263,8 +255,8 @@ static void fc_rport_work(struct work_struct *work)
 
                         fc_rport_state_enter(new_rport, RPORT_ST_READY);
                 } else {
-                        FC_DBG("Failed to create the rport for port "
-                               "(%6x).\n", ids.port_id);
+                        printk(KERN_WARNING "libfc: Failed to allocate "
+                               " memory for rport (%6x)\n", ids.port_id);
                         event = RPORT_EV_FAILED;
                 }
                 if (rport->port_id != FC_FID_DIR_SERV)
@@ -309,7 +301,7 @@ int fc_rport_login(struct fc_rport *rport)
 
         mutex_lock(&rdata->rp_mutex);
 
-        FC_DEBUG_RPORT("Login to port (%6x)\n", rport->port_id);
+        FC_RPORT_DBG(rport, "Login to port\n");
 
         fc_rport_enter_plogi(rport);
 
@@ -329,16 +321,13 @@ int fc_rport_login(struct fc_rport *rport)
 int fc_rport_logoff(struct fc_rport *rport)
 {
         struct fc_rport_libfc_priv *rdata = rport->dd_data;
-        struct fc_lport *lport = rdata->local_port;
 
         mutex_lock(&rdata->rp_mutex);
 
-        FC_DEBUG_RPORT("Remove port (%6x)\n", rport->port_id);
+        FC_RPORT_DBG(rport, "Remove port\n");
 
         if (rdata->rp_state == RPORT_ST_NONE) {
-                FC_DEBUG_RPORT("(%6x): Port (%6x) in NONE state,"
-                               " not removing", fc_host_port_id(lport->host),
-                               rport->port_id);
+                FC_RPORT_DBG(rport, "Port in NONE state, not removing\n");
                 mutex_unlock(&rdata->rp_mutex);
                 goto out;
         }
@@ -379,7 +368,7 @@ static void fc_rport_enter_ready(struct fc_rport *rport)
 
         fc_rport_state_enter(rport, RPORT_ST_READY);
 
-        FC_DEBUG_RPORT("Port (%6x) is Ready\n", rport->port_id);
+        FC_RPORT_DBG(rport, "Port is Ready\n");
 
         rdata->event = RPORT_EV_CREATED;
         queue_work(rport_event_queue, &rdata->event_work);
@@ -436,8 +425,8 @@ static void fc_rport_error(struct fc_rport *rport, struct fc_frame *fp)
 {
         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 
-        FC_DEBUG_RPORT("Error %ld in state %s, retries %d\n",
-                       PTR_ERR(fp), fc_rport_state(rport), rdata->retries);
+        FC_RPORT_DBG(rport, "Error %ld in state %s, retries %d\n",
+                     PTR_ERR(fp), fc_rport_state(rport), rdata->retries);
 
         switch (rdata->rp_state) {
         case RPORT_ST_PLOGI:
@@ -479,8 +468,8 @@ static void fc_rport_error_retry(struct fc_rport *rport, struct fc_frame *fp)
                 return fc_rport_error(rport, fp);
 
         if (rdata->retries < rdata->local_port->max_rport_retry_count) {
-                FC_DEBUG_RPORT("Error %ld in state %s, retrying\n",
-                               PTR_ERR(fp), fc_rport_state(rport));
+                FC_RPORT_DBG(rport, "Error %ld in state %s, retrying\n",
+                             PTR_ERR(fp), fc_rport_state(rport));
                 rdata->retries++;
                 /* no additional delay on exchange timeouts */
                 if (PTR_ERR(fp) == -FC_EX_TIMEOUT)
@@ -517,12 +506,11 @@ static void fc_rport_plogi_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&rdata->rp_mutex);
 
-        FC_DEBUG_RPORT("Received a PLOGI response from port (%6x)\n",
-                       rport->port_id);
+        FC_RPORT_DBG(rport, "Received a PLOGI response\n");
 
         if (rdata->rp_state != RPORT_ST_PLOGI) {
-                FC_DBG("Received a PLOGI response, but in state %s\n",
-                       fc_rport_state(rport));
+                FC_RPORT_DBG(rport, "Received a PLOGI response, but in state "
+                             "%s\n", fc_rport_state(rport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -583,8 +571,8 @@ static void fc_rport_enter_plogi(struct fc_rport *rport)
         struct fc_lport *lport = rdata->local_port;
         struct fc_frame *fp;
 
-        FC_DEBUG_RPORT("Port (%6x) entered PLOGI state from %s state\n",
-                       rport->port_id, fc_rport_state(rport));
+        FC_RPORT_DBG(rport, "Port entered PLOGI state from %s state\n",
+                     fc_rport_state(rport));
 
         fc_rport_state_enter(rport, RPORT_ST_PLOGI);
 
@@ -628,12 +616,11 @@ static void fc_rport_prli_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&rdata->rp_mutex);
 
-        FC_DEBUG_RPORT("Received a PRLI response from port (%6x)\n",
-                       rport->port_id);
+        FC_RPORT_DBG(rport, "Received a PRLI response\n");
 
         if (rdata->rp_state != RPORT_ST_PRLI) {
-                FC_DBG("Received a PRLI response, but in state %s\n",
-                       fc_rport_state(rport));
+                FC_RPORT_DBG(rport, "Received a PRLI response, but in state "
+                             "%s\n", fc_rport_state(rport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -663,7 +650,7 @@ static void fc_rport_prli_resp(struct fc_seq *sp, struct fc_frame *fp,
                 fc_rport_enter_rtv(rport);
 
         } else {
-                FC_DBG("Bad ELS response\n");
+                FC_RPORT_DBG(rport, "Bad ELS response for PRLI command\n");
                 rdata->event = RPORT_EV_FAILED;
                 fc_rport_state_enter(rport, RPORT_ST_NONE);
                 queue_work(rport_event_queue, &rdata->event_work);
@@ -695,12 +682,11 @@ static void fc_rport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&rdata->rp_mutex);
 
-        FC_DEBUG_RPORT("Received a LOGO response from port (%6x)\n",
-                       rport->port_id);
+        FC_RPORT_DBG(rport, "Received a LOGO response\n");
 
         if (rdata->rp_state != RPORT_ST_LOGO) {
-                FC_DEBUG_RPORT("Received a LOGO response, but in state %s\n",
-                               fc_rport_state(rport));
+                FC_RPORT_DBG(rport, "Received a LOGO response, but in state "
+                             "%s\n", fc_rport_state(rport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -715,7 +701,7 @@ static void fc_rport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
         if (op == ELS_LS_ACC) {
                 fc_rport_enter_rtv(rport);
         } else {
-                FC_DBG("Bad ELS response\n");
+                FC_RPORT_DBG(rport, "Bad ELS response for LOGO command\n");
                 rdata->event = RPORT_EV_LOGO;
                 fc_rport_state_enter(rport, RPORT_ST_NONE);
                 queue_work(rport_event_queue, &rdata->event_work);
@@ -745,8 +731,8 @@ static void fc_rport_enter_prli(struct fc_rport *rport)
         } *pp;
         struct fc_frame *fp;
 
-        FC_DEBUG_RPORT("Port (%6x) entered PRLI state from %s state\n",
-                       rport->port_id, fc_rport_state(rport));
+        FC_RPORT_DBG(rport, "Port entered PRLI state from %s state\n",
+                     fc_rport_state(rport));
 
         fc_rport_state_enter(rport, RPORT_ST_PRLI);
 
@@ -784,12 +770,11 @@ static void fc_rport_rtv_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&rdata->rp_mutex);
 
-        FC_DEBUG_RPORT("Received a RTV response from port (%6x)\n",
-                       rport->port_id);
+        FC_RPORT_DBG(rport, "Received a RTV response\n");
 
         if (rdata->rp_state != RPORT_ST_RTV) {
-                FC_DBG("Received a RTV response, but in state %s\n",
-                       fc_rport_state(rport));
+                FC_RPORT_DBG(rport, "Received a RTV response, but in state "
+                             "%s\n", fc_rport_state(rport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -844,8 +829,8 @@ static void fc_rport_enter_rtv(struct fc_rport *rport)
         struct fc_rport_libfc_priv *rdata = rport->dd_data;
         struct fc_lport *lport = rdata->local_port;
 
-        FC_DEBUG_RPORT("Port (%6x) entered RTV state from %s state\n",
-                       rport->port_id, fc_rport_state(rport));
+        FC_RPORT_DBG(rport, "Port entered RTV state from %s state\n",
+                     fc_rport_state(rport));
 
         fc_rport_state_enter(rport, RPORT_ST_RTV);
 
@@ -875,8 +860,8 @@ static void fc_rport_enter_logo(struct fc_rport *rport)
         struct fc_lport *lport = rdata->local_port;
         struct fc_frame *fp;
 
-        FC_DEBUG_RPORT("Port (%6x) entered LOGO state from %s state\n",
-                       rport->port_id, fc_rport_state(rport));
+        FC_RPORT_DBG(rport, "Port entered LOGO state from %s state\n",
+                     fc_rport_state(rport));
 
         fc_rport_state_enter(rport, RPORT_ST_LOGO);
 
@@ -983,14 +968,13 @@ static void fc_rport_recv_plogi_req(struct fc_rport *rport,
 
         fh = fc_frame_header_get(fp);
 
-        FC_DEBUG_RPORT("Received PLOGI request from port (%6x) "
-                       "while in state %s\n", ntoh24(fh->fh_s_id),
-                       fc_rport_state(rport));
+        FC_RPORT_DBG(rport, "Received PLOGI request while in state %s\n",
+                     fc_rport_state(rport));
 
         sid = ntoh24(fh->fh_s_id);
         pl = fc_frame_payload_get(fp, sizeof(*pl));
         if (!pl) {
-                FC_DBG("incoming PLOGI from %x too short\n", sid);
+                FC_RPORT_DBG(rport, "Received PLOGI too short\n");
                 WARN_ON(1);
                 /* XXX TBD: send reject? */
                 fc_frame_free(fp);
@@ -1012,26 +996,26 @@ static void fc_rport_recv_plogi_req(struct fc_rport *rport,
          */
         switch (rdata->rp_state) {
         case RPORT_ST_INIT:
-                FC_DEBUG_RPORT("incoming PLOGI from %6x wwpn %llx state INIT "
-                               "- reject\n", sid, (unsigned long long)wwpn);
+                FC_RPORT_DBG(rport, "Received PLOGI, wwpn %llx state INIT "
+                             "- reject\n", (unsigned long long)wwpn);
                 reject = ELS_RJT_UNSUP;
                 break;
         case RPORT_ST_PLOGI:
-                FC_DEBUG_RPORT("incoming PLOGI from %x in PLOGI state %d\n",
-                               sid, rdata->rp_state);
+                FC_RPORT_DBG(rport, "Received PLOGI in PLOGI state %d\n",
+                             rdata->rp_state);
                 if (wwpn < lport->wwpn)
                         reject = ELS_RJT_INPROG;
                 break;
         case RPORT_ST_PRLI:
         case RPORT_ST_READY:
-                FC_DEBUG_RPORT("incoming PLOGI from %x in logged-in state %d "
-                               "- ignored for now\n", sid, rdata->rp_state);
+                FC_RPORT_DBG(rport, "Received PLOGI in logged-in state %d "
+                             "- ignored for now\n", rdata->rp_state);
                 /* XXX TBD - should reset */
                 break;
         case RPORT_ST_NONE:
         default:
-                FC_DEBUG_RPORT("incoming PLOGI from %x in unexpected "
-                               "state %d\n", sid, rdata->rp_state);
+                FC_RPORT_DBG(rport, "Received PLOGI in unexpected "
+                             "state %d\n", rdata->rp_state);
                 fc_frame_free(fp);
                 return;
                 break;
@@ -1115,9 +1099,8 @@ static void fc_rport_recv_prli_req(struct fc_rport *rport,
 
         fh = fc_frame_header_get(rx_fp);
 
-        FC_DEBUG_RPORT("Received PRLI request from port (%6x) "
-                       "while in state %s\n", ntoh24(fh->fh_s_id),
-                       fc_rport_state(rport));
+        FC_RPORT_DBG(rport, "Received PRLI request while in state %s\n",
+                     fc_rport_state(rport));
 
         switch (rdata->rp_state) {
         case RPORT_ST_PRLI:
@@ -1252,9 +1235,8 @@ static void fc_rport_recv_prlo_req(struct fc_rport *rport, struct fc_seq *sp,
 
         fh = fc_frame_header_get(fp);
 
-        FC_DEBUG_RPORT("Received PRLO request from port (%6x) "
-                       "while in state %s\n", ntoh24(fh->fh_s_id),
-                       fc_rport_state(rport));
+        FC_RPORT_DBG(rport, "Received PRLO request while in state %s\n",
+                     fc_rport_state(rport));
 
         if (rdata->rp_state == RPORT_ST_NONE) {
                 fc_frame_free(fp);
@@ -1286,9 +1268,8 @@ static void fc_rport_recv_logo_req(struct fc_rport *rport, struct fc_seq *sp,
 
         fh = fc_frame_header_get(fp);
 
-        FC_DEBUG_RPORT("Received LOGO request from port (%6x) "
-                       "while in state %s\n", ntoh24(fh->fh_s_id),
-                       fc_rport_state(rport));
+        FC_RPORT_DBG(rport, "Received LOGO request while in state %s\n",
+                     fc_rport_state(rport));
 
         if (rdata->rp_state == RPORT_ST_NONE) {
                 fc_frame_free(fp);
@@ -1308,7 +1289,6 @@ static void fc_rport_flush_queue(void)
         flush_workqueue(rport_event_queue);
 }
 
-
 int fc_rport_init(struct fc_lport *lport)
 {
         if (!lport->tt.rport_create)