/*
 * 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
 * or http://www.opensolaris.org/os/licensing.
 * 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 (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 *
 * Copyright 2017 Nexenta Systems, Inc.  All rights reserved.
 */

#ifndef _STMF_SBD_H
#define _STMF_SBD_H

#include <sys/dkio.h>

#ifdef  __cplusplus
extern "C" {
#endif

typedef stmf_status_t   sbd_status_t;
#include "ats_copy_mgr.h"
extern char sbd_vendor_id[];
extern char sbd_product_id[];
extern char sbd_revision[];
extern char *sbd_mgmt_url;
extern uint16_t sbd_mgmt_url_alloc_size;
extern krwlock_t sbd_global_prop_lock;

/*
 * Error codes
 */
#define SBD_SUCCESS             STMF_SUCCESS
#define SBD_FAILURE             STMF_LU_FAILURE

#define SBD_ALREADY             (SBD_FAILURE | STMF_FSC(1))
#define SBD_NOT_SUPPORTED       (SBD_FAILURE | STMF_FSC(2))
#define SBD_META_CORRUPTED      (SBD_FAILURE | STMF_FSC(3))
#define SBD_INVALID_ARG         (SBD_FAILURE | STMF_FSC(4))
#define SBD_NOT_FOUND           (SBD_FAILURE | STMF_FSC(5))
#define SBD_ALLOC_FAILURE       (SBD_FAILURE | STMF_FSC(6))
#define SBD_FILEIO_FAILURE      (SBD_FAILURE | STMF_FSC(7))
#define SBD_IO_PAST_EOF         (SBD_FAILURE | STMF_FSC(8))
#define SBD_BUSY                (SBD_FAILURE | STMF_FSC(9))
#define SBD_COMPARE_FAILED      (SBD_FAILURE | STMF_FSC(10))

#define SHARED_META_DATA_SIZE   65536
#define SBD_META_OFFSET         4096
#define SBD_MIN_LU_SIZE         (1024 * 1024)

/*
 * sms endianess
 */
#define SMS_BIG_ENDIAN                  0x00
#define SMS_LITTLE_ENDIAN               0xFF

#ifdef  _BIG_ENDIAN
#define SMS_DATA_ORDER  SMS_BIG_ENDIAN
#else
#define SMS_DATA_ORDER  SMS_LITTLE_ENDIAN
#endif

#define SBD_MAGIC       0x53554e5342444c55

#define SBD_VER_MAJOR           1
#define SBD_VER_MINOR           1
#define SBD_VER_SUBMINOR        0

#if 0
typedef struct sbd_meta_start {
        uint64_t                sm_magic;
        uint64_t                sm_meta_size;
        uint64_t                sm_meta_size_used;
        uint64_t                sm_rsvd1;       /* Defaults to zero */
        uint64_t                sm_rsvd2;
        uint16_t                sm_ver_major;
        uint16_t                sm_ver_minor;
        uint16_t                sm_ver_subminor;
        uint8_t                 sm_flags;
        uint8_t                 sm_chksum;
} sbd_meta_start_t;
#endif

typedef struct sm_section_hdr {
        uint64_t        sms_offset;     /* Offset of this section */
        uint32_t        sms_size;       /* Includes the header and padding */
        uint16_t        sms_id;         /* Section identifier */
        uint8_t         sms_data_order; /* 0x00 or 0xff */
        uint8_t         sms_chksum;
} sm_section_hdr_t;

/*
 * sbd meta section identifiers
 */
#define SMS_ID_LU_INFO_1_0      0
#define SMS_ID_LU_INFO_1_1      1
#define SMS_ID_PGR_INFO         2
#define SMS_ID_UNUSED           0x1000

typedef struct sbd_lu_info_1_0 {
        sm_section_hdr_t        sli_sms_header;
        uint64_t                sli_total_store_size;
        uint64_t                sli_total_meta_size;
        uint64_t                sli_lu_data_offset;
        uint64_t                sli_lu_data_size;
        uint32_t                sli_flags;
        uint16_t                sli_blocksize;
        uint8_t                 sli_data_order;
        uint8_t                 rsvd1;
        uint8_t                 sli_lu_devid[20];
        uint32_t                rsvd2;
} sbd_lu_info_1_0_t;

typedef struct sbd_lu_info_1_1 {
        sm_section_hdr_t        sli_sms_header;
        uint32_t                sli_flags;
        char                    sli_rev[4];
        char                    sli_vid[8];
        char                    sli_pid[16];
        uint64_t                sli_lu_size;    /* Read capacity size */

        /*
         * Essetially zfs volume name for zvols to verify that the
         * metadata is coming in from the correct zvol and not from a
         * clone. Has no meaning in any other case.
         */
        uint64_t                sli_meta_fname_offset;

        /*
         * Data filename or the media filename when the metadata is in
         * a separate file. Its not needed if the metadata is shared
         * with data as the user supplied name is the data filename.
         */
        uint64_t                sli_data_fname_offset;
        uint64_t                sli_serial_offset;
        uint64_t                sli_alias_offset;
        uint8_t                 sli_data_blocksize_shift;
        uint8_t                 sli_data_order;
        uint8_t                 sli_serial_size;
        uint8_t                 sli_rsvd1;
        uint8_t                 sli_device_id[20];
        uint64_t                sli_mgmt_url_offset;
        uint8_t                 sli_rsvd2[248];

        /*
         * In case there is no separate meta, sli_meta_fname_offset wont
         * be valid. The same is true for zfs based metadata. The data_fname
         * is the zvol.
         */
        uint8_t                 sli_buf[8];
} sbd_lu_info_1_1_t;

/*
 * sli flags
 */
#define SLI_SEPARATE_META                       0x0001
#define SLI_WRITE_PROTECTED                     0x0002
#define SLI_VID_VALID                           0x0004
#define SLI_PID_VALID                           0x0008
#define SLI_REV_VALID                           0x0010
#define SLI_META_FNAME_VALID                    0x0020
#define SLI_DATA_FNAME_VALID                    0x0040
#define SLI_SERIAL_VALID                        0x0080
#define SLI_ALIAS_VALID                         0x0100
#define SLI_WRITEBACK_CACHE_DISABLE             0x0200
#define SLI_ZFS_META                            0x0400
#define SLI_MGMT_URL_VALID                      0x0800

struct sbd_it_data;

typedef struct sbd_lu {
        struct sbd_lu   *sl_next;
        stmf_lu_t       *sl_lu;
        uint32_t        sl_alloc_size;

        /* Current LU state */
        kmutex_t        sl_lock;
        uint32_t        sl_flags;
        uint8_t         sl_trans_op;
        uint8_t         sl_state:7,
                        sl_state_not_acked:1;

        char            *sl_name;               /* refers to meta or data */

        /* Metadata */
        kmutex_t        sl_metadata_lock;
        krwlock_t       sl_access_state_lock;
        char            *sl_alias;
        char            *sl_meta_filename;      /* If applicable */
        char            *sl_mgmt_url;
        vnode_t         *sl_meta_vp;
        vtype_t         sl_meta_vtype;
        uint8_t         sl_device_id[20];       /* 4(hdr) + 16(GUID) */
        uint8_t         sl_meta_blocksize_shift; /* Left shift multiplier */
        uint8_t         sl_data_blocksize_shift;
        uint8_t         sl_data_fs_nbits;
        uint8_t         sl_serial_no_size;
        uint64_t        sl_total_meta_size;
        uint64_t        sl_meta_size_used;
        uint8_t         *sl_serial_no;          /* optional */
        char            sl_vendor_id[8];
        char            sl_product_id[16];
        char            sl_revision[4];
        uint32_t        sl_data_fname_alloc_size; /* for an explicit alloc */
        uint16_t        sl_alias_alloc_size;
        uint16_t        sl_mgmt_url_alloc_size;
        uint8_t         sl_serial_no_alloc_size;
        uint8_t         sl_access_state;
        uint64_t        sl_meta_offset;

        /* zfs metadata */
        krwlock_t       sl_zfs_meta_lock;
        char            *sl_zfs_meta;
        minor_t         sl_zvol_minor;          /* for direct zvol calls */
        /* opaque handles for zvol direct calls */
        void            *sl_zvol_minor_hdl;
        void            *sl_zvol_objset_hdl;
        void            *sl_zvol_zil_hdl;
        void            *sl_zvol_rl_hdl;
        void            *sl_zvol_dn_hdl;

        /* Backing store */
        char            *sl_data_filename;
        vnode_t         *sl_data_vp;
        vtype_t         sl_data_vtype;
        uint64_t        sl_total_data_size;
        uint64_t        sl_data_readable_size;  /* read() fails after this */
        uint64_t        sl_data_offset;         /* After the metadata,if any */
        uint64_t        sl_lu_size;             /* READ CAPACITY size */
        uint64_t        sl_blksize;             /* used for zvols */
        uint64_t        sl_max_xfer_len;        /* used for zvols */

        struct sbd_it_data      *sl_it_list;
        struct sbd_pgr          *sl_pgr;
        uint64_t        sl_rs_owner_session_id;
        list_t          sl_ats_io_list;
} sbd_lu_t;

/*
 * sl_flags
 */
#define SL_LINKED                           0x00000001
#define SL_META_OPENED                      0x00000002
#define SL_REGISTERED                       0x00000004
#define SL_META_NEEDS_FLUSH                 0x00000008
#define SL_DATA_NEEDS_FLUSH                 0x00000010
#define SL_VID_VALID                        0x00000020
#define SL_PID_VALID                        0x00000040
#define SL_REV_VALID                        0x00000080
#define SL_WRITE_PROTECTED                  0x00000100
#define SL_MEDIA_LOADED                     0x00000200
#define SL_LU_HAS_SCSI2_RESERVATION         0x00000400
#define SL_WRITEBACK_CACHE_DISABLE          0x00000800
#define SL_SAVED_WRITE_CACHE_DISABLE        0x00001000
#define SL_MEDIUM_REMOVAL_PREVENTED         0x00002000
#define SL_NO_DATA_DKIOFLUSH                0x00004000
#define SL_SHARED_META                      0x00008000
#define SL_ZFS_META                         0x00010000
#define SL_WRITEBACK_CACHE_SET_UNSUPPORTED  0x00020000
#define SL_FLUSH_ON_DISABLED_WRITECACHE     0x00040000
#define SL_CALL_ZVOL                        0x00080000
#define SL_UNMAP_ENABLED                    0x00100000

/*
 * sl_trans_op. LU is undergoing some transition and this field
 * tells what kind of transition that is.
 */
#define SL_OP_NONE                              0
#define SL_OP_CREATE_REGISTER_LU                1
#define SL_OP_IMPORT_LU                         2
#define SL_OP_DELETE_LU                         3
#define SL_OP_MODIFY_LU                         4
#define SL_OP_LU_PROPS                          5

sbd_status_t sbd_data_read(sbd_lu_t *sl, scsi_task_t *task,
    uint64_t offset, uint64_t size, uint8_t *buf);
sbd_status_t sbd_data_write(sbd_lu_t *sl, scsi_task_t *task,
    uint64_t offset, uint64_t size, uint8_t *buf);
stmf_status_t sbd_task_alloc(struct scsi_task *task);
void sbd_new_task(struct scsi_task *task, struct stmf_data_buf *initial_dbuf);
void sbd_dbuf_xfer_done(struct scsi_task *task, struct stmf_data_buf *dbuf);
void sbd_send_status_done(struct scsi_task *task);
void sbd_task_free(struct scsi_task *task);
stmf_status_t sbd_abort(struct stmf_lu *lu, int abort_cmd, void *arg,
    uint32_t flags);
void sbd_ctl(struct stmf_lu *lu, int cmd, void *arg);
stmf_status_t sbd_info(uint32_t cmd, stmf_lu_t *lu, void *arg, uint8_t *buf,
    uint32_t *bufsizep);
sbd_status_t sbd_write_lu_info(sbd_lu_t *sl);
sbd_status_t sbd_flush_data_cache(sbd_lu_t *sl, int fsync_done);
sbd_status_t sbd_wcd_set(int wcd, sbd_lu_t *sl);
void sbd_wcd_get(int *wcd, sbd_lu_t *sl);
int sbd_unmap(sbd_lu_t *sl, dkioc_free_list_t *dfl);

void sbd_handle_short_write_transfers(scsi_task_t *, stmf_data_buf_t *,
    uint32_t);
void sbd_handle_short_read_transfers(scsi_task_t *, stmf_data_buf_t *,
    uint8_t *, uint32_t, uint32_t);

#ifdef  __cplusplus
}
#endif

#endif /* _STMF_SBD_H */