自学教程：C++ FC_LPORT_DBG函数代码示例

/** * fc_lport_rport_callback() - Event handler for rport events * @lport: The lport which is receiving the event * @rdata: private remote port data * @event: The event that occured * * Locking Note: The rport lock should not be held when calling *		 this function. */static void fc_lport_rport_callback(struct fc_lport *lport,				    struct fc_rport_priv *rdata,				    enum fc_rport_event event){	FC_LPORT_DBG(lport, "Received a %d event for port (%6.6x)/n", event,		     rdata->ids.port_id);	mutex_lock(&lport->lp_mutex);	switch (event) {	case RPORT_EV_READY:		if (lport->state == LPORT_ST_DNS) {			lport->dns_rdata = rdata;			fc_lport_enter_ns(lport, LPORT_ST_RNN_ID);		} else {			FC_LPORT_DBG(lport, "Received an READY event "				     "on port (%6.6x) for the directory "				     "server, but the lport is not "				     "in the DNS state, it's in the "				     "%d state", rdata->ids.port_id,				     lport->state);			lport->tt.rport_logoff(rdata);		}		break;	case RPORT_EV_LOGO:	case RPORT_EV_FAILED:	case RPORT_EV_STOP:		lport->dns_rdata = NULL;		break;	case RPORT_EV_NONE:		break;	}	mutex_unlock(&lport->lp_mutex);}

static void fc_lport_recv_flogi_req(struct fc_lport *lport,				    struct fc_frame *rx_fp){	struct fc_frame *fp;	struct fc_frame_header *fh;	struct fc_els_flogi *flp;	struct fc_els_flogi *new_flp;	u64 remote_wwpn;	u32 remote_fid;	u32 local_fid;	FC_LPORT_DBG(lport, "Received FLOGI request while in state %s/n",		     fc_lport_state(lport));	remote_fid = fc_frame_sid(rx_fp);	flp = fc_frame_payload_get(rx_fp, sizeof(*flp));	if (!flp)		goto out;	remote_wwpn = get_unaligned_be64(&flp->fl_wwpn);	if (remote_wwpn == lport->wwpn) {		printk(KERN_WARNING "host%d: libfc: Received FLOGI from port "		       "with same WWPN %16.16llx/n",		       lport->host->host_no, remote_wwpn);		goto out;	}	FC_LPORT_DBG(lport, "FLOGI from port WWPN %16.16llx/n", remote_wwpn);	local_fid = FC_LOCAL_PTP_FID_LO;	if (remote_wwpn < lport->wwpn) {		local_fid = FC_LOCAL_PTP_FID_HI;		if (!remote_fid || remote_fid == local_fid)			remote_fid = FC_LOCAL_PTP_FID_LO;	} else if (!remote_fid) {		remote_fid = FC_LOCAL_PTP_FID_HI;	}	fc_lport_set_port_id(lport, local_fid, rx_fp);	fp = fc_frame_alloc(lport, sizeof(*flp));	if (fp) {		new_flp = fc_frame_payload_get(fp, sizeof(*flp));		fc_lport_flogi_fill(lport, new_flp, ELS_FLOGI);		new_flp->fl_cmd = (u8) ELS_LS_ACC;		fc_fill_reply_hdr(fp, rx_fp, FC_RCTL_ELS_REP, 0);		fh = fc_frame_header_get(fp);		hton24(fh->fh_s_id, local_fid);		hton24(fh->fh_d_id, remote_fid);		lport->tt.frame_send(lport, fp);	} else {		fc_lport_error(lport, fp);	}	fc_lport_ptp_setup(lport, remote_fid, remote_wwpn,			   get_unaligned_be64(&flp->fl_wwnn));out:	fc_frame_free(rx_fp);}

/** * fc_lport_error() - Handler for any errors * @lport: The local port that the error was on * @fp:	   The error code encoded in a frame pointer * * If the error was caused by a resource allocation failure * then wait for half a second and retry, otherwise retry * after the e_d_tov time. */static void fc_lport_error(struct fc_lport *lport, struct fc_frame *fp){	unsigned long delay = 0;	FC_LPORT_DBG(lport, "Error %ld in state %s, retries %d/n",		     PTR_ERR(fp), fc_lport_state(lport),		     lport->retry_count);	if (PTR_ERR(fp) == -FC_EX_CLOSED)		return;	/*	 * Memory allocation failure, or the exchange timed out	 * or we received LS_RJT.	 * Retry after delay	 */	if (lport->retry_count < lport->max_retry_count) {		lport->retry_count++;		if (!fp)			delay = msecs_to_jiffies(500);		else			delay =	msecs_to_jiffies(lport->e_d_tov);		schedule_delayed_work(&lport->retry_work, delay);	} else		fc_lport_enter_reset(lport);}

