linux/drivers/target/target_core_iblock.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*******************************************************************************
 * Filename:  target_core_iblock.c
 *
 * This file contains the Storage Engine  <-> Linux BlockIO transport
 * specific functions.
 *
 * (c) Copyright 2003-2013 Datera, Inc.
 *
 * Nicholas A. Bellinger <[email protected]>
 *
 ******************************************************************************/

#include <linux/string.h>
#include <linux/parser.h>
#include <linux/timer.h>
#include <linux/fs.h>
#include <linux/blkdev.h>
#include <linux/blk-integrity.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/bio.h>
#include <linux/file.h>
#include <linux/module.h>
#include <linux/scatterlist.h>
#include <linux/pr.h>
#include <scsi/scsi_proto.h>
#include <scsi/scsi_common.h>
#include <asm/unaligned.h>

#include <target/target_core_base.h>
#include <target/target_core_backend.h>

#include "target_core_iblock.h"
#include "target_core_pr.h"

#define IBLOCK_MAX_BIO_PER_TASK …
#define IBLOCK_BIO_POOL_SIZE …

static inline struct iblock_dev *IBLOCK_DEV(struct se_device *dev)
{ … }


static int iblock_attach_hba(struct se_hba *hba, u32 host_id)
{ … }

static void iblock_detach_hba(struct se_hba *hba)
{ … }

static struct se_device *iblock_alloc_device(struct se_hba *hba, const char *name)
{ … }

static bool iblock_configure_unmap(struct se_device *dev)
{ … }

static int iblock_configure_device(struct se_device *dev)
{ … }

static void iblock_dev_call_rcu(struct rcu_head *p)
{ … }

static void iblock_free_device(struct se_device *dev)
{ … }

static void iblock_destroy_device(struct se_device *dev)
{ … }

static struct se_dev_plug *iblock_plug_device(struct se_device *se_dev)
{ … }

static void iblock_unplug_device(struct se_dev_plug *se_plug)
{ … }

static sector_t iblock_get_blocks(struct se_device *dev)
{ … }

static void iblock_complete_cmd(struct se_cmd *cmd, blk_status_t blk_status)
{ … }

static void iblock_bio_done(struct bio *bio)
{ … }

static struct bio *iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num,
				  blk_opf_t opf)
{ … }

static void iblock_submit_bios(struct bio_list *list)
{ … }

static void iblock_end_io_flush(struct bio *bio)
{ … }

/*
 * Implement SYCHRONIZE CACHE.  Note that we can't handle lba ranges and must
 * always flush the whole cache.
 */
static sense_reason_t
iblock_execute_sync_cache(struct se_cmd *cmd)
{ … }

static sense_reason_t
iblock_execute_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb)
{ … }

static sense_reason_t
iblock_execute_zero_out(struct block_device *bdev, struct se_cmd *cmd)
{ … }

static sense_reason_t
iblock_execute_write_same(struct se_cmd *cmd)
{ … }

enum { … };

static match_table_t tokens = …;

static ssize_t iblock_set_configfs_dev_params(struct se_device *dev,
		const char *page, ssize_t count)
{ … }

static ssize_t iblock_show_configfs_dev_params(struct se_device *dev, char *b)
{ … }

static int
iblock_alloc_bip(struct se_cmd *cmd, struct bio *bio,
		 struct sg_mapping_iter *miter)
{ … }

static sense_reason_t
iblock_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
		  enum dma_data_direction data_direction)
{ … }

static sense_reason_t iblock_execute_pr_out(struct se_cmd *cmd, u8 sa, u64 key,
					    u64 sa_key, u8 type, bool aptpl)
{ … }

static void iblock_pr_report_caps(unsigned char *param_data)
{ … }

static sense_reason_t iblock_pr_read_keys(struct se_cmd *cmd,
					  unsigned char *param_data)
{ … }

static sense_reason_t iblock_pr_read_reservation(struct se_cmd *cmd,
						 unsigned char *param_data)
{ … }

static sense_reason_t iblock_execute_pr_in(struct se_cmd *cmd, u8 sa,
					   unsigned char *param_data)
{ … }

static sector_t iblock_get_alignment_offset_lbas(struct se_device *dev)
{ … }

static unsigned int iblock_get_lbppbe(struct se_device *dev)
{ … }

static unsigned int iblock_get_io_min(struct se_device *dev)
{ … }

static unsigned int iblock_get_io_opt(struct se_device *dev)
{ … }

static struct exec_cmd_ops iblock_exec_cmd_ops = …;

static sense_reason_t
iblock_parse_cdb(struct se_cmd *cmd)
{ … }

static bool iblock_get_write_cache(struct se_device *dev)
{ … }

static const struct target_backend_ops iblock_ops = …;

static int __init iblock_module_init(void)
{ … }

static void __exit iblock_module_exit(void)
{ … }

MODULE_DESCRIPTION(…) …;
MODULE_AUTHOR(…) …;
MODULE_LICENSE(…) …;

module_init(…) …;
module_exit(iblock_module_exit);