C++ sdev_to_zfcp函数代码示例

static void zfcp_erp_lun_unblock(struct scsi_device *sdev)
{
    struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

    if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status))
        zfcp_dbf_rec_run("erlubl1", &sdev_to_zfcp(sdev)->erp_action);
    atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status);
}

static void zfcp_scsi_slave_destroy(struct scsi_device *sdev)
{
	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

	zfcp_erp_lun_shutdown_wait(sdev, "scssd_1");
	put_device(&zfcp_sdev->port->dev);
}

static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
{
    struct zfcp_adapter *adapter = erp_action->adapter;
    struct zfcp_scsi_dev *zfcp_sdev;

    adapter->erp_total_count--;
    if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
        adapter->erp_low_mem_count--;
        erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
    }

    list_del(&erp_action->list);
    zfcp_dbf_rec_run("eractd1", erp_action);

    switch (erp_action->action) {
    case ZFCP_ERP_ACTION_REOPEN_LUN:
        zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
        atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
                          &zfcp_sdev->status);
        break;

    case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
    case ZFCP_ERP_ACTION_REOPEN_PORT:
        atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
                          &erp_action->port->status);
        break;

    case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
        atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
                          &erp_action->adapter->status);
        break;
    }
}

static int zfcp_erp_strategy_check_lun(struct scsi_device *sdev, int result)
{
    struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

    switch (result) {
    case ZFCP_ERP_SUCCEEDED :
        atomic_set(&zfcp_sdev->erp_counter, 0);
        zfcp_erp_lun_unblock(sdev);
        break;
    case ZFCP_ERP_FAILED :
        atomic_inc(&zfcp_sdev->erp_counter);
        if (atomic_read(&zfcp_sdev->erp_counter) > ZFCP_MAX_ERPS) {
            dev_err(&zfcp_sdev->port->adapter->ccw_device->dev,
                    "ERP failed for LUN 0x%016Lx on "
                    "port 0x%016Lx\n",
                    (unsigned long long)zfcp_scsi_dev_lun(sdev),
                    (unsigned long long)zfcp_sdev->port->wwpn);
            zfcp_erp_set_lun_status(sdev,
                                    ZFCP_STATUS_COMMON_ERP_FAILED);
        }
        break;
    }

    if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
        zfcp_erp_lun_block(sdev, 0);
        result = ZFCP_ERP_EXIT;
    }
    return result;
}

static void zfcp_erp_lun_strategy_clearstati(struct scsi_device *sdev)
{
	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

	atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_DENIED,
			  &zfcp_sdev->status);
}

static void zfcp_erp_action_dismiss_lun(struct scsi_device *sdev)
{
    struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

    if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
        zfcp_erp_action_dismiss(&zfcp_sdev->erp_action);
}

/**
 * zfcp_dbf_rec_run_lvl - trace event related to running recovery
 * @level: trace level to be used for event
 * @tag: identifier for event
 * @erp: erp_action running
 */
void zfcp_dbf_rec_run_lvl(int level, char *tag, struct zfcp_erp_action *erp)
{
	struct zfcp_dbf *dbf = erp->adapter->dbf;
	struct zfcp_dbf_rec *rec = &dbf->rec_buf;
	unsigned long flags;

	if (!debug_level_enabled(dbf->rec, level))
		return;

	spin_lock_irqsave(&dbf->rec_lock, flags);
	memset(rec, 0, sizeof(*rec));

	rec->id = ZFCP_DBF_REC_RUN;
	memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
	zfcp_dbf_set_common(rec, erp->adapter, erp->port, erp->sdev);

	rec->u.run.fsf_req_id = erp->fsf_req_id;
	rec->u.run.rec_status = erp->status;
	rec->u.run.rec_step = erp->step;
	rec->u.run.rec_action = erp->action;

	if (erp->sdev)
		rec->u.run.rec_count =
			atomic_read(&sdev_to_zfcp(erp->sdev)->erp_counter);
	else if (erp->port)
		rec->u.run.rec_count = atomic_read(&erp->port->erp_counter);
	else
		rec->u.run.rec_count = atomic_read(&erp->adapter->erp_counter);

	debug_event(dbf->rec, level, rec, sizeof(*rec));
	spin_unlock_irqrestore(&dbf->rec_lock, flags);
}

static struct zfcp_erp_action *zfcp_erp_setup_act(int need, u32 act_status,
        struct zfcp_adapter *adapter,
        struct zfcp_port *port,
        struct scsi_device *sdev)
{
    struct zfcp_erp_action *erp_action;
    struct zfcp_scsi_dev *zfcp_sdev;

    switch (need) {
    case ZFCP_ERP_ACTION_REOPEN_LUN:
        zfcp_sdev = sdev_to_zfcp(sdev);
        if (!(act_status & ZFCP_STATUS_ERP_NO_REF))
            if (scsi_device_get(sdev))
                return NULL;
        atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
                        &zfcp_sdev->status);
        erp_action = &zfcp_sdev->erp_action;
        memset(erp_action, 0, sizeof(struct zfcp_erp_action));
        erp_action->port = port;
        erp_action->sdev = sdev;
        if (!(atomic_read(&zfcp_sdev->status) &
                ZFCP_STATUS_COMMON_RUNNING))
            act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
        break;