static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,				   struct fc_lport *lport){	struct fc_frame *fp;	struct fc_exch *ep = fc_seq_exch(sp);	unsigned int len;	void *pp;	void *dp;	u32 f_ctl;	FC_LPORT_DBG(lport, "Received ECHO 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);	if (len < sizeof(__be32))		len = sizeof(__be32);	fp = fc_frame_alloc(lport, len);	if (fp) {		dp = fc_frame_payload_get(fp, len);		memcpy(dp, pp, len);		*((__be32 *)dp) = htonl(ELS_LS_ACC << 24);		sp = lport->tt.seq_start_next(sp);		f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ;		fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,			       FC_TYPE_ELS, f_ctl, 0);		lport->tt.seq_send(lport, sp, fp);	}	fc_frame_free(in_fp);}

/** * fc_rport_enter_flogi() - Send a FLOGI request to the fabric manager * @lport: Fibre Channel local port to be logged in to the fabric * * Locking Note: The lport lock is expected to be held before calling * this routine. */void fc_lport_enter_flogi(struct fc_lport *lport){	struct fc_frame *fp;	FC_LPORT_DBG(lport, "Entered FLOGI state from %s state/n",		     fc_lport_state(lport));	fc_lport_state_enter(lport, LPORT_ST_FLOGI);	if (lport->point_to_multipoint) {		if (lport->port_id)			fc_lport_enter_ready(lport);		return;	}	fp = fc_frame_alloc(lport, sizeof(struct fc_els_flogi));	if (!fp)		return fc_lport_error(lport, fp);	if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp,				  lport->vport ? ELS_FDISC : ELS_FLOGI,				  fc_lport_flogi_resp, lport,				  lport->vport ? 2 * lport->r_a_tov :				  lport->e_d_tov))		fc_lport_error(lport, NULL);}

/** * fc_lport_recv_echo_req() - Handle received ECHO request * @lport: The local port recieving the ECHO * @fp:	   ECHO request frame * * Locking Note: The lport lock is expected to be held before calling * this function. */static void fc_lport_recv_echo_req(struct fc_lport *lport,				   struct fc_frame *in_fp){	struct fc_frame *fp;	unsigned int len;	void *pp;	void *dp;	FC_LPORT_DBG(lport, "Received ECHO 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);	if (len < sizeof(__be32))		len = sizeof(__be32);	fp = fc_frame_alloc(lport, len);	if (fp) {		dp = fc_frame_payload_get(fp, len);		memcpy(dp, pp, len);		*((__be32 *)dp) = htonl(ELS_LS_ACC << 24);		fc_fill_reply_hdr(fp, in_fp, FC_RCTL_ELS_REP, 0);		lport->tt.frame_send(lport, fp);	}	fc_frame_free(in_fp);}

/** * fc_lport_recv_rlir_req() - Handle received Registered Link Incident Report. * @lport: Fibre Channel local port recieving the RLIR * @fp:	   The RLIR request frame * * Locking Note: The lport lock is expected to be held before calling * this function. */static void fc_lport_recv_rlir_req(struct fc_lport *lport, struct fc_frame *fp){	FC_LPORT_DBG(lport, "Received RLIR request while in state %s/n",		     fc_lport_state(lport));	lport->tt.seq_els_rsp_send(fp, ELS_LS_ACC, NULL);	fc_frame_free(fp);}

/** * fc_lport_enter_ns() - register some object with the name server * @lport: Fibre Channel local port to register * * Locking Note: The lport lock is expected to be held before calling * this routine. */static void fc_lport_enter_ns(struct fc_lport *lport, enum fc_lport_state state){	struct fc_frame *fp;	enum fc_ns_req cmd;	int size = sizeof(struct fc_ct_hdr);	size_t len;	FC_LPORT_DBG(lport, "Entered %s state from %s state/n",		     fc_lport_state_names[state],		     fc_lport_state(lport));	fc_lport_state_enter(lport, state);	switch (state) {	case LPORT_ST_RNN_ID:		cmd = FC_NS_RNN_ID;		size += sizeof(struct fc_ns_rn_id);		break;	case LPORT_ST_RSNN_NN:		len = strnlen(fc_host_symbolic_name(lport->host), 255);		/* if there is no symbolic name, skip to RFT_ID */		if (!len)			return fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);		cmd = FC_NS_RSNN_NN;		size += sizeof(struct fc_ns_rsnn) + len;		break;	case LPORT_ST_RSPN_ID:		len = strnlen(fc_host_symbolic_name(lport->host), 255);		/* if there is no symbolic name, skip to RFT_ID */		if (!len)			return fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);		cmd = FC_NS_RSPN_ID;		size += sizeof(struct fc_ns_rspn) + len;		break;	case LPORT_ST_RFT_ID:		cmd = FC_NS_RFT_ID;		size += sizeof(struct fc_ns_rft);		break;	case LPORT_ST_RFF_ID:		cmd = FC_NS_RFF_ID;		size += sizeof(struct fc_ns_rff_id);		break;	default:		fc_lport_error(lport, NULL);		return;	}	fp = fc_frame_alloc(lport, size);	if (!fp) {		fc_lport_error(lport, fp);		return;	}	if (!lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, cmd,				  fc_lport_ns_resp,				  lport, 3 * lport->r_a_tov))		fc_lport_error(lport, fp);}

