Quelle  ccwreq.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 *  Handling of internal CCW device requests.
 *
 *    Copyright IBM Corp. 2009, 2011
 *    Author(s): Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
 */

#define KMSG_COMPONENT "cio"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

#include <linux/types.h>
#include <linux/err.h>
#include <asm/ccwdev.h>
#include <asm/cio.h>

#include "io_sch.h"
#include "cio.h"
#include "device.h"
#include "cio_debug.h"

/**
 * lpm_adjust - adjust path mask
 * @lpm: path mask to adjust
 * @mask: mask of available paths
 *
 * Shift @lpm right until @lpm and @mask have at least one bit in common or
 * until @lpm is zero. Return the resulting lpm.
 */
int lpm_adjust(int lpm, int mask)
{
 while (lpm && ((lpm & mask) == 0))
  lpm >>= 1;
 return lpm;
}

/*
 * Adjust path mask to use next path and reset retry count. Return resulting
 * path mask.
 */
static u16 ccwreq_next_path(struct ccw_device *cdev)
{
 struct ccw_request *req = &cdev->private->req;

 if (!req->singlepath) {
  req->mask = 0;
  goto out;
 }
 req->retries = req->maxretries;
 req->mask = lpm_adjust(req->mask >> 1, req->lpm);
out:
 return req->mask;
}

/*
 * Clean up device state and report to callback.
 */
static void ccwreq_stop(struct ccw_device *cdev, int rc)
{
 struct ccw_request *req = &cdev->private->req;

 if (req->done)
  return;
 req->done = 1;
 ccw_device_set_timeout(cdev, 0);
 memset(&cdev->private->dma_area->irb, 0, sizeof(struct irb));
 if (rc && rc != -ENODEV && req->drc)
  rc = req->drc;
 req->callback(cdev, req->data, rc);
}

/*
 * (Re-)Start the operation until retries and paths are exhausted.
 */
static void ccwreq_do(struct ccw_device *cdev)
{
 struct ccw_request *req = &cdev->private->req;
 struct subchannel *sch = to_subchannel(cdev->dev.parent);
 struct ccw1 *cp = req->cp;
 int rc = -EACCES;

 while (req->mask) {
  if (req->retries-- == 0) {
   /* Retries exhausted, try next path. */
   ccwreq_next_path(cdev);
   continue;
  }
  /* Perform start function. */
  memset(&cdev->private->dma_area->irb, 0, sizeof(struct irb));
  rc = cio_start(sch, cp, (u8) req->mask);
  if (rc == 0) {
   /* I/O started successfully. */
   ccw_device_set_timeout(cdev, req->timeout);
   return;
  }
  if (rc == -ENODEV) {
   /* Permanent device error. */
   break;
  }
  if (rc == -EACCES) {
   /* Permant path error. */
   ccwreq_next_path(cdev);
   continue;
  }
  /* Temporary improper status. */
  rc = cio_clear(sch);
  if (rc)
   break;
  return;
 }
 ccwreq_stop(cdev, rc);
}

/**
 * ccw_request_start - perform I/O request
 * @cdev: ccw device
 *
 * Perform the I/O request specified by cdev->req.
 */
void ccw_request_start(struct ccw_device *cdev)
{
 struct ccw_request *req = &cdev->private->req;

 if (req->singlepath) {
  /* Try all paths twice to counter link flapping. */
  req->mask = 0x8080;
 } else
  req->mask = req->lpm;

 req->retries = req->maxretries;
 req->mask = lpm_adjust(req->mask, req->lpm);
 req->drc = 0;
 req->done = 0;
 req->cancel = 0;
 if (!req->mask)
  goto out_nopath;
 ccwreq_do(cdev);
 return;

out_nopath:
 ccwreq_stop(cdev, -EACCES);
}

/**
 * ccw_request_cancel - cancel running I/O request
 * @cdev: ccw device
 *
 * Cancel the I/O request specified by cdev->req. Return non-zero if request
 * has already finished, zero otherwise.
 */
int ccw_request_cancel(struct ccw_device *cdev)
{
 struct subchannel *sch = to_subchannel(cdev->dev.parent);
 struct ccw_request *req = &cdev->private->req;
 int rc;

 if (req->done)
  return 1;
 req->cancel = 1;
 rc = cio_clear(sch);
 if (rc)
  ccwreq_stop(cdev, rc);
 return 0;
}

/*
 * Return the status of the internal I/O started on the specified ccw device.
 * Perform BASIC SENSE if required.
 */
static enum io_status ccwreq_status(struct ccw_device *cdev, struct irb *lcirb)
{
 struct irb *irb = &cdev->private->dma_area->irb;
 struct cmd_scsw *scsw = &irb->scsw.cmd;
 enum uc_todo todo;