    case ZFCP_ERP_ACTION_REOPEN_PORT:
    case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
        if (!get_device(&port->dev))
            return NULL;
        zfcp_erp_action_dismiss_port(port);
        atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
        erp_action = &port->erp_action;
        memset(erp_action, 0, sizeof(struct zfcp_erp_action));
        erp_action->port = port;
        if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_RUNNING))
            act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
        break;

    case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
        kref_get(&adapter->ref);
        zfcp_erp_action_dismiss_adapter(adapter);
        atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
        erp_action = &adapter->erp_action;
        memset(erp_action, 0, sizeof(struct zfcp_erp_action));
        if (!(atomic_read(&adapter->status) &
                ZFCP_STATUS_COMMON_RUNNING))
            act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
        break;

    default:
        return NULL;
    }

    erp_action->adapter = adapter;
    erp_action->action = need;
    erp_action->status = act_status;

    return erp_action;
}

static void zfcp_erp_lun_strategy_clearstati(struct scsi_device *sdev)
{
    struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

    atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
                      ZFCP_STATUS_LUN_SHARED | ZFCP_STATUS_LUN_READONLY,
                      &zfcp_sdev->status);
}

static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,
				     char *id)
{
	struct scsi_device *sdev;

	shost_for_each_device(sdev, port->adapter->scsi_host)
		if (sdev_to_zfcp(sdev)->port == port)
			_zfcp_erp_lun_reopen(sdev, clear, id, 0);
}

static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
{
	struct scsi_device *sdev;

	if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
		zfcp_erp_action_dismiss(&port->erp_action);
	else
		shost_for_each_device(sdev, port->adapter->scsi_host)
			if (sdev_to_zfcp(sdev)->port == port)
				zfcp_erp_action_dismiss_lun(sdev);
}

void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id)
{
    unsigned long flags;
    struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
    struct zfcp_port *port = zfcp_sdev->port;
    struct zfcp_adapter *adapter = port->adapter;

    write_lock_irqsave(&adapter->erp_lock, flags);
    _zfcp_erp_lun_reopen(sdev, clear, id, 0);
    write_unlock_irqrestore(&adapter->erp_lock, flags);
}

static void zfcp_scsi_slave_destroy(struct scsi_device *sdev)
{
	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

	/* if previous slave_alloc returned early, there is nothing to do */
	if (!zfcp_sdev->port)
		return;

	zfcp_erp_lun_shutdown_wait(sdev, "scssd_1");
	put_device(&zfcp_sdev->port->dev);
}

/**
 * zfcp_erp_try_rport_unblock - unblock rport if no more/new recovery
 * @port: zfcp_port whose fc_rport we should try to unblock
 */
static void zfcp_erp_try_rport_unblock(struct zfcp_port *port)
{
	unsigned long flags;
	struct zfcp_adapter *adapter = port->adapter;
	int port_status;
	struct Scsi_Host *shost = adapter->scsi_host;
	struct scsi_device *sdev;

	write_lock_irqsave(&adapter->erp_lock, flags);
	port_status = atomic_read(&port->status);
	if ((port_status & ZFCP_STATUS_COMMON_UNBLOCKED)    == 0 ||
	    (port_status & (ZFCP_STATUS_COMMON_ERP_INUSE |
			    ZFCP_STATUS_COMMON_ERP_FAILED)) != 0) {
		/* new ERP of severity >= port triggered elsewhere meanwhile or
		 * local link down (adapter erp_failed but not clear unblock)
		 */
		zfcp_dbf_rec_run_lvl(4, "ertru_p", &port->erp_action);
		write_unlock_irqrestore(&adapter->erp_lock, flags);
		return;
	}
	spin_lock(shost->host_lock);
	__shost_for_each_device(sdev, shost) {
		struct zfcp_scsi_dev *zsdev = sdev_to_zfcp(sdev);
		int lun_status;

		if (zsdev->port != port)
			continue;
		/* LUN under port of interest */
		lun_status = atomic_read(&zsdev->status);
		if ((lun_status & ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
			continue; /* unblock rport despite failed LUNs */
		/* LUN recovery not given up yet [maybe follow-up pending] */
		if ((lun_status & ZFCP_STATUS_COMMON_UNBLOCKED) == 0 ||
		    (lun_status & ZFCP_STATUS_COMMON_ERP_INUSE) != 0) {
			/* LUN blocked:
			 * not yet unblocked [LUN recovery pending]
			 * or meanwhile blocked [new LUN recovery triggered]
			 */
			zfcp_dbf_rec_run_lvl(4, "ertru_l", &zsdev->erp_action);
			spin_unlock(shost->host_lock);
			write_unlock_irqrestore(&adapter->erp_lock, flags);
			return;
		}
	}
	/* now port has no child or all children have completed recovery,
	 * and no ERP of severity >= port was meanwhile triggered elsewhere
	 */
	zfcp_scsi_schedule_rport_register(port);
	spin_unlock(shost->host_lock);
	write_unlock_irqrestore(&adapter->erp_lock, flags);
}

void zfcp_erp_lun_shutdown_wait(struct scsi_device *sdev, char *id)
{
    unsigned long flags;
    struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
    struct zfcp_port *port = zfcp_sdev->port;
    struct zfcp_adapter *adapter = port->adapter;
    int clear = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;

    write_lock_irqsave(&adapter->erp_lock, flags);
    _zfcp_erp_lun_reopen(sdev, clear, id, ZFCP_STATUS_ERP_NO_REF);
    write_unlock_irqrestore(&adapter->erp_lock, flags);

    zfcp_erp_wait(adapter);
}