static void fc_lport_recv_req(struct fc_lport *lport, struct fc_seq *sp,			      struct fc_frame *fp){	struct fc_frame_header *fh = fc_frame_header_get(fp);	void (*recv) (struct fc_seq *, struct fc_frame *, struct fc_lport *);	mutex_lock(&lport->lp_mutex);	/*	 * Handle special ELS cases like FLOGI, LOGO, and	 * RSCN here.  These don't require a session.	 * Even if we had a session, it might not be ready.	 */	if (!lport->link_up)		fc_frame_free(fp);	else if (fh->fh_type == FC_TYPE_ELS &&		 fh->fh_r_ctl == FC_RCTL_ELS_REQ) {		/*		 * Check opcode.		 */		recv = lport->tt.rport_recv_req;		switch (fc_frame_payload_op(fp)) {		case ELS_FLOGI:			recv = fc_lport_recv_flogi_req;			break;		case ELS_LOGO:			fh = fc_frame_header_get(fp);			if (ntoh24(fh->fh_s_id) == FC_FID_FLOGI)				recv = fc_lport_recv_logo_req;			break;		case ELS_RSCN:			recv = lport->tt.disc_recv_req;			break;		case ELS_ECHO:			recv = fc_lport_recv_echo_req;			break;		case ELS_RLIR:			recv = fc_lport_recv_rlir_req;			break;		case ELS_RNID:			recv = fc_lport_recv_rnid_req;			break;		}		recv(sp, fp, lport);	} else {		FC_LPORT_DBG(lport, "dropping invalid frame (eof %x)/n",			     fr_eof(fp));		fc_frame_free(fp);	}	mutex_unlock(&lport->lp_mutex);	/*	 *  The common exch_done for all request may not be good	 *  if any request requires longer hold on exhange. XXX	 */	lport->tt.exch_done(sp);}

static void fc_lport_recv_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp,				   struct fc_lport *lport){	struct fc_frame *fp;	struct fc_exch *ep = fc_seq_exch(sp);	struct fc_els_rnid *req;	struct {		struct fc_els_rnid_resp rnid;		struct fc_els_rnid_cid cid;		struct fc_els_rnid_gen gen;	} *rp;	struct fc_seq_els_data rjt_data;	u8 fmt;	size_t len;	u32 f_ctl;	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) {		rjt_data.fp = NULL;		rjt_data.reason = ELS_RJT_LOGIC;		rjt_data.explan = ELS_EXPL_NONE;		lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);	} else {		fmt = req->rnid_fmt;		len = sizeof(*rp);		if (fmt != ELS_RNIDF_GEN ||		    ntohl(lport->rnid_gen.rnid_atype) == 0) {			fmt = ELS_RNIDF_NONE;	/* nothing to provide */			len -= sizeof(rp->gen);		}		fp = fc_frame_alloc(lport, len);		if (fp) {			rp = fc_frame_payload_get(fp, len);			memset(rp, 0, len);			rp->rnid.rnid_cmd = ELS_LS_ACC;			rp->rnid.rnid_fmt = fmt;			rp->rnid.rnid_cid_len = sizeof(rp->cid);			rp->cid.rnid_wwpn = htonll(lport->wwpn);			rp->cid.rnid_wwnn = htonll(lport->wwnn);			if (fmt == ELS_RNIDF_GEN) {				rp->rnid.rnid_sid_len = sizeof(rp->gen);				memcpy(&rp->gen, &lport->rnid_gen,				       sizeof(rp->gen));			}			sp = lport->tt.seq_start_next(sp);			f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ;			f_ctl |= FC_FC_END_SEQ | FC_FC_SEQ_INIT;			fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,				       FC_TYPE_ELS, f_ctl, 0);			lport->tt.seq_send(lport, sp, fp);		}	}	fc_frame_free(in_fp);}

