/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2016 Nexenta Systems, Inc.  All rights reserved.
 */

#ifndef	_ATS_COPY_MGR_H
#define	_ATS_COPY_MGR_H

#ifdef	__cplusplus
extern "C" {
#endif

/* ATS structures and functions. */

typedef struct ats_state_s {
	/*
	 * We actually dont allow I/O which conflicts with current ats.
	 * The conflicting_rw_count is for those I/Os which are currently
	 * running and are potentally conflicting.
	 */
	list_node_t	as_next;
	uint8_t		as_cmd;
	uint32_t	as_conflicting_rw_count;
	uint32_t	as_non_conflicting_rw_count;
	uint32_t	as_ats_gen_ndx;
	uint32_t	as_cur_ats_handle;
	uint64_t	as_cur_ats_lba;
	uint64_t	as_cur_ats_lba_end;
	uint64_t	as_cur_ats_len;		/* in nblks */
	struct scsi_task *as_cur_ats_task;
} ats_state_t;

/* Since we're technically part of stmf_sbd.h, use some defines here. */
#define	sl_conflicting_rw_count	sl_ats_state.as_conflicting_rw_count
#define	sl_non_conflicting_rw_count sl_ats_state.as_non_conflicting_rw_count
#define	sl_ats_gen_ndx sl_ats_state.as_ats_gen_ndx
#define	sl_cur_ats_handle sl_ats_state.as_cur_ats_handle
#define	sl_cur_ats_lba sl_ats_state.as_cur_ats_lba
#define	sl_cur_ats_len sl_ats_state.as_cur_ats_len
#define	sl_cur_ats_task sl_ats_state.as_cur_ats_task

struct sbd_cmd;
struct sbd_lu;

void sbd_handle_ats_xfer_completion(struct scsi_task *, struct sbd_cmd *,
    struct stmf_data_buf *, uint8_t);
void sbd_do_ats_xfer(struct scsi_task *, struct sbd_cmd *,
    struct stmf_data_buf *, uint8_t);
void sbd_handle_ats(scsi_task_t *, struct stmf_data_buf *);
void sbd_handle_recv_copy_results(struct scsi_task *, struct stmf_data_buf *);
void sbd_free_ats_handle(struct scsi_task *, struct sbd_cmd *);
void sbd_handle_ats(scsi_task_t *, struct stmf_data_buf *);
uint8_t sbd_ats_max_nblks(void);
void sbd_ats_remove_by_task(scsi_task_t *);
sbd_status_t sbd_ats_handling_before_io(scsi_task_t *task, struct sbd_lu *sl,
    uint64_t lba, uint64_t count);

/* Block-copy structures and functions. */

struct scsi_task;
typedef	void *cpmgr_handle_t;

#define	CPMGR_INVALID_HANDLE		((cpmgr_handle_t)NULL)

#define	CPMGR_DEFAULT_TIMEOUT		30

#define	CPMGR_PARAM_HDR_LEN		16
#define	CPMGR_IDENT_TARGET_DESCRIPTOR	0xE4
#define	CPMGR_MAX_TARGET_DESCRIPTORS	2
#define	CPMGR_TARGET_DESCRIPTOR_SIZE	32

#define	CPMGR_B2B_SEGMENT_DESCRIPTOR		2
#define	CPMGR_MAX_SEGMENT_DESCRIPTORS		1
#define	CPMGR_B2B_SEGMENT_DESCRIPTOR_SIZE	28

/*
 * SCSI errors before copy starts.
 */
#define	CPMGR_PARAM_LIST_LEN_ERROR		0x051A00
#define	CPMGR_INVALID_FIELD_IN_PARAM_LIST	0x052600
#define	CPMGR_TOO_MANY_TARGET_DESCRIPTORS	0x052606
#define	CPMGR_UNSUPPORTED_TARGET_DESCRIPTOR	0x052607
#define	CPMGR_TOO_MANY_SEGMENT_DESCRIPTORS	0x052608
#define	CPMGR_UNSUPPORTED_SEGMENT_DESCRIPTOR	0x052609
#define	CPMGR_COPY_TARGET_NOT_REACHABLE		0x050D02
#define	CPMGR_INSUFFICIENT_RESOURCES		0x0B5503

/*
 * SCSI errors after copy has started.
 */
#define	CPMGR_LBA_OUT_OF_RANGE			0x0A2100
#define	CPMGR_THIRD_PARTY_DEVICE_FAILURE	0x0A0D01

/*
 * SCSI errors which dont result in STATUS_CHECK.
 * Use and invalid sense key to mark these.
 */
#define	CPMGR_RESERVATION_CONFLICT		0xF00001

typedef enum cm_state {
	CM_STARTING = 0,
	CM_COPYING,
	CM_COMPLETE
} cm_state_t;

#define	CPMGR_XFER_BUF_SIZE		(128 * 1024)

typedef struct cm_target_desc {
	stmf_lu_t	*td_lu;
	uint32_t	td_disk_block_len;
	uint8_t		td_lbasize_shift;
} cm_target_desc_t;

/*
 * Current implementation supports 2 target descriptors (identification type)
 * for src and dst and one segment descriptor (block -> block).
 */
typedef struct cpmgr {
	cm_target_desc_t	cm_tds[CPMGR_MAX_TARGET_DESCRIPTORS];
	uint8_t			cm_td_count;
	uint16_t		cm_src_td_ndx;
	uint16_t		cm_dst_td_ndx;
	cm_state_t		cm_state;
	uint32_t		cm_status;
	uint64_t		cm_src_offset;
	uint64_t		cm_dst_offset;
	uint64_t		cm_copy_size;
	uint64_t		cm_size_done;
	void			*cm_xfer_buf;
	scsi_task_t		*cm_task;
} cpmgr_t;

#define	cpmgr_done(cm)	(((cpmgr_t *)(cm))->cm_state == CM_COMPLETE)
#define	cpmgr_status(cm) (((cpmgr_t *)(cm))->cm_status)

cpmgr_handle_t cpmgr_create(struct scsi_task *task, uint8_t *params);
void cpmgr_destroy(cpmgr_handle_t h);
void cpmgr_run(cpmgr_t *cm, clock_t preemption_point);
void cpmgr_abort(cpmgr_t *cm, uint32_t s);
void sbd_handle_xcopy_xfer(scsi_task_t *, uint8_t *);
void sbd_handle_xcopy(scsi_task_t *, stmf_data_buf_t *);

#ifdef	__cplusplus
}
#endif

#endif /* _ATS_COPY_MGR_H */