LXR linux/include/scsi/scsi_transport

   1/* SPDX-License-Identifier: GPL-2.0 */
   2#ifndef SCSI_TRANSPORT_SRP_H
   3#define SCSI_TRANSPORT_SRP_H
   4
   5#include <linux/transport_class.h>
   6#include <linux/types.h>
   7#include <linux/mutex.h>
   8
   9#define SRP_RPORT_ROLE_INITIATOR 0
  10#define SRP_RPORT_ROLE_TARGET 1
  11
  12struct srp_rport_identifiers {
  13        u8 port_id[16];
  14        u8 roles;
  15};
  16
  17/**
  18 * enum srp_rport_state - SRP transport layer state
  19 * @SRP_RPORT_RUNNING:   Transport layer operational.
  20 * @SRP_RPORT_BLOCKED:   Transport layer not operational; fast I/O fail timer
  21 *                       is running and I/O has been blocked.
  22 * @SRP_RPORT_FAIL_FAST: Fast I/O fail timer has expired; fail I/O fast.
  23 * @SRP_RPORT_LOST:      Port is being removed.
  24 */
  25enum srp_rport_state {
  26        SRP_RPORT_RUNNING,
  27        SRP_RPORT_BLOCKED,
  28        SRP_RPORT_FAIL_FAST,
  29        SRP_RPORT_LOST,
  30};
  31
  32/**
  33 * struct srp_rport - SRP initiator or target port
  34 *
  35 * Fields that are relevant for SRP initiator and SRP target drivers:
  36 * @dev:               Device associated with this rport.
  37 * @port_id:           16-byte port identifier.
  38 * @roles:             Role of this port - initiator or target.
  39 *
  40 * Fields that are only relevant for SRP initiator drivers:
  41 * @lld_data:          LLD private data.
  42 * @mutex:             Protects against concurrent rport reconnect /
  43 *                     fast_io_fail / dev_loss_tmo activity.
  44 * @state:             rport state.
  45 * @reconnect_delay:   Reconnect delay in seconds.
  46 * @failed_reconnects: Number of failed reconnect attempts.
  47 * @reconnect_work:    Work structure used for scheduling reconnect attempts.
  48 * @fast_io_fail_tmo:  Fast I/O fail timeout in seconds.
  49 * @dev_loss_tmo:      Device loss timeout in seconds.
  50 * @fast_io_fail_work: Work structure used for scheduling fast I/O fail work.
  51 * @dev_loss_work:     Work structure used for scheduling device loss work.
  52 */
  53struct srp_rport {
  54        /* for initiator and target drivers */
  55
  56        struct device dev;
  57
  58        u8 port_id[16];
  59        u8 roles;
  60
  61        /* for initiator drivers */
  62
  63        void                    *lld_data;
  64
  65        struct mutex            mutex;
  66        enum srp_rport_state    state;
  67        int                     reconnect_delay;
  68        int                     failed_reconnects;
  69        struct delayed_work     reconnect_work;
  70        int                     fast_io_fail_tmo;
  71        int                     dev_loss_tmo;
  72        struct delayed_work     fast_io_fail_work;
  73        struct delayed_work     dev_loss_work;
  74};
  75
  76/**
  77 * struct srp_function_template
  78 *
  79 * Fields that are only relevant for SRP initiator drivers:
  80 * @has_rport_state: Whether or not to create the state, fast_io_fail_tmo and
  81 *     dev_loss_tmo sysfs attribute for an rport.
  82 * @reset_timer_if_blocked: Whether or srp_timed_out() should reset the command
  83 *     timer if the device on which it has been queued is blocked.
  84 * @reconnect_delay: If not NULL, points to the default reconnect_delay value.
  85 * @fast_io_fail_tmo: If not NULL, points to the default fast_io_fail_tmo value.
  86 * @dev_loss_tmo: If not NULL, points to the default dev_loss_tmo value.
  87 * @reconnect: Callback function for reconnecting to the target. See also
  88 *     srp_reconnect_rport().
  89 * @terminate_rport_io: Callback function for terminating all outstanding I/O
  90 *     requests for an rport.
  91 * @rport_delete: Callback function that deletes an rport.
  92 */
  93struct srp_function_template {
  94        /* for initiator drivers */
  95        bool has_rport_state;
  96        bool reset_timer_if_blocked;
  97        int *reconnect_delay;
  98        int *fast_io_fail_tmo;
  99        int *dev_loss_tmo;
 100        int (*reconnect)(struct srp_rport *rport);
 101        void (*terminate_rport_io)(struct srp_rport *rport);
 102        void (*rport_delete)(struct srp_rport *rport);
 103};
 104
 105extern struct scsi_transport_template *
 106srp_attach_transport(struct srp_function_template *);
 107extern void srp_release_transport(struct scsi_transport_template *);
 108
 109extern void srp_rport_get(struct srp_rport *rport);
 110extern void srp_rport_put(struct srp_rport *rport);
 111extern struct srp_rport *srp_rport_add(struct Scsi_Host *,
 112                                       struct srp_rport_identifiers *);
 113extern void srp_rport_del(struct srp_rport *);
 114extern int srp_tmo_valid(int reconnect_delay, int fast_io_fail_tmo,
 115                         long dev_loss_tmo);
 116int srp_parse_tmo(int *tmo, const char *buf);
 117extern int srp_reconnect_rport(struct srp_rport *rport);
 118extern void srp_start_tl_fail_timers(struct srp_rport *rport);
 119extern void srp_remove_host(struct Scsi_Host *);
 120extern void srp_stop_rport_timers(struct srp_rport *rport);
 121enum blk_eh_timer_return srp_timed_out(struct scsi_cmnd *scmd);
 122
 123/**
 124 * srp_chkready() - evaluate the transport layer state before I/O
 125 * @rport: SRP target port pointer.
 126 *
 127 * Returns a SCSI result code that can be returned by the LLD queuecommand()
 128 * implementation. The role of this function is similar to that of
 129 * fc_remote_port_chkready().
 130 */
 131static inline int srp_chkready(struct srp_rport *rport)
 132{
 133        switch (rport->state) {
 134        case SRP_RPORT_RUNNING:
 135        case SRP_RPORT_BLOCKED:
 136        default:
 137                return 0;
 138        case SRP_RPORT_FAIL_FAST:
 139                return DID_TRANSPORT_FAILFAST << 16;
 140        case SRP_RPORT_LOST:
 141                return DID_NO_CONNECT << 16;
 142        }
 143}
 144
 145#endif
 146