/** * fc_rport_enter_ready() - Enter the ready state and start discovery * @lport: The local port that is ready * * Locking Note: The lport lock is expected to be held before calling * this routine. */static void fc_lport_enter_ready(struct fc_lport *lport){	FC_LPORT_DBG(lport, "Entered READY from state %s/n",		     fc_lport_state(lport));	fc_lport_state_enter(lport, LPORT_ST_READY);	if (lport->vport)		fc_vport_set_state(lport->vport, FC_VPORT_ACTIVE);	fc_vports_linkchange(lport);	if (!lport->ptp_rdata)		lport->tt.disc_start(fc_lport_disc_callback, lport);}

/** * fc_lport_recv_req() - The generic lport request handler * @lport: The local port that received the request * @fp:	   The request frame * * This function will see if the lport handles the request or * if an rport should handle the request. * * Locking Note: This function should not be called with the lport *		 lock held becuase it will grab the lock. */static void fc_lport_recv_req(struct fc_lport *lport, struct fc_frame *fp){	struct fc_frame_header *fh = fc_frame_header_get(fp);	void (*recv)(struct fc_lport *, struct fc_frame *);	mutex_lock(&lport->lp_mutex);	/*	 * Handle special ELS cases like FLOGI, LOGO, and	 * RSCN here.  These don't require a session.	 * Even if we had a session, it might not be ready.	 */	if (!lport->link_up)		fc_frame_free(fp);	else if (fh->fh_type == FC_TYPE_ELS &&		 fh->fh_r_ctl == FC_RCTL_ELS_REQ) {		/*		 * Check opcode.		 */		recv = lport->tt.rport_recv_req;		switch (fc_frame_payload_op(fp)) {		case ELS_FLOGI:			if (!lport->point_to_multipoint)				recv = fc_lport_recv_flogi_req;			break;		case ELS_LOGO:			if (fc_frame_sid(fp) == FC_FID_FLOGI)				recv = fc_lport_recv_logo_req;			break;		case ELS_RSCN:			recv = lport->tt.disc_recv_req;			break;		case ELS_ECHO:			recv = fc_lport_recv_echo_req;			break;		case ELS_RLIR:			recv = fc_lport_recv_rlir_req;			break;		case ELS_RNID:			recv = fc_lport_recv_rnid_req;			break;		}		recv(lport, fp);	} else {		FC_LPORT_DBG(lport, "dropping invalid frame (eof %x)/n",			     fr_eof(fp));		fc_frame_free(fp);	}	mutex_unlock(&lport->lp_mutex);}

/** * fc_lport_recv_rnid_req() - Handle received Request Node ID data request * @lport: The local port recieving the RNID * @fp:	   The RNID request frame * * Locking Note: The lport lock is expected to be held before calling * this function. */static void fc_lport_recv_rnid_req(struct fc_lport *lport,				   struct fc_frame *in_fp){	struct fc_frame *fp;	struct fc_els_rnid *req;	struct {		struct fc_els_rnid_resp rnid;		struct fc_els_rnid_cid cid;		struct fc_els_rnid_gen gen;	} *rp;	struct fc_seq_els_data rjt_data;	u8 fmt;	size_t len;	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) {		rjt_data.reason = ELS_RJT_LOGIC;		rjt_data.explan = ELS_EXPL_NONE;		lport->tt.seq_els_rsp_send(in_fp, ELS_LS_RJT, &rjt_data);	} else {		fmt = req->rnid_fmt;		len = sizeof(*rp);		if (fmt != ELS_RNIDF_GEN ||		    ntohl(lport->rnid_gen.rnid_atype) == 0) {			fmt = ELS_RNIDF_NONE;	/* nothing to provide */			len -= sizeof(rp->gen);		}		fp = fc_frame_alloc(lport, len);		if (fp) {			rp = fc_frame_payload_get(fp, len);			memset(rp, 0, len);			rp->rnid.rnid_cmd = ELS_LS_ACC;			rp->rnid.rnid_fmt = fmt;			rp->rnid.rnid_cid_len = sizeof(rp->cid);			rp->cid.rnid_wwpn = htonll(lport->wwpn);			rp->cid.rnid_wwnn = htonll(lport->wwnn);			if (fmt == ELS_RNIDF_GEN) {				rp->rnid.rnid_sid_len = sizeof(rp->gen);				memcpy(&rp->gen, &lport->rnid_gen,				       sizeof(rp->gen));			}			fc_fill_reply_hdr(fp, in_fp, FC_RCTL_ELS_REP, 0);			lport->tt.frame_send(lport, fp);		}	}	fc_frame_free(in_fp);}

