t10.h revision 36c5fee33fa8b822175d410202aebcf592c8d342
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#ifndef _T10_H
#define _T10_H
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* This header file describes the service level between the transport
* layer and the emulation portion. These procedure calls can be thought
* of as part of the T10 SAM-3 specification.
*/
#ifdef __cplusplus
extern "C" {
#endif
/*
* Here are the header files which are required to define references found
* in this file. No other header files are to be included.
*/
#include <pthread.h>
#include <signal.h>
#include "queue.h"
#ifdef lint
/*
* lints sees aio_return64, but can't find it in the aio structure. To keep
* lint happy this define is used.
*/
#define aio_return64 aio_return
#endif
typedef void *transport_t;
typedef void *t10_targ_handle_t;
typedef void *t10_lun_handle_t;
typedef void *emul_handle_t;
typedef void *emul_cmd_t;
typedef enum {
} TaskOp_t;
typedef enum {
T10_Cmd_Free = 1,
typedef enum {
typedef enum {
/*
* The t10_cmd_t structure bridges the gap between the transport and
* emulation services. At certain times either the transport or emulation
* service needs to access the data stored within this structure.
* For now we'll just use macros which hide the reference, but in the
* future when the transport and emulation services are loadable modules
* these macros will become functions so that the structure can change
* inside of the T10 space and not cause compatibility issues.
*/
#define T10_DEFAULT_TPG 1
/*
* []------------------------------------------------------------------[]
* | SAM-3 revision 14, section 4.9 -- Logical Unit Numbers |
* | The specification allows for 64-bit LUNs, but at this point |
* | most OSes don't support that many. Section 4.9.7, table 9 gives |
* | the Flat Space Addressing Method which allows for 16,383 LUNs. |
* | This will be the imposed maximum even though the code can support |
* | more. Raise this number if needed. |
* []------------------------------------------------------------------[]
*/
#define T10_MAX_LUNS 16383
/*
* SPC-3 Revision 21c, Section 6.4.2 Table 85
* Version Descriptor Values
*/
typedef struct t10_aio {
/*
* take as one of the arguments an pointer to a aio_result_t
* structure. When the operation is complete the aio_return and
* aio_errno of that structure are updated. When aiowait() is
* called the address of that aio_result_t is returned. By having
* this structure at the beginning we can pass in the data_ptr
* structure address. The ste_aio_process thread will get everything
* it needs from the aiowait to send a message to the correct
* STE thread. Clear as mud?
*/
} t10_aio_t;
/*
* Bidirectional structure used to track requests from the transport
* and send reponse data from the emulation.
*
* The glue logic for t10_send_cmd will allocate this structure, fill in
* in with the provided data and put it on the LUN queue. The LUN thread
* will dequeue this request and call the appropriate LUN command interpreter.
*/
typedef struct t10_cmd {
/*
* Transport specific tracking value. If this value is non-zero it
* means this command was part of a previous command that wasn't
* completed. Currently this is only used for DATA_OUT (SCSI write op)
* commands.
*/
/*
* Emulation specific tracking value.
*/
/*
* Per I_T_L structure used to determine which command
* interpreter to call and which transport queue to send the response.
*/
struct t10_lu_impl *c_lu;
/*
* Pointer to command buffer. No interpretation of data is
* done by the glue logic. Interpretation is done by the LUN
* emulation code.
*/
/*
* Optional offset into the command. If more than one response
* is required this value indicates where the data belongs.
*/
/*
* Data for transfer.
*/
char *c_data;
/*
* Indicates if this response is the last to be sent
* and will be followed closely by a complete message. Enables
* transports to phase collapse the final READ data PDU with
* completion PDU if possible.
*/
/*
* When the transport is finished sending the data it will
* call t10_cmd_destroy() which will cause the SAM-3 layer to
* call the emulation function stored here with this command
* pointer. The emulation code is responsible for freeing any
* memory it allocated.
*/
/*
* SCSI sense information.
*/
int c_cmd_status;
char *c_cmd_sense;
/*
* List of active commands at the ITL level.
*/
} t10_cmd_t;
/*
* Each LU has a structure which contains common data for all I_T's who
* access this LU.
*/
typedef struct t10_lu_common {
/*
* Logic Unit Number
*/
int l_num;
/*
* state of device
*/
/*
* Internal ID which will be unique for all LUs. This will be
* used for log messages to help tracking details.
*/
int l_internal_num;
/*
* Thread ID which is running this logical unit. This is currently
* used for only one purpose which is to locate this structure
* in case of a SIGBUS. It's possible for the underlying file system
* to run out of space for an mmap'd LU. The only means of notification
* the OS has is to send a SIGBUS. The thread only receives the memory
* address, so we look for our thread ID amongst all of the LU
* available.
*/
/*
* If we receive a SIGBUS the initiator needs to be notified that
* something bad has occurred. This means we need to know which
* command was being emulated so that we can find the appropriate
* transport.
* Special handling needs to be done if the thread is initializing
* the LU so we need a flag to indicate that fact.
*/
/*
* The implementation uses a 16 byte EUI value for the GUID.
* Not only is this value used for SCSI INQUIRY data, but it
* is used to distinquish this common LUN from other LUNs in
* the AVL tree.
*/
/*
* Other common information which is needed for ever device
* type.
*/
int l_dtype;
char *l_pid,
*l_vid;
/*
* Each dtype has different parameters that it uses. This
* is a place holder for storing a pointer to some structure which
* contains that information.
*/
void *l_dtype_params;
/*
* Parameter information in XML format.
*/
/*
* File descriptor for the open file which is the backing store
* for this device. This can be a regular file or a character
* special device if we're acting as a bridge between transports.
*/
int l_fd;
void *l_mmap;
/*
* AVL tree containing all I_T_Q nexus' which are actively using
* this LUN.
*/
/*
* Each I_T will place requests for command emulation on this
* queue. Common requests are msg_ste_cmd and msg_ste_shutdown
*/
/*
* Mutex used to lock access to the AVL tree.
*/
/*
* When a target is looking to see if an existing LUN is opened
* a search of all LUNs needs to be done and will use this
* AVL node. This field is modified only by the AVL code.
*/
/*
* Each I_T_Q has a LU structure associated with it.
*/
typedef struct t10_lu_impl {
/*
* pointer to common area of LUN.
*/
/*
* Mutex to protect access to active commands
*/
/*
* Queue for sending command results and R2T results back
* to the transport.
*/
/*
* Back pointer to target structure who created this LUN reference.
*/
struct t10_targ_impl *l_targ;
struct scsi_cmd_table *l_cmd_table;
/*
* Per LU methods for issuing commands and data to the
* DTYPE emulator.
*/
/*
* AVL node information for all other I_T nexus' who are referencing
* this LUN. This is used by the AVL code and *not* modified by
* this daemon directly.
*/
/*
* AVL node information for all LUN's being access by this I_T nexus.
* This is used by the AVL code and *not* modified by this daemon
* directly.
*/
/*
* Logical Unit Number. This value is used as the comparision value
* for the AVL search at the per target level.
*/
int l_targ_lun;
/*
* Statistics on a per ITL basis
*/
/*
* Each time a command is run the value of l_status is checked.
* If non-zero the command isn't executed and instead a transport
* complete message is sent with these values. This is commonly
* used to send UNIT ATTENTION for things like power on.
* -- Do we need some sort of stack to push and pop these values?
*/
int l_status,
typedef struct t10_targ_impl {
char *s_targ_base;
int s_targ_num; /* used in log messages */
/*
* The transport layer will set the maximum output size
* it's able to deal with during a call to set_create_handle()
*/
/*
* Target Port Set
*/
int s_tp_grp;
/*
* transport version number to use in standard inquiry data
*/
int s_trans_vers;
/*
* Transport response queue. This queue will be stored in each
* lun that gets created.
*/
/*
* During a SCSI WRITE the emulation will call trans_rqst_datain.
* If the transport indicated data was available by using non-zero
* values for the optional data and length when t10_send_cmd was
* called this callback is used when the emulation requests data.
*/
typedef struct t10_shutdown {
typedef struct scsi_cmd_table {
void (*cmd_end)(emul_handle_t e);
char *cmd_name;
/*
* []----
* | Interfaces
* []----
*/
extern target_queue_t *mgmtq;
void t10_init(target_queue_t *q);
/*
* []------------------------------------------------------------------[]
* | Methods called by the transports |
* []------------------------------------------------------------------[]
*/
/*
* t10_handle_create -- create target handle to be used by transports
*/
/*
* t10_handle_disable -- drains commands from emulation queues
*/
void
/*
* t10_handle_destroy -- free resources used by handle
*/
void
/*
*/
/*
* t10_cmd_state -- issue an event to change the state of a T10 layer command
*/
/*
* t10_thick_provision -- management function used when creating a new lun
*/
/*
* []------------------------------------------------------------------[]
* | Methods called by the emulation routines |
* []------------------------------------------------------------------[]
*/
/*
* trans_send_datain -- Emulation layer sending data to initiator
*/
/*
* trans_rqst_dataout -- Emulation needs more data to complete request
*/
/*
* trans_send_complete -- Emulation has completed request w/ opt. sense data
*/
void
/*
* trans_aiowrite -- asynchronous write and kicks the aio wait thread
*/
aio_result_t *aiop);
/*
* trans_aioread -- asynchronous read and kicks the aio wait thread
*/
aio_result_t *aiop);
/*
* trans_params_area -- given a t10_cmd return the dtype params
*/
/*
* []------------------------------------------------------------------[]
* | Declaration of emulation entry points |
* []------------------------------------------------------------------[]
*/
#ifdef __cplusplus
}
#endif
#endif /* _T10_H */