 /* Perform BASIC SENSE if needed. */
 if (ccw_device_accumulate_and_sense(cdev, lcirb))
  return IO_RUNNING;
 /* Check for halt/clear interrupt. */
 if (scsw->fctl & (SCSW_FCTL_HALT_FUNC | SCSW_FCTL_CLEAR_FUNC))
  return IO_KILLED;
 /* Check for path error. */
 if (scsw->cc == 3 || scsw->pno)
  return IO_PATH_ERROR;
 /* Handle BASIC SENSE data. */
 if (irb->esw.esw0.erw.cons) {
  CIO_TRACE_EVENT(2, "sensedata");
  CIO_HEX_EVENT(2, &cdev->private->dev_id,
         sizeof(struct ccw_dev_id));
  CIO_HEX_EVENT(2, &cdev->private->dma_area->irb.ecw,
         SENSE_MAX_COUNT);
  /* Check for command reject. */
  if (irb->ecw[0] & SNS0_CMD_REJECT)
   return IO_REJECTED;
  /* Ask the driver what to do */
  if (cdev->drv && cdev->drv->uc_handler) {
   todo = cdev->drv->uc_handler(cdev, lcirb);
   CIO_TRACE_EVENT(2, "uc_response");
   CIO_HEX_EVENT(2, &todo, sizeof(todo));
   switch (todo) {
   case UC_TODO_RETRY:
    return IO_STATUS_ERROR;
   case UC_TODO_RETRY_ON_NEW_PATH:
    return IO_PATH_ERROR;
   case UC_TODO_STOP:
    return IO_REJECTED;
   default:
    return IO_STATUS_ERROR;
   }
  }
  /* Assume that unexpected SENSE data implies an error. */
  return IO_STATUS_ERROR;
 }
 /* Check for channel errors. */
 if (scsw->cstat != 0)
  return IO_STATUS_ERROR;
 /* Check for device errors. */
 if (scsw->dstat & ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END))
  return IO_STATUS_ERROR;
 /* Check for final state. */
 if (!(scsw->dstat & DEV_STAT_DEV_END))
  return IO_RUNNING;
 /* Check for other improper status. */
 if (scsw->cc == 1 && (scsw->stctl & SCSW_STCTL_ALERT_STATUS))
  return IO_STATUS_ERROR;
 return IO_DONE;
}

/*
 * Log ccw request status.
 */
static void ccwreq_log_status(struct ccw_device *cdev, enum io_status status)
{
 struct ccw_request *req = &cdev->private->req;
 struct {
  struct ccw_dev_id dev_id;
  u16 retries;
  u8 lpm;
  u8 status;
 }  __attribute__ ((packed)) data;
 data.dev_id = cdev->private->dev_id;
 data.retries = req->retries;
 data.lpm = (u8) req->mask;
 data.status = (u8) status;
 CIO_TRACE_EVENT(2, "reqstat");
 CIO_HEX_EVENT(2, &data, sizeof(data));
}

/**
 * ccw_request_handler - interrupt handler for I/O request procedure.
 * @cdev: ccw device
 *
 * Handle interrupt during I/O request procedure.
 */
void ccw_request_handler(struct ccw_device *cdev)
{
 struct irb *irb = this_cpu_ptr(&cio_irb);
 struct ccw_request *req = &cdev->private->req;
 enum io_status status;
 int rc = -EOPNOTSUPP;

 /* Check status of I/O request. */
 status = ccwreq_status(cdev, irb);
 if (req->filter)
  status = req->filter(cdev, req->data, irb, status);
 if (status != IO_RUNNING)
  ccw_device_set_timeout(cdev, 0);
 if (status != IO_DONE && status != IO_RUNNING)
  ccwreq_log_status(cdev, status);
 switch (status) {
 case IO_DONE:
  break;
 case IO_RUNNING:
  return;
 case IO_REJECTED:
  goto err;
 case IO_PATH_ERROR:
  goto out_next_path;
 case IO_STATUS_ERROR:
  goto out_restart;
 case IO_KILLED:
  /* Check if request was cancelled on purpose. */
  if (req->cancel) {
   rc = -EIO;
   goto err;
  }
  goto out_restart;
 }
 /* Check back with request initiator. */
 if (!req->check)
  goto out;
 switch (req->check(cdev, req->data)) {
 case 0:
  break;
 case -EAGAIN:
  goto out_restart;
 case -EACCES:
  goto out_next_path;
 default:
  goto err;
 }
out:
 ccwreq_stop(cdev, 0);
 return;

out_next_path:
 /* Try next path and restart I/O. */
 if (!ccwreq_next_path(cdev)) {
  rc = -EACCES;
  goto err;
 }
out_restart:
 /* Restart. */
 ccwreq_do(cdev);
 return;
err:
 ccwreq_stop(cdev, rc);
}


/**
 * ccw_request_timeout - timeout handler for I/O request procedure
 * @cdev: ccw device
 *
 * Handle timeout during I/O request procedure.
 */
void ccw_request_timeout(struct ccw_device *cdev)
{
 struct subchannel *sch = to_subchannel(cdev->dev.parent);
 struct ccw_request *req = &cdev->private->req;
 int rc = -ENODEV, chp;

 if (cio_update_schib(sch))
  goto err;

 for (chp = 0; chp < 8; chp++) {
  if ((0x80 >> chp) & sch->schib.pmcw.lpum)
   pr_warn("%s: No interrupt was received within %lus (CS=%02x, DS=%02x, CHPID=%x.%02x)\n",
    dev_name(&cdev->dev), req->timeout / HZ,
    scsw_cstat(&sch->schib.scsw),
    scsw_dstat(&sch->schib.scsw),
    sch->schid.cssid,
    sch->schib.pmcw.chpid[chp]);
 }

 if (!ccwreq_next_path(cdev)) {
  /* set the final return code for this request */
  req->drc = -ETIME;
 }
 rc = cio_clear(sch);
 if (rc)
  goto err;
 return;

err:
 ccwreq_stop(cdev, rc);
}

/**
 * ccw_request_notoper - notoper handler for I/O request procedure
 * @cdev: ccw device
 *
 * Handle notoper during I/O request procedure.
 */
void ccw_request_notoper(struct ccw_device *cdev)
{
 ccwreq_stop(cdev, -ENODEV);
}