/** * fc_lport_logo_resp() - Handle response to LOGO request * @sp:	    The sequence that the LOGO was on * @fp:	    The LOGO frame * @lp_arg: The lport port that received the LOGO request * * Locking Note: This function will be called without the lport lock * held, but it will lock, call an _enter_* function or fc_lport_error() * and then unlock the lport. */void fc_lport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,			void *lp_arg){	struct fc_lport *lport = lp_arg;	u8 op;	FC_LPORT_DBG(lport, "Received a LOGO %s/n", fc_els_resp_type(fp));	if (fp == ERR_PTR(-FC_EX_CLOSED))		return;	mutex_lock(&lport->lp_mutex);	if (lport->state != LPORT_ST_LOGO) {		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;	}	if (IS_ERR(fp)) {		fc_lport_error(lport, fp);		goto err;	}	op = fc_frame_payload_op(fp);	if (op == ELS_LS_ACC)		fc_lport_enter_disabled(lport);	else		fc_lport_error(lport, fp);out:	fc_frame_free(fp);err:	mutex_unlock(&lport->lp_mutex);}

/** * fc_lport_enter_reset() - Reset the local port * @lport: The local port to be reset * * Locking Note: The lport lock is expected to be held before calling * this routine. */static void fc_lport_enter_reset(struct fc_lport *lport){	FC_LPORT_DBG(lport, "Entered RESET state from %s state/n",		     fc_lport_state(lport));	if (lport->vport) {		if (lport->link_up)			fc_vport_set_state(lport->vport, FC_VPORT_INITIALIZING);		else			fc_vport_set_state(lport->vport, FC_VPORT_LINKDOWN);	}	fc_lport_state_enter(lport, LPORT_ST_RESET);	fc_vports_linkchange(lport);	fc_lport_reset_locked(lport);	if (lport->link_up)		fc_lport_enter_flogi(lport);}

static void fc_lport_error(struct fc_lport *lport, struct fc_frame *fp){	unsigned long delay = 0;	FC_LPORT_DBG(lport, "Error %ld in state %s, retries %d/n",		     PTR_ERR(fp), fc_lport_state(lport),		     lport->retry_count);	if (PTR_ERR(fp) == -FC_EX_CLOSED)		return;	if (lport->retry_count < lport->max_retry_count) {		lport->retry_count++;		if (!fp)			delay = msecs_to_jiffies(500);		else			delay =	msecs_to_jiffies(lport->e_d_tov);		schedule_delayed_work(&lport->retry_work, delay);	} else		fc_lport_enter_reset(lport);}

/** * fc_rport_enter_dns() - Create a fc_rport for the name server * @lport: The local port requesting a remote port for the name server * * Locking Note: The lport lock is expected to be held before calling * this routine. */static void fc_lport_enter_dns(struct fc_lport *lport){	struct fc_rport_priv *rdata;	FC_LPORT_DBG(lport, "Entered DNS state from %s state/n",		     fc_lport_state(lport));	fc_lport_state_enter(lport, LPORT_ST_DNS);	mutex_lock(&lport->disc.disc_mutex);	rdata = lport->tt.rport_create(lport, FC_FID_DIR_SERV);	mutex_unlock(&lport->disc.disc_mutex);	if (!rdata)		goto err;	rdata->ops = &fc_lport_rport_ops;	lport->tt.rport_login(rdata);	return;err:	fc_lport_error(lport, NULL);}