* [PATCH v3 01/20] sg: move functions around
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-12 14:22 ` Christoph Hellwig
2019-08-07 11:42 ` [PATCH v3 02/20] sg: remove typedefs, type+formatting cleanup Douglas Gilbert
` (19 subsequent siblings)
20 siblings, 1 reply; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
Move main entry point functions around so submission code comes
before completion code. Prior to this, the driver used the
traditional open(), close(), read(), write(), ioctl() ordering
however in this case that places completion code (i.e.
sg_read()) before submission code (i.e. sg_write()). The main
driver entry points are considered to be those named in struct
file_operations sg_fops' definition.
Helper functions are often placed above their caller to reduce
the number of forward function declarations needed.
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 499 ++++++++++++++++++++++++----------------------
1 file changed, 261 insertions(+), 238 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index cce757506383..9f1587761d86 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -8,11 +8,12 @@
* Original driver (sg.c):
* Copyright (C) 1992 Lawrence Foard
* Version 2 and 3 extensions to driver:
- * Copyright (C) 1998 - 2014 Douglas Gilbert
+ * Copyright (C) 1998 - 2019 Douglas Gilbert
*/
-static int sg_version_num = 30536; /* 2 digits for each component */
-#define SG_VERSION_STR "3.5.36"
+static int sg_version_num = 30901; /* [x]xyyzz where [x] empty when x=0 */
+#define SG_VERSION_STR "3.9.01" /* [x]x.[y]y.zz */
+static char *sg_version_date = "20190606";
/*
* D. P. Gilbert (dgilbert@interlog.com), notes:
@@ -47,6 +48,7 @@ static int sg_version_num = 30536; /* 2 digits for each component */
#include <linux/ratelimit.h>
#include <linux/uio.h>
#include <linux/cred.h> /* for sg_check_file_access() */
+#include <linux/proc_fs.h>
#include "scsi.h"
#include <scsi/scsi_dbg.h>
@@ -57,12 +59,6 @@ static int sg_version_num = 30536; /* 2 digits for each component */
#include "scsi_logging.h"
-#ifdef CONFIG_SCSI_PROC_FS
-#include <linux/proc_fs.h>
-static char *sg_version_date = "20140603";
-
-static int sg_proc_init(void);
-#endif
#define SG_ALLOW_DIO_DEF 0
@@ -173,11 +169,11 @@ typedef struct sg_device { /* holds the state of each scsi generic device */
/* tasklet or soft irq callback */
static void sg_rq_end_io(struct request *rq, blk_status_t status);
+/* Declarations of other static functions used before they are defined */
+static int sg_proc_init(void);
static int sg_start_req(Sg_request *srp, unsigned char *cmd);
static int sg_finish_rem_req(Sg_request * srp);
static int sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size);
-static ssize_t sg_new_read(Sg_fd * sfp, char __user *buf, size_t count,
- Sg_request * srp);
static ssize_t sg_new_write(Sg_fd *sfp, struct file *file,
const char __user *buf, size_t count, int blocking,
int read_only, int sg_io_owned, Sg_request **o_srp);
@@ -190,7 +186,6 @@ static void sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size);
static void sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp);
static Sg_fd *sg_add_sfp(Sg_device * sdp);
static void sg_remove_sfp(struct kref *);
-static Sg_request *sg_get_rq_mark(Sg_fd * sfp, int pack_id);
static Sg_request *sg_add_request(Sg_fd * sfp);
static int sg_remove_request(Sg_fd * sfp, Sg_request * srp);
static Sg_device *sg_get_dev(int dev);
@@ -232,16 +227,6 @@ static int sg_check_file_access(struct file *filp, const char *caller)
return 0;
}
-static int sg_allow_access(struct file *filp, unsigned char *cmd)
-{
- struct sg_fd *sfp = filp->private_data;
-
- if (sfp->parentdp->device->type == TYPE_SCANNER)
- return 0;
-
- return blk_verify_command(cmd, filp->f_mode);
-}
-
static int
open_wait(Sg_device *sdp, int flags)
{
@@ -405,200 +390,12 @@ sg_release(struct inode *inode, struct file *filp)
return 0;
}
-static ssize_t
-sg_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
-{
- Sg_device *sdp;
- Sg_fd *sfp;
- Sg_request *srp;
- int req_pack_id = -1;
- sg_io_hdr_t *hp;
- struct sg_header *old_hdr = NULL;
- int retval = 0;
-
- /*
- * This could cause a response to be stranded. Close the associated
- * file descriptor to free up any resources being held.
- */
- retval = sg_check_file_access(filp, __func__);
- if (retval)
- return retval;
-
- if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
- return -ENXIO;
- SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
- "sg_read: count=%d\n", (int) count));
-
- if (!access_ok(buf, count))
- return -EFAULT;
- if (sfp->force_packid && (count >= SZ_SG_HEADER)) {
- old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL);
- if (!old_hdr)
- return -ENOMEM;
- if (__copy_from_user(old_hdr, buf, SZ_SG_HEADER)) {
- retval = -EFAULT;
- goto free_old_hdr;
- }
- if (old_hdr->reply_len < 0) {
- if (count >= SZ_SG_IO_HDR) {
- sg_io_hdr_t *new_hdr;
- new_hdr = kmalloc(SZ_SG_IO_HDR, GFP_KERNEL);
- if (!new_hdr) {
- retval = -ENOMEM;
- goto free_old_hdr;
- }
- retval =__copy_from_user
- (new_hdr, buf, SZ_SG_IO_HDR);
- req_pack_id = new_hdr->pack_id;
- kfree(new_hdr);
- if (retval) {
- retval = -EFAULT;
- goto free_old_hdr;
- }
- }
- } else
- req_pack_id = old_hdr->pack_id;
- }
- srp = sg_get_rq_mark(sfp, req_pack_id);
- if (!srp) { /* now wait on packet to arrive */
- if (atomic_read(&sdp->detaching)) {
- retval = -ENODEV;
- goto free_old_hdr;
- }
- if (filp->f_flags & O_NONBLOCK) {
- retval = -EAGAIN;
- goto free_old_hdr;
- }
- retval = wait_event_interruptible(sfp->read_wait,
- (atomic_read(&sdp->detaching) ||
- (srp = sg_get_rq_mark(sfp, req_pack_id))));
- if (atomic_read(&sdp->detaching)) {
- retval = -ENODEV;
- goto free_old_hdr;
- }
- if (retval) {
- /* -ERESTARTSYS as signal hit process */
- goto free_old_hdr;
- }
- }
- if (srp->header.interface_id != '\0') {
- retval = sg_new_read(sfp, buf, count, srp);
- goto free_old_hdr;
- }
-
- hp = &srp->header;
- if (old_hdr == NULL) {
- old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL);
- if (! old_hdr) {
- retval = -ENOMEM;
- goto free_old_hdr;
- }
- }
- memset(old_hdr, 0, SZ_SG_HEADER);
- old_hdr->reply_len = (int) hp->timeout;
- old_hdr->pack_len = old_hdr->reply_len; /* old, strange behaviour */
- old_hdr->pack_id = hp->pack_id;
- old_hdr->twelve_byte =
- ((srp->data.cmd_opcode >= 0xc0) && (12 == hp->cmd_len)) ? 1 : 0;
- old_hdr->target_status = hp->masked_status;
- old_hdr->host_status = hp->host_status;
- old_hdr->driver_status = hp->driver_status;
- if ((CHECK_CONDITION & hp->masked_status) ||
- (DRIVER_SENSE & hp->driver_status))
- memcpy(old_hdr->sense_buffer, srp->sense_b,
- sizeof (old_hdr->sense_buffer));
- switch (hp->host_status) {
- /* This setup of 'result' is for backward compatibility and is best
- ignored by the user who should use target, host + driver status */
- case DID_OK:
- case DID_PASSTHROUGH:
- case DID_SOFT_ERROR:
- old_hdr->result = 0;
- break;
- case DID_NO_CONNECT:
- case DID_BUS_BUSY:
- case DID_TIME_OUT:
- old_hdr->result = EBUSY;
- break;
- case DID_BAD_TARGET:
- case DID_ABORT:
- case DID_PARITY:
- case DID_RESET:
- case DID_BAD_INTR:
- old_hdr->result = EIO;
- break;
- case DID_ERROR:
- old_hdr->result = (srp->sense_b[0] == 0 &&
- hp->masked_status == GOOD) ? 0 : EIO;
- break;
- default:
- old_hdr->result = EIO;
- break;
- }
-
- /* Now copy the result back to the user buffer. */
- if (count >= SZ_SG_HEADER) {
- if (__copy_to_user(buf, old_hdr, SZ_SG_HEADER)) {
- retval = -EFAULT;
- goto free_old_hdr;
- }
- buf += SZ_SG_HEADER;
- if (count > old_hdr->reply_len)
- count = old_hdr->reply_len;
- if (count > SZ_SG_HEADER) {
- if (sg_read_oxfer(srp, buf, count - SZ_SG_HEADER)) {
- retval = -EFAULT;
- goto free_old_hdr;
- }
- }
- } else
- count = (old_hdr->result == 0) ? 0 : -EIO;
- sg_finish_rem_req(srp);
- sg_remove_request(sfp, srp);
- retval = count;
-free_old_hdr:
- kfree(old_hdr);
- return retval;
-}
-
-static ssize_t
-sg_new_read(Sg_fd * sfp, char __user *buf, size_t count, Sg_request * srp)
-{
- sg_io_hdr_t *hp = &srp->header;
- int err = 0, err2;
- int len;
-
- if (count < SZ_SG_IO_HDR) {
- err = -EINVAL;
- goto err_out;
- }
- hp->sb_len_wr = 0;
- if ((hp->mx_sb_len > 0) && hp->sbp) {
- if ((CHECK_CONDITION & hp->masked_status) ||
- (DRIVER_SENSE & hp->driver_status)) {
- int sb_len = SCSI_SENSE_BUFFERSIZE;
- sb_len = (hp->mx_sb_len > sb_len) ? sb_len : hp->mx_sb_len;
- len = 8 + (int) srp->sense_b[7]; /* Additional sense length field */
- len = (len > sb_len) ? sb_len : len;
- if (copy_to_user(hp->sbp, srp->sense_b, len)) {
- err = -EFAULT;
- goto err_out;
- }
- hp->sb_len_wr = len;
- }
- }
- if (hp->masked_status || hp->host_status || hp->driver_status)
- hp->info |= SG_INFO_CHECK;
- if (copy_to_user(buf, hp, SZ_SG_IO_HDR)) {
- err = -EFAULT;
- goto err_out;
- }
-err_out:
- err2 = sg_finish_rem_req(srp);
- sg_remove_request(sfp, srp);
- return err ? : err2 ? : count;
-}
-
+/*
+ * write(2) related functions follow. They are shown before read(2) related
+ * functions. That is because SCSI commands/requests are first "written" to
+ * the SCSI device by using write(2), ioctl(SG_IOSUBMIT) or the first half
+ * of the synchronous ioctl(SG_IO) system call.
+ */
static ssize_t
sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
{
@@ -710,6 +507,16 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
return (k < 0) ? k : count;
}
+static int sg_allow_access(struct file *filp, unsigned char *cmd)
+{
+ struct sg_fd *sfp = filp->private_data;
+
+ if (sfp->parentdp->device->type == TYPE_SCANNER)
+ return 0;
+
+ return blk_verify_command(cmd, filp->f_mode);
+}
+
static ssize_t
sg_new_write(Sg_fd *sfp, struct file *file, const char __user *buf,
size_t count, int blocking, int read_only, int sg_io_owned,
@@ -840,6 +647,74 @@ sg_common_write(Sg_fd * sfp, Sg_request * srp,
return 0;
}
+
+/*
+ * read(2) related functions follow. They are shown after write(2) related
+ * functions. Apart from read(2) itself, ioctl(SG_IORECEIVE) and the second
+ * half of the ioctl(SG_IO) share code with read(2).
+ */
+
+static Sg_request *
+sg_get_rq_mark(Sg_fd *sfp, int pack_id)
+{
+ Sg_request *resp;
+ unsigned long iflags;
+
+ write_lock_irqsave(&sfp->rq_list_lock, iflags);
+ list_for_each_entry(resp, &sfp->rq_list, entry) {
+ /* look for requests that are ready + not SG_IO owned */
+ if ((resp->done == 1) && (!resp->sg_io_owned) &&
+ ((-1 == pack_id) || (resp->header.pack_id == pack_id))) {
+ resp->done = 2; /* guard against other readers */
+ write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
+ return resp;
+ }
+ }
+ write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
+ return NULL;
+}
+
+static ssize_t
+sg_new_read(Sg_fd *sfp, char __user *buf, size_t count, Sg_request *srp)
+{
+ sg_io_hdr_t *hp = &srp->header;
+ int err = 0, err2;
+ int len;
+
+ if (count < SZ_SG_IO_HDR) {
+ err = -EINVAL;
+ goto err_out;
+ }
+ hp->sb_len_wr = 0;
+ if ((hp->mx_sb_len > 0) && hp->sbp) {
+ if ((CHECK_CONDITION & hp->masked_status) ||
+ (DRIVER_SENSE & hp->driver_status)) {
+ int sb_len = SCSI_SENSE_BUFFERSIZE;
+
+ sb_len = (hp->mx_sb_len > sb_len) ? sb_len :
+ hp->mx_sb_len;
+ /* Additional sense length field */
+ len = 8 + (int) srp->sense_b[7];
+ len = (len > sb_len) ? sb_len : len;
+ if (copy_to_user(hp->sbp, srp->sense_b, len)) {
+ err = -EFAULT;
+ goto err_out;
+ }
+ hp->sb_len_wr = len;
+ }
+ }
+ if (hp->masked_status || hp->host_status || hp->driver_status)
+ hp->info |= SG_INFO_CHECK;
+ if (copy_to_user(buf, hp, SZ_SG_IO_HDR)) {
+ err = -EFAULT;
+ goto err_out;
+ }
+err_out:
+ err2 = sg_finish_rem_req(srp);
+ sg_remove_request(sfp, srp);
+ return err ? : err2 ? : count;
+}
+
static int srp_done(Sg_fd *sfp, Sg_request *srp)
{
unsigned long flags;
@@ -851,6 +726,168 @@ static int srp_done(Sg_fd *sfp, Sg_request *srp)
return ret;
}
+static ssize_t
+sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
+{
+ Sg_device *sdp;
+ Sg_fd *sfp;
+ Sg_request *srp;
+ int req_pack_id = -1;
+ sg_io_hdr_t *hp;
+ struct sg_header *old_hdr = NULL;
+ int retval = 0;
+
+ /*
+ * This could cause a response to be stranded. Close the associated
+ * file descriptor to free up any resources being held.
+ */
+ retval = sg_check_file_access(filp, __func__);
+ if (retval)
+ return retval;
+
+ sfp = filp->private_data;
+ sdp = sfp->parentdp;
+ SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
+ "%s: count=%d\n", __func__,
+ (int) count));
+ if (!sdp)
+ return -ENXIO;
+
+ if (!access_ok(buf, count))
+ return -EFAULT;
+ if (sfp->force_packid && (count >= SZ_SG_HEADER)) {
+ old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL);
+ if (!old_hdr)
+ return -ENOMEM;
+ if (__copy_from_user(old_hdr, buf, SZ_SG_HEADER)) {
+ retval = -EFAULT;
+ goto free_old_hdr;
+ }
+ if (old_hdr->reply_len < 0) {
+ if (count >= SZ_SG_IO_HDR) {
+ sg_io_hdr_t *new_hdr;
+
+ new_hdr = kmalloc(SZ_SG_IO_HDR, GFP_KERNEL);
+ if (!new_hdr) {
+ retval = -ENOMEM;
+ goto free_old_hdr;
+ }
+ retval = __copy_from_user
+ (new_hdr, buf, SZ_SG_IO_HDR);
+ req_pack_id = new_hdr->pack_id;
+ kfree(new_hdr);
+ if (retval) {
+ retval = -EFAULT;
+ goto free_old_hdr;
+ }
+ }
+ } else
+ req_pack_id = old_hdr->pack_id;
+ }
+ srp = sg_get_rq_mark(sfp, req_pack_id);
+ if (!srp) { /* now wait on packet to arrive */
+ if (atomic_read(&sdp->detaching)) {
+ retval = -ENODEV;
+ goto free_old_hdr;
+ }
+ if (filp->f_flags & O_NONBLOCK) {
+ retval = -EAGAIN;
+ goto free_old_hdr;
+ }
+ retval = wait_event_interruptible(sfp->read_wait,
+ (atomic_read(&sdp->detaching) ||
+ (srp = sg_get_rq_mark(sfp, req_pack_id))));
+ if (atomic_read(&sdp->detaching)) {
+ retval = -ENODEV;
+ goto free_old_hdr;
+ }
+ if (retval) {
+ /* -ERESTARTSYS as signal hit process */
+ goto free_old_hdr;
+ }
+ }
+ if (srp->header.interface_id != '\0') {
+ retval = sg_new_read(sfp, buf, count, srp);
+ goto free_old_hdr;
+ }
+
+ hp = &srp->header;
+ if (old_hdr == NULL) {
+ old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL);
+ if (!old_hdr) {
+ retval = -ENOMEM;
+ goto free_old_hdr;
+ }
+ }
+ memset(old_hdr, 0, SZ_SG_HEADER);
+ old_hdr->reply_len = (int) hp->timeout;
+ old_hdr->pack_len = old_hdr->reply_len; /* old, strange behaviour */
+ old_hdr->pack_id = hp->pack_id;
+ old_hdr->twelve_byte =
+ ((srp->data.cmd_opcode >= 0xc0) && (hp->cmd_len == 12)) ? 1 : 0;
+ old_hdr->target_status = hp->masked_status;
+ old_hdr->host_status = hp->host_status;
+ old_hdr->driver_status = hp->driver_status;
+ if ((hp->masked_status & CHECK_CONDITION) ||
+ (hp->driver_status & DRIVER_SENSE))
+ memcpy(old_hdr->sense_buffer, srp->sense_b,
+ sizeof(old_hdr->sense_buffer));
+ switch (hp->host_status) {
+ /*
+ * This setup of 'result' is for backward compatibility and is best
+ * ignored by the user who should use target, host + driver status
+ */
+ case DID_OK:
+ case DID_PASSTHROUGH:
+ case DID_SOFT_ERROR:
+ old_hdr->result = 0;
+ break;
+ case DID_NO_CONNECT:
+ case DID_BUS_BUSY:
+ case DID_TIME_OUT:
+ old_hdr->result = EBUSY;
+ break;
+ case DID_BAD_TARGET:
+ case DID_ABORT:
+ case DID_PARITY:
+ case DID_RESET:
+ case DID_BAD_INTR:
+ old_hdr->result = EIO;
+ break;
+ case DID_ERROR:
+ old_hdr->result = (srp->sense_b[0] == 0 &&
+ hp->masked_status == GOOD) ? 0 : EIO;
+ break;
+ default:
+ old_hdr->result = EIO;
+ break;
+ }
+
+ /* Now copy the result back to the user buffer. */
+ if (count >= SZ_SG_HEADER) {
+ if (__copy_to_user(buf, old_hdr, SZ_SG_HEADER)) {
+ retval = -EFAULT;
+ goto free_old_hdr;
+ }
+ buf += SZ_SG_HEADER;
+ if (count > old_hdr->reply_len)
+ count = old_hdr->reply_len;
+ if (count > SZ_SG_HEADER) {
+ if (sg_read_oxfer(srp, buf, count - SZ_SG_HEADER)) {
+ retval = -EFAULT;
+ goto free_old_hdr;
+ }
+ }
+ } else
+ count = (old_hdr->result == 0) ? 0 : -EIO;
+ sg_finish_rem_req(srp);
+ sg_remove_request(sfp, srp);
+ retval = count;
+free_old_hdr:
+ kfree(old_hdr);
+ return retval;
+}
+
static int max_sectors_bytes(struct request_queue *q)
{
unsigned int max_sectors = queue_max_sectors(q);
@@ -1669,9 +1706,7 @@ init_sg(void)
sg_sysfs_valid = 1;
rc = scsi_register_interface(&sg_interface);
if (0 == rc) {
-#ifdef CONFIG_SCSI_PROC_FS
sg_proc_init();
-#endif /* CONFIG_SCSI_PROC_FS */
return 0;
}
class_destroy(sg_sysfs_class);
@@ -1680,6 +1715,14 @@ init_sg(void)
return rc;
}
+#ifndef CONFIG_SCSI_PROC_FS
+static int
+sg_proc_init(void)
+{
+ return 0;
+}
+#endif
+
static void __exit
exit_sg(void)
{
@@ -2069,26 +2112,6 @@ sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp)
sfp->res_in_use = 0;
}
-static Sg_request *
-sg_get_rq_mark(Sg_fd * sfp, int pack_id)
-{
- Sg_request *resp;
- unsigned long iflags;
-
- write_lock_irqsave(&sfp->rq_list_lock, iflags);
- list_for_each_entry(resp, &sfp->rq_list, entry) {
- /* look for requests that are ready + not SG_IO owned */
- if ((1 == resp->done) && (!resp->sg_io_owned) &&
- ((-1 == pack_id) || (resp->header.pack_id == pack_id))) {
- resp->done = 2; /* guard against other readers */
- write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
- return resp;
- }
- }
- write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
- return NULL;
-}
-
/* always adds to end of list */
static Sg_request *
sg_add_request(Sg_fd * sfp)
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 01/20] sg: move functions around
2019-08-07 11:42 ` [PATCH v3 01/20] sg: move functions around Douglas Gilbert
@ 2019-08-12 14:22 ` Christoph Hellwig
0 siblings, 0 replies; 63+ messages in thread
From: Christoph Hellwig @ 2019-08-12 14:22 UTC (permalink / raw)
To: Douglas Gilbert; +Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche
On Wed, Aug 07, 2019 at 01:42:33PM +0200, Douglas Gilbert wrote:
> Move main entry point functions around so submission code comes
> before completion code. Prior to this, the driver used the
> traditional open(), close(), read(), write(), ioctl() ordering
> however in this case that places completion code (i.e.
> sg_read()) before submission code (i.e. sg_write()). The main
> driver entry points are considered to be those named in struct
> file_operations sg_fops' definition.
>
> Helper functions are often placed above their caller to reduce
> the number of forward function declarations needed.
This looks generally sensible. But can you also move the whole
procfs code to the very end of the file to follow the usual
pattern elsewhere and avoid the extra forward declaration?
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 02/20] sg: remove typedefs, type+formatting cleanup
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
2019-08-07 11:42 ` [PATCH v3 01/20] sg: move functions around Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-12 14:22 ` Christoph Hellwig
2019-08-07 11:42 ` [PATCH v3 03/20] sg: sg_log and is_enabled Douglas Gilbert
` (18 subsequent siblings)
20 siblings, 1 reply; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
Typedefs for structure types are discouraged so those structures
that are private to the driver have had their typedefs removed.
This also means that most "camel" type variable names (i.e. mixed
case) have been removed.
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 394 ++++++++++++++++++++++++++--------------------
1 file changed, 219 insertions(+), 175 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 9f1587761d86..6615777931f7 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -3,7 +3,7 @@
* History:
* Started: Aug 9 by Lawrence Foard (entropy@world.std.com),
* to allow user process control of SCSI devices.
- * Development Sponsored by Killy Corp. NY NY
+ * Development Sponsored by Killy Corp. NY NY [1992 ??]
*
* Original driver (sg.c):
* Copyright (C) 1992 Lawrence Foard
@@ -15,13 +15,6 @@ static int sg_version_num = 30901; /* [x]xyyzz where [x] empty when x=0 */
#define SG_VERSION_STR "3.9.01" /* [x]x.[y]y.zz */
static char *sg_version_date = "20190606";
-/*
- * D. P. Gilbert (dgilbert@interlog.com), notes:
- * - scsi logging is available via SCSI_LOG_TIMEOUT macros. First
- * the kernel/module needs to be built with CONFIG_SCSI_LOGGING
- * (otherwise the macros compile to empty statements).
- *
- */
#include <linux/module.h>
#include <linux/fs.h>
@@ -91,33 +84,32 @@ static int sg_add_device(struct device *, struct class_interface *);
static void sg_remove_device(struct device *, struct class_interface *);
static DEFINE_IDR(sg_index_idr);
-static DEFINE_RWLOCK(sg_index_lock); /* Also used to lock
- file descriptor list for device */
+static DEFINE_RWLOCK(sg_index_lock); /* Also used to lock fd list for device */
static struct class_interface sg_interface = {
.add_dev = sg_add_device,
.remove_dev = sg_remove_device,
};
-typedef struct sg_scatter_hold { /* holding area for scsi scatter gather info */
- unsigned short k_use_sg; /* Count of kernel scatter-gather pieces */
- unsigned sglist_len; /* size of malloc'd scatter-gather list ++ */
- unsigned bufflen; /* Size of (aggregate) data buffer */
+struct sg_scatter_hold { /* holding area for scsi scatter gather info */
+ u16 k_use_sg; /* Count of kernel scatter-gather pieces */
+ unsigned int sglist_len; /* size of malloc'd scatter-gather list ++ */
+ unsigned int bufflen; /* Size of (aggregate) data buffer */
struct page **pages;
int page_order;
char dio_in_use; /* 0->indirect IO (or mmap), 1->dio */
- unsigned char cmd_opcode; /* first byte of command */
-} Sg_scatter_hold;
+ u8 cmd_opcode; /* first byte of command */
+};
struct sg_device; /* forward declarations */
struct sg_fd;
-typedef struct sg_request { /* SG_MAX_QUEUE requests outstanding per file */
+struct sg_request { /* SG_MAX_QUEUE requests outstanding per file */
struct list_head entry; /* list entry */
struct sg_fd *parentfp; /* NULL -> not in use */
- Sg_scatter_hold data; /* hold buffer, perhaps scatter list */
+ struct sg_scatter_hold data; /* hold buffer, perhaps scatter list */
sg_io_hdr_t header; /* scsi command+info, see <scsi/sg.h> */
- unsigned char sense_b[SCSI_SENSE_BUFFERSIZE];
+ u8 sense_b[SCSI_SENSE_BUFFERSIZE];
char res_used; /* 1 -> using reserve buffer, 0 -> not ... */
char orphan; /* 1 -> drop on sight, 0 -> normal */
char sg_io_owned; /* 1 -> packet belongs to SG_IO */
@@ -126,9 +118,9 @@ typedef struct sg_request { /* SG_MAX_QUEUE requests outstanding per file */
struct request *rq;
struct bio *bio;
struct execute_work ew;
-} Sg_request;
+};
-typedef struct sg_fd { /* holds the state of a file descriptor */
+struct sg_fd { /* holds the state of a file descriptor */
struct list_head sfd_siblings; /* protected by device's sfd_lock */
struct sg_device *parentdp; /* owning device */
wait_queue_head_t read_wait; /* queue read until command done */
@@ -136,21 +128,21 @@ typedef struct sg_fd { /* holds the state of a file descriptor */
struct mutex f_mutex; /* protect against changes in this fd */
int timeout; /* defaults to SG_DEFAULT_TIMEOUT */
int timeout_user; /* defaults to SG_DEFAULT_TIMEOUT_USER */
- Sg_scatter_hold reserve; /* buffer held for this file descriptor */
+ struct sg_scatter_hold reserve; /* buffer for this file descriptor */
struct list_head rq_list; /* head of request list */
struct fasync_struct *async_qp; /* used by asynchronous notification */
- Sg_request req_arr[SG_MAX_QUEUE]; /* used as singly-linked list */
+ struct sg_request req_arr[SG_MAX_QUEUE];/* use as singly-linked list */
char force_packid; /* 1 -> pack_id input to read(), 0 -> ignored */
char cmd_q; /* 1 -> allow command queuing, 0 -> don't */
- unsigned char next_cmd_len; /* 0: automatic, >0: use on next write() */
+ u8 next_cmd_len; /* 0: automatic, >0: use on next write() */
char keep_orphan; /* 0 -> drop orphan (def), 1 -> keep for read() */
char mmap_called; /* 0 -> mmap() never called on this fd */
char res_in_use; /* 1 -> 'reserve' array in use */
struct kref f_ref;
struct execute_work ew;
-} Sg_fd;
+};
-typedef struct sg_device { /* holds the state of each scsi generic device */
+struct sg_device { /* holds the state of each scsi generic device */
struct scsi_device *device;
wait_queue_head_t open_wait; /* queue open() when O_EXCL present */
struct mutex open_rel_lock; /* held when in open() or release() */
@@ -165,30 +157,34 @@ typedef struct sg_device { /* holds the state of each scsi generic device */
struct gendisk *disk;
struct cdev * cdev; /* char_dev [sysfs: /sys/cdev/major/sg<n>] */
struct kref d_ref;
-} Sg_device;
+};
/* tasklet or soft irq callback */
static void sg_rq_end_io(struct request *rq, blk_status_t status);
/* Declarations of other static functions used before they are defined */
static int sg_proc_init(void);
-static int sg_start_req(Sg_request *srp, unsigned char *cmd);
-static int sg_finish_rem_req(Sg_request * srp);
-static int sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size);
-static ssize_t sg_new_write(Sg_fd *sfp, struct file *file,
+static int sg_start_req(struct sg_request *srp, u8 *cmd);
+static int sg_finish_rem_req(struct sg_request *srp);
+static int sg_build_indirect(struct sg_scatter_hold *schp, struct sg_fd *sfp,
+ int buff_size);
+static ssize_t sg_new_write(struct sg_fd *sfp, struct file *file,
const char __user *buf, size_t count, int blocking,
- int read_only, int sg_io_owned, Sg_request **o_srp);
-static int sg_common_write(Sg_fd * sfp, Sg_request * srp,
- unsigned char *cmnd, int timeout, int blocking);
-static int sg_read_oxfer(Sg_request * srp, char __user *outp, int num_read_xfer);
-static void sg_remove_scat(Sg_fd * sfp, Sg_scatter_hold * schp);
-static void sg_build_reserve(Sg_fd * sfp, int req_size);
-static void sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size);
-static void sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp);
-static Sg_fd *sg_add_sfp(Sg_device * sdp);
+ int read_only, int sg_io_owned,
+ struct sg_request **o_srp);
+static int sg_common_write(struct sg_fd *sfp, struct sg_request *srp,
+ u8 *cmnd, int timeout, int blocking);
+static int sg_read_oxfer(struct sg_request *srp, char __user *outp,
+ int num_read_xfer);
+static void sg_remove_scat(struct sg_fd *sfp, struct sg_scatter_hold *schp);
+static void sg_build_reserve(struct sg_fd *sfp, int req_size);
+static void sg_link_reserve(struct sg_fd *sfp, struct sg_request *srp,
+ int size);
+static void sg_unlink_reserve(struct sg_fd *sfp, struct sg_request *srp);
+static struct sg_fd *sg_add_sfp(struct sg_device *sdp);
static void sg_remove_sfp(struct kref *);
-static Sg_request *sg_add_request(Sg_fd * sfp);
-static int sg_remove_request(Sg_fd * sfp, Sg_request * srp);
-static Sg_device *sg_get_dev(int dev);
+static struct sg_request *sg_add_request(struct sg_fd *sfp);
+static int sg_remove_request(struct sg_fd *sfp, struct sg_request *srp);
+static struct sg_device *sg_get_dev(int dev);
static void sg_device_destroy(struct kref *kref);
#define SZ_SG_HEADER sizeof(struct sg_header)
@@ -212,7 +208,8 @@ static void sg_device_destroy(struct kref *kref);
* This function provides protection for the legacy API by restricting the
* calling context.
*/
-static int sg_check_file_access(struct file *filp, const char *caller)
+static int
+sg_check_file_access(struct file *filp, const char *caller)
{
if (filp->f_cred != current_real_cred()) {
pr_err_once("%s: process %d (%s) changed security contexts after opening file descriptor, this is not allowed.\n",
@@ -228,11 +225,11 @@ static int sg_check_file_access(struct file *filp, const char *caller)
}
static int
-open_wait(Sg_device *sdp, int flags)
+sg_wait_open_event(struct sg_device *sdp, bool o_excl)
{
int retval = 0;
- if (flags & O_EXCL) {
+ if (o_excl) {
while (sdp->open_cnt > 0) {
mutex_unlock(&sdp->open_rel_lock);
retval = wait_event_interruptible(sdp->open_wait,
@@ -263,26 +260,34 @@ open_wait(Sg_device *sdp, int flags)
return retval;
}
-/* Returns 0 on success, else a negated errno value */
+/*
+ * Corresponds to the open() system call on sg devices. Implements O_EXCL on
+ * a per device basis using 'open_cnt'. If O_EXCL and O_NONBLOCK and there is
+ * already a sg handle open on this device then it fails with an errno of
+ * EBUSY. Without the O_NONBLOCK flag then this thread enters an interruptible
+ * wait until the other handle(s) are closed.
+ */
static int
sg_open(struct inode *inode, struct file *filp)
{
- int dev = iminor(inode);
- int flags = filp->f_flags;
+ bool o_excl;
+ int min_dev = iminor(inode);
+ int op_flags = filp->f_flags;
struct request_queue *q;
- Sg_device *sdp;
- Sg_fd *sfp;
+ struct sg_device *sdp;
+ struct sg_fd *sfp;
int retval;
nonseekable_open(inode, filp);
- if ((flags & O_EXCL) && (O_RDONLY == (flags & O_ACCMODE)))
+ o_excl = !!(op_flags & O_EXCL);
+ if (o_excl && ((op_flags & O_ACCMODE) == O_RDONLY))
return -EPERM; /* Can't lock it with read only access */
- sdp = sg_get_dev(dev);
+ sdp = sg_get_dev(min_dev);
if (IS_ERR(sdp))
return PTR_ERR(sdp);
SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
- "sg_open: flags=0x%x\n", flags));
+ "sg_open: flags=0x%x\n", op_flags));
/* This driver's module count bumped by fops_get in <linux/fs.h> */
/* Prevent the device driver from vanishing while we sleep */
@@ -297,7 +302,7 @@ sg_open(struct inode *inode, struct file *filp)
/* scsi_block_when_processing_errors() may block so bypass
* check if O_NONBLOCK. Permits SCSI commands to be issued
* during error recovery. Tread carefully. */
- if (!((flags & O_NONBLOCK) ||
+ if (!((op_flags & O_NONBLOCK) ||
scsi_block_when_processing_errors(sdp->device))) {
retval = -ENXIO;
/* we are in error recovery for this device */
@@ -305,8 +310,8 @@ sg_open(struct inode *inode, struct file *filp)
}
mutex_lock(&sdp->open_rel_lock);
- if (flags & O_NONBLOCK) {
- if (flags & O_EXCL) {
+ if (op_flags & O_NONBLOCK) {
+ if (o_excl) {
if (sdp->open_cnt > 0) {
retval = -EBUSY;
goto error_mutex_locked;
@@ -318,13 +323,13 @@ sg_open(struct inode *inode, struct file *filp)
}
}
} else {
- retval = open_wait(sdp, flags);
+ retval = sg_wait_open_event(sdp, o_excl);
if (retval) /* -ERESTARTSYS or -ENODEV */
goto error_mutex_locked;
}
/* N.B. at this point we are holding the open_rel_lock */
- if (flags & O_EXCL)
+ if (o_excl)
sdp->exclude = true;
if (sdp->open_cnt < 1) { /* no existing opens */
@@ -348,7 +353,7 @@ sg_open(struct inode *inode, struct file *filp)
return retval;
out_undo:
- if (flags & O_EXCL) {
+ if (o_excl) {
sdp->exclude = false; /* undo if error */
wake_up_interruptible(&sdp->open_wait);
}
@@ -366,10 +371,12 @@ sg_open(struct inode *inode, struct file *filp)
static int
sg_release(struct inode *inode, struct file *filp)
{
- Sg_device *sdp;
- Sg_fd *sfp;
+ struct sg_device *sdp;
+ struct sg_fd *sfp;
- if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
+ sfp = filp->private_data;
+ sdp = sfp->parentdp;
+ if (!sdp)
return -ENXIO;
SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp, "sg_release\n"));
@@ -401,20 +408,22 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
{
int mxsize, cmd_size, k;
int input_size, blocking;
- unsigned char opcode;
- Sg_device *sdp;
- Sg_fd *sfp;
- Sg_request *srp;
+ u8 opcode;
+ struct sg_device *sdp;
+ struct sg_fd *sfp;
+ struct sg_request *srp;
struct sg_header old_hdr;
sg_io_hdr_t *hp;
- unsigned char cmnd[SG_MAX_CDB_SIZE];
+ u8 cmnd[SG_MAX_CDB_SIZE];
int retval;
retval = sg_check_file_access(filp, __func__);
if (retval)
return retval;
- if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
+ sfp = filp->private_data;
+ sdp = sfp->parentdp;
+ if (!sdp)
return -ENXIO;
SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
"sg_write: count=%d\n", (int) count));
@@ -467,7 +476,7 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
}
hp = &srp->header;
hp->interface_id = '\0'; /* indicator of old interface tunnelled */
- hp->cmd_len = (unsigned char) cmd_size;
+ hp->cmd_len = (u8) cmd_size;
hp->iovec_count = 0;
hp->mx_sb_len = 0;
if (input_size > 0)
@@ -507,7 +516,8 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
return (k < 0) ? k : count;
}
-static int sg_allow_access(struct file *filp, unsigned char *cmd)
+static int
+sg_allow_access(struct file *filp, u8 *cmd)
{
struct sg_fd *sfp = filp->private_data;
@@ -518,14 +528,14 @@ static int sg_allow_access(struct file *filp, unsigned char *cmd)
}
static ssize_t
-sg_new_write(Sg_fd *sfp, struct file *file, const char __user *buf,
+sg_new_write(struct sg_fd *sfp, struct file *file, const char __user *buf,
size_t count, int blocking, int read_only, int sg_io_owned,
- Sg_request **o_srp)
+ struct sg_request **o_srp)
{
int k;
- Sg_request *srp;
+ struct sg_request *srp;
sg_io_hdr_t *hp;
- unsigned char cmnd[SG_MAX_CDB_SIZE];
+ u8 cmnd[SG_MAX_CDB_SIZE];
int timeout;
unsigned long ul_timeout;
@@ -591,11 +601,11 @@ sg_new_write(Sg_fd *sfp, struct file *file, const char __user *buf,
}
static int
-sg_common_write(Sg_fd * sfp, Sg_request * srp,
- unsigned char *cmnd, int timeout, int blocking)
+sg_common_write(struct sg_fd *sfp, struct sg_request *srp,
+ u8 *cmnd, int timeout, int blocking)
{
int k, at_head;
- Sg_device *sdp = sfp->parentdp;
+ struct sg_device *sdp = sfp->parentdp;
sg_io_hdr_t *hp = &srp->header;
srp->data.cmd_opcode = cmnd[0]; /* hold opcode of command */
@@ -654,10 +664,10 @@ sg_common_write(Sg_fd * sfp, Sg_request * srp,
* half of the ioctl(SG_IO) share code with read(2).
*/
-static Sg_request *
-sg_get_rq_mark(Sg_fd *sfp, int pack_id)
+static struct sg_request *
+sg_get_rq_mark(struct sg_fd *sfp, int pack_id)
{
- Sg_request *resp;
+ struct sg_request *resp;
unsigned long iflags;
write_lock_irqsave(&sfp->rq_list_lock, iflags);
@@ -675,7 +685,8 @@ sg_get_rq_mark(Sg_fd *sfp, int pack_id)
}
static ssize_t
-sg_new_read(Sg_fd *sfp, char __user *buf, size_t count, Sg_request *srp)
+sg_new_read(struct sg_fd *sfp, char __user *buf, size_t count,
+ struct sg_request *srp)
{
sg_io_hdr_t *hp = &srp->header;
int err = 0, err2;
@@ -715,7 +726,8 @@ sg_new_read(Sg_fd *sfp, char __user *buf, size_t count, Sg_request *srp)
return err ? : err2 ? : count;
}
-static int srp_done(Sg_fd *sfp, Sg_request *srp)
+static int
+srp_done(struct sg_fd *sfp, struct sg_request *srp)
{
unsigned long flags;
int ret;
@@ -729,9 +741,9 @@ static int srp_done(Sg_fd *sfp, Sg_request *srp)
static ssize_t
sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
{
- Sg_device *sdp;
- Sg_fd *sfp;
- Sg_request *srp;
+ struct sg_device *sdp;
+ struct sg_fd *sfp;
+ struct sg_request *srp;
int req_pack_id = -1;
sg_io_hdr_t *hp;
struct sg_header *old_hdr = NULL;
@@ -888,7 +900,8 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
return retval;
}
-static int max_sectors_bytes(struct request_queue *q)
+static int
+max_sectors_bytes(struct request_queue *q)
{
unsigned int max_sectors = queue_max_sectors(q);
@@ -898,9 +911,9 @@ static int max_sectors_bytes(struct request_queue *q)
}
static void
-sg_fill_request_table(Sg_fd *sfp, sg_req_info_t *rinfo)
+sg_fill_request_table(struct sg_fd *sfp, struct sg_req_info *rinfo)
{
- Sg_request *srp;
+ struct sg_request *srp;
int val;
unsigned int ms;
@@ -936,14 +949,15 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
void __user *p = (void __user *)arg;
int __user *ip = p;
int result, val, read_only;
- Sg_device *sdp;
- Sg_fd *sfp;
- Sg_request *srp;
+ struct sg_device *sdp;
+ struct sg_fd *sfp;
+ struct sg_request *srp;
unsigned long iflags;
- if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
+ sfp = filp->private_data;
+ sdp = sfp->parentdp;
+ if (!sdp)
return -ENXIO;
-
SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
"sg_ioctl: cmd=0x%x\n", (int) cmd_in));
read_only = (O_RDWR != (filp->f_flags & O_ACCMODE));
@@ -1178,13 +1192,16 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
}
#ifdef CONFIG_COMPAT
-static long sg_compat_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
+static long
+sg_compat_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
{
- Sg_device *sdp;
- Sg_fd *sfp;
+ struct sg_device *sdp;
+ struct sg_fd *sfp;
struct scsi_device *sdev;
- if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
+ sfp = filp->private_data;
+ sdp = sfp->parentdp;
+ if (!sdp)
return -ENXIO;
sdev = sdp->device;
@@ -1204,9 +1221,9 @@ static __poll_t
sg_poll(struct file *filp, poll_table * wait)
{
__poll_t res = 0;
- Sg_device *sdp;
- Sg_fd *sfp;
- Sg_request *srp;
+ struct sg_device *sdp;
+ struct sg_fd *sfp;
+ struct sg_request *srp;
int count = 0;
unsigned long iflags;
@@ -1241,10 +1258,12 @@ sg_poll(struct file *filp, poll_table * wait)
static int
sg_fasync(int fd, struct file *filp, int mode)
{
- Sg_device *sdp;
- Sg_fd *sfp;
+ struct sg_device *sdp;
+ struct sg_fd *sfp;
- if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
+ sfp = filp->private_data;
+ sdp = sfp->parentdp;
+ if (!sdp)
return -ENXIO;
SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
"sg_fasync: mode=%d\n", mode));
@@ -1256,13 +1275,21 @@ static vm_fault_t
sg_vma_fault(struct vm_fault *vmf)
{
struct vm_area_struct *vma = vmf->vma;
- Sg_fd *sfp;
+ struct sg_fd *sfp;
unsigned long offset, len, sa;
- Sg_scatter_hold *rsv_schp;
+ struct sg_scatter_hold *rsv_schp;
int k, length;
+ const char *nbp = "==NULL, bad";
- if ((NULL == vma) || (!(sfp = (Sg_fd *) vma->vm_private_data)))
- return VM_FAULT_SIGBUS;
+ if (!vma) {
+ pr_warn("%s: vma%s\n", __func__, nbp);
+ goto out_err;
+ }
+ sfp = vma->vm_private_data;
+ if (!sfp) {
+ pr_warn("%s: sfp%s\n", __func__, nbp);
+ goto out_err;
+ }
rsv_schp = &sfp->reserve;
offset = vmf->pgoff << PAGE_SHIFT;
if (offset >= rsv_schp->bufflen)
@@ -1285,7 +1312,7 @@ sg_vma_fault(struct vm_fault *vmf)
sa += len;
offset -= len;
}
-
+out_err:
return VM_FAULT_SIGBUS;
}
@@ -1296,14 +1323,19 @@ static const struct vm_operations_struct sg_mmap_vm_ops = {
static int
sg_mmap(struct file *filp, struct vm_area_struct *vma)
{
- Sg_fd *sfp;
+ struct sg_fd *sfp;
unsigned long req_sz, len, sa;
- Sg_scatter_hold *rsv_schp;
+ struct sg_scatter_hold *rsv_schp;
int k, length;
int ret = 0;
- if ((!filp) || (!vma) || (!(sfp = (Sg_fd *) filp->private_data)))
+ if (!filp || !vma)
+ return -ENXIO;
+ sfp = filp->private_data;
+ if (!sfp) {
+ pr_warn("sg: %s: sfp is NULL\n", __func__);
return -ENXIO;
+ }
req_sz = vma->vm_end - vma->vm_start;
SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sfp->parentdp,
"sg_mmap starting, vm_start=%p, len=%d\n",
@@ -1354,8 +1386,8 @@ sg_rq_end_io(struct request *rq, blk_status_t status)
{
struct sg_request *srp = rq->end_io_data;
struct scsi_request *req = scsi_req(rq);
- Sg_device *sdp;
- Sg_fd *sfp;
+ struct sg_device *sdp;
+ struct sg_fd *sfp;
unsigned long iflags;
unsigned int ms;
char *sense;
@@ -1467,21 +1499,18 @@ static struct class *sg_sysfs_class;
static int sg_sysfs_valid = 0;
-static Sg_device *
+static struct sg_device *
sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
{
struct request_queue *q = scsidp->request_queue;
- Sg_device *sdp;
+ struct sg_device *sdp;
unsigned long iflags;
int error;
u32 k;
- sdp = kzalloc(sizeof(Sg_device), GFP_KERNEL);
- if (!sdp) {
- sdev_printk(KERN_WARNING, scsidp, "%s: kmalloc Sg_device "
- "failure\n", __func__);
+ sdp = kzalloc(sizeof(struct sg_device), GFP_KERNEL);
+ if (!sdp)
return ERR_PTR(-ENOMEM);
- }
idr_preload(GFP_KERNEL);
write_lock_irqsave(&sg_index_lock, iflags);
@@ -1494,8 +1523,8 @@ sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
scsidp->type, SG_MAX_DEVS - 1);
error = -ENODEV;
} else {
- sdev_printk(KERN_WARNING, scsidp, "%s: idr "
- "allocation Sg_device failure: %d\n",
+ sdev_printk(KERN_WARNING, scsidp,
+ "%s: idr alloc sg_device failure: %d\n",
__func__, error);
}
goto out_unlock;
@@ -1534,7 +1563,7 @@ sg_add_device(struct device *cl_dev, struct class_interface *cl_intf)
{
struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
struct gendisk *disk;
- Sg_device *sdp = NULL;
+ struct sg_device *sdp = NULL;
struct cdev * cdev = NULL;
int error;
unsigned long iflags;
@@ -1633,9 +1662,9 @@ static void
sg_remove_device(struct device *cl_dev, struct class_interface *cl_intf)
{
struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
- Sg_device *sdp = dev_get_drvdata(cl_dev);
+ struct sg_device *sdp = dev_get_drvdata(cl_dev);
unsigned long iflags;
- Sg_fd *sfp;
+ struct sg_fd *sfp;
int val;
if (!sdp)
@@ -1738,22 +1767,22 @@ exit_sg(void)
}
static int
-sg_start_req(Sg_request *srp, unsigned char *cmd)
+sg_start_req(struct sg_request *srp, u8 *cmd)
{
int res;
struct request *rq;
struct scsi_request *req;
- Sg_fd *sfp = srp->parentfp;
+ struct sg_fd *sfp = srp->parentfp;
sg_io_hdr_t *hp = &srp->header;
int dxfer_len = (int) hp->dxfer_len;
int dxfer_dir = hp->dxfer_direction;
unsigned int iov_count = hp->iovec_count;
- Sg_scatter_hold *req_schp = &srp->data;
- Sg_scatter_hold *rsv_schp = &sfp->reserve;
+ struct sg_scatter_hold *req_schp = &srp->data;
+ struct sg_scatter_hold *rsv_schp = &sfp->reserve;
struct request_queue *q = sfp->parentdp->device->request_queue;
struct rq_map_data *md, map_data;
int rw = hp->dxfer_direction == SG_DXFER_TO_DEV ? WRITE : READ;
- unsigned char *long_cmdp = NULL;
+ u8 *long_cmdp = NULL;
SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
"sg_start_req: dxfer_len=%d\n",
@@ -1868,12 +1897,12 @@ sg_start_req(Sg_request *srp, unsigned char *cmd)
}
static int
-sg_finish_rem_req(Sg_request *srp)
+sg_finish_rem_req(struct sg_request *srp)
{
int ret = 0;
- Sg_fd *sfp = srp->parentfp;
- Sg_scatter_hold *req_schp = &srp->data;
+ struct sg_fd *sfp = srp->parentfp;
+ struct sg_scatter_hold *req_schp = &srp->data;
SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
"sg_finish_rem_req: res_used=%d\n",
@@ -1895,7 +1924,8 @@ sg_finish_rem_req(Sg_request *srp)
}
static int
-sg_build_sgat(Sg_scatter_hold * schp, const Sg_fd * sfp, int tablesize)
+sg_build_sgat(struct sg_scatter_hold *schp, const struct sg_fd *sfp,
+ int tablesize)
{
int sg_bufflen = tablesize * sizeof(struct page *);
gfp_t gfp_flags = GFP_ATOMIC | __GFP_NOWARN;
@@ -1908,7 +1938,8 @@ sg_build_sgat(Sg_scatter_hold * schp, const Sg_fd * sfp, int tablesize)
}
static int
-sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size)
+sg_build_indirect(struct sg_scatter_hold *schp, struct sg_fd *sfp,
+ int buff_size)
{
int ret_sz = 0, i, k, rem_sz, num, mx_sc_elems;
int sg_tablesize = sfp->parentdp->sg_tablesize;
@@ -1990,7 +2021,7 @@ sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size)
}
static void
-sg_remove_scat(Sg_fd * sfp, Sg_scatter_hold * schp)
+sg_remove_scat(struct sg_fd *sfp, struct sg_scatter_hold *schp)
{
SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
"sg_remove_scat: k_use_sg=%d\n", schp->k_use_sg));
@@ -2013,9 +2044,9 @@ sg_remove_scat(Sg_fd * sfp, Sg_scatter_hold * schp)
}
static int
-sg_read_oxfer(Sg_request * srp, char __user *outp, int num_read_xfer)
+sg_read_oxfer(struct sg_request *srp, char __user *outp, int num_read_xfer)
{
- Sg_scatter_hold *schp = &srp->data;
+ struct sg_scatter_hold *schp = &srp->data;
int k, num;
SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, srp->parentfp->parentdp,
@@ -2046,9 +2077,9 @@ sg_read_oxfer(Sg_request * srp, char __user *outp, int num_read_xfer)
}
static void
-sg_build_reserve(Sg_fd * sfp, int req_size)
+sg_build_reserve(struct sg_fd *sfp, int req_size)
{
- Sg_scatter_hold *schp = &sfp->reserve;
+ struct sg_scatter_hold *schp = &sfp->reserve;
SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
"sg_build_reserve: req_size=%d\n", req_size));
@@ -2064,10 +2095,10 @@ sg_build_reserve(Sg_fd * sfp, int req_size)
}
static void
-sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size)
+sg_link_reserve(struct sg_fd *sfp, struct sg_request *srp, int size)
{
- Sg_scatter_hold *req_schp = &srp->data;
- Sg_scatter_hold *rsv_schp = &sfp->reserve;
+ struct sg_scatter_hold *req_schp = &srp->data;
+ struct sg_scatter_hold *rsv_schp = &sfp->reserve;
int k, num, rem;
srp->res_used = 1;
@@ -2095,9 +2126,9 @@ sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size)
}
static void
-sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp)
+sg_unlink_reserve(struct sg_fd *sfp, struct sg_request *srp)
{
- Sg_scatter_hold *req_schp = &srp->data;
+ struct sg_scatter_hold *req_schp = &srp->data;
SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, srp->parentfp->parentdp,
"sg_unlink_reserve: req->k_use_sg=%d\n",
@@ -2113,12 +2144,12 @@ sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp)
}
/* always adds to end of list */
-static Sg_request *
-sg_add_request(Sg_fd * sfp)
+static struct sg_request *
+sg_add_request(struct sg_fd *sfp)
{
int k;
unsigned long iflags;
- Sg_request *rp = sfp->req_arr;
+ struct sg_request *rp = sfp->req_arr;
write_lock_irqsave(&sfp->rq_list_lock, iflags);
if (!list_empty(&sfp->rq_list)) {
@@ -2132,7 +2163,7 @@ sg_add_request(Sg_fd * sfp)
if (k >= SG_MAX_QUEUE)
goto out_unlock;
}
- memset(rp, 0, sizeof (Sg_request));
+ memset(rp, 0, sizeof(struct sg_request));
rp->parentfp = sfp;
rp->header.duration = jiffies_to_msecs(jiffies);
list_add_tail(&rp->entry, &sfp->rq_list);
@@ -2145,7 +2176,7 @@ sg_add_request(Sg_fd * sfp)
/* Return of 1 for found; 0 for not found */
static int
-sg_remove_request(Sg_fd * sfp, Sg_request * srp)
+sg_remove_request(struct sg_fd *sfp, struct sg_request *srp)
{
unsigned long iflags;
int res = 0;
@@ -2162,10 +2193,10 @@ sg_remove_request(Sg_fd * sfp, Sg_request * srp)
return res;
}
-static Sg_fd *
-sg_add_sfp(Sg_device * sdp)
+static struct sg_fd *
+sg_add_sfp(struct sg_device *sdp)
{
- Sg_fd *sfp;
+ struct sg_fd *sfp;
unsigned long iflags;
int bufflen;
@@ -2215,13 +2246,13 @@ sg_remove_sfp_usercontext(struct work_struct *work)
{
struct sg_fd *sfp = container_of(work, struct sg_fd, ew.work);
struct sg_device *sdp = sfp->parentdp;
- Sg_request *srp;
+ struct sg_request *srp;
unsigned long iflags;
/* Cleanup any responses which were never read(). */
write_lock_irqsave(&sfp->rq_list_lock, iflags);
while (!list_empty(&sfp->rq_list)) {
- srp = list_first_entry(&sfp->rq_list, Sg_request, entry);
+ srp = list_first_entry(&sfp->rq_list, struct sg_request, entry);
sg_finish_rem_req(srp);
list_del(&srp->entry);
srp->parentfp = NULL;
@@ -2286,12 +2317,13 @@ sg_last_dev(void)
#endif
/* must be called with sg_index_lock held */
-static Sg_device *sg_lookup_dev(int dev)
+static struct sg_device *
+sg_lookup_dev(int dev)
{
return idr_find(&sg_index_idr, dev);
}
-static Sg_device *
+static struct sg_device *
sg_get_dev(int dev)
{
struct sg_device *sdp;
@@ -2389,13 +2421,15 @@ sg_proc_init(void)
}
-static int sg_proc_seq_show_int(struct seq_file *s, void *v)
+static int
+sg_proc_seq_show_int(struct seq_file *s, void *v)
{
seq_printf(s, "%d\n", *((int *)s->private));
return 0;
}
-static int sg_proc_single_open_adio(struct inode *inode, struct file *file)
+static int
+sg_proc_single_open_adio(struct inode *inode, struct file *file)
{
return single_open(file, sg_proc_seq_show_int, &sg_allow_dio);
}
@@ -2416,7 +2450,8 @@ sg_proc_write_adio(struct file *filp, const char __user *buffer,
return count;
}
-static int sg_proc_single_open_dressz(struct inode *inode, struct file *file)
+static int
+sg_proc_single_open_dressz(struct inode *inode, struct file *file)
{
return single_open(file, sg_proc_seq_show_int, &sg_big_buff);
}
@@ -2441,14 +2476,16 @@ sg_proc_write_dressz(struct file *filp, const char __user *buffer,
return -ERANGE;
}
-static int sg_proc_seq_show_version(struct seq_file *s, void *v)
+static int
+sg_proc_seq_show_version(struct seq_file *s, void *v)
{
seq_printf(s, "%d\t%s [%s]\n", sg_version_num, SG_VERSION_STR,
sg_version_date);
return 0;
}
-static int sg_proc_seq_show_devhdr(struct seq_file *s, void *v)
+static int
+sg_proc_seq_show_devhdr(struct seq_file *s, void *v)
{
seq_puts(s, "host\tchan\tid\tlun\ttype\topens\tqdepth\tbusy\tonline\n");
return 0;
@@ -2459,7 +2496,8 @@ struct sg_proc_deviter {
size_t max;
};
-static void * dev_seq_start(struct seq_file *s, loff_t *pos)
+static void *
+dev_seq_start(struct seq_file *s, loff_t *pos)
{
struct sg_proc_deviter * it = kmalloc(sizeof(*it), GFP_KERNEL);
@@ -2474,7 +2512,8 @@ static void * dev_seq_start(struct seq_file *s, loff_t *pos)
return it;
}
-static void * dev_seq_next(struct seq_file *s, void *v, loff_t *pos)
+static void *
+dev_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
struct sg_proc_deviter * it = s->private;
@@ -2482,15 +2521,17 @@ static void * dev_seq_next(struct seq_file *s, void *v, loff_t *pos)
return (it->index < it->max) ? it : NULL;
}
-static void dev_seq_stop(struct seq_file *s, void *v)
+static void
+dev_seq_stop(struct seq_file *s, void *v)
{
kfree(s->private);
}
-static int sg_proc_seq_show_dev(struct seq_file *s, void *v)
+static int
+sg_proc_seq_show_dev(struct seq_file *s, void *v)
{
struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
- Sg_device *sdp;
+ struct sg_device *sdp;
struct scsi_device *scsidp;
unsigned long iflags;
@@ -2513,10 +2554,11 @@ static int sg_proc_seq_show_dev(struct seq_file *s, void *v)
return 0;
}
-static int sg_proc_seq_show_devstrs(struct seq_file *s, void *v)
+static int
+sg_proc_seq_show_devstrs(struct seq_file *s, void *v)
{
struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
- Sg_device *sdp;
+ struct sg_device *sdp;
struct scsi_device *scsidp;
unsigned long iflags;
@@ -2533,11 +2575,12 @@ static int sg_proc_seq_show_devstrs(struct seq_file *s, void *v)
}
/* must be called while holding sg_index_lock */
-static void sg_proc_debug_helper(struct seq_file *s, Sg_device * sdp)
+static void
+sg_proc_debug_helper(struct seq_file *s, struct sg_device *sdp)
{
int k, new_interface, blen, usg;
- Sg_request *srp;
- Sg_fd *fp;
+ struct sg_request *srp;
+ struct sg_fd *fp;
const sg_io_hdr_t *hp;
const char * cp;
unsigned int ms;
@@ -2596,10 +2639,11 @@ static void sg_proc_debug_helper(struct seq_file *s, Sg_device * sdp)
}
}
-static int sg_proc_seq_show_debug(struct seq_file *s, void *v)
+static int
+sg_proc_seq_show_debug(struct seq_file *s, void *v)
{
struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
- Sg_device *sdp;
+ struct sg_device *sdp;
unsigned long iflags;
if (it && (0 == it->index))
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 02/20] sg: remove typedefs, type+formatting cleanup
2019-08-07 11:42 ` [PATCH v3 02/20] sg: remove typedefs, type+formatting cleanup Douglas Gilbert
@ 2019-08-12 14:22 ` Christoph Hellwig
0 siblings, 0 replies; 63+ messages in thread
From: Christoph Hellwig @ 2019-08-12 14:22 UTC (permalink / raw)
To: Douglas Gilbert; +Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche
On Wed, Aug 07, 2019 at 01:42:34PM +0200, Douglas Gilbert wrote:
> Typedefs for structure types are discouraged so those structures
> that are private to the driver have had their typedefs removed.
>
> This also means that most "camel" type variable names (i.e. mixed
> case) have been removed.
>
> Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
Looks good,
Reviewed-by: Christoph Hellwig <hch@lst.de>
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 03/20] sg: sg_log and is_enabled
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
2019-08-07 11:42 ` [PATCH v3 01/20] sg: move functions around Douglas Gilbert
2019-08-07 11:42 ` [PATCH v3 02/20] sg: remove typedefs, type+formatting cleanup Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-12 14:23 ` Christoph Hellwig
2019-08-07 11:42 ` [PATCH v3 04/20] sg: rework sg_poll(), minor changes Douglas Gilbert
` (17 subsequent siblings)
20 siblings, 1 reply; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
Replace SCSI_LOG_TIMEOUT macros with SG_LOG macros across the driver.
The definition of SG_LOG calls SCSI_LOG_TIMEOUT if given and derived
pointers are non-zero, calls pr_info otherwise. SG_LOGS additionally
prints the sg device name and the thread id. The thread id is very
useful, even in single threaded invocations because the driver not
only uses the invocer's thread but also uses work queues and the
main callback (i.e. sg_rq_end_io()) may hit any thread. Some
interesting cases arise when the callback hits its invocer's
thread.
SG_LOGS takes 48 bytes on the stack to build this printf format
string: "sg%u: tid=%d" whose size is clearly bounded above by
the maximum size of those two integers.
Protecting against the 'current' pointer being zero is for safety
and the case where the boot device is SCSI and the sg driver is
built into the kernel. Also when debugging, getting a message
from a compromised kernel can be very useful in pinpointing the
location of the failure.
The simple fact that the SG_LOG macro is shorter than
SCSI_LOG_TIMEOUT macro allow more error message "payload" per line.
Also replace #if and #ifdef conditional compilations with
the IS_ENABLED macro.
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 252 +++++++++++++++++++++++-----------------------
1 file changed, 125 insertions(+), 127 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 6615777931f7..d14ba4a5441c 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -57,6 +57,15 @@ static char *sg_version_date = "20190606";
#define SG_MAX_DEVS 32768
+/* Comment out the following line to compile out SCSI_LOGGING stuff */
+#define SG_DEBUG 1
+
+#if !IS_ENABLED(SG_DEBUG)
+#if IS_ENABLED(DEBUG) /* If SG_DEBUG not defined, check for DEBUG */
+#define SG_DEBUG DEBUG
+#endif
+#endif
+
/* SG_MAX_CDB_SIZE should be 260 (spc4r37 section 3.1.30) however the type
* of sg_io_hdr::cmd_len can only represent 255. All SCSI commands greater
* than 16 bytes are "variable length" whose length is a multiple of 4
@@ -174,7 +183,7 @@ static ssize_t sg_new_write(struct sg_fd *sfp, struct file *file,
static int sg_common_write(struct sg_fd *sfp, struct sg_request *srp,
u8 *cmnd, int timeout, int blocking);
static int sg_read_oxfer(struct sg_request *srp, char __user *outp,
- int num_read_xfer);
+ int num_xfer);
static void sg_remove_scat(struct sg_fd *sfp, struct sg_scatter_hold *schp);
static void sg_build_reserve(struct sg_fd *sfp, int req_size);
static void sg_link_reserve(struct sg_fd *sfp, struct sg_request *srp,
@@ -187,14 +196,45 @@ static int sg_remove_request(struct sg_fd *sfp, struct sg_request *srp);
static struct sg_device *sg_get_dev(int dev);
static void sg_device_destroy(struct kref *kref);
-#define SZ_SG_HEADER sizeof(struct sg_header)
-#define SZ_SG_IO_HDR sizeof(sg_io_hdr_t)
-#define SZ_SG_IOVEC sizeof(sg_iovec_t)
-#define SZ_SG_REQ_INFO sizeof(sg_req_info_t)
+#define SZ_SG_HEADER ((int)sizeof(struct sg_header)) /* v1 and v2 header */
+#define SZ_SG_IO_HDR ((int)sizeof(struct sg_io_hdr)) /* v3 header */
+#define SZ_SG_REQ_INFO ((int)sizeof(struct sg_req_info))
+
+/*
+ * Kernel needs to be built with CONFIG_SCSI_LOGGING to see log messages.
+ * 'depth' is a number between 1 (most severe) and 7 (most noisy, most
+ * information). All messages are logged as informational (KERN_INFO). In
+ * the unexpected situation where sfp or sdp is NULL the macro reverts to
+ * a pr_info and ignores SCSI_LOG_TIMEOUT and always prints to the log.
+ * Example: this invocation: 'scsi_logging_level -s -T 3' will print
+ * depth (aka level) 1 and 2 SG_LOG() messages.
+ */
+
+#define SG_PROC_DEBUG_SZ 8192
+
+#if IS_ENABLED(CONFIG_SCSI_LOGGING) && IS_ENABLED(SG_DEBUG)
+#define SG_LOG_BUFF_SZ 48
+
+#define SG_LOG(depth, sfp, fmt, a...) \
+ do { \
+ char _b[SG_LOG_BUFF_SZ]; \
+ int _tid = (current ? current->pid : -1); \
+ struct sg_fd *_fp = sfp; \
+ struct sg_device *_sdp = _fp ? _fp->parentdp : NULL; \
+ \
+ if (likely(_sdp && _sdp->disk)) { \
+ snprintf(_b, sizeof(_b), "sg%u: tid=%d", \
+ _sdp->index, _tid); \
+ SCSI_LOG_TIMEOUT(depth, \
+ sdev_prefix_printk(KERN_INFO, \
+ _sdp->device, _b, fmt, ##a)); \
+ } else \
+ pr_info("sg: sdp or sfp NULL, " fmt, ##a); \
+ } while (0)
+#else
+#define SG_LOG(depth, sfp, fmt, a...)
+#endif /* end of CONFIG_SCSI_LOGGING && SG_DEBUG conditional */
-#define sg_printk(prefix, sdp, fmt, a...) \
- sdev_prefix_printk(prefix, (sdp)->device, \
- (sdp)->disk->disk_name, fmt, ##a)
/*
* The SCSI interfaces that use read() and write() as an asynchronous variant of
@@ -286,9 +326,6 @@ sg_open(struct inode *inode, struct file *filp)
if (IS_ERR(sdp))
return PTR_ERR(sdp);
- SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
- "sg_open: flags=0x%x\n", op_flags));
-
/* This driver's module count bumped by fops_get in <linux/fs.h> */
/* Prevent the device driver from vanishing while we sleep */
retval = scsi_device_get(sdp->device);
@@ -346,6 +383,9 @@ sg_open(struct inode *inode, struct file *filp)
filp->private_data = sfp;
sdp->open_cnt++;
mutex_unlock(&sdp->open_rel_lock);
+ SG_LOG(3, sfp, "%s: minor=%d, op_flags=0x%x; %s count prior=%d%s\n",
+ __func__, min_dev, op_flags, "device open", sdp->open_cnt,
+ ((op_flags & O_NONBLOCK) ? " O_NONBLOCK" : ""));
retval = 0;
sg_put:
@@ -376,9 +416,10 @@ sg_release(struct inode *inode, struct file *filp)
sfp = filp->private_data;
sdp = sfp->parentdp;
+ SG_LOG(3, sfp, "%s: device open count prior=%d\n", __func__,
+ sdp->open_cnt);
if (!sdp)
return -ENXIO;
- SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp, "sg_release\n"));
mutex_lock(&sdp->open_rel_lock);
scsi_autopm_put_device(sdp->device);
@@ -423,10 +464,9 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
sfp = filp->private_data;
sdp = sfp->parentdp;
+ SG_LOG(3, sfp, "%s: write(3rd arg) count=%d\n", __func__, (int)count);
if (!sdp)
return -ENXIO;
- SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
- "sg_write: count=%d\n", (int) count));
if (atomic_read(&sdp->detaching))
return -ENODEV;
if (!((filp->f_flags & O_NONBLOCK) ||
@@ -447,8 +487,7 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
return -EIO; /* The minimum scsi command length is 6 bytes. */
if (!(srp = sg_add_request(sfp))) {
- SCSI_LOG_TIMEOUT(1, sg_printk(KERN_INFO, sdp,
- "sg_write: queue full\n"));
+ SG_LOG(1, sfp, "%s: queue full\n", __func__);
return -EDOM;
}
buf += SZ_SG_HEADER;
@@ -463,9 +502,8 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
cmd_size = 12;
}
mutex_unlock(&sfp->f_mutex);
- SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sdp,
- "sg_write: scsi opcode=0x%02x, cmd_size=%d\n", (int) opcode, cmd_size));
-/* Determine buffer size. */
+ SG_LOG(4, sfp, "%s: scsi opcode=0x%02x, cmd_size=%d\n", __func__,
+ (unsigned int)opcode, cmd_size);
input_size = count - cmd_size;
mxsize = (input_size > old_hdr.reply_len) ? input_size : old_hdr.reply_len;
mxsize -= SZ_SG_HEADER;
@@ -546,8 +584,7 @@ sg_new_write(struct sg_fd *sfp, struct file *file, const char __user *buf,
sfp->cmd_q = 1; /* when sg_io_hdr seen, set command queuing on */
if (!(srp = sg_add_request(sfp))) {
- SCSI_LOG_TIMEOUT(1, sg_printk(KERN_INFO, sfp->parentdp,
- "sg_new_write: queue full\n"));
+ SG_LOG(1, sfp, "%s: queue full\n", __func__);
return -EDOM;
}
srp->sg_io_owned = sg_io_owned;
@@ -616,17 +653,15 @@ sg_common_write(struct sg_fd *sfp, struct sg_request *srp,
hp->host_status = 0;
hp->driver_status = 0;
hp->resid = 0;
- SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
- "sg_common_write: scsi opcode=0x%02x, cmd_size=%d\n",
- (int) cmnd[0], (int) hp->cmd_len));
+ SG_LOG(4, sfp, "%s: opcode=0x%02x, cmd_sz=%d\n", __func__,
+ (int)cmnd[0], hp->cmd_len);
if (hp->dxfer_len >= SZ_256M)
return -EINVAL;
k = sg_start_req(srp, cmnd);
if (k) {
- SCSI_LOG_TIMEOUT(1, sg_printk(KERN_INFO, sfp->parentdp,
- "sg_common_write: start_req err=%d\n", k));
+ SG_LOG(1, sfp, "%s: start_req err=%d\n", __func__, k);
sg_finish_rem_req(srp);
sg_remove_request(sfp, srp);
return k; /* probably out of space --> ENOMEM */
@@ -759,9 +794,7 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
sfp = filp->private_data;
sdp = sfp->parentdp;
- SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
- "%s: count=%d\n", __func__,
- (int) count));
+ SG_LOG(3, sfp, "%s: read() count=%d\n", __func__, (int)count);
if (!sdp)
return -ENXIO;
@@ -956,10 +989,10 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
sfp = filp->private_data;
sdp = sfp->parentdp;
+ SG_LOG(6, sfp, "%s: cmd=0x%x, O_NONBLOCK=%d\n", __func__, cmd_in,
+ !!(filp->f_flags & O_NONBLOCK));
if (!sdp)
return -ENXIO;
- SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
- "sg_ioctl: cmd=0x%x\n", (int) cmd_in));
read_only = (O_RDWR != (filp->f_flags & O_ACCMODE));
switch (cmd_in) {
@@ -1191,7 +1224,7 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
return scsi_ioctl(sdp->device, cmd_in, p);
}
-#ifdef CONFIG_COMPAT
+#if IS_ENABLED(CONFIG_COMPAT)
static long
sg_compat_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
{
@@ -1250,24 +1283,16 @@ sg_poll(struct file *filp, poll_table * wait)
res |= EPOLLOUT | EPOLLWRNORM;
} else if (count < SG_MAX_QUEUE)
res |= EPOLLOUT | EPOLLWRNORM;
- SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
- "sg_poll: res=0x%x\n", (__force u32) res));
+ SG_LOG(3, sfp, "%s: res=0x%x\n", __func__, (__force u32)res);
return res;
}
static int
sg_fasync(int fd, struct file *filp, int mode)
{
- struct sg_device *sdp;
- struct sg_fd *sfp;
-
- sfp = filp->private_data;
- sdp = sfp->parentdp;
- if (!sdp)
- return -ENXIO;
- SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
- "sg_fasync: mode=%d\n", mode));
+ struct sg_fd *sfp = filp->private_data;
+ SG_LOG(3, sfp, "%s: mode(%s)\n", __func__, (mode ? "add" : "remove"));
return fasync_helper(fd, filp, mode, &sfp->async_qp);
}
@@ -1294,10 +1319,8 @@ sg_vma_fault(struct vm_fault *vmf)
offset = vmf->pgoff << PAGE_SHIFT;
if (offset >= rsv_schp->bufflen)
return VM_FAULT_SIGBUS;
- SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sfp->parentdp,
- "sg_vma_fault: offset=%lu, scatg=%d\n",
- offset, rsv_schp->k_use_sg));
sa = vma->vm_start;
+ SG_LOG(3, sfp, "%s: vm_start=0x%lx, off=%lu\n", __func__, sa, offset);
length = 1 << (PAGE_SHIFT + rsv_schp->page_order);
for (k = 0; k < rsv_schp->k_use_sg && sa < vma->vm_end; k++) {
len = vma->vm_end - sa;
@@ -1337,9 +1360,8 @@ sg_mmap(struct file *filp, struct vm_area_struct *vma)
return -ENXIO;
}
req_sz = vma->vm_end - vma->vm_start;
- SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sfp->parentdp,
- "sg_mmap starting, vm_start=%p, len=%d\n",
- (void *) vma->vm_start, (int) req_sz));
+ SG_LOG(3, sfp, "%s: vm_start=%p, len=%d\n", __func__,
+ (void *)vma->vm_start, (int)req_sz);
if (vma->vm_pgoff)
return -EINVAL; /* want no offset */
rsv_schp = &sfp->reserve;
@@ -1408,10 +1430,9 @@ sg_rq_end_io(struct request *rq, blk_status_t status)
result = req->result;
resid = req->resid_len;
- SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sdp,
- "sg_cmd_done: pack_id=%d, res=0x%x\n",
- srp->header.pack_id, result));
srp->header.resid = resid;
+ SG_LOG(6, sfp, "%s: pack_id=%d, res=0x%x\n", __func__,
+ srp->header.pack_id, result);
ms = jiffies_to_msecs(jiffies);
srp->header.duration = (ms > srp->header.duration) ?
(ms - srp->header.duration) : 0;
@@ -1485,7 +1506,7 @@ static const struct file_operations sg_fops = {
.write = sg_write,
.poll = sg_poll,
.unlocked_ioctl = sg_ioctl,
-#ifdef CONFIG_COMPAT
+#if IS_ENABLED(CONFIG_COMPAT)
.compat_ioctl = sg_compat_ioctl,
#endif
.open = sg_open,
@@ -1532,7 +1553,7 @@ sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
k = error;
SCSI_LOG_TIMEOUT(3, sdev_printk(KERN_INFO, scsidp,
- "sg_alloc: dev=%d \n", k));
+ "%s: dev=%d, sdp=0x%p ++\n", __func__, k, sdp));
sprintf(disk->disk_name, "sg%d", k);
disk->first_minor = k;
sdp->disk = disk;
@@ -1651,8 +1672,8 @@ sg_device_destroy(struct kref *kref)
idr_remove(&sg_index_idr, sdp->index);
write_unlock_irqrestore(&sg_index_lock, flags);
- SCSI_LOG_TIMEOUT(3,
- sg_printk(KERN_INFO, sdp, "sg_device_destroy\n"));
+ sdev_printk(KERN_INFO, sdp->device, "[tid=%d] %s: sdp=0x%p --\n",
+ (current ? current->pid : -1), __func__, sdp);
put_disk(sdp->disk);
kfree(sdp);
@@ -1674,8 +1695,8 @@ sg_remove_device(struct device *cl_dev, struct class_interface *cl_intf)
if (val > 1)
return; /* only want to do following once per device */
- SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
- "%s\n", __func__));
+ SCSI_LOG_TIMEOUT(3, sdev_printk(KERN_INFO, sdp->device,
+ "%s: 0x%p\n", __func__, sdp));
read_lock_irqsave(&sdp->sfd_lock, iflags);
list_for_each_entry(sfp, &sdp->sfds, sfd_siblings) {
@@ -1744,7 +1765,7 @@ init_sg(void)
return rc;
}
-#ifndef CONFIG_SCSI_PROC_FS
+#if !IS_ENABLED(CONFIG_SCSI_PROC_FS)
static int
sg_proc_init(void)
{
@@ -1755,9 +1776,8 @@ sg_proc_init(void)
static void __exit
exit_sg(void)
{
-#ifdef CONFIG_SCSI_PROC_FS
- remove_proc_subtree("scsi/sg", NULL);
-#endif /* CONFIG_SCSI_PROC_FS */
+ if (IS_ENABLED(CONFIG_SCSI_PROC_FS))
+ remove_proc_subtree("scsi/sg", NULL);
scsi_unregister_interface(&sg_interface);
class_destroy(sg_sysfs_class);
sg_sysfs_valid = 0;
@@ -1784,15 +1804,14 @@ sg_start_req(struct sg_request *srp, u8 *cmd)
int rw = hp->dxfer_direction == SG_DXFER_TO_DEV ? WRITE : READ;
u8 *long_cmdp = NULL;
- SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
- "sg_start_req: dxfer_len=%d\n",
- dxfer_len));
-
if (hp->cmd_len > BLK_MAX_CDB) {
long_cmdp = kzalloc(hp->cmd_len, GFP_KERNEL);
if (!long_cmdp)
return -ENOMEM;
+ SG_LOG(5, sfp, "%s: long_cmdp=0x%p ++\n", __func__, long_cmdp);
}
+ SG_LOG(4, sfp, "%s: dxfer_len=%d, data-%s\n", __func__, dxfer_len,
+ (rw ? "OUT" : "IN"));
/*
* NOTE
@@ -1904,9 +1923,8 @@ sg_finish_rem_req(struct sg_request *srp)
struct sg_fd *sfp = srp->parentfp;
struct sg_scatter_hold *req_schp = &srp->data;
- SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
- "sg_finish_rem_req: res_used=%d\n",
- (int) srp->res_used));
+ SG_LOG(4, sfp, "%s: srp=0x%p%s\n", __func__, srp,
+ (srp->res_used) ? " rsv" : "");
if (srp->bio)
ret = blk_rq_unmap_user(srp->bio);
@@ -1953,9 +1971,8 @@ sg_build_indirect(struct sg_scatter_hold *schp, struct sg_fd *sfp,
++blk_size; /* don't know why */
/* round request up to next highest SG_SECTOR_SZ byte boundary */
blk_size = ALIGN(blk_size, SG_SECTOR_SZ);
- SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
- "sg_build_indirect: buff_size=%d, blk_size=%d\n",
- buff_size, blk_size));
+ SG_LOG(4, sfp, "%s: buff_size=%d, blk_size=%d\n", __func__, buff_size,
+ blk_size);
/* N.B. ret_sz carried into this block ... */
mx_sc_elems = sg_build_sgat(schp, sfp, sg_tablesize);
@@ -1994,18 +2011,13 @@ sg_build_indirect(struct sg_scatter_hold *schp, struct sg_fd *sfp,
scatter_elem_sz_prev = ret_sz;
}
}
-
- SCSI_LOG_TIMEOUT(5, sg_printk(KERN_INFO, sfp->parentdp,
- "sg_build_indirect: k=%d, num=%d, ret_sz=%d\n",
- k, num, ret_sz));
+ SG_LOG(5, sfp, "%s: k=%d, num=%d, ret_sz=%d\n", __func__, k,
+ num, ret_sz);
} /* end of for loop */
schp->page_order = order;
schp->k_use_sg = k;
- SCSI_LOG_TIMEOUT(5, sg_printk(KERN_INFO, sfp->parentdp,
- "sg_build_indirect: k_use_sg=%d, rem_sz=%d\n",
- k, rem_sz));
-
+ SG_LOG(5, sfp, "%s: k_use_sg=%d, order=%d\n", __func__, k, order);
schp->bufflen = blk_size;
if (rem_sz > 0) /* must have failed */
return -ENOMEM;
@@ -2023,35 +2035,34 @@ sg_build_indirect(struct sg_scatter_hold *schp, struct sg_fd *sfp,
static void
sg_remove_scat(struct sg_fd *sfp, struct sg_scatter_hold *schp)
{
- SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
- "sg_remove_scat: k_use_sg=%d\n", schp->k_use_sg));
+ SG_LOG(4, sfp, "%s: num_sgat=%d\n", __func__, schp->k_use_sg);
if (schp->pages && schp->sglist_len > 0) {
if (!schp->dio_in_use) {
int k;
for (k = 0; k < schp->k_use_sg && schp->pages[k]; k++) {
- SCSI_LOG_TIMEOUT(5,
- sg_printk(KERN_INFO, sfp->parentdp,
- "sg_remove_scat: k=%d, pg=0x%p\n",
- k, schp->pages[k]));
+ SG_LOG(5, sfp, "%s: pg[%d]=0x%p --\n",
+ __func__, k, schp->pages[k]);
__free_pages(schp->pages[k], schp->page_order);
}
-
kfree(schp->pages);
}
}
memset(schp, 0, sizeof (*schp));
}
+/*
+ * For sg v1 and v2 interface: with a command yielding a data-in buffer, after
+ * it has arrived in kernel memory, this function copies it to the user space,
+ * appended to given struct sg_header object.
+ */
static int
sg_read_oxfer(struct sg_request *srp, char __user *outp, int num_read_xfer)
{
struct sg_scatter_hold *schp = &srp->data;
int k, num;
- SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, srp->parentfp->parentdp,
- "sg_read_oxfer: num_read_xfer=%d\n",
- num_read_xfer));
+ SG_LOG(4, srp->parentfp, "%s: num_xfer=%d\n", __func__, num_read_xfer);
if ((!outp) || (num_read_xfer <= 0))
return 0;
@@ -2081,8 +2092,7 @@ sg_build_reserve(struct sg_fd *sfp, int req_size)
{
struct sg_scatter_hold *schp = &sfp->reserve;
- SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
- "sg_build_reserve: req_size=%d\n", req_size));
+ SG_LOG(3, sfp, "%s: buflen=%d\n", __func__, req_size);
do {
if (req_size < PAGE_SIZE)
req_size = PAGE_SIZE;
@@ -2102,8 +2112,7 @@ sg_link_reserve(struct sg_fd *sfp, struct sg_request *srp, int size)
int k, num, rem;
srp->res_used = 1;
- SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
- "sg_link_reserve: size=%d\n", size));
+ SG_LOG(4, sfp, "%s: size=%d\n", __func__, size);
rem = size;
num = 1 << (PAGE_SHIFT + rsv_schp->page_order);
@@ -2121,8 +2130,7 @@ sg_link_reserve(struct sg_fd *sfp, struct sg_request *srp, int size)
}
if (k >= rsv_schp->k_use_sg)
- SCSI_LOG_TIMEOUT(1, sg_printk(KERN_INFO, sfp->parentdp,
- "sg_link_reserve: BAD size\n"));
+ SG_LOG(1, sfp, "%s: BAD size\n", __func__);
}
static void
@@ -2130,9 +2138,8 @@ sg_unlink_reserve(struct sg_fd *sfp, struct sg_request *srp)
{
struct sg_scatter_hold *req_schp = &srp->data;
- SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, srp->parentfp->parentdp,
- "sg_unlink_reserve: req->k_use_sg=%d\n",
- (int) req_schp->k_use_sg));
+ SG_LOG(4, srp->parentfp, "%s: req->k_use_sg=%d\n", __func__,
+ (int)req_schp->k_use_sg);
req_schp->k_use_sg = 0;
req_schp->bufflen = 0;
req_schp->pages = NULL;
@@ -2223,18 +2230,15 @@ sg_add_sfp(struct sg_device *sdp)
}
list_add_tail(&sfp->sfd_siblings, &sdp->sfds);
write_unlock_irqrestore(&sdp->sfd_lock, iflags);
- SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
- "sg_add_sfp: sfp=0x%p\n", sfp));
+ SG_LOG(3, sfp, "%s: sfp=0x%p\n", __func__, sfp);
if (unlikely(sg_big_buff != def_reserved_size))
sg_big_buff = def_reserved_size;
bufflen = min_t(int, sg_big_buff,
max_sectors_bytes(sdp->device->request_queue));
sg_build_reserve(sfp, bufflen);
- SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
- "sg_add_sfp: bufflen=%d, k_use_sg=%d\n",
- sfp->reserve.bufflen,
- sfp->reserve.k_use_sg));
+ SG_LOG(3, sfp, "%s: bufflen=%d, k_use_sg=%d\n", __func__,
+ sfp->reserve.bufflen, sfp->reserve.k_use_sg);
kref_get(&sdp->d_ref);
__module_get(THIS_MODULE);
@@ -2260,15 +2264,12 @@ sg_remove_sfp_usercontext(struct work_struct *work)
write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
if (sfp->reserve.bufflen > 0) {
- SCSI_LOG_TIMEOUT(6, sg_printk(KERN_INFO, sdp,
- "sg_remove_sfp: bufflen=%d, k_use_sg=%d\n",
- (int) sfp->reserve.bufflen,
- (int) sfp->reserve.k_use_sg));
+ SG_LOG(6, sfp, "%s: bufflen=%d, k_use_sg=%d\n", __func__,
+ (int)sfp->reserve.bufflen, (int)sfp->reserve.k_use_sg);
sg_remove_scat(sfp, &sfp->reserve);
}
- SCSI_LOG_TIMEOUT(6, sg_printk(KERN_INFO, sdp,
- "sg_remove_sfp: sfp=0x%p\n", sfp));
+ SG_LOG(6, sfp, "%s: sfp=0x%p\n", __func__, sfp);
kfree(sfp);
scsi_device_put(sdp->device);
@@ -2291,7 +2292,6 @@ sg_remove_sfp(struct kref *kref)
schedule_work(&sfp->ew.work);
}
-#ifdef CONFIG_SCSI_PROC_FS
static int
sg_idr_max_id(int id, void *p, void *data)
{
@@ -2303,19 +2303,6 @@ sg_idr_max_id(int id, void *p, void *data)
return 0;
}
-static int
-sg_last_dev(void)
-{
- int k = -1;
- unsigned long iflags;
-
- read_lock_irqsave(&sg_index_lock, iflags);
- idr_for_each(&sg_index_idr, sg_idr_max_id, &k);
- read_unlock_irqrestore(&sg_index_lock, iflags);
- return k + 1; /* origin 1 */
-}
-#endif
-
/* must be called with sg_index_lock held */
static struct sg_device *
sg_lookup_dev(int dev)
@@ -2345,7 +2332,7 @@ sg_get_dev(int dev)
return sdp;
}
-#ifdef CONFIG_SCSI_PROC_FS
+#if IS_ENABLED(CONFIG_SCSI_PROC_FS) /* long, almost to end of file */
static int sg_proc_seq_show_int(struct seq_file *s, void *v);
static int sg_proc_single_open_adio(struct inode *inode, struct file *file);
@@ -2420,6 +2407,17 @@ sg_proc_init(void)
return 0;
}
+static int
+sg_last_dev(void)
+{
+ int k = -1;
+ unsigned long iflags;
+
+ read_lock_irqsave(&sg_index_lock, iflags);
+ idr_for_each(&sg_index_idr, sg_idr_max_id, &k);
+ read_unlock_irqrestore(&sg_index_lock, iflags);
+ return k + 1; /* origin 1 */
+}
static int
sg_proc_seq_show_int(struct seq_file *s, void *v)
@@ -2678,7 +2676,7 @@ sg_proc_seq_show_debug(struct seq_file *s, void *v)
return 0;
}
-#endif /* CONFIG_SCSI_PROC_FS */
+#endif /* CONFIG_SCSI_PROC_FS (~300 lines back) */
module_init(init_sg);
module_exit(exit_sg);
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 03/20] sg: sg_log and is_enabled
2019-08-07 11:42 ` [PATCH v3 03/20] sg: sg_log and is_enabled Douglas Gilbert
@ 2019-08-12 14:23 ` Christoph Hellwig
2019-08-13 22:57 ` Douglas Gilbert
0 siblings, 1 reply; 63+ messages in thread
From: Christoph Hellwig @ 2019-08-12 14:23 UTC (permalink / raw)
To: Douglas Gilbert; +Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche
On Wed, Aug 07, 2019 at 01:42:35PM +0200, Douglas Gilbert wrote:
> Replace SCSI_LOG_TIMEOUT macros with SG_LOG macros across the driver.
> The definition of SG_LOG calls SCSI_LOG_TIMEOUT if given and derived
> pointers are non-zero, calls pr_info otherwise. SG_LOGS additionally
> prints the sg device name and the thread id. The thread id is very
> useful, even in single threaded invocations because the driver not
> only uses the invocer's thread but also uses work queues and the
> main callback (i.e. sg_rq_end_io()) may hit any thread. Some
> interesting cases arise when the callback hits its invocer's
> thread.
>
> SG_LOGS takes 48 bytes on the stack to build this printf format
> string: "sg%u: tid=%d" whose size is clearly bounded above by
> the maximum size of those two integers.
> Protecting against the 'current' pointer being zero is for safety
> and the case where the boot device is SCSI and the sg driver is
> built into the kernel. Also when debugging, getting a message
> from a compromised kernel can be very useful in pinpointing the
> location of the failure.
>
> The simple fact that the SG_LOG macro is shorter than
> SCSI_LOG_TIMEOUT macro allow more error message "payload" per line.
>
> Also replace #if and #ifdef conditional compilations with
> the IS_ENABLED macro.
>
> Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
> ---
> drivers/scsi/sg.c | 252 +++++++++++++++++++++++-----------------------
> 1 file changed, 125 insertions(+), 127 deletions(-)
>
> diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
> index 6615777931f7..d14ba4a5441c 100644
> --- a/drivers/scsi/sg.c
> +++ b/drivers/scsi/sg.c
> @@ -57,6 +57,15 @@ static char *sg_version_date = "20190606";
>
> #define SG_MAX_DEVS 32768
>
> +/* Comment out the following line to compile out SCSI_LOGGING stuff */
> +#define SG_DEBUG 1
> +
> +#if !IS_ENABLED(SG_DEBUG)
> +#if IS_ENABLED(DEBUG) /* If SG_DEBUG not defined, check for DEBUG */
> +#define SG_DEBUG DEBUG
> +#endif
> +#endif
IS_ENABLED is mostly useful for checking it from C-level if statements.
No need to use this from cpp. But even more importantly we generally
try to avoid cpp checks that aren't driven from Kconfig. Please make
these an actual CONFIG_ options.
> static int sg_read_oxfer(struct sg_request *srp, char __user *outp,
> - int num_read_xfer);
> + int num_xfer);
This looks like a random unrelated change.
> -#define SZ_SG_HEADER sizeof(struct sg_header)
> -#define SZ_SG_IO_HDR sizeof(sg_io_hdr_t)
> -#define SZ_SG_IOVEC sizeof(sg_iovec_t)
> -#define SZ_SG_REQ_INFO sizeof(sg_req_info_t)
> +#define SZ_SG_HEADER ((int)sizeof(struct sg_header)) /* v1 and v2 header */
> +#define SZ_SG_IO_HDR ((int)sizeof(struct sg_io_hdr)) /* v3 header */
> +#define SZ_SG_REQ_INFO ((int)sizeof(struct sg_req_info))
Doesn't look related to the patch. But more importantly there should
be no point to cast or even have the macros wrapping the sizeof to
start with.
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 03/20] sg: sg_log and is_enabled
2019-08-12 14:23 ` Christoph Hellwig
@ 2019-08-13 22:57 ` Douglas Gilbert
0 siblings, 0 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-13 22:57 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche
On 2019-08-12 10:23 a.m., Christoph Hellwig wrote:
> On Wed, Aug 07, 2019 at 01:42:35PM +0200, Douglas Gilbert wrote:
>> Replace SCSI_LOG_TIMEOUT macros with SG_LOG macros across the driver.
>> The definition of SG_LOG calls SCSI_LOG_TIMEOUT if given and derived
>> pointers are non-zero, calls pr_info otherwise. SG_LOGS additionally
>> prints the sg device name and the thread id. The thread id is very
>> useful, even in single threaded invocations because the driver not
>> only uses the invocer's thread but also uses work queues and the
>> main callback (i.e. sg_rq_end_io()) may hit any thread. Some
>> interesting cases arise when the callback hits its invocer's
>> thread.
>>
>> SG_LOGS takes 48 bytes on the stack to build this printf format
>> string: "sg%u: tid=%d" whose size is clearly bounded above by
>> the maximum size of those two integers.
>> Protecting against the 'current' pointer being zero is for safety
>> and the case where the boot device is SCSI and the sg driver is
>> built into the kernel. Also when debugging, getting a message
>> from a compromised kernel can be very useful in pinpointing the
>> location of the failure.
>>
>> The simple fact that the SG_LOG macro is shorter than
>> SCSI_LOG_TIMEOUT macro allow more error message "payload" per line.
>>
>> Also replace #if and #ifdef conditional compilations with
>> the IS_ENABLED macro.
>>
>> Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
>> ---
>> drivers/scsi/sg.c | 252 +++++++++++++++++++++++-----------------------
>> 1 file changed, 125 insertions(+), 127 deletions(-)
>>
>> diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
>> index 6615777931f7..d14ba4a5441c 100644
>> --- a/drivers/scsi/sg.c
>> +++ b/drivers/scsi/sg.c
>> @@ -57,6 +57,15 @@ static char *sg_version_date = "20190606";
>>
>> #define SG_MAX_DEVS 32768
>>
>> +/* Comment out the following line to compile out SCSI_LOGGING stuff */
>> +#define SG_DEBUG 1
>> +
>> +#if !IS_ENABLED(SG_DEBUG)
>> +#if IS_ENABLED(DEBUG) /* If SG_DEBUG not defined, check for DEBUG */
>> +#define SG_DEBUG DEBUG
>> +#endif
>> +#endif
>
> IS_ENABLED is mostly useful for checking it from C-level if statements.
> No need to use this from cpp. But even more importantly we generally
> try to avoid cpp checks that aren't driven from Kconfig. Please make
> these an actual CONFIG_ options.
Another reviewer (called James) didn't like #ifdef_s (at file scope).
Surely it is simpler to allow an experienced C programmer to add
#define DEBUG 1
or
#define SG_DEBUG 1
to the driver source code than to add to the existing Linux config
nightmare with a new config parameter:
CONFIG_CHR_DEV_SG_DEBUG
$ grep "^CONF" <linux-stable>/.config | wc
2480
on my system.
Linux: where too much is never enough.
>> static int sg_read_oxfer(struct sg_request *srp, char __user *outp,
>> - int num_read_xfer);
>> + int num_xfer);
>
> This looks like a random unrelated change.
Separate patch maybe :-)
>> -#define SZ_SG_HEADER sizeof(struct sg_header)
>> -#define SZ_SG_IO_HDR sizeof(sg_io_hdr_t)
>> -#define SZ_SG_IOVEC sizeof(sg_iovec_t)
>> -#define SZ_SG_REQ_INFO sizeof(sg_req_info_t)
>> +#define SZ_SG_HEADER ((int)sizeof(struct sg_header)) /* v1 and v2 header */
>> +#define SZ_SG_IO_HDR ((int)sizeof(struct sg_io_hdr)) /* v3 header */
>> +#define SZ_SG_REQ_INFO ((int)sizeof(struct sg_req_info))
>
> Doesn't look related to the patch. But more importantly there should
> be no point to cast or even have the macros wrapping the sizeof to
> start with.
Well I find it useful as I spend a fair bit of time re-reading
my code. To me a dozen upper case letters is easier to decode
than a sea of parentheses.
And the tide is moving back against "unsigned" types, at least in
C++. It is now regarded as a mistake the way STL introduced lots
of "unsigned" types and they are looking at whether they can move
some of them back to int.
Closer to home, I use ints wherever possible and the kernel seems
to favour them with negated errno return values. However the compiler
mindlessly warns about signed/unsigned comparisons when an int is
compared to a sizeof(). [If it had half a brain, it would check the
_value_ of the sizeof, and realize that often, even on an 8 bit
machine, there is no reason for the warning.]
Then there is the "Fortran rule" in checkpatch.pl (i.e. no lines
than 80 characters). "(int)sizeof(struct sg_io_hdr)" is 30 characters
long and that length often pushes simple conditionals like:
if (A > B)
onto two lines which IMO is stupid.
Doug Gilbert
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 04/20] sg: rework sg_poll(), minor changes
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (2 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 03/20] sg: sg_log and is_enabled Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-12 14:23 ` Christoph Hellwig
2019-08-07 11:42 ` [PATCH v3 05/20] sg: bitops in sg_device Douglas Gilbert
` (16 subsequent siblings)
20 siblings, 1 reply; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
Re-arrange code in sg_poll(). Rename sg_read_oxfer() to
sg_rd_append(). In sg_start_req() rename rw to r0w.
Plus associated changes demanded by checkpatch.pl
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 65 ++++++++++++++++++++++-------------------------
1 file changed, 30 insertions(+), 35 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index d14ba4a5441c..9aa1b1030033 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -177,13 +177,13 @@ static int sg_finish_rem_req(struct sg_request *srp);
static int sg_build_indirect(struct sg_scatter_hold *schp, struct sg_fd *sfp,
int buff_size);
static ssize_t sg_new_write(struct sg_fd *sfp, struct file *file,
- const char __user *buf, size_t count, int blocking,
- int read_only, int sg_io_owned,
- struct sg_request **o_srp);
+ const char __user *buf, size_t count, int blocking,
+ int read_only, int sg_io_owned,
+ struct sg_request **o_srp);
static int sg_common_write(struct sg_fd *sfp, struct sg_request *srp,
u8 *cmnd, int timeout, int blocking);
-static int sg_read_oxfer(struct sg_request *srp, char __user *outp,
- int num_xfer);
+static int sg_rd_append(struct sg_request *srp, char __user *outp,
+ int num_xfer);
static void sg_remove_scat(struct sg_fd *sfp, struct sg_scatter_hold *schp);
static void sg_build_reserve(struct sg_fd *sfp, int req_size);
static void sg_link_reserve(struct sg_fd *sfp, struct sg_request *srp,
@@ -918,7 +918,7 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
if (count > old_hdr->reply_len)
count = old_hdr->reply_len;
if (count > SZ_SG_HEADER) {
- if (sg_read_oxfer(srp, buf, count - SZ_SG_HEADER)) {
+ if (sg_rd_append(srp, buf, count - SZ_SG_HEADER)) {
retval = -EFAULT;
goto free_old_hdr;
}
@@ -1253,38 +1253,34 @@ sg_compat_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
static __poll_t
sg_poll(struct file *filp, poll_table * wait)
{
- __poll_t res = 0;
- struct sg_device *sdp;
- struct sg_fd *sfp;
+ __poll_t p_res = 0;
+ struct sg_fd *sfp = filp->private_data;
struct sg_request *srp;
int count = 0;
unsigned long iflags;
- sfp = filp->private_data;
if (!sfp)
return EPOLLERR;
- sdp = sfp->parentdp;
- if (!sdp)
- return EPOLLERR;
poll_wait(filp, &sfp->read_wait, wait);
read_lock_irqsave(&sfp->rq_list_lock, iflags);
list_for_each_entry(srp, &sfp->rq_list, entry) {
/* if any read waiting, flag it */
- if ((0 == res) && (1 == srp->done) && (!srp->sg_io_owned))
- res = EPOLLIN | EPOLLRDNORM;
+ if (p_res == 0 && srp->done == 1 && !srp->sg_io_owned)
+ p_res = EPOLLIN | EPOLLRDNORM;
++count;
}
read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
- if (atomic_read(&sdp->detaching))
- res |= EPOLLHUP;
- else if (!sfp->cmd_q) {
- if (0 == count)
- res |= EPOLLOUT | EPOLLWRNORM;
- } else if (count < SG_MAX_QUEUE)
- res |= EPOLLOUT | EPOLLWRNORM;
- SG_LOG(3, sfp, "%s: res=0x%x\n", __func__, (__force u32)res);
- return res;
+ if (sfp->parentdp && atomic_read(&sfp->parentdp->detaching)) {
+ p_res |= EPOLLHUP;
+ } else if (!sfp->cmd_q) {
+ if (count == 0)
+ p_res |= EPOLLOUT | EPOLLWRNORM;
+ } else if (count < SG_MAX_QUEUE) {
+ p_res |= EPOLLOUT | EPOLLWRNORM;
+ }
+ SG_LOG(3, sfp, "%s: p_res=0x%x\n", __func__, (__force u32)p_res);
+ return p_res;
}
static int
@@ -1801,7 +1797,7 @@ sg_start_req(struct sg_request *srp, u8 *cmd)
struct sg_scatter_hold *rsv_schp = &sfp->reserve;
struct request_queue *q = sfp->parentdp->device->request_queue;
struct rq_map_data *md, map_data;
- int rw = hp->dxfer_direction == SG_DXFER_TO_DEV ? WRITE : READ;
+ int r0w = hp->dxfer_direction == SG_DXFER_TO_DEV ? WRITE : READ;
u8 *long_cmdp = NULL;
if (hp->cmd_len > BLK_MAX_CDB) {
@@ -1811,7 +1807,7 @@ sg_start_req(struct sg_request *srp, u8 *cmd)
SG_LOG(5, sfp, "%s: long_cmdp=0x%p ++\n", __func__, long_cmdp);
}
SG_LOG(4, sfp, "%s: dxfer_len=%d, data-%s\n", __func__, dxfer_len,
- (rw ? "OUT" : "IN"));
+ (r0w ? "OUT" : "IN"));
/*
* NOTE
@@ -1888,7 +1884,7 @@ sg_start_req(struct sg_request *srp, u8 *cmd)
struct iovec *iov = NULL;
struct iov_iter i;
- res = import_iovec(rw, hp->dxferp, iov_count, 0, &iov, &i);
+ res = import_iovec(r0w, hp->dxferp, iov_count, 0, &iov, &i);
if (res < 0)
return res;
@@ -2057,33 +2053,32 @@ sg_remove_scat(struct sg_fd *sfp, struct sg_scatter_hold *schp)
* appended to given struct sg_header object.
*/
static int
-sg_read_oxfer(struct sg_request *srp, char __user *outp, int num_read_xfer)
+sg_rd_append(struct sg_request *srp, char __user *outp, int num_xfer)
{
struct sg_scatter_hold *schp = &srp->data;
int k, num;
- SG_LOG(4, srp->parentfp, "%s: num_xfer=%d\n", __func__, num_read_xfer);
- if ((!outp) || (num_read_xfer <= 0))
+ SG_LOG(4, srp->parentfp, "%s: num_xfer=%d\n", __func__, num_xfer);
+ if (!outp || num_xfer <= 0)
return 0;
num = 1 << (PAGE_SHIFT + schp->page_order);
for (k = 0; k < schp->k_use_sg && schp->pages[k]; k++) {
- if (num > num_read_xfer) {
+ if (num > num_xfer) {
if (__copy_to_user(outp, page_address(schp->pages[k]),
- num_read_xfer))
+ num_xfer))
return -EFAULT;
break;
} else {
if (__copy_to_user(outp, page_address(schp->pages[k]),
num))
return -EFAULT;
- num_read_xfer -= num;
- if (num_read_xfer <= 0)
+ num_xfer -= num;
+ if (num_xfer <= 0)
break;
outp += num;
}
}
-
return 0;
}
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 04/20] sg: rework sg_poll(), minor changes
2019-08-07 11:42 ` [PATCH v3 04/20] sg: rework sg_poll(), minor changes Douglas Gilbert
@ 2019-08-12 14:23 ` Christoph Hellwig
2019-08-13 0:35 ` Douglas Gilbert
0 siblings, 1 reply; 63+ messages in thread
From: Christoph Hellwig @ 2019-08-12 14:23 UTC (permalink / raw)
To: Douglas Gilbert; +Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche
On Wed, Aug 07, 2019 at 01:42:36PM +0200, Douglas Gilbert wrote:
> Re-arrange code in sg_poll(). Rename sg_read_oxfer() to
> sg_rd_append(). In sg_start_req() rename rw to r0w.
> Plus associated changes demanded by checkpatch.pl
r0w seems like a really odd variably name that doesn't help
readability. Also all these changes seem independent from each
other to me, so they should be split into multiple patches.
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 04/20] sg: rework sg_poll(), minor changes
2019-08-12 14:23 ` Christoph Hellwig
@ 2019-08-13 0:35 ` Douglas Gilbert
0 siblings, 0 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-13 0:35 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche
On 2019-08-12 10:23 a.m., Christoph Hellwig wrote:
> On Wed, Aug 07, 2019 at 01:42:36PM +0200, Douglas Gilbert wrote:
>> Re-arrange code in sg_poll(). Rename sg_read_oxfer() to
>> sg_rd_append(). In sg_start_req() rename rw to r0w.
>> Plus associated changes demanded by checkpatch.pl
>
> r0w seems like a really odd variably name that doesn't help
> readability. Also all these changes seem independent from each
> other to me, so they should be split into multiple patches.
When I see a bool called "rw" I wonder whether true means write
or read. When I see a bool called "r0w" then I would guess
false means read. Maybe it's just me ...
Doug Gilbert
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 05/20] sg: bitops in sg_device
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (3 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 04/20] sg: rework sg_poll(), minor changes Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-12 14:23 ` Christoph Hellwig
2019-08-07 11:42 ` [PATCH v3 06/20] sg: make open count an atomic Douglas Gilbert
` (15 subsequent siblings)
20 siblings, 1 reply; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
Introduce bitops in sg_device to replace an atomic, a bool and a
char. That char (sgdebug) had been reduced to only two states.
Add some associated macros to make the code a little clearer.
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 104 +++++++++++++++++++++++-----------------------
1 file changed, 53 insertions(+), 51 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 9aa1b1030033..97ce84f0c51b 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -74,6 +74,11 @@ static char *sg_version_date = "20190606";
#define SG_DEFAULT_TIMEOUT mult_frac(SG_DEFAULT_TIMEOUT_USER, HZ, USER_HZ)
+/* Bit positions (flags) for sg_device::fdev_bm bitmask follow */
+#define SG_FDEV_EXCLUDE 0 /* have fd open with O_EXCL */
+#define SG_FDEV_DETACHING 1 /* may be unexpected device removal */
+#define SG_FDEV_LOG_SENSE 2 /* set by ioctl(SG_SET_DEBUG) */
+
int sg_big_buff = SG_DEF_RESERVED_SIZE;
/* N.B. This variable is readable and writeable via
/proc/scsi/sg/def_reserved_size . Each time sg_open() is called a buffer
@@ -155,14 +160,12 @@ struct sg_device { /* holds the state of each scsi generic device */
struct scsi_device *device;
wait_queue_head_t open_wait; /* queue open() when O_EXCL present */
struct mutex open_rel_lock; /* held when in open() or release() */
- int sg_tablesize; /* adapter's max scatter-gather table size */
- u32 index; /* device index number */
struct list_head sfds;
rwlock_t sfd_lock; /* protect access to sfd list */
- atomic_t detaching; /* 0->device usable, 1->device detaching */
- bool exclude; /* 1->open(O_EXCL) succeeded and is active */
+ int sg_tablesize; /* adapter's max scatter-gather table size */
+ u32 index; /* device index number */
int open_cnt; /* count of opens (perhaps < num(sfds) ) */
- char sgdebug; /* 0->off, 1->sense, 9->dump dev, 10-> all devs */
+ unsigned long fdev_bm[1]; /* see SG_FDEV_* defines above */
struct gendisk *disk;
struct cdev * cdev; /* char_dev [sysfs: /sys/cdev/major/sg<n>] */
struct kref d_ref;
@@ -200,6 +203,9 @@ static void sg_device_destroy(struct kref *kref);
#define SZ_SG_IO_HDR ((int)sizeof(struct sg_io_hdr)) /* v3 header */
#define SZ_SG_REQ_INFO ((int)sizeof(struct sg_req_info))
+#define SG_IS_DETACHING(sdp) test_bit(SG_FDEV_DETACHING, (sdp)->fdev_bm)
+#define SG_HAVE_EXCLUDE(sdp) test_bit(SG_FDEV_EXCLUDE, (sdp)->fdev_bm)
+
/*
* Kernel needs to be built with CONFIG_SCSI_LOGGING to see log messages.
* 'depth' is a number between 1 (most severe) and 7 (most noisy, most
@@ -273,26 +279,26 @@ sg_wait_open_event(struct sg_device *sdp, bool o_excl)
while (sdp->open_cnt > 0) {
mutex_unlock(&sdp->open_rel_lock);
retval = wait_event_interruptible(sdp->open_wait,
- (atomic_read(&sdp->detaching) ||
+ (SG_IS_DETACHING(sdp) ||
!sdp->open_cnt));
mutex_lock(&sdp->open_rel_lock);
if (retval) /* -ERESTARTSYS */
return retval;
- if (atomic_read(&sdp->detaching))
+ if (SG_IS_DETACHING(sdp))
return -ENODEV;
}
} else {
- while (sdp->exclude) {
+ while (SG_HAVE_EXCLUDE(sdp)) {
mutex_unlock(&sdp->open_rel_lock);
retval = wait_event_interruptible(sdp->open_wait,
- (atomic_read(&sdp->detaching) ||
- !sdp->exclude));
+ (SG_IS_DETACHING(sdp) ||
+ !SG_HAVE_EXCLUDE(sdp)));
mutex_lock(&sdp->open_rel_lock);
if (retval) /* -ERESTARTSYS */
return retval;
- if (atomic_read(&sdp->detaching))
+ if (SG_IS_DETACHING(sdp))
return -ENODEV;
}
}
@@ -354,7 +360,7 @@ sg_open(struct inode *inode, struct file *filp)
goto error_mutex_locked;
}
} else {
- if (sdp->exclude) {
+ if (SG_HAVE_EXCLUDE(sdp)) {
retval = -EBUSY;
goto error_mutex_locked;
}
@@ -367,10 +373,10 @@ sg_open(struct inode *inode, struct file *filp)
/* N.B. at this point we are holding the open_rel_lock */
if (o_excl)
- sdp->exclude = true;
+ set_bit(SG_FDEV_EXCLUDE, sdp->fdev_bm);
if (sdp->open_cnt < 1) { /* no existing opens */
- sdp->sgdebug = 0;
+ clear_bit(SG_FDEV_LOG_SENSE, sdp->fdev_bm);
q = sdp->device->request_queue;
sdp->sg_tablesize = queue_max_segments(q);
}
@@ -393,8 +399,8 @@ sg_open(struct inode *inode, struct file *filp)
return retval;
out_undo:
- if (o_excl) {
- sdp->exclude = false; /* undo if error */
+ if (o_excl) { /* undo if error */
+ clear_bit(SG_FDEV_EXCLUDE, sdp->fdev_bm);
wake_up_interruptible(&sdp->open_wait);
}
error_mutex_locked:
@@ -428,12 +434,10 @@ sg_release(struct inode *inode, struct file *filp)
/* possibly many open()s waiting on exlude clearing, start many;
* only open(O_EXCL)s wait on 0==open_cnt so only start one */
- if (sdp->exclude) {
- sdp->exclude = false;
+ if (test_and_clear_bit(SG_FDEV_EXCLUDE, sdp->fdev_bm))
wake_up_interruptible_all(&sdp->open_wait);
- } else if (0 == sdp->open_cnt) {
+ else if (sdp->open_cnt == 0)
wake_up_interruptible(&sdp->open_wait);
- }
mutex_unlock(&sdp->open_rel_lock);
return 0;
}
@@ -467,7 +471,7 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
SG_LOG(3, sfp, "%s: write(3rd arg) count=%d\n", __func__, (int)count);
if (!sdp)
return -ENXIO;
- if (atomic_read(&sdp->detaching))
+ if (SG_IS_DETACHING(sdp))
return -ENODEV;
if (!((filp->f_flags & O_NONBLOCK) ||
scsi_block_when_processing_errors(sdp->device)))
@@ -666,7 +670,7 @@ sg_common_write(struct sg_fd *sfp, struct sg_request *srp,
sg_remove_request(sfp, srp);
return k; /* probably out of space --> ENOMEM */
}
- if (atomic_read(&sdp->detaching)) {
+ if (SG_IS_DETACHING(sdp)) {
if (srp->bio) {
scsi_req_free_cmd(scsi_req(srp->rq));
blk_put_request(srp->rq);
@@ -831,7 +835,7 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
}
srp = sg_get_rq_mark(sfp, req_pack_id);
if (!srp) { /* now wait on packet to arrive */
- if (atomic_read(&sdp->detaching)) {
+ if (SG_IS_DETACHING(sdp)) {
retval = -ENODEV;
goto free_old_hdr;
}
@@ -840,9 +844,9 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
goto free_old_hdr;
}
retval = wait_event_interruptible(sfp->read_wait,
- (atomic_read(&sdp->detaching) ||
+ (SG_IS_DETACHING(sdp) ||
(srp = sg_get_rq_mark(sfp, req_pack_id))));
- if (atomic_read(&sdp->detaching)) {
+ if (SG_IS_DETACHING(sdp)) {
retval = -ENODEV;
goto free_old_hdr;
}
@@ -997,7 +1001,7 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
switch (cmd_in) {
case SG_IO:
- if (atomic_read(&sdp->detaching))
+ if (SG_IS_DETACHING(sdp))
return -ENODEV;
if (!scsi_block_when_processing_errors(sdp->device))
return -ENXIO;
@@ -1008,8 +1012,8 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
if (result < 0)
return result;
result = wait_event_interruptible(sfp->read_wait,
- (srp_done(sfp, srp) || atomic_read(&sdp->detaching)));
- if (atomic_read(&sdp->detaching))
+ (srp_done(sfp, srp) || SG_IS_DETACHING(sdp)));
+ if (SG_IS_DETACHING(sdp))
return -ENODEV;
write_lock_irq(&sfp->rq_list_lock);
if (srp->done) {
@@ -1052,7 +1056,7 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
else {
sg_scsi_id_t __user *sg_idp = p;
- if (atomic_read(&sdp->detaching))
+ if (SG_IS_DETACHING(sdp))
return -ENODEV;
__put_user((int) sdp->device->host->host_no,
&sg_idp->host_no);
@@ -1176,18 +1180,18 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
return result;
}
case SG_EMULATED_HOST:
- if (atomic_read(&sdp->detaching))
+ if (SG_IS_DETACHING(sdp))
return -ENODEV;
return put_user(sdp->device->host->hostt->emulated, ip);
case SCSI_IOCTL_SEND_COMMAND:
- if (atomic_read(&sdp->detaching))
+ if (SG_IS_DETACHING(sdp))
return -ENODEV;
return sg_scsi_ioctl(sdp->device->request_queue, NULL, filp->f_mode, p);
case SG_SET_DEBUG:
result = get_user(val, ip);
if (result)
return result;
- sdp->sgdebug = (char) val;
+ assign_bit(SG_FDEV_LOG_SENSE, sdp->fdev_bm, val);
return 0;
case BLKSECTGET:
return put_user(max_sectors_bytes(sdp->device->request_queue),
@@ -1208,7 +1212,7 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
case SCSI_IOCTL_PROBE_HOST:
case SG_GET_TRANSFORM:
case SG_SCSI_RESET:
- if (atomic_read(&sdp->detaching))
+ if (SG_IS_DETACHING(sdp))
return -ENODEV;
break;
default:
@@ -1271,7 +1275,7 @@ sg_poll(struct file *filp, poll_table * wait)
}
read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
- if (sfp->parentdp && atomic_read(&sfp->parentdp->detaching)) {
+ if (sfp->parentdp && SG_IS_DETACHING(sfp->parentdp)) {
p_res |= EPOLLHUP;
} else if (!sfp->cmd_q) {
if (count == 0)
@@ -1419,7 +1423,7 @@ sg_rq_end_io(struct request *rq, blk_status_t status)
return;
sdp = sfp->parentdp;
- if (unlikely(atomic_read(&sdp->detaching)))
+ if (unlikely(SG_IS_DETACHING(sdp)))
pr_info("%s: device detaching\n", __func__);
sense = req->sense;
@@ -1440,9 +1444,9 @@ sg_rq_end_io(struct request *rq, blk_status_t status)
srp->header.msg_status = msg_byte(result);
srp->header.host_status = host_byte(result);
srp->header.driver_status = driver_byte(result);
- if ((sdp->sgdebug > 0) &&
- ((CHECK_CONDITION == srp->header.masked_status) ||
- (COMMAND_TERMINATED == srp->header.masked_status)))
+ if (test_bit(SG_FDEV_LOG_SENSE, sdp->fdev_bm) &&
+ (srp->header.masked_status == CHECK_CONDITION ||
+ srp->header.masked_status == COMMAND_TERMINATED))
__scsi_print_sense(sdp->device, __func__, sense,
SCSI_SENSE_BUFFERSIZE);
@@ -1557,7 +1561,7 @@ sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
mutex_init(&sdp->open_rel_lock);
INIT_LIST_HEAD(&sdp->sfds);
init_waitqueue_head(&sdp->open_wait);
- atomic_set(&sdp->detaching, 0);
+ clear_bit(SG_FDEV_DETACHING, sdp->fdev_bm);
rwlock_init(&sdp->sfd_lock);
sdp->sg_tablesize = queue_max_segments(q);
sdp->index = k;
@@ -1682,13 +1686,11 @@ sg_remove_device(struct device *cl_dev, struct class_interface *cl_intf)
struct sg_device *sdp = dev_get_drvdata(cl_dev);
unsigned long iflags;
struct sg_fd *sfp;
- int val;
if (!sdp)
return;
- /* want sdp->detaching non-zero as soon as possible */
- val = atomic_inc_return(&sdp->detaching);
- if (val > 1)
+ /* set this flag as soon as possible as it could be a surprise */
+ if (test_and_set_bit(SG_FDEV_DETACHING, sdp->fdev_bm))
return; /* only want to do following once per device */
SCSI_LOG_TIMEOUT(3, sdev_printk(KERN_INFO, sdp->device,
@@ -2218,7 +2220,7 @@ sg_add_sfp(struct sg_device *sdp)
sfp->keep_orphan = SG_DEF_KEEP_ORPHAN;
sfp->parentdp = sdp;
write_lock_irqsave(&sdp->sfd_lock, iflags);
- if (atomic_read(&sdp->detaching)) {
+ if (SG_IS_DETACHING(sdp)) {
write_unlock_irqrestore(&sdp->sfd_lock, iflags);
kfree(sfp);
return ERR_PTR(-ENODEV);
@@ -2315,8 +2317,8 @@ sg_get_dev(int dev)
sdp = sg_lookup_dev(dev);
if (!sdp)
sdp = ERR_PTR(-ENXIO);
- else if (atomic_read(&sdp->detaching)) {
- /* If sdp->detaching, then the refcount may already be 0, in
+ else if (SG_IS_DETACHING(sdp)) {
+ /* If detaching, then the refcount may already be 0, in
* which case it would be a bug to do kref_get().
*/
sdp = ERR_PTR(-ENODEV);
@@ -2530,8 +2532,7 @@ sg_proc_seq_show_dev(struct seq_file *s, void *v)
read_lock_irqsave(&sg_index_lock, iflags);
sdp = it ? sg_lookup_dev(it->index) : NULL;
- if ((NULL == sdp) || (NULL == sdp->device) ||
- (atomic_read(&sdp->detaching)))
+ if (!sdp || !sdp->device || SG_IS_DETACHING(sdp))
seq_puts(s, "-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\n");
else {
scsidp = sdp->device;
@@ -2558,7 +2559,7 @@ sg_proc_seq_show_devstrs(struct seq_file *s, void *v)
read_lock_irqsave(&sg_index_lock, iflags);
sdp = it ? sg_lookup_dev(it->index) : NULL;
scsidp = sdp ? sdp->device : NULL;
- if (sdp && scsidp && (!atomic_read(&sdp->detaching)))
+ if (sdp && scsidp && !SG_IS_DETACHING(sdp))
seq_printf(s, "%8.8s\t%16.16s\t%4.4s\n",
scsidp->vendor, scsidp->model, scsidp->rev);
else
@@ -2650,7 +2651,7 @@ sg_proc_seq_show_debug(struct seq_file *s, void *v)
read_lock(&sdp->sfd_lock);
if (!list_empty(&sdp->sfds)) {
seq_printf(s, " >>> device=%s ", sdp->disk->disk_name);
- if (atomic_read(&sdp->detaching))
+ if (SG_IS_DETACHING(sdp))
seq_puts(s, "detaching pending close ");
else if (sdp->device) {
struct scsi_device *scsidp = sdp->device;
@@ -2662,7 +2663,8 @@ sg_proc_seq_show_debug(struct seq_file *s, void *v)
scsidp->host->hostt->emulated);
}
seq_printf(s, " sg_tablesize=%d excl=%d open_cnt=%d\n",
- sdp->sg_tablesize, sdp->exclude, sdp->open_cnt);
+ sdp->sg_tablesize, SG_HAVE_EXCLUDE(sdp),
+ sdp->open_cnt);
sg_proc_debug_helper(s, sdp);
}
read_unlock(&sdp->sfd_lock);
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 05/20] sg: bitops in sg_device
2019-08-07 11:42 ` [PATCH v3 05/20] sg: bitops in sg_device Douglas Gilbert
@ 2019-08-12 14:23 ` Christoph Hellwig
2019-08-14 1:35 ` Douglas Gilbert
0 siblings, 1 reply; 63+ messages in thread
From: Christoph Hellwig @ 2019-08-12 14:23 UTC (permalink / raw)
To: Douglas Gilbert; +Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche
On Wed, Aug 07, 2019 at 01:42:37PM +0200, Douglas Gilbert wrote:
> + unsigned long fdev_bm[1]; /* see SG_FDEV_* defines above */
No need for the array of one here.
> +#define SG_IS_DETACHING(sdp) test_bit(SG_FDEV_DETACHING, (sdp)->fdev_bm)
> +#define SG_HAVE_EXCLUDE(sdp) test_bit(SG_FDEV_EXCLUDE, (sdp)->fdev_bm)
No real need for these wrappers.
Otherwise this looks sane to me.
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 05/20] sg: bitops in sg_device
2019-08-12 14:23 ` Christoph Hellwig
@ 2019-08-14 1:35 ` Douglas Gilbert
0 siblings, 0 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-14 1:35 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche
On 2019-08-12 10:23 a.m., Christoph Hellwig wrote:
> On Wed, Aug 07, 2019 at 01:42:37PM +0200, Douglas Gilbert wrote:
>> + unsigned long fdev_bm[1]; /* see SG_FDEV_* defines above */
>
> No need for the array of one here.
Justification here:
https://www.spinics.net/lists/linux-scsi/msg132477.html
>> +#define SG_IS_DETACHING(sdp) test_bit(SG_FDEV_DETACHING, (sdp)->fdev_bm)
>> +#define SG_HAVE_EXCLUDE(sdp) test_bit(SG_FDEV_EXCLUDE, (sdp)->fdev_bm)
>
> No real need for these wrappers.
True of all wrappers. Again, these wrappers are fighting the tyranny of
checkpatch.pl
> Otherwise this looks sane to me.
>
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 06/20] sg: make open count an atomic
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (4 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 05/20] sg: bitops in sg_device Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-12 14:23 ` Christoph Hellwig
2019-08-07 11:42 ` [PATCH v3 07/20] sg: move header to uapi section Douglas Gilbert
` (14 subsequent siblings)
20 siblings, 1 reply; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
Convert sg_device::open_cnt into an atomic. Also rename
sg_tablesize into the more descriptive max_sgat_elems.
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 39 ++++++++++++++++++++-------------------
1 file changed, 20 insertions(+), 19 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 97ce84f0c51b..9e9470944fe3 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -162,9 +162,9 @@ struct sg_device { /* holds the state of each scsi generic device */
struct mutex open_rel_lock; /* held when in open() or release() */
struct list_head sfds;
rwlock_t sfd_lock; /* protect access to sfd list */
- int sg_tablesize; /* adapter's max scatter-gather table size */
+ int max_sgat_elems; /* adapter's max sgat number of elements */
u32 index; /* device index number */
- int open_cnt; /* count of opens (perhaps < num(sfds) ) */
+ atomic_t open_cnt; /* count of opens (perhaps < num(sfds) ) */
unsigned long fdev_bm[1]; /* see SG_FDEV_* defines above */
struct gendisk *disk;
struct cdev * cdev; /* char_dev [sysfs: /sys/cdev/major/sg<n>] */
@@ -276,11 +276,11 @@ sg_wait_open_event(struct sg_device *sdp, bool o_excl)
int retval = 0;
if (o_excl) {
- while (sdp->open_cnt > 0) {
+ while (atomic_read(&sdp->open_cnt) > 0) {
mutex_unlock(&sdp->open_rel_lock);
retval = wait_event_interruptible(sdp->open_wait,
(SG_IS_DETACHING(sdp) ||
- !sdp->open_cnt));
+ atomic_read(&sdp->open_cnt) == 0));
mutex_lock(&sdp->open_rel_lock);
if (retval) /* -ERESTARTSYS */
@@ -355,7 +355,7 @@ sg_open(struct inode *inode, struct file *filp)
mutex_lock(&sdp->open_rel_lock);
if (op_flags & O_NONBLOCK) {
if (o_excl) {
- if (sdp->open_cnt > 0) {
+ if (atomic_read(&sdp->open_cnt) > 0) {
retval = -EBUSY;
goto error_mutex_locked;
}
@@ -375,10 +375,10 @@ sg_open(struct inode *inode, struct file *filp)
if (o_excl)
set_bit(SG_FDEV_EXCLUDE, sdp->fdev_bm);
- if (sdp->open_cnt < 1) { /* no existing opens */
+ if (atomic_read(&sdp->open_cnt) < 1) { /* no existing opens */
clear_bit(SG_FDEV_LOG_SENSE, sdp->fdev_bm);
q = sdp->device->request_queue;
- sdp->sg_tablesize = queue_max_segments(q);
+ sdp->max_sgat_elems = queue_max_segments(q);
}
sfp = sg_add_sfp(sdp);
if (IS_ERR(sfp)) {
@@ -387,10 +387,11 @@ sg_open(struct inode *inode, struct file *filp)
}
filp->private_data = sfp;
- sdp->open_cnt++;
+ atomic_inc(&sdp->open_cnt);
mutex_unlock(&sdp->open_rel_lock);
SG_LOG(3, sfp, "%s: minor=%d, op_flags=0x%x; %s count prior=%d%s\n",
- __func__, min_dev, op_flags, "device open", sdp->open_cnt,
+ __func__, min_dev, op_flags, "device open",
+ atomic_read(&sdp->open_cnt),
((op_flags & O_NONBLOCK) ? " O_NONBLOCK" : ""));
retval = 0;
@@ -423,20 +424,20 @@ sg_release(struct inode *inode, struct file *filp)
sfp = filp->private_data;
sdp = sfp->parentdp;
SG_LOG(3, sfp, "%s: device open count prior=%d\n", __func__,
- sdp->open_cnt);
+ atomic_read(&sdp->open_cnt));
if (!sdp)
return -ENXIO;
mutex_lock(&sdp->open_rel_lock);
scsi_autopm_put_device(sdp->device);
kref_put(&sfp->f_ref, sg_remove_sfp);
- sdp->open_cnt--;
+ atomic_dec(&sdp->open_cnt);
/* possibly many open()s waiting on exlude clearing, start many;
* only open(O_EXCL)s wait on 0==open_cnt so only start one */
if (test_and_clear_bit(SG_FDEV_EXCLUDE, sdp->fdev_bm))
wake_up_interruptible_all(&sdp->open_wait);
- else if (sdp->open_cnt == 0)
+ else if (atomic_read(&sdp->open_cnt) == 0)
wake_up_interruptible(&sdp->open_wait);
mutex_unlock(&sdp->open_rel_lock);
return 0;
@@ -1104,7 +1105,7 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
return put_user(val, ip);
case SG_GET_SG_TABLESIZE:
- return put_user(sdp->sg_tablesize, ip);
+ return put_user(sdp->max_sgat_elems, ip);
case SG_SET_RESERVED_SIZE:
result = get_user(val, ip);
if (result)
@@ -1563,7 +1564,7 @@ sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
init_waitqueue_head(&sdp->open_wait);
clear_bit(SG_FDEV_DETACHING, sdp->fdev_bm);
rwlock_init(&sdp->sfd_lock);
- sdp->sg_tablesize = queue_max_segments(q);
+ sdp->max_sgat_elems = queue_max_segments(q);
sdp->index = k;
kref_init(&sdp->d_ref);
error = 0;
@@ -1958,7 +1959,7 @@ sg_build_indirect(struct sg_scatter_hold *schp, struct sg_fd *sfp,
int buff_size)
{
int ret_sz = 0, i, k, rem_sz, num, mx_sc_elems;
- int sg_tablesize = sfp->parentdp->sg_tablesize;
+ int max_sgat_elems = sfp->parentdp->max_sgat_elems;
int blk_size = buff_size, order;
gfp_t gfp_mask = GFP_ATOMIC | __GFP_COMP | __GFP_NOWARN | __GFP_ZERO;
struct sg_device *sdp = sfp->parentdp;
@@ -1973,7 +1974,7 @@ sg_build_indirect(struct sg_scatter_hold *schp, struct sg_fd *sfp,
blk_size);
/* N.B. ret_sz carried into this block ... */
- mx_sc_elems = sg_build_sgat(schp, sfp, sg_tablesize);
+ mx_sc_elems = sg_build_sgat(schp, sfp, max_sgat_elems);
if (mx_sc_elems < 0)
return mx_sc_elems; /* most likely -ENOMEM */
@@ -2662,9 +2663,9 @@ sg_proc_seq_show_debug(struct seq_file *s, void *v)
scsidp->lun,
scsidp->host->hostt->emulated);
}
- seq_printf(s, " sg_tablesize=%d excl=%d open_cnt=%d\n",
- sdp->sg_tablesize, SG_HAVE_EXCLUDE(sdp),
- sdp->open_cnt);
+ seq_printf(s, " max_sgat_elems=%d excl=%d open_cnt=%d\n",
+ sdp->max_sgat_elems, SG_HAVE_EXCLUDE(sdp),
+ atomic_read(&sdp->open_cnt));
sg_proc_debug_helper(s, sdp);
}
read_unlock(&sdp->sfd_lock);
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 07/20] sg: move header to uapi section
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (5 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 06/20] sg: make open count an atomic Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-12 14:24 ` Christoph Hellwig
2019-08-07 11:42 ` [PATCH v3 08/20] sg: speed sg_poll and sg_get_num_waiting Douglas Gilbert
` (13 subsequent siblings)
20 siblings, 1 reply; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche, kbuild test robot
Move user interface part of scsi/sg.h into the new header file:
include/uapi/scsi/sg.h . Since scsi/sg.h includes the new header,
other code including scsi/sg.h should not be impacted.
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
Reported-by: kbuild test robot <lkp@intel.com>
-
kbuild noted a problem with including <linux/bsg.h> in
include/uapi/scsi/sg.h that should be fixed by changing
the bsg.h include to <uapi/linux/bsg.h>
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
include/scsi/sg.h | 268 ++-------------------------------
include/uapi/scsi/sg.h | 329 +++++++++++++++++++++++++++++++++++++++++
2 files changed, 338 insertions(+), 259 deletions(-)
create mode 100644 include/uapi/scsi/sg.h
diff --git a/include/scsi/sg.h b/include/scsi/sg.h
index f91bcca604e4..46fc7cbffd78 100644
--- a/include/scsi/sg.h
+++ b/include/scsi/sg.h
@@ -4,271 +4,21 @@
#include <linux/compiler.h>
-/*
- * History:
- * Started: Aug 9 by Lawrence Foard (entropy@world.std.com), to allow user
- * process control of SCSI devices.
- * Development Sponsored by Killy Corp. NY NY
- *
- * Original driver (sg.h):
- * Copyright (C) 1992 Lawrence Foard
- * Version 2 and 3 extensions to driver:
- * Copyright (C) 1998 - 2014 Douglas Gilbert
- *
- * Version: 3.5.36 (20140603)
- * This version is for 2.6 and 3 series kernels.
- *
- * Documentation
- * =============
- * A web site for the SG device driver can be found at:
- * http://sg.danny.cz/sg [alternatively check the MAINTAINERS file]
- * The documentation for the sg version 3 driver can be found at:
- * http://sg.danny.cz/sg/p/sg_v3_ho.html
- * Also see: <kernel_source>/Documentation/scsi/scsi-generic.txt
- *
- * For utility and test programs see: http://sg.danny.cz/sg/sg3_utils.html
- */
-
#ifdef __KERNEL__
extern int sg_big_buff; /* for sysctl */
#endif
+/*
+ * In version 3.9.01 of the sg driver, this file was spilt in two, with the
+ * bulk of the user space interface being placed in the file being included
+ * in the following line.
+ */
+#include <uapi/scsi/sg.h>
-typedef struct sg_iovec /* same structure as used by readv() Linux system */
-{ /* call. It defines one scatter-gather element. */
- void __user *iov_base; /* Starting address */
- size_t iov_len; /* Length in bytes */
-} sg_iovec_t;
-
-
-typedef struct sg_io_hdr
-{
- int interface_id; /* [i] 'S' for SCSI generic (required) */
- int dxfer_direction; /* [i] data transfer direction */
- unsigned char cmd_len; /* [i] SCSI command length */
- unsigned char mx_sb_len; /* [i] max length to write to sbp */
- unsigned short iovec_count; /* [i] 0 implies no scatter gather */
- unsigned int dxfer_len; /* [i] byte count of data transfer */
- void __user *dxferp; /* [i], [*io] points to data transfer memory
- or scatter gather list */
- unsigned char __user *cmdp; /* [i], [*i] points to command to perform */
- void __user *sbp; /* [i], [*o] points to sense_buffer memory */
- unsigned int timeout; /* [i] MAX_UINT->no timeout (unit: millisec) */
- unsigned int flags; /* [i] 0 -> default, see SG_FLAG... */
- int pack_id; /* [i->o] unused internally (normally) */
- void __user * usr_ptr; /* [i->o] unused internally */
- unsigned char status; /* [o] scsi status */
- unsigned char masked_status;/* [o] shifted, masked scsi status */
- unsigned char msg_status; /* [o] messaging level data (optional) */
- unsigned char sb_len_wr; /* [o] byte count actually written to sbp */
- unsigned short host_status; /* [o] errors from host adapter */
- unsigned short driver_status;/* [o] errors from software driver */
- int resid; /* [o] dxfer_len - actual_transferred */
- unsigned int duration; /* [o] time taken by cmd (unit: millisec) */
- unsigned int info; /* [o] auxiliary information */
-} sg_io_hdr_t; /* 64 bytes long (on i386) */
-
-#define SG_INTERFACE_ID_ORIG 'S'
-
-/* Use negative values to flag difference from original sg_header structure */
-#define SG_DXFER_NONE (-1) /* e.g. a SCSI Test Unit Ready command */
-#define SG_DXFER_TO_DEV (-2) /* e.g. a SCSI WRITE command */
-#define SG_DXFER_FROM_DEV (-3) /* e.g. a SCSI READ command */
-#define SG_DXFER_TO_FROM_DEV (-4) /* treated like SG_DXFER_FROM_DEV with the
- additional property than during indirect
- IO the user buffer is copied into the
- kernel buffers before the transfer */
-#define SG_DXFER_UNKNOWN (-5) /* Unknown data direction */
-
-/* following flag values can be "or"-ed together */
-#define SG_FLAG_DIRECT_IO 1 /* default is indirect IO */
-#define SG_FLAG_UNUSED_LUN_INHIBIT 2 /* default is overwrite lun in SCSI */
- /* command block (when <= SCSI_2) */
-#define SG_FLAG_MMAP_IO 4 /* request memory mapped IO */
-#define SG_FLAG_NO_DXFER 0x10000 /* no transfer of kernel buffers to/from */
- /* user space (debug indirect IO) */
-/* defaults:: for sg driver: Q_AT_HEAD; for block layer: Q_AT_TAIL */
-#define SG_FLAG_Q_AT_TAIL 0x10
-#define SG_FLAG_Q_AT_HEAD 0x20
-
-/* following 'info' values are "or"-ed together */
-#define SG_INFO_OK_MASK 0x1
-#define SG_INFO_OK 0x0 /* no sense, host nor driver "noise" */
-#define SG_INFO_CHECK 0x1 /* something abnormal happened */
-
-#define SG_INFO_DIRECT_IO_MASK 0x6
-#define SG_INFO_INDIRECT_IO 0x0 /* data xfer via kernel buffers (or no xfer) */
-#define SG_INFO_DIRECT_IO 0x2 /* direct IO requested and performed */
-#define SG_INFO_MIXED_IO 0x4 /* part direct, part indirect IO */
-
-
-typedef struct sg_scsi_id { /* used by SG_GET_SCSI_ID ioctl() */
- int host_no; /* as in "scsi<n>" where 'n' is one of 0, 1, 2 etc */
- int channel;
- int scsi_id; /* scsi id of target device */
- int lun;
- int scsi_type; /* TYPE_... defined in scsi/scsi.h */
- short h_cmd_per_lun;/* host (adapter) maximum commands per lun */
- short d_queue_depth;/* device (or adapter) maximum queue length */
- int unused[2]; /* probably find a good use, set 0 for now */
-} sg_scsi_id_t; /* 32 bytes long on i386 */
-
-typedef struct sg_req_info { /* used by SG_GET_REQUEST_TABLE ioctl() */
- char req_state; /* 0 -> not used, 1 -> written, 2 -> ready to read */
- char orphan; /* 0 -> normal request, 1 -> from interruped SG_IO */
- char sg_io_owned; /* 0 -> complete with read(), 1 -> owned by SG_IO */
- char problem; /* 0 -> no problem detected, 1 -> error to report */
- int pack_id; /* pack_id associated with request */
- void __user *usr_ptr; /* user provided pointer (in new interface) */
- unsigned int duration; /* millisecs elapsed since written (req_state==1)
- or request duration (req_state==2) */
- int unused;
-} sg_req_info_t; /* 20 bytes long on i386 */
-
-
-/* IOCTLs: Those ioctls that are relevant to the SG 3.x drivers follow.
- [Those that only apply to the SG 2.x drivers are at the end of the file.]
- (_GET_s yield result via 'int *' 3rd argument unless otherwise indicated) */
-
-#define SG_EMULATED_HOST 0x2203 /* true for emulated host adapter (ATAPI) */
-
-/* Used to configure SCSI command transformation layer for ATAPI devices */
-/* Only supported by the ide-scsi driver */
-#define SG_SET_TRANSFORM 0x2204 /* N.B. 3rd arg is not pointer but value: */
- /* 3rd arg = 0 to disable transform, 1 to enable it */
-#define SG_GET_TRANSFORM 0x2205
-
-#define SG_SET_RESERVED_SIZE 0x2275 /* request a new reserved buffer size */
-#define SG_GET_RESERVED_SIZE 0x2272 /* actual size of reserved buffer */
-
-/* The following ioctl has a 'sg_scsi_id_t *' object as its 3rd argument. */
-#define SG_GET_SCSI_ID 0x2276 /* Yields fd's bus, chan, dev, lun + type */
-/* SCSI id information can also be obtained from SCSI_IOCTL_GET_IDLUN */
-
-/* Override host setting and always DMA using low memory ( <16MB on i386) */
-#define SG_SET_FORCE_LOW_DMA 0x2279 /* 0-> use adapter setting, 1-> force */
-#define SG_GET_LOW_DMA 0x227a /* 0-> use all ram for dma; 1-> low dma ram */
-
-/* When SG_SET_FORCE_PACK_ID set to 1, pack_id is input to read() which
- tries to fetch a packet with a matching pack_id, waits, or returns EAGAIN.
- If pack_id is -1 then read oldest waiting. When ...FORCE_PACK_ID set to 0
- then pack_id ignored by read() and oldest readable fetched. */
-#define SG_SET_FORCE_PACK_ID 0x227b
-#define SG_GET_PACK_ID 0x227c /* Yields oldest readable pack_id (or -1) */
-
-#define SG_GET_NUM_WAITING 0x227d /* Number of commands awaiting read() */
-
-/* Yields max scatter gather tablesize allowed by current host adapter */
-#define SG_GET_SG_TABLESIZE 0x227F /* 0 implies can't do scatter gather */
-
-#define SG_GET_VERSION_NUM 0x2282 /* Example: version 2.1.34 yields 20134 */
-
-/* Returns -EBUSY if occupied. 3rd argument pointer to int (see next) */
-#define SG_SCSI_RESET 0x2284
-/* Associated values that can be given to SG_SCSI_RESET follow.
- * SG_SCSI_RESET_NO_ESCALATE may be OR-ed to the _DEVICE, _TARGET, _BUS
- * or _HOST reset value so only that action is attempted. */
-#define SG_SCSI_RESET_NOTHING 0
-#define SG_SCSI_RESET_DEVICE 1
-#define SG_SCSI_RESET_BUS 2
-#define SG_SCSI_RESET_HOST 3
-#define SG_SCSI_RESET_TARGET 4
-#define SG_SCSI_RESET_NO_ESCALATE 0x100
-
-/* synchronous SCSI command ioctl, (only in version 3 interface) */
-#define SG_IO 0x2285 /* similar effect as write() followed by read() */
-
-#define SG_GET_REQUEST_TABLE 0x2286 /* yields table of active requests */
-
-/* How to treat EINTR during SG_IO ioctl(), only in SG 3.x series */
-#define SG_SET_KEEP_ORPHAN 0x2287 /* 1 -> hold for read(), 0 -> drop (def) */
-#define SG_GET_KEEP_ORPHAN 0x2288
-
-/* yields scsi midlevel's access_count for this SCSI device */
-#define SG_GET_ACCESS_COUNT 0x2289
-
-
-#define SG_SCATTER_SZ (8 * 4096)
-/* Largest size (in bytes) a single scatter-gather list element can have.
- The value used by the driver is 'max(SG_SCATTER_SZ, PAGE_SIZE)'.
- This value should be a power of 2 (and may be rounded up internally).
- If scatter-gather is not supported by adapter then this value is the
- largest data block that can be read/written by a single scsi command. */
-
-#define SG_DEFAULT_RETRIES 0
-
-/* Defaults, commented if they differ from original sg driver */
-#define SG_DEF_FORCE_PACK_ID 0
-#define SG_DEF_KEEP_ORPHAN 0
-#define SG_DEF_RESERVED_SIZE SG_SCATTER_SZ /* load time option */
-
-/* maximum outstanding requests, write() yields EDOM if exceeded */
-#define SG_MAX_QUEUE 16
-
-#define SG_BIG_BUFF SG_DEF_RESERVED_SIZE /* for backward compatibility */
-
-/* Alternate style type names, "..._t" variants preferred */
-typedef struct sg_io_hdr Sg_io_hdr;
-typedef struct sg_io_vec Sg_io_vec;
-typedef struct sg_scsi_id Sg_scsi_id;
-typedef struct sg_req_info Sg_req_info;
-
-
-/* vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv */
-/* The older SG interface based on the 'sg_header' structure follows. */
-/* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */
-
-#define SG_MAX_SENSE 16 /* this only applies to the sg_header interface */
-
-struct sg_header
-{
- int pack_len; /* [o] reply_len (ie useless), ignored as input */
- int reply_len; /* [i] max length of expected reply (inc. sg_header) */
- int pack_id; /* [io] id number of packet (use ints >= 0) */
- int result; /* [o] 0==ok, else (+ve) Unix errno (best ignored) */
- unsigned int twelve_byte:1;
- /* [i] Force 12 byte command length for group 6 & 7 commands */
- unsigned int target_status:5; /* [o] scsi status from target */
- unsigned int host_status:8; /* [o] host status (see "DID" codes) */
- unsigned int driver_status:8; /* [o] driver status+suggestion */
- unsigned int other_flags:10; /* unused */
- unsigned char sense_buffer[SG_MAX_SENSE]; /* [o] Output in 3 cases:
- when target_status is CHECK_CONDITION or
- when target_status is COMMAND_TERMINATED or
- when (driver_status & DRIVER_SENSE) is true. */
-}; /* This structure is 36 bytes long on i386 */
-
-
-/* IOCTLs: The following are not required (or ignored) when the sg_io_hdr_t
- interface is used. They are kept for backward compatibility with
- the original and version 2 drivers. */
-
-#define SG_SET_TIMEOUT 0x2201 /* unit: jiffies (10ms on i386) */
-#define SG_GET_TIMEOUT 0x2202 /* yield timeout as _return_ value */
-
-/* Get/set command queuing state per fd (default is SG_DEF_COMMAND_Q.
- Each time a sg_io_hdr_t object is seen on this file descriptor, this
- command queuing flag is set on (overriding the previous setting). */
-#define SG_GET_COMMAND_Q 0x2270 /* Yields 0 (queuing off) or 1 (on) */
-#define SG_SET_COMMAND_Q 0x2271 /* Change queuing state with 0 or 1 */
-
-/* Turn on/off error sense trace (1 and 0 respectively, default is off).
- Try using: "# cat /proc/scsi/sg/debug" instead in the v3 driver */
-#define SG_SET_DEBUG 0x227e /* 0 -> turn off debug */
-
-#define SG_NEXT_CMD_LEN 0x2283 /* override SCSI command length with given
- number on the next write() on this file descriptor */
-
-
-/* Defaults, commented if they differ from original sg driver */
#ifdef __KERNEL__
-#define SG_DEFAULT_TIMEOUT_USER (60*USER_HZ) /* HZ == 'jiffies in 1 second' */
-#else
-#define SG_DEFAULT_TIMEOUT (60*HZ) /* HZ == 'jiffies in 1 second' */
+#define SG_DEFAULT_TIMEOUT_USER (60*USER_HZ) /* HZ == 'jiffies in 1 second' */
#endif
-#define SG_DEF_COMMAND_Q 0 /* command queuing is always on when
- the new interface is used */
-#define SG_DEF_UNDERRUN_FLAG 0
+#undef SG_DEFAULT_TIMEOUT /* because of conflicting define in sg.c */
-#endif
+#endif /* end of ifndef _SCSI_GENERIC_H guard */
diff --git a/include/uapi/scsi/sg.h b/include/uapi/scsi/sg.h
new file mode 100644
index 000000000000..072b45bd732f
--- /dev/null
+++ b/include/uapi/scsi/sg.h
@@ -0,0 +1,329 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _UAPI_SCSI_SG_H
+#define _UAPI_SCSI_SG_H
+
+/*
+ * History:
+ * Started: Aug 9 by Lawrence Foard (entropy@world.std.com), to allow user
+ * process control of SCSI devices.
+ * Development Sponsored by Killy Corp. NY NY
+ *
+ * Original driver (sg.h):
+ * Copyright (C) 1992 Lawrence Foard
+ *
+ * Later extensions (versions 2, 3 and 4) to driver:
+ * Copyright (C) 1998 - 2018 Douglas Gilbert
+ *
+ * Version 4.0.11 (20190502)
+ * This version is for Linux 4 and 5 series kernels.
+ *
+ * Documentation
+ * =============
+ * A web site for the SG device driver can be found at:
+ * http://sg.danny.cz/sg [alternatively check the MAINTAINERS file]
+ * The documentation for the sg version 3 driver can be found at:
+ * http://sg.danny.cz/sg/p/sg_v3_ho.html
+ * Also see: <kernel_source>/Documentation/scsi/scsi-generic.txt
+ *
+ * For utility and test programs see: http://sg.danny.cz/sg/sg3_utils.html
+ */
+
+#include <linux/types.h>
+#include <linux/major.h>
+
+/* bsg.h contains the sg v4 user space interface structure (sg_io_v4). */
+#include <uapi/linux/bsg.h>
+
+/*
+ * Same structure as used by readv() call. It defines one scatter-gather
+ * element. "Scatter-gather" is abbreviated to "sgat" in this driver to
+ * avoid confusion with this driver's name.
+ */
+typedef struct sg_iovec {
+ void __user *iov_base; /* Starting address (of a byte) */
+ size_t iov_len; /* Length in bytes */
+} sg_iovec_t;
+
+
+typedef struct sg_io_hdr {
+ int interface_id; /* [i] 'S' for SCSI generic (required) */
+ int dxfer_direction; /* [i] data transfer direction */
+ unsigned char cmd_len; /* [i] SCSI command length */
+ unsigned char mx_sb_len;/* [i] max length to write to sbp */
+ unsigned short iovec_count; /* [i] 0 implies no sgat list */
+ unsigned int dxfer_len; /* [i] byte count of data transfer */
+ /* dxferp points to data transfer memory or scatter gather list */
+ void __user *dxferp; /* [i], [*io] */
+ unsigned char __user *cmdp;/* [i], [*i] points to command to perform */
+ void __user *sbp; /* [i], [*o] points to sense_buffer memory */
+ unsigned int timeout; /* [i] MAX_UINT->no timeout (unit: millisec) */
+ unsigned int flags; /* [i] 0 -> default, see SG_FLAG... */
+ int pack_id; /* [i->o] unused internally (normally) */
+ void __user *usr_ptr; /* [i->o] unused internally */
+ unsigned char status; /* [o] scsi status */
+ unsigned char masked_status;/* [o] shifted, masked scsi status */
+ unsigned char msg_status;/* [o] messaging level data (optional) */
+ unsigned char sb_len_wr; /* [o] byte count actually written to sbp */
+ unsigned short host_status; /* [o] errors from host adapter */
+ unsigned short driver_status;/* [o] errors from software driver */
+ int resid; /* [o] dxfer_len - actual_transferred */
+ /* unit may be nanoseconds after SG_SET_GET_EXTENDED ioctl use */
+ unsigned int duration; /* [o] time taken by cmd (unit: millisec) */
+ unsigned int info; /* [o] auxiliary information */
+} sg_io_hdr_t;
+
+#define SG_INTERFACE_ID_ORIG 'S'
+
+/* Use negative values to flag difference from original sg_header structure */
+#define SG_DXFER_NONE (-1) /* e.g. a SCSI Test Unit Ready command */
+#define SG_DXFER_TO_DEV (-2) /* data-out buffer e.g. SCSI WRITE command */
+#define SG_DXFER_FROM_DEV (-3) /* data-in buffer e.g. SCSI READ command */
+/*
+ * SG_DXFER_TO_FROM_DEV is treated like SG_DXFER_FROM_DEV with the additional
+ * property than during indirect IO the user buffer is copied into the kernel
+ * buffers _before_ the transfer from the device takes place. Useful if short
+ * DMA transfers (less than requested) are not reported (e.g. resid always 0).
+ */
+#define SG_DXFER_TO_FROM_DEV (-4)
+#define SG_DXFER_UNKNOWN (-5) /* Unknown data direction, do not use */
+
+/* following flag values can be OR-ed together in v3::flags or v4::flags */
+#define SG_FLAG_DIRECT_IO 1 /* default is indirect IO */
+/* SG_FLAG_UNUSED_LUN_INHIBIT is ignored in sg v4 driver */
+#define SG_FLAG_UNUSED_LUN_INHIBIT 2 /* ignored, was LUN overwrite in cdb */
+#define SG_FLAG_MMAP_IO 4 /* request memory mapped IO */
+/* no transfer of kernel buffers to/from user space; used for sharing */
+#define SG_FLAG_NO_DXFER 0x10000
+/* defaults: for sg driver (v3_v4): Q_AT_HEAD; for block layer: Q_AT_TAIL */
+#define SG_FLAG_Q_AT_TAIL 0x10
+#define SG_FLAG_Q_AT_HEAD 0x20
+
+/* Output (potentially OR-ed together) in v3::info or v4::info field */
+#define SG_INFO_OK_MASK 0x1
+#define SG_INFO_OK 0x0 /* no sense, host nor driver "noise" */
+#define SG_INFO_CHECK 0x1 /* something abnormal happened */
+
+#define SG_INFO_DIRECT_IO_MASK 0x6
+#define SG_INFO_INDIRECT_IO 0x0 /* data xfer via kernel buffers (or no xfer) */
+#define SG_INFO_DIRECT_IO 0x2 /* direct IO requested and performed */
+#define SG_INFO_MIXED_IO 0x4 /* not used, always 0 */
+#define SG_INFO_DEVICE_DETACHING 0x8 /* completed successfully but ... */
+#define SG_INFO_ABORTED 0x10 /* this command has been aborted */
+#define SG_INFO_MRQ_FINI 0x20 /* marks multi-reqs that have finished */
+
+/*
+ * Pointer to object of this structure filled by ioctl(SG_GET_SCSI_ID). Last
+ * field changed in v4 driver, was 'int unused[2]' so remains the same size.
+ */
+typedef struct sg_scsi_id {
+ int host_no; /* as in "scsi<n>" where 'n' is one of 0, 1, 2 etc */
+ int channel;
+ int scsi_id; /* scsi id of target device */
+ int lun; /* lower 32 bits of internal 64 bit integer */
+ int scsi_type; /* TYPE_... defined in scsi/scsi.h */
+ short h_cmd_per_lun;/* host (adapter) maximum commands per lun */
+ short d_queue_depth;/* device (or adapter) maximum queue length */
+ int unused[2];
+} sg_scsi_id_t;
+
+/* For backward compatibility v4 driver yields at most SG_MAX_QUEUE of these */
+typedef struct sg_req_info { /* used by SG_GET_REQUEST_TABLE ioctl() */
+ char req_state; /* See 'enum sg_rq_state' definition in v4 driver */
+ char orphan; /* 0 -> normal request, 1 -> from interrupted SG_IO */
+ /* sg_io_owned set imples synchronous, clear implies asynchronous */
+ char sg_io_owned;/* 0 -> complete with read(), 1 -> owned by SG_IO */
+ char problem; /* 0 -> no problem detected, 1 -> error to report */
+ /* If SG_CTL_FLAGM_TAG_FOR_PACK_ID set on fd then next field is tag */
+ int pack_id; /* pack_id, in v4 driver may be tag instead */
+ void __user *usr_ptr; /* user provided pointer in v3+v4 interface */
+ unsigned int duration;
+ int unused;
+} sg_req_info_t;
+
+/*
+ * IOCTLs: Those ioctls that are relevant to the SG 3.x drivers follow.
+ * [Those that only apply to the SG 2.x drivers are at the end of the file.]
+ * (_GET_s yield result via 'int *' 3rd argument unless otherwise indicated)
+ */
+
+#define SG_EMULATED_HOST 0x2203 /* true for emulated host adapter (ATAPI) */
+
+/*
+ * Used to configure SCSI command transformation layer for ATAPI devices.
+ * Only supported by the ide-scsi driver. 20181014 No longer supported, this
+ * driver passes them to the mid-level which returns a EINVAL (22) errno.
+ *
+ * Original note: N.B. 3rd arg is not pointer but value: 3rd arg = 0 to
+ * disable transform, 1 to enable it
+ */
+#define SG_SET_TRANSFORM 0x2204
+#define SG_GET_TRANSFORM 0x2205
+
+#define SG_SET_RESERVED_SIZE 0x2275 /* request new reserved buffer size */
+#define SG_GET_RESERVED_SIZE 0x2272 /* actual size of reserved buffer */
+
+/* The following ioctl has a 'sg_scsi_id_t *' object as its 3rd argument. */
+#define SG_GET_SCSI_ID 0x2276 /* Yields fd's bus, chan, dev, lun + type */
+/* SCSI id information can also be obtained from SCSI_IOCTL_GET_IDLUN */
+
+/* Override host setting and always DMA using low memory ( <16MB on i386) */
+#define SG_SET_FORCE_LOW_DMA 0x2279 /* 0-> use adapter setting, 1-> force */
+#define SG_GET_LOW_DMA 0x227a /* 0-> use all ram for dma; 1-> low dma ram */
+
+/*
+ * When SG_SET_FORCE_PACK_ID set to 1, pack_id (or tag) is input to read() or
+ * ioctl(SG_IO_RECEIVE). These functions wait until matching packet (request/
+ * command) is finished but they will return with EAGAIN quickly if the file
+ * descriptor was opened O_NONBLOCK or (in v4) if SGV4_FLAG_IMMED is given.
+ * The tag is used when SG_CTL_FLAGM_TAG_FOR_PACK_ID is set on the parent
+ * file descriptor (default: use pack_id). If pack_id or tag is -1 then read
+ * oldest waiting and this is the same action as when FORCE_PACK_ID is
+ * clear on the parent file descriptor. In the v4 interface the pack_id is
+ * placed the in sg_io_v4::request_extra field .
+ */
+#define SG_SET_FORCE_PACK_ID 0x227b /* pack_id or in v4 can be tag */
+#define SG_GET_PACK_ID 0x227c /* Yields oldest readable pack_id/tag, or -1 */
+
+#define SG_GET_NUM_WAITING 0x227d /* Number of commands awaiting read() */
+
+/* Yields max scatter gather tablesize allowed by current host adapter */
+#define SG_GET_SG_TABLESIZE 0x227F /* 0 implies can't do scatter gather */
+
+/*
+ * Integer form of version number: [x]xyyzz where [x] empty when x=0 .
+ * String form of version number: "[x]x.[y]y.zz"
+ */
+#define SG_GET_VERSION_NUM 0x2282 /* Example: version "2.1.34" yields 20134 */
+
+/* Returns -EBUSY if occupied. 3rd argument pointer to int (see next) */
+#define SG_SCSI_RESET 0x2284
+/*
+ * Associated values that can be given to SG_SCSI_RESET follow.
+ * SG_SCSI_RESET_NO_ESCALATE may be OR-ed to the _DEVICE, _TARGET, _BUS
+ * or _HOST reset value so only that action is attempted.
+ */
+#define SG_SCSI_RESET_NOTHING 0
+#define SG_SCSI_RESET_DEVICE 1
+#define SG_SCSI_RESET_BUS 2
+#define SG_SCSI_RESET_HOST 3
+#define SG_SCSI_RESET_TARGET 4
+#define SG_SCSI_RESET_NO_ESCALATE 0x100
+
+/* synchronous SCSI command ioctl, (for version 3 and 4 interface) */
+#define SG_IO 0x2285 /* similar effect as write() followed by read() */
+
+#define SG_GET_REQUEST_TABLE 0x2286 /* yields table of active requests */
+
+/* How to treat EINTR during SG_IO ioctl(), only in sg v3 and v4 driver */
+#define SG_SET_KEEP_ORPHAN 0x2287 /* 1 -> hold for read(), 0 -> drop (def) */
+#define SG_GET_KEEP_ORPHAN 0x2288
+
+/*
+ * Yields scsi midlevel's access_count for this SCSI device. 20181014 No
+ * longer available, always yields 1.
+ */
+#define SG_GET_ACCESS_COUNT 0x2289
+
+
+/*
+ * Default size (in bytes) a single scatter-gather list element can have.
+ * The value used by the driver is 'max(SG_SCATTER_SZ, PAGE_SIZE)'. This
+ * value should be a power of 2 (and may be rounded up internally). In the
+ * v4 driver this can be changed by ioctl(SG_SET_GET_EXTENDED{SGAT_ELEM_SZ}).
+ */
+#define SG_SCATTER_SZ (8 * 4096)
+
+/* sg driver users' code should handle retries (e.g. from Unit Attentions) */
+#define SG_DEFAULT_RETRIES 0
+
+/* Defaults, commented if they differ from original sg driver */
+#define SG_DEF_FORCE_PACK_ID 0
+#define SG_DEF_KEEP_ORPHAN 0
+#define SG_DEF_RESERVED_SIZE SG_SCATTER_SZ /* load time option */
+
+/*
+ * Maximum outstanding requests (i.e write()s without corresponding read()s)
+ * yields EDOM from write() if exceeded. This limit only applies prior to
+ * version 3.9 . It is still used as a maximum number of sg_req_info objects
+ * that are returned from the SG_GET_REQUEST_TABLE ioctl.
+ */
+#define SG_MAX_QUEUE 16
+
+#define SG_BIG_BUFF SG_DEF_RESERVED_SIZE /* for backward compatibility */
+
+/*
+ * Alternate style type names, "..._t" variants (as found in the
+ * 'typedef struct * {};' definitions above) are preferred to these:
+ */
+typedef struct sg_io_hdr Sg_io_hdr;
+typedef struct sg_io_vec Sg_io_vec;
+typedef struct sg_scsi_id Sg_scsi_id;
+typedef struct sg_req_info Sg_req_info;
+
+
+/* vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv */
+/* The v1+v2 SG interface based on the 'sg_header' structure follows. */
+/* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */
+
+#define SG_MAX_SENSE 16 /* this only applies to the sg_header interface */
+
+struct sg_header {
+ int pack_len; /* [o] reply_len (ie useless), ignored as input */
+ int reply_len; /* [i] max length of expected reply (inc. sg_header) */
+ int pack_id; /* [io] id number of packet (use ints >= 0) */
+ int result; /* [o] 0==ok, else (+ve) Unix errno (best ignored) */
+ unsigned int twelve_byte:1;
+ /* [i] Force 12 byte command length for group 6 & 7 commands */
+ unsigned int target_status:5; /* [o] scsi status from target */
+ unsigned int host_status:8; /* [o] host status (see "DID" codes) */
+ unsigned int driver_status:8; /* [o] driver status+suggestion */
+ unsigned int other_flags:10; /* unused */
+ unsigned char sense_buffer[SG_MAX_SENSE];
+ /*
+ * [o] Output in 3 cases:
+ * when target_status is CHECK_CONDITION or
+ * when target_status is COMMAND_TERMINATED or
+ * when (driver_status & DRIVER_SENSE) is true.
+ */
+};
+
+/*
+ * IOCTLs: The following are not required (or ignored) when the v3 or v4
+ * interface is used as those structures contain a timeout field. These
+ * ioctls are kept for backward compatibility with v1+v2 interfaces.
+ */
+
+#define SG_SET_TIMEOUT 0x2201 /* unit: (user space) jiffies */
+#define SG_GET_TIMEOUT 0x2202 /* yield timeout as _return_ value */
+
+/*
+ * Get/set command queuing state per fd (default is SG_DEF_COMMAND_Q.
+ * Each time a sg_io_hdr_t object is seen on this file descriptor, this
+ * command queuing flag is set on (overriding the previous setting).
+ * This setting defaults to 0 (i.e. no queuing) but gets set the first
+ * time that fd sees a v3 or v4 interface request.
+ */
+#define SG_GET_COMMAND_Q 0x2270 /* Yields 0 (queuing off) or 1 (on) */
+#define SG_SET_COMMAND_Q 0x2271 /* Change queuing state with 0 or 1 */
+
+/*
+ * Turn on/off error sense trace (1 and 0 respectively, default is off).
+ * Try using: "# cat /proc/scsi/sg/debug" instead in the v3 driver
+ */
+#define SG_SET_DEBUG 0x227e /* 0 -> turn off debug */
+
+/*
+ * override SCSI command length with given number on the next write() on
+ * this file descriptor (v1 and v2 interface only)
+ */
+#define SG_NEXT_CMD_LEN 0x2283
+
+/* command queuing is always on when the v3 or v4 interface is used */
+#define SG_DEF_COMMAND_Q 0
+
+#define SG_DEF_UNDERRUN_FLAG 0
+
+/* If the timeout value in the v3_v4 interfaces is 0, this value is used */
+#define SG_DEFAULT_TIMEOUT (60*HZ) /* HZ == 'jiffies in 1 second' */
+
+#endif /* end of _UAPI_SCSI_SG_H guard */
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 07/20] sg: move header to uapi section
2019-08-07 11:42 ` [PATCH v3 07/20] sg: move header to uapi section Douglas Gilbert
@ 2019-08-12 14:24 ` Christoph Hellwig
2019-08-12 14:32 ` Greg KH
` (2 more replies)
0 siblings, 3 replies; 63+ messages in thread
From: Christoph Hellwig @ 2019-08-12 14:24 UTC (permalink / raw)
To: Douglas Gilbert
Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche, linux-spdx
[note: question for the linux-spdx audience below]
> -
> #ifdef __KERNEL__
> extern int sg_big_buff; /* for sysctl */
> #endif
FYI, these __KERNEL__ ifdefs in non-uapi headers should go away.
>
> +/*
> + * In version 3.9.01 of the sg driver, this file was spilt in two, with the
> + * bulk of the user space interface being placed in the file being included
> + * in the following line.
> + */
> +#include <uapi/scsi/sg.h>
Splitting uapi headers is standard practive, no need for the comment,
especially not with a meaningless driver version number.
> diff --git a/include/uapi/scsi/sg.h b/include/uapi/scsi/sg.h
> new file mode 100644
> index 000000000000..072b45bd732f
> --- /dev/null
> +++ b/include/uapi/scsi/sg.h
> @@ -0,0 +1,329 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
This needs the syscall noticed for uapi headers. FYI, what is our
stance of just adding that notice to headers newly moved to UAPI?
Do we need agreement from everyone who touched the file? Or just
after we started the split and SPDX annotations, as in this case
this header used to be available to user programs?
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 07/20] sg: move header to uapi section
2019-08-12 14:24 ` Christoph Hellwig
@ 2019-08-12 14:32 ` Greg KH
2019-08-12 14:35 ` James Bottomley
2019-08-13 0:21 ` Douglas Gilbert
2 siblings, 0 replies; 63+ messages in thread
From: Greg KH @ 2019-08-12 14:32 UTC (permalink / raw)
To: Christoph Hellwig
Cc: Douglas Gilbert, linux-scsi, martin.petersen, jejb, hare,
bvanassche, linux-spdx
On Mon, Aug 12, 2019 at 07:24:51AM -0700, Christoph Hellwig wrote:
> > diff --git a/include/uapi/scsi/sg.h b/include/uapi/scsi/sg.h
> > new file mode 100644
> > index 000000000000..072b45bd732f
> > --- /dev/null
> > +++ b/include/uapi/scsi/sg.h
> > @@ -0,0 +1,329 @@
> > +/* SPDX-License-Identifier: GPL-2.0 */
>
> This needs the syscall noticed for uapi headers. FYI, what is our
> stance of just adding that notice to headers newly moved to UAPI?
Just add them.
> Do we need agreement from everyone who touched the file? Or just
> after we started the split and SPDX annotations, as in this case
> this header used to be available to user programs?
The license of the entire kernel source is pretty obvious that anything
UABI related needs the dual license, so adding it is fine.
If not, the scripts will notice and we will just end up generating a
patch to fix it anyway :)
thanks,
greg k-h
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 07/20] sg: move header to uapi section
2019-08-12 14:24 ` Christoph Hellwig
2019-08-12 14:32 ` Greg KH
@ 2019-08-12 14:35 ` James Bottomley
2019-08-13 0:21 ` Douglas Gilbert
2 siblings, 0 replies; 63+ messages in thread
From: James Bottomley @ 2019-08-12 14:35 UTC (permalink / raw)
To: Christoph Hellwig, Douglas Gilbert
Cc: linux-scsi, martin.petersen, hare, bvanassche, linux-spdx
On Mon, 2019-08-12 at 07:24 -0700, Christoph Hellwig wrote:
> [note: question for the linux-spdx audience below]
>
> > -
> > #ifdef __KERNEL__
> > extern int sg_big_buff; /* for sysctl */
> > #endif
>
> FYI, these __KERNEL__ ifdefs in non-uapi headers should go away.
>
> >
> > +/*
> > + * In version 3.9.01 of the sg driver, this file was spilt in two,
> > with the
> > + * bulk of the user space interface being placed in the file being
> > included
> > + * in the following line.
> > + */
> > +#include <uapi/scsi/sg.h>
>
> Splitting uapi headers is standard practive, no need for the comment,
> especially not with a meaningless driver version number.
>
> > diff --git a/include/uapi/scsi/sg.h b/include/uapi/scsi/sg.h
> > new file mode 100644
> > index 000000000000..072b45bd732f
> > --- /dev/null
> > +++ b/include/uapi/scsi/sg.h
> > @@ -0,0 +1,329 @@
> > +/* SPDX-License-Identifier: GPL-2.0 */
>
> This needs the syscall noticed for uapi headers. FYI, what is our
> stance of just adding that notice to headers newly moved to UAPI?
> Do we need agreement from everyone who touched the file? Or just
> after we started the split and SPDX annotations, as in this case
> this header used to be available to user programs?
It's pretty much covered by the original linux COPYING file, which
contains the systemcall exception for everything. I think our
intention is that this still applies globally, so things can be moved
into the UAPI without additional permissions.
James
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 07/20] sg: move header to uapi section
2019-08-12 14:24 ` Christoph Hellwig
2019-08-12 14:32 ` Greg KH
2019-08-12 14:35 ` James Bottomley
@ 2019-08-13 0:21 ` Douglas Gilbert
2 siblings, 0 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-13 0:21 UTC (permalink / raw)
To: Christoph Hellwig
Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche, linux-spdx
On 2019-08-12 10:24 a.m., Christoph Hellwig wrote:
> [note: question for the linux-spdx audience below]
>
>> -
>> #ifdef __KERNEL__
>> extern int sg_big_buff; /* for sysctl */
>> #endif
>
> FYI, these __KERNEL__ ifdefs in non-uapi headers should go away.
Yes, that could be removed, but perhaps not yet, see below.
>> +/*
>> + * In version 3.9.01 of the sg driver, this file was spilt in two, with the
>> + * bulk of the user space interface being placed in the file being included
>> + * in the following line.
>> + */
>> +#include <uapi/scsi/sg.h>
>
> Splitting uapi headers is standard practive, no need for the comment,
> especially not with a meaningless driver version number.
The "meaningless driver version number" is in the sg (and bsg and
generalized ioctl(SG_IO)) API via ioctl(SG_GET_VERSION_NUM). All
versions of Windows have driver version numbers. So no, one kernel
version number doesn't tell the full story. FreeBSD implements a
subset of the sg driver, and I hope to expand that. The driver version
number will be useful to differentiate the driver API there too.
My libsgutils library which is under the sg3_utils, sdparm and ddpt
packages now acts on that version number when run on Linux. When it
is between 4.0.0 and 4.0.29 then the driver API as per the end of
this patchset is assumed. If the driver version number is 4.0.30
or above the sg interface as defined here:
http://sg.danny.cz/sg/sg_v40.html is assumed.
Also version numbers are more human friendly and convey an ordering
unlike git with its handles, for example:
c578603bab2ec27dd6bb2d38ad4c3fc44423c570
which obviously is this patch.
That comment is a heads up to the GNU library folks who need to
be careful when the publicly visible part of an API is moved from
say include/scsi/sg.h to include/uapi/scsi/sg.h . After that move
and without that __KERNEL__ conditional then user code will break in
compilation if the former (non-uapi) header is accidentally included.
Lack of that conditional will also catch out those who include:
/lib/modules/<kernel_version>/build/include/scsi/sg.h
Doug Gilbert
>> diff --git a/include/uapi/scsi/sg.h b/include/uapi/scsi/sg.h
>> new file mode 100644
>> index 000000000000..072b45bd732f
>> --- /dev/null
>> +++ b/include/uapi/scsi/sg.h
>> @@ -0,0 +1,329 @@
>> +/* SPDX-License-Identifier: GPL-2.0 */
>
> This needs the syscall noticed for uapi headers. FYI, what is our
> stance of just adding that notice to headers newly moved to UAPI?
> Do we need agreement from everyone who touched the file? Or just
> after we started the split and SPDX annotations, as in this case
> this header used to be available to user programs?
>
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 08/20] sg: speed sg_poll and sg_get_num_waiting
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (6 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 07/20] sg: move header to uapi section Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-12 14:31 ` Christoph Hellwig
2019-08-07 11:42 ` [PATCH v3 09/20] sg: sg_allow_if_err_recovery and renames Douglas Gilbert
` (12 subsequent siblings)
20 siblings, 1 reply; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
Track the number of submitted and waiting (for read/receive)
requests on each file descriptor with two atomic integers.
This speeds sg_poll() and ioctl(SG_GET_NUM_WAITING) which
are oft used with the asynchronous (non-blocking) interfaces.
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 54 +++++++++++++++++++++++------------------------
1 file changed, 27 insertions(+), 27 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 9e9470944fe3..7c9c56bda7ba 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -142,6 +142,8 @@ struct sg_fd { /* holds the state of a file descriptor */
struct mutex f_mutex; /* protect against changes in this fd */
int timeout; /* defaults to SG_DEFAULT_TIMEOUT */
int timeout_user; /* defaults to SG_DEFAULT_TIMEOUT_USER */
+ atomic_t submitted; /* number inflight or awaiting read */
+ atomic_t waiting; /* number of requests awaiting read */
struct sg_scatter_hold reserve; /* buffer for this file descriptor */
struct list_head rq_list; /* head of request list */
struct fasync_struct *async_qp; /* used by asynchronous notification */
@@ -690,6 +692,8 @@ sg_common_write(struct sg_fd *sfp, struct sg_request *srp,
else
at_head = 1;
+ if (!blocking)
+ atomic_inc(&sfp->submitted);
srp->rq->timeout = timeout;
kref_get(&sfp->f_ref); /* sg_rq_end_io() does kref_put(). */
blk_execute_rq_nowait(sdp->device->request_queue, sdp->disk,
@@ -1096,14 +1100,7 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
__put_user(-1, ip);
return 0;
case SG_GET_NUM_WAITING:
- read_lock_irqsave(&sfp->rq_list_lock, iflags);
- val = 0;
- list_for_each_entry(srp, &sfp->rq_list, entry) {
- if ((1 == srp->done) && (!srp->sg_io_owned))
- ++val;
- }
- read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
- return put_user(val, ip);
+ return put_user(atomic_read(&sfp->waiting), ip);
case SG_GET_SG_TABLESIZE:
return put_user(sdp->max_sgat_elems, ip);
case SG_SET_RESERVED_SIZE:
@@ -1255,35 +1252,26 @@ sg_compat_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
}
#endif
+/*
+ * Implements the poll(2) system call for this driver. Returns various EPOLL*
+ * flags OR-ed together.
+ */
static __poll_t
sg_poll(struct file *filp, poll_table * wait)
{
__poll_t p_res = 0;
struct sg_fd *sfp = filp->private_data;
- struct sg_request *srp;
- int count = 0;
- unsigned long iflags;
- if (!sfp)
- return EPOLLERR;
poll_wait(filp, &sfp->read_wait, wait);
- read_lock_irqsave(&sfp->rq_list_lock, iflags);
- list_for_each_entry(srp, &sfp->rq_list, entry) {
- /* if any read waiting, flag it */
- if (p_res == 0 && srp->done == 1 && !srp->sg_io_owned)
- p_res = EPOLLIN | EPOLLRDNORM;
- ++count;
- }
- read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
+ if (atomic_read(&sfp->waiting) > 0)
+ p_res = EPOLLIN | EPOLLRDNORM;
- if (sfp->parentdp && SG_IS_DETACHING(sfp->parentdp)) {
+ if (unlikely(SG_IS_DETACHING(sfp->parentdp)))
p_res |= EPOLLHUP;
- } else if (!sfp->cmd_q) {
- if (count == 0)
- p_res |= EPOLLOUT | EPOLLWRNORM;
- } else if (count < SG_MAX_QUEUE) {
+ else if (likely(sfp->cmd_q))
+ p_res |= EPOLLOUT | EPOLLWRNORM;
+ else if (atomic_read(&sfp->submitted) == 0)
p_res |= EPOLLOUT | EPOLLWRNORM;
- }
SG_LOG(3, sfp, "%s: p_res=0x%x\n", __func__, (__force u32)p_res);
return p_res;
}
@@ -1468,6 +1456,8 @@ sg_rq_end_io(struct request *rq, blk_status_t status)
/* Rely on write phase to clean out srp status values, so no "else" */
+ if (!srp->sg_io_owned)
+ atomic_inc(&sfp->waiting);
/*
* Free the request as soon as it is complete so that its resources
* can be reused without waiting for userspace to read() the
@@ -1924,6 +1914,10 @@ sg_finish_rem_req(struct sg_request *srp)
SG_LOG(4, sfp, "%s: srp=0x%p%s\n", __func__, srp,
(srp->res_used) ? " rsv" : "");
+ if (!srp->sg_io_owned) {
+ atomic_dec(&sfp->submitted);
+ atomic_dec(&sfp->waiting);
+ }
if (srp->bio)
ret = blk_rq_unmap_user(srp->bio);
@@ -2220,6 +2214,9 @@ sg_add_sfp(struct sg_device *sdp)
sfp->cmd_q = SG_DEF_COMMAND_Q;
sfp->keep_orphan = SG_DEF_KEEP_ORPHAN;
sfp->parentdp = sdp;
+ atomic_set(&sfp->submitted, 0);
+ atomic_set(&sfp->waiting, 0);
+
write_lock_irqsave(&sdp->sfd_lock, iflags);
if (SG_IS_DETACHING(sdp)) {
write_unlock_irqrestore(&sdp->sfd_lock, iflags);
@@ -2593,6 +2590,9 @@ sg_proc_debug_helper(struct seq_file *s, struct sg_device *sdp)
seq_printf(s, " cmd_q=%d f_packid=%d k_orphan=%d closed=0\n",
(int) fp->cmd_q, (int) fp->force_packid,
(int) fp->keep_orphan);
+ seq_printf(s, " submitted=%d waiting=%d\n",
+ atomic_read(&fp->submitted),
+ atomic_read(&fp->waiting));
list_for_each_entry(srp, &fp->rq_list, entry) {
hp = &srp->header;
new_interface = (hp->interface_id == '\0') ? 0 : 1;
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 08/20] sg: speed sg_poll and sg_get_num_waiting
2019-08-07 11:42 ` [PATCH v3 08/20] sg: speed sg_poll and sg_get_num_waiting Douglas Gilbert
@ 2019-08-12 14:31 ` Christoph Hellwig
2019-08-12 16:31 ` Douglas Gilbert
0 siblings, 1 reply; 63+ messages in thread
From: Christoph Hellwig @ 2019-08-12 14:31 UTC (permalink / raw)
To: Douglas Gilbert; +Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche
On Wed, Aug 07, 2019 at 01:42:40PM +0200, Douglas Gilbert wrote:
> Track the number of submitted and waiting (for read/receive)
> requests on each file descriptor with two atomic integers.
> This speeds sg_poll() and ioctl(SG_GET_NUM_WAITING) which
> are oft used with the asynchronous (non-blocking) interfaces.
The idea of just tracking a count here seems sensible.
Tiny nitpick below:
> + else if (likely(sfp->cmd_q))
> + p_res |= EPOLLOUT | EPOLLWRNORM;
> + else if (atomic_read(&sfp->submitted) == 0)
> p_res |= EPOLLOUT | EPOLLWRNORM;
Why not simply:
else if (sfp->cmd_q || atomic_read(&sfp->submitted)
p_res |= EPOLLOUT | EPOLLWRNORM;
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 08/20] sg: speed sg_poll and sg_get_num_waiting
2019-08-12 14:31 ` Christoph Hellwig
@ 2019-08-12 16:31 ` Douglas Gilbert
0 siblings, 0 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-12 16:31 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche
On 2019-08-12 10:31 a.m., Christoph Hellwig wrote:
> On Wed, Aug 07, 2019 at 01:42:40PM +0200, Douglas Gilbert wrote:
>> Track the number of submitted and waiting (for read/receive)
>> requests on each file descriptor with two atomic integers.
>> This speeds sg_poll() and ioctl(SG_GET_NUM_WAITING) which
>> are oft used with the asynchronous (non-blocking) interfaces.
>
> The idea of just tracking a count here seems sensible.
With the added benefit of ioctl(SG_GET_NUM_WAITING) becoming O(1).
I clocked it an 500 nanoseconds per invocation on my laptop.
> Tiny nitpick below:
>
>> + else if (likely(sfp->cmd_q))
>> + p_res |= EPOLLOUT | EPOLLWRNORM;
>> + else if (atomic_read(&sfp->submitted) == 0)
>> p_res |= EPOLLOUT | EPOLLWRNORM;
>
> Why not simply:
>
> else if (sfp->cmd_q || atomic_read(&sfp->submitted)
> p_res |= EPOLLOUT | EPOLLWRNORM;
Loses the "likely", doesn't compile, and is logically wrong.
Brown paper bag :-)
And this is getting beyond a joke. I have had to repeatedly rebuild
dev kernels because:
1) Torvalds forces Martin to use buggy "rc1" kernels in his
scsi-queue branches, and
2) in lk 5.3-rc1 there is your snafu in scsi_lib.c
Please go light on such "optimizations".
Doug Gilbert
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 09/20] sg: sg_allow_if_err_recovery and renames
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (7 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 08/20] sg: speed sg_poll and sg_get_num_waiting Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-12 14:31 ` Christoph Hellwig
2019-08-07 11:42 ` [PATCH v3 10/20] sg: remove most access_ok functions Douglas Gilbert
` (11 subsequent siblings)
20 siblings, 1 reply; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
Add sg_allow_if_err_recover() to do checks common to several entry
points. Replace retval with either res or ret. Rename
sg_finish_rem_req() to sg_finish_scsi_blk_rq(). Rename
sg_new_write() to sg_submit(). Other cleanups triggered by
checkpatch.pl .
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 245 +++++++++++++++++++++++++---------------------
1 file changed, 133 insertions(+), 112 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 7c9c56bda7ba..7e188ac2f182 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -68,7 +68,7 @@ static char *sg_version_date = "20190606";
/* SG_MAX_CDB_SIZE should be 260 (spc4r37 section 3.1.30) however the type
* of sg_io_hdr::cmd_len can only represent 255. All SCSI commands greater
- * than 16 bytes are "variable length" whose length is a multiple of 4
+ * than 16 bytes are "variable length" whose length is a multiple of 4, so:
*/
#define SG_MAX_CDB_SIZE 252
@@ -178,16 +178,16 @@ static void sg_rq_end_io(struct request *rq, blk_status_t status);
/* Declarations of other static functions used before they are defined */
static int sg_proc_init(void);
static int sg_start_req(struct sg_request *srp, u8 *cmd);
-static int sg_finish_rem_req(struct sg_request *srp);
+static int sg_finish_scsi_blk_rq(struct sg_request *srp);
static int sg_build_indirect(struct sg_scatter_hold *schp, struct sg_fd *sfp,
int buff_size);
-static ssize_t sg_new_write(struct sg_fd *sfp, struct file *file,
- const char __user *buf, size_t count, int blocking,
- int read_only, int sg_io_owned,
- struct sg_request **o_srp);
+static ssize_t sg_submit(struct sg_fd *sfp, struct file *filp,
+ const char __user *buf, size_t count, bool blocking,
+ bool read_only, bool sg_io_owned,
+ struct sg_request **o_srp);
static int sg_common_write(struct sg_fd *sfp, struct sg_request *srp,
u8 *cmnd, int timeout, int blocking);
-static int sg_rd_append(struct sg_request *srp, char __user *outp,
+static int sg_rd_append(struct sg_request *srp, void __user *outp,
int num_xfer);
static void sg_remove_scat(struct sg_fd *sfp, struct sg_scatter_hold *schp);
static void sg_build_reserve(struct sg_fd *sfp, int req_size);
@@ -275,37 +275,60 @@ sg_check_file_access(struct file *filp, const char *caller)
static int
sg_wait_open_event(struct sg_device *sdp, bool o_excl)
{
- int retval = 0;
+ int res = 0;
if (o_excl) {
while (atomic_read(&sdp->open_cnt) > 0) {
mutex_unlock(&sdp->open_rel_lock);
- retval = wait_event_interruptible(sdp->open_wait,
- (SG_IS_DETACHING(sdp) ||
- atomic_read(&sdp->open_cnt) == 0));
+ res = wait_event_interruptible
+ (sdp->open_wait,
+ (SG_IS_DETACHING(sdp) ||
+ atomic_read(&sdp->open_cnt) == 0));
mutex_lock(&sdp->open_rel_lock);
- if (retval) /* -ERESTARTSYS */
- return retval;
+ if (res) /* -ERESTARTSYS */
+ return res;
if (SG_IS_DETACHING(sdp))
return -ENODEV;
}
} else {
while (SG_HAVE_EXCLUDE(sdp)) {
mutex_unlock(&sdp->open_rel_lock);
- retval = wait_event_interruptible(sdp->open_wait,
- (SG_IS_DETACHING(sdp) ||
- !SG_HAVE_EXCLUDE(sdp)));
+ res = wait_event_interruptible
+ (sdp->open_wait,
+ (SG_IS_DETACHING(sdp) ||
+ !SG_HAVE_EXCLUDE(sdp)));
mutex_lock(&sdp->open_rel_lock);
- if (retval) /* -ERESTARTSYS */
- return retval;
+ if (res) /* -ERESTARTSYS */
+ return res;
if (SG_IS_DETACHING(sdp))
return -ENODEV;
}
}
- return retval;
+ return res;
+}
+
+/*
+ * scsi_block_when_processing_errors() returns 0 when dev was taken offline by
+ * error recovery, 1 otherwise (i.e. okay). Even if in error recovery, let
+ * user continue if O_NONBLOCK set. Permits SCSI commands to be issued during
+ * error recovery. Tread carefully.
+ * Returns 0 for ok (i.e. allow), -EPROTO if sdp is NULL, otherwise -ENXIO .
+ */
+static inline int
+sg_allow_if_err_recovery(struct sg_device *sdp, bool non_block)
+{
+ if (!sdp)
+ return -EPROTO;
+ if (SG_IS_DETACHING(sdp))
+ return -ENODEV;
+ if (non_block)
+ return 0;
+ if (likely(scsi_block_when_processing_errors(sdp->device)))
+ return 0;
+ return -ENXIO;
}
/*
@@ -318,16 +341,17 @@ sg_wait_open_event(struct sg_device *sdp, bool o_excl)
static int
sg_open(struct inode *inode, struct file *filp)
{
- bool o_excl;
+ bool o_excl, non_block;
int min_dev = iminor(inode);
int op_flags = filp->f_flags;
+ int res;
struct request_queue *q;
struct sg_device *sdp;
struct sg_fd *sfp;
- int retval;
nonseekable_open(inode, filp);
o_excl = !!(op_flags & O_EXCL);
+ non_block = !!(op_flags & O_NONBLOCK);
if (o_excl && ((op_flags & O_ACCMODE) == O_RDONLY))
return -EPERM; /* Can't lock it with read only access */
sdp = sg_get_dev(min_dev);
@@ -336,20 +360,23 @@ sg_open(struct inode *inode, struct file *filp)
/* This driver's module count bumped by fops_get in <linux/fs.h> */
/* Prevent the device driver from vanishing while we sleep */
- retval = scsi_device_get(sdp->device);
- if (retval)
+ res = scsi_device_get(sdp->device);
+ if (res)
goto sg_put;
- retval = scsi_autopm_get_device(sdp->device);
- if (retval)
+ res = scsi_autopm_get_device(sdp->device);
+ if (res)
goto sdp_put;
+ res = sg_allow_if_err_recovery(sdp, non_block);
+ if (res)
+ goto error_out;
/* scsi_block_when_processing_errors() may block so bypass
* check if O_NONBLOCK. Permits SCSI commands to be issued
* during error recovery. Tread carefully. */
if (!((op_flags & O_NONBLOCK) ||
scsi_block_when_processing_errors(sdp->device))) {
- retval = -ENXIO;
+ res = -ENXIO;
/* we are in error recovery for this device */
goto error_out;
}
@@ -358,18 +385,18 @@ sg_open(struct inode *inode, struct file *filp)
if (op_flags & O_NONBLOCK) {
if (o_excl) {
if (atomic_read(&sdp->open_cnt) > 0) {
- retval = -EBUSY;
+ res = -EBUSY;
goto error_mutex_locked;
}
} else {
if (SG_HAVE_EXCLUDE(sdp)) {
- retval = -EBUSY;
+ res = -EBUSY;
goto error_mutex_locked;
}
}
} else {
- retval = sg_wait_open_event(sdp, o_excl);
- if (retval) /* -ERESTARTSYS or -ENODEV */
+ res = sg_wait_open_event(sdp, o_excl);
+ if (res) /* -ERESTARTSYS or -ENODEV */
goto error_mutex_locked;
}
@@ -384,7 +411,7 @@ sg_open(struct inode *inode, struct file *filp)
}
sfp = sg_add_sfp(sdp);
if (IS_ERR(sfp)) {
- retval = PTR_ERR(sfp);
+ res = PTR_ERR(sfp);
goto out_undo;
}
@@ -396,10 +423,10 @@ sg_open(struct inode *inode, struct file *filp)
atomic_read(&sdp->open_cnt),
((op_flags & O_NONBLOCK) ? " O_NONBLOCK" : ""));
- retval = 0;
+ res = 0;
sg_put:
kref_put(&sdp->d_ref, sg_device_destroy);
- return retval;
+ return res;
out_undo:
if (o_excl) { /* undo if error */
@@ -454,31 +481,26 @@ sg_release(struct inode *inode, struct file *filp)
static ssize_t
sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
{
- int mxsize, cmd_size, k;
- int input_size, blocking;
+ bool blocking = !(filp->f_flags & O_NONBLOCK);
u8 opcode;
+ int mxsize, cmd_size, input_size, res;
struct sg_device *sdp;
struct sg_fd *sfp;
struct sg_request *srp;
struct sg_header old_hdr;
sg_io_hdr_t *hp;
u8 cmnd[SG_MAX_CDB_SIZE];
- int retval;
- retval = sg_check_file_access(filp, __func__);
- if (retval)
- return retval;
+ res = sg_check_file_access(filp, __func__);
+ if (res)
+ return res;
sfp = filp->private_data;
sdp = sfp->parentdp;
SG_LOG(3, sfp, "%s: write(3rd arg) count=%d\n", __func__, (int)count);
- if (!sdp)
- return -ENXIO;
- if (SG_IS_DETACHING(sdp))
- return -ENODEV;
- if (!((filp->f_flags & O_NONBLOCK) ||
- scsi_block_when_processing_errors(sdp->device)))
- return -ENXIO;
+ res = sg_allow_if_err_recovery(sdp, !blocking);
+ if (res)
+ return res;
if (!access_ok(buf, count))
return -EFAULT; /* protects following copy_from_user()s + get_user()s */
@@ -486,10 +508,9 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
return -EIO;
if (__copy_from_user(&old_hdr, buf, SZ_SG_HEADER))
return -EFAULT;
- blocking = !(filp->f_flags & O_NONBLOCK);
if (old_hdr.reply_len < 0)
- return sg_new_write(sfp, filp, buf, count,
- blocking, 0, 0, NULL);
+ return sg_submit(sfp, filp, buf, count, blocking, false, false,
+ NULL);
if (count < (SZ_SG_HEADER + 6))
return -EIO; /* The minimum scsi command length is 6 bytes. */
@@ -557,8 +578,8 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
input_size, (unsigned int) cmnd[0],
current->comm);
}
- k = sg_common_write(sfp, srp, cmnd, sfp->timeout, blocking);
- return (k < 0) ? k : count;
+ res = sg_common_write(sfp, srp, cmnd, sfp->timeout, blocking);
+ return (res < 0) ? res : count;
}
static int
@@ -573,9 +594,9 @@ sg_allow_access(struct file *filp, u8 *cmd)
}
static ssize_t
-sg_new_write(struct sg_fd *sfp, struct file *file, const char __user *buf,
- size_t count, int blocking, int read_only, int sg_io_owned,
- struct sg_request **o_srp)
+sg_submit(struct sg_fd *sfp, struct file *filp, const char __user *buf,
+ size_t count, bool blocking, bool read_only, bool sg_io_owned,
+ struct sg_request **o_srp)
{
int k;
struct sg_request *srp;
@@ -632,7 +653,7 @@ sg_new_write(struct sg_fd *sfp, struct file *file, const char __user *buf,
sg_remove_request(sfp, srp);
return -EFAULT;
}
- if (read_only && sg_allow_access(file, cmnd)) {
+ if (read_only && sg_allow_access(filp, cmnd)) {
sg_remove_request(sfp, srp);
return -EPERM;
}
@@ -669,7 +690,7 @@ sg_common_write(struct sg_fd *sfp, struct sg_request *srp,
k = sg_start_req(srp, cmnd);
if (k) {
SG_LOG(1, sfp, "%s: start_req err=%d\n", __func__, k);
- sg_finish_rem_req(srp);
+ sg_finish_scsi_blk_rq(srp);
sg_remove_request(sfp, srp);
return k; /* probably out of space --> ENOMEM */
}
@@ -680,7 +701,7 @@ sg_common_write(struct sg_fd *sfp, struct sg_request *srp,
srp->rq = NULL;
}
- sg_finish_rem_req(srp);
+ sg_finish_scsi_blk_rq(srp);
sg_remove_request(sfp, srp);
return -ENODEV;
}
@@ -765,7 +786,7 @@ sg_new_read(struct sg_fd *sfp, char __user *buf, size_t count,
goto err_out;
}
err_out:
- err2 = sg_finish_rem_req(srp);
+ err2 = sg_finish_scsi_blk_rq(srp);
sg_remove_request(sfp, srp);
return err ? : err2 ? : count;
}
@@ -789,23 +810,24 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
struct sg_fd *sfp;
struct sg_request *srp;
int req_pack_id = -1;
+ int ret = 0;
sg_io_hdr_t *hp;
struct sg_header *old_hdr = NULL;
- int retval = 0;
/*
* This could cause a response to be stranded. Close the associated
* file descriptor to free up any resources being held.
*/
- retval = sg_check_file_access(filp, __func__);
- if (retval)
- return retval;
+ ret = sg_check_file_access(filp, __func__);
+ if (ret)
+ return ret;
sfp = filp->private_data;
sdp = sfp->parentdp;
SG_LOG(3, sfp, "%s: read() count=%d\n", __func__, (int)count);
- if (!sdp)
- return -ENXIO;
+ ret = sg_allow_if_err_recovery(sdp, false);
+ if (ret)
+ return ret;
if (!access_ok(buf, count))
return -EFAULT;
@@ -814,7 +836,7 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
if (!old_hdr)
return -ENOMEM;
if (__copy_from_user(old_hdr, buf, SZ_SG_HEADER)) {
- retval = -EFAULT;
+ ret = -EFAULT;
goto free_old_hdr;
}
if (old_hdr->reply_len < 0) {
@@ -823,15 +845,15 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
new_hdr = kmalloc(SZ_SG_IO_HDR, GFP_KERNEL);
if (!new_hdr) {
- retval = -ENOMEM;
+ ret = -ENOMEM;
goto free_old_hdr;
}
- retval = __copy_from_user
+ ret = __copy_from_user
(new_hdr, buf, SZ_SG_IO_HDR);
req_pack_id = new_hdr->pack_id;
kfree(new_hdr);
- if (retval) {
- retval = -EFAULT;
+ if (ret) {
+ ret = -EFAULT;
goto free_old_hdr;
}
}
@@ -841,27 +863,28 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
srp = sg_get_rq_mark(sfp, req_pack_id);
if (!srp) { /* now wait on packet to arrive */
if (SG_IS_DETACHING(sdp)) {
- retval = -ENODEV;
+ ret = -ENODEV;
goto free_old_hdr;
}
if (filp->f_flags & O_NONBLOCK) {
- retval = -EAGAIN;
+ ret = -EAGAIN;
goto free_old_hdr;
}
- retval = wait_event_interruptible(sfp->read_wait,
- (SG_IS_DETACHING(sdp) ||
- (srp = sg_get_rq_mark(sfp, req_pack_id))));
+ ret = wait_event_interruptible
+ (sfp->read_wait,
+ (SG_IS_DETACHING(sdp) ||
+ (srp = sg_get_rq_mark(sfp, req_pack_id))));
if (SG_IS_DETACHING(sdp)) {
- retval = -ENODEV;
+ ret = -ENODEV;
goto free_old_hdr;
}
- if (retval) {
+ if (ret) {
/* -ERESTARTSYS as signal hit process */
goto free_old_hdr;
}
}
if (srp->header.interface_id != '\0') {
- retval = sg_new_read(sfp, buf, count, srp);
+ ret = sg_new_read(sfp, buf, count, srp);
goto free_old_hdr;
}
@@ -869,7 +892,7 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
if (old_hdr == NULL) {
old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL);
if (!old_hdr) {
- retval = -ENOMEM;
+ ret = -ENOMEM;
goto free_old_hdr;
}
}
@@ -920,7 +943,7 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
/* Now copy the result back to the user buffer. */
if (count >= SZ_SG_HEADER) {
if (__copy_to_user(buf, old_hdr, SZ_SG_HEADER)) {
- retval = -EFAULT;
+ ret = -EFAULT;
goto free_old_hdr;
}
buf += SZ_SG_HEADER;
@@ -928,18 +951,18 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
count = old_hdr->reply_len;
if (count > SZ_SG_HEADER) {
if (sg_rd_append(srp, buf, count - SZ_SG_HEADER)) {
- retval = -EFAULT;
+ ret = -EFAULT;
goto free_old_hdr;
}
}
} else
count = (old_hdr->result == 0) ? 0 : -EIO;
- sg_finish_rem_req(srp);
+ sg_finish_scsi_blk_rq(srp);
sg_remove_request(sfp, srp);
- retval = count;
+ ret = count;
free_old_hdr:
kfree(old_hdr);
- return retval;
+ return ret;
}
static int
@@ -1006,14 +1029,13 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
switch (cmd_in) {
case SG_IO:
- if (SG_IS_DETACHING(sdp))
- return -ENODEV;
- if (!scsi_block_when_processing_errors(sdp->device))
- return -ENXIO;
+ result = sg_allow_if_err_recovery(sdp, false);
+ if (result)
+ return result;
if (!access_ok(p, SZ_SG_IO_HDR))
return -EFAULT;
- result = sg_new_write(sfp, filp, p, SZ_SG_IO_HDR,
- 1, read_only, 1, &srp);
+ result = sg_submit(sfp, filp, p, SZ_SG_IO_HDR, true, read_only,
+ true, &srp);
if (result < 0)
return result;
result = wait_event_interruptible(sfp->read_wait,
@@ -1219,8 +1241,7 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
break;
}
- result = scsi_ioctl_block_when_processing_errors(sdp->device,
- cmd_in, filp->f_flags & O_NDELAY);
+ result = sg_allow_if_err_recovery(sdp, filp->f_flags & O_NDELAY);
if (result)
return result;
return scsi_ioctl(sdp->device, cmd_in, p);
@@ -1383,7 +1404,7 @@ sg_rq_end_io_usercontext(struct work_struct *work)
struct sg_request *srp = container_of(work, struct sg_request, ew.work);
struct sg_fd *sfp = srp->parentfp;
- sg_finish_rem_req(srp);
+ sg_finish_scsi_blk_rq(srp);
sg_remove_request(sfp, srp);
kref_put(&sfp->f_ref, sg_remove_sfp);
}
@@ -1905,7 +1926,7 @@ sg_start_req(struct sg_request *srp, u8 *cmd)
}
static int
-sg_finish_rem_req(struct sg_request *srp)
+sg_finish_scsi_blk_rq(struct sg_request *srp)
{
int ret = 0;
@@ -2050,7 +2071,7 @@ sg_remove_scat(struct sg_fd *sfp, struct sg_scatter_hold *schp)
* appended to given struct sg_header object.
*/
static int
-sg_rd_append(struct sg_request *srp, char __user *outp, int num_xfer)
+sg_rd_append(struct sg_request *srp, void __user *outp, int num_xfer)
{
struct sg_scatter_hold *schp = &srp->data;
int k, num;
@@ -2252,7 +2273,7 @@ sg_remove_sfp_usercontext(struct work_struct *work)
write_lock_irqsave(&sfp->rq_list_lock, iflags);
while (!list_empty(&sfp->rq_list)) {
srp = list_first_entry(&sfp->rq_list, struct sg_request, entry);
- sg_finish_rem_req(srp);
+ sg_finish_scsi_blk_rq(srp);
list_del(&srp->entry);
srp->parentfp = NULL;
}
@@ -2330,7 +2351,7 @@ sg_get_dev(int dev)
#if IS_ENABLED(CONFIG_SCSI_PROC_FS) /* long, almost to end of file */
static int sg_proc_seq_show_int(struct seq_file *s, void *v);
-static int sg_proc_single_open_adio(struct inode *inode, struct file *file);
+static int sg_proc_single_open_adio(struct inode *inode, struct file *filp);
static ssize_t sg_proc_write_adio(struct file *filp, const char __user *buffer,
size_t count, loff_t *off);
static const struct file_operations adio_fops = {
@@ -2342,7 +2363,7 @@ static const struct file_operations adio_fops = {
.release = single_release,
};
-static int sg_proc_single_open_dressz(struct inode *inode, struct file *file);
+static int sg_proc_single_open_dressz(struct inode *inode, struct file *filp);
static ssize_t sg_proc_write_dressz(struct file *filp,
const char __user *buffer, size_t count, loff_t *off);
static const struct file_operations dressz_fops = {
@@ -2392,13 +2413,13 @@ sg_proc_init(void)
if (!p)
return 1;
- proc_create("allow_dio", S_IRUGO | S_IWUSR, p, &adio_fops);
- proc_create_seq("debug", S_IRUGO, p, &debug_seq_ops);
- proc_create("def_reserved_size", S_IRUGO | S_IWUSR, p, &dressz_fops);
- proc_create_single("device_hdr", S_IRUGO, p, sg_proc_seq_show_devhdr);
- proc_create_seq("devices", S_IRUGO, p, &dev_seq_ops);
- proc_create_seq("device_strs", S_IRUGO, p, &devstrs_seq_ops);
- proc_create_single("version", S_IRUGO, p, sg_proc_seq_show_version);
+ proc_create("allow_dio", 0644, p, &adio_fops);
+ proc_create_seq("debug", 0444, p, &debug_seq_ops);
+ proc_create("def_reserved_size", 0644, p, &dressz_fops);
+ proc_create_single("device_hdr", 0444, p, sg_proc_seq_show_devhdr);
+ proc_create_seq("devices", 0444, p, &dev_seq_ops);
+ proc_create_seq("device_strs", 0444, p, &devstrs_seq_ops);
+ proc_create_single("version", 0444, p, sg_proc_seq_show_version);
return 0;
}
@@ -2422,9 +2443,9 @@ sg_proc_seq_show_int(struct seq_file *s, void *v)
}
static int
-sg_proc_single_open_adio(struct inode *inode, struct file *file)
+sg_proc_single_open_adio(struct inode *inode, struct file *filp)
{
- return single_open(file, sg_proc_seq_show_int, &sg_allow_dio);
+ return single_open(filp, sg_proc_seq_show_int, &sg_allow_dio);
}
static ssize_t
@@ -2444,9 +2465,9 @@ sg_proc_write_adio(struct file *filp, const char __user *buffer,
}
static int
-sg_proc_single_open_dressz(struct inode *inode, struct file *file)
+sg_proc_single_open_dressz(struct inode *inode, struct file *filp)
{
- return single_open(file, sg_proc_seq_show_int, &sg_big_buff);
+ return single_open(filp, sg_proc_seq_show_int, &sg_big_buff);
}
static ssize_t
@@ -2508,7 +2529,7 @@ dev_seq_start(struct seq_file *s, loff_t *pos)
static void *
dev_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
- struct sg_proc_deviter * it = s->private;
+ struct sg_proc_deviter *it = s->private;
*pos = ++it->index;
return (it->index < it->max) ? it : NULL;
@@ -2523,7 +2544,7 @@ dev_seq_stop(struct seq_file *s, void *v)
static int
sg_proc_seq_show_dev(struct seq_file *s, void *v)
{
- struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
+ struct sg_proc_deviter *it = (struct sg_proc_deviter *)v;
struct sg_device *sdp;
struct scsi_device *scsidp;
unsigned long iflags;
@@ -2549,7 +2570,7 @@ sg_proc_seq_show_dev(struct seq_file *s, void *v)
static int
sg_proc_seq_show_devstrs(struct seq_file *s, void *v)
{
- struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
+ struct sg_proc_deviter *it = (struct sg_proc_deviter *)v;
struct sg_device *sdp;
struct scsi_device *scsidp;
unsigned long iflags;
@@ -2637,7 +2658,7 @@ sg_proc_debug_helper(struct seq_file *s, struct sg_device *sdp)
static int
sg_proc_seq_show_debug(struct seq_file *s, void *v)
{
- struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
+ struct sg_proc_deviter *it = (struct sg_proc_deviter *)v;
struct sg_device *sdp;
unsigned long iflags;
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 09/20] sg: sg_allow_if_err_recovery and renames
2019-08-07 11:42 ` [PATCH v3 09/20] sg: sg_allow_if_err_recovery and renames Douglas Gilbert
@ 2019-08-12 14:31 ` Christoph Hellwig
2019-08-14 1:26 ` Douglas Gilbert
0 siblings, 1 reply; 63+ messages in thread
From: Christoph Hellwig @ 2019-08-12 14:31 UTC (permalink / raw)
To: Douglas Gilbert; +Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche
On Wed, Aug 07, 2019 at 01:42:41PM +0200, Douglas Gilbert wrote:
> Add sg_allow_if_err_recover() to do checks common to several entry
> points. Replace retval with either res or ret. Rename
> sg_finish_rem_req() to sg_finish_scsi_blk_rq(). Rename
> sg_new_write() to sg_submit(). Other cleanups triggered by
> checkpatch.pl .
I think you want to split adding a new helper from random renames.
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 09/20] sg: sg_allow_if_err_recovery and renames
2019-08-12 14:31 ` Christoph Hellwig
@ 2019-08-14 1:26 ` Douglas Gilbert
0 siblings, 0 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-14 1:26 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche
On 2019-08-12 10:31 a.m., Christoph Hellwig wrote:
> On Wed, Aug 07, 2019 at 01:42:41PM +0200, Douglas Gilbert wrote:
>> Add sg_allow_if_err_recover() to do checks common to several entry
>> points. Replace retval with either res or ret. Rename
>> sg_finish_rem_req() to sg_finish_scsi_blk_rq(). Rename
>> sg_new_write() to sg_submit(). Other cleanups triggered by
>> checkpatch.pl .
>
> I think you want to split adding a new helper from random renames.
"Random" is in the eye of the beholder. Take sg_new_write(), 20
years ago that referred to the newly introduced v3 interface. Its
a bit misleading to leave that name in place when the whole point
of the patchset is to add the v4 interface.
I don't understand why reviewers don't defer to a driver author and/or
maintainer in the cases of function and variable names. 20 years of
pigeonhole patches and kernel interface changes corrupt the original
naming and style of a driver. There are more significant things to
criticize if one looked deeper.
Doug Gilbert
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 10/20] sg: remove most access_ok functions
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (8 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 09/20] sg: sg_allow_if_err_recovery and renames Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-12 14:32 ` Christoph Hellwig
2019-08-07 11:42 ` [PATCH v3 11/20] sg: replace rq array with lists Douglas Gilbert
` (10 subsequent siblings)
20 siblings, 1 reply; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
Since access_ok() has lost it direction (3rd) parameter there
seems to be no benefit in calling access_ok() before
__copy_{to|from}_user(). Simplify code by using the variant of
these functions that do not start with "__".
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 50 ++++++++++++++++-------------------------------
1 file changed, 17 insertions(+), 33 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 7e188ac2f182..123d8516a9a0 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -502,11 +502,9 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
if (res)
return res;
- if (!access_ok(buf, count))
- return -EFAULT; /* protects following copy_from_user()s + get_user()s */
if (count < SZ_SG_HEADER)
return -EIO;
- if (__copy_from_user(&old_hdr, buf, SZ_SG_HEADER))
+ if (copy_from_user(&old_hdr, buf, SZ_SG_HEADER))
return -EFAULT;
if (old_hdr.reply_len < 0)
return sg_submit(sfp, filp, buf, count, blocking, false, false,
@@ -561,7 +559,7 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
hp->flags = input_size; /* structure abuse ... */
hp->pack_id = old_hdr.pack_id;
hp->usr_ptr = NULL;
- if (__copy_from_user(cmnd, buf, cmd_size))
+ if (copy_from_user(cmnd, buf, cmd_size))
return -EFAULT;
/*
* SG_DXFER_TO_FROM_DEV is functionally equivalent to SG_DXFER_FROM_DEV,
@@ -607,8 +605,6 @@ sg_submit(struct sg_fd *sfp, struct file *filp, const char __user *buf,
if (count < SZ_SG_IO_HDR)
return -EINVAL;
- if (!access_ok(buf, count))
- return -EFAULT; /* protects following copy_from_user()s + get_user()s */
sfp->cmd_q = 1; /* when sg_io_hdr seen, set command queuing on */
if (!(srp = sg_add_request(sfp))) {
@@ -617,7 +613,7 @@ sg_submit(struct sg_fd *sfp, struct file *filp, const char __user *buf,
}
srp->sg_io_owned = sg_io_owned;
hp = &srp->header;
- if (__copy_from_user(hp, buf, SZ_SG_IO_HDR)) {
+ if (copy_from_user(hp, buf, SZ_SG_IO_HDR)) {
sg_remove_request(sfp, srp);
return -EFAULT;
}
@@ -645,11 +641,7 @@ sg_submit(struct sg_fd *sfp, struct file *filp, const char __user *buf,
sg_remove_request(sfp, srp);
return -EMSGSIZE;
}
- if (!access_ok(hp->cmdp, hp->cmd_len)) {
- sg_remove_request(sfp, srp);
- return -EFAULT; /* protects following copy_from_user()s + get_user()s */
- }
- if (__copy_from_user(cmnd, hp->cmdp, hp->cmd_len)) {
+ if (copy_from_user(cmnd, hp->cmdp, hp->cmd_len)) {
sg_remove_request(sfp, srp);
return -EFAULT;
}
@@ -829,13 +821,11 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
if (ret)
return ret;
- if (!access_ok(buf, count))
- return -EFAULT;
if (sfp->force_packid && (count >= SZ_SG_HEADER)) {
old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL);
if (!old_hdr)
return -ENOMEM;
- if (__copy_from_user(old_hdr, buf, SZ_SG_HEADER)) {
+ if (copy_from_user(old_hdr, buf, SZ_SG_HEADER)) {
ret = -EFAULT;
goto free_old_hdr;
}
@@ -848,8 +838,8 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
ret = -ENOMEM;
goto free_old_hdr;
}
- ret = __copy_from_user
- (new_hdr, buf, SZ_SG_IO_HDR);
+ ret = copy_from_user(new_hdr, buf,
+ SZ_SG_IO_HDR);
req_pack_id = new_hdr->pack_id;
kfree(new_hdr);
if (ret) {
@@ -942,7 +932,7 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
/* Now copy the result back to the user buffer. */
if (count >= SZ_SG_HEADER) {
- if (__copy_to_user(buf, old_hdr, SZ_SG_HEADER)) {
+ if (copy_to_user(buf, old_hdr, SZ_SG_HEADER)) {
ret = -EFAULT;
goto free_old_hdr;
}
@@ -1032,8 +1022,6 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
result = sg_allow_if_err_recovery(sdp, false);
if (result)
return result;
- if (!access_ok(p, SZ_SG_IO_HDR))
- return -EFAULT;
result = sg_submit(sfp, filp, p, SZ_SG_IO_HDR, true, read_only,
true, &srp);
if (result < 0)
@@ -1107,19 +1095,17 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
sfp->force_packid = val ? 1 : 0;
return 0;
case SG_GET_PACK_ID:
- if (!access_ok(ip, sizeof (int)))
- return -EFAULT;
read_lock_irqsave(&sfp->rq_list_lock, iflags);
list_for_each_entry(srp, &sfp->rq_list, entry) {
if ((1 == srp->done) && (!srp->sg_io_owned)) {
read_unlock_irqrestore(&sfp->rq_list_lock,
iflags);
- __put_user(srp->header.pack_id, ip);
+ put_user(srp->header.pack_id, ip);
return 0;
}
}
read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
- __put_user(-1, ip);
+ put_user(-1, ip);
return 0;
case SG_GET_NUM_WAITING:
return put_user(atomic_read(&sfp->waiting), ip);
@@ -1181,9 +1167,7 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
val = (sdp->device ? 1 : 0);
return put_user(val, ip);
case SG_GET_REQUEST_TABLE:
- if (!access_ok(p, SZ_SG_REQ_INFO * SG_MAX_QUEUE))
- return -EFAULT;
- else {
+ {
sg_req_info_t *rinfo;
rinfo = kcalloc(SG_MAX_QUEUE, SZ_SG_REQ_INFO,
@@ -1193,8 +1177,8 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
read_lock_irqsave(&sfp->rq_list_lock, iflags);
sg_fill_request_table(sfp, rinfo);
read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
- result = __copy_to_user(p, rinfo,
- SZ_SG_REQ_INFO * SG_MAX_QUEUE);
+ result = copy_to_user(p, rinfo,
+ SZ_SG_REQ_INFO * SG_MAX_QUEUE);
result = result ? -EFAULT : 0;
kfree(rinfo);
return result;
@@ -2083,13 +2067,13 @@ sg_rd_append(struct sg_request *srp, void __user *outp, int num_xfer)
num = 1 << (PAGE_SHIFT + schp->page_order);
for (k = 0; k < schp->k_use_sg && schp->pages[k]; k++) {
if (num > num_xfer) {
- if (__copy_to_user(outp, page_address(schp->pages[k]),
- num_xfer))
+ if (copy_to_user(outp, page_address(schp->pages[k]),
+ num_xfer))
return -EFAULT;
break;
} else {
- if (__copy_to_user(outp, page_address(schp->pages[k]),
- num))
+ if (copy_to_user(outp, page_address(schp->pages[k]),
+ num))
return -EFAULT;
num_xfer -= num;
if (num_xfer <= 0)
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 10/20] sg: remove most access_ok functions
2019-08-07 11:42 ` [PATCH v3 10/20] sg: remove most access_ok functions Douglas Gilbert
@ 2019-08-12 14:32 ` Christoph Hellwig
0 siblings, 0 replies; 63+ messages in thread
From: Christoph Hellwig @ 2019-08-12 14:32 UTC (permalink / raw)
To: Douglas Gilbert; +Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche
On Wed, Aug 07, 2019 at 01:42:42PM +0200, Douglas Gilbert wrote:
> Since access_ok() has lost it direction (3rd) parameter there
> seems to be no benefit in calling access_ok() before
> __copy_{to|from}_user(). Simplify code by using the variant of
> these functions that do not start with "__".
Even before there was not much of a benefit. In general a normal
driver should never use access_ok directly, so this looks like
a good improvement. But which access_ok calls do you want to keep
and why?
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 11/20] sg: replace rq array with lists
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (9 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 10/20] sg: remove most access_ok functions Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-12 14:35 ` Christoph Hellwig
2019-08-07 11:42 ` [PATCH v3 12/20] sg: sense buffer rework Douglas Gilbert
` (9 subsequent siblings)
20 siblings, 1 reply; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
Remove the fixed size array of 16 request elements per file
descriptor and replace with two linked lists per file descriptor.
One list is for active commands, the other list is a free list.
sg_request objects are now kept, available for re-use, until
their owning file descriptor is closed. The sg_request deletions
are now in sg_remove_sfp_usercontext(). Each active sg_request
has associated block request and scsi_request objects which are
released much earlier; their lifetime is the same as it was in
the v3 sg driver. The lifetime of the bio is also the same (but
is stretched in a later patch).
Add an enum for request state (sg_rq_state) and collect
various flags into bit maps: one for requests (SG_FRQ_*) and
the other for file descriptors (SG_FFD_*). They join a
per sg_device bit map (SG_FDEV_*) added in an earlier
patch.
Prior to a new sg_request object being (re-)built, information
that will be placed in it uses a new struct sg_comm_wr_t
object.
Since the above changes touch almost every function and low
level structures, this patch is big. With so many changes, the
diff utility that generates the patch sometimes loses track.
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 3033 +++++++++++++++++++++++++++++----------------
1 file changed, 1949 insertions(+), 1084 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 123d8516a9a0..75f515b3fc8c 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -72,7 +72,46 @@ static char *sg_version_date = "20190606";
*/
#define SG_MAX_CDB_SIZE 252
+#define uptr64(val) ((void __user *)(uintptr_t)(val))
+#define cuptr64(val) ((const void __user *)(uintptr_t)(val))
+
+/* Following enum contains the states of sg_request::rq_st */
+enum sg_rq_state {
+ SG_RS_INACTIVE = 0, /* request not in use (e.g. on fl) */
+ SG_RS_INFLIGHT, /* active: cmd/req issued, no response yet */
+ SG_RS_AWAIT_RD, /* response received, awaiting read */
+ SG_RS_DONE_RD, /* read is ongoing or done */
+ SG_RS_BUSY, /* temporary state should rarely be seen */
+};
+
+#define SG_TIME_UNIT_MS 0 /* milliseconds */
+#define SG_DEF_TIME_UNIT SG_TIME_UNIT_MS
#define SG_DEFAULT_TIMEOUT mult_frac(SG_DEFAULT_TIMEOUT_USER, HZ, USER_HZ)
+#define SG_FD_Q_AT_HEAD 0
+#define SG_DEFAULT_Q_AT SG_FD_Q_AT_HEAD /* for backward compatibility */
+#define SG_FL_MMAP_DIRECT (SG_FLAG_MMAP_IO | SG_FLAG_DIRECT_IO)
+
+/* Only take lower 4 bits of driver byte, all host byte and sense byte */
+#define SG_ML_RESULT_MSK 0x0fff00ff /* mid-level's 32 bit result value */
+
+#define SG_PACK_ID_WILDCARD (-1)
+
+#define SG_ADD_RQ_MAX_RETRIES 40 /* to stop infinite _trylock(s) */
+
+/* Bit positions (flags) for sg_request::frq_bm bitmask follow */
+#define SG_FRQ_IS_ORPHAN 1 /* owner of request gone */
+#define SG_FRQ_SYNC_INVOC 2 /* synchronous (blocking) invocation */
+#define SG_FRQ_DIO_IN_USE 3 /* false->indirect_IO,mmap; 1->dio */
+#define SG_FRQ_NO_US_XFER 4 /* no user space transfer of data */
+#define SG_FRQ_DEACT_ORPHAN 7 /* not keeping orphan so de-activate */
+#define SG_FRQ_BLK_PUT_REQ 9 /* set when blk_put_request() called */
+
+/* Bit positions (flags) for sg_fd::ffd_bm bitmask follow */
+#define SG_FFD_FORCE_PACKID 0 /* receive only given pack_id/tag */
+#define SG_FFD_CMD_Q 1 /* clear: only 1 active req per fd */
+#define SG_FFD_KEEP_ORPHAN 2 /* policy for this fd */
+#define SG_FFD_MMAP_CALLED 3 /* mmap(2) system call made on fd */
+#define SG_FFD_Q_AT_TAIL 5 /* set: queue reqs at tail of blk q */
/* Bit positions (flags) for sg_device::fdev_bm bitmask follow */
#define SG_FDEV_EXCLUDE 0 /* have fd open with O_EXCL */
@@ -80,19 +119,17 @@ static char *sg_version_date = "20190606";
#define SG_FDEV_LOG_SENSE 2 /* set by ioctl(SG_SET_DEBUG) */
int sg_big_buff = SG_DEF_RESERVED_SIZE;
-/* N.B. This variable is readable and writeable via
- /proc/scsi/sg/def_reserved_size . Each time sg_open() is called a buffer
- of this size (or less if there is not enough memory) will be reserved
- for use by this file descriptor. [Deprecated usage: this variable is also
- readable via /proc/sys/kernel/sg-big-buff if the sg driver is built into
- the kernel (i.e. it is not a module).] */
+/*
+ * This variable is accessible via /proc/scsi/sg/def_reserved_size . Each
+ * time sg_open() is called a sg_request of this size (or less if there is
+ * not enough memory) will be reserved for use by this file descriptor.
+ */
static int def_reserved_size = -1; /* picks up init parameter */
static int sg_allow_dio = SG_ALLOW_DIO_DEF;
static int scatter_elem_sz = SG_SCATTER_SZ;
-static int scatter_elem_sz_prev = SG_SCATTER_SZ;
-#define SG_SECTOR_SZ 512
+#define SG_DEF_SECTOR_SZ 512
static int sg_add_device(struct device *, struct class_interface *);
static void sg_remove_device(struct device *, struct class_interface *);
@@ -105,57 +142,78 @@ static struct class_interface sg_interface = {
.remove_dev = sg_remove_device,
};
-struct sg_scatter_hold { /* holding area for scsi scatter gather info */
- u16 k_use_sg; /* Count of kernel scatter-gather pieces */
- unsigned int sglist_len; /* size of malloc'd scatter-gather list ++ */
- unsigned int bufflen; /* Size of (aggregate) data buffer */
- struct page **pages;
- int page_order;
- char dio_in_use; /* 0->indirect IO (or mmap), 1->dio */
- u8 cmd_opcode; /* first byte of command */
+/* Subset of sg_io_hdr found in <scsi/sg.h>, has only [i] and [i->o] fields */
+struct sg_slice_hdr3 {
+ int interface_id;
+ int dxfer_direction;
+ u8 cmd_len;
+ u8 mx_sb_len;
+ u16 iovec_count;
+ unsigned int dxfer_len;
+ void __user *dxferp;
+ u8 __user *cmdp;
+ void __user *sbp;
+ unsigned int timeout;
+ unsigned int flags;
+ int pack_id;
+ void __user *usr_ptr;
+};
+
+struct sg_scatter_hold { /* holding area for scsi scatter gather info */
+ struct page **pages; /* num_sgat element array of struct page* */
+ int buflen; /* capacity in bytes (dlen<=buflen) */
+ int dlen; /* current valid data length of this req */
+ u16 page_order; /* byte_len = (page_size*(2**page_order)) */
+ u16 num_sgat; /* actual number of scatter-gather segments */
};
struct sg_device; /* forward declarations */
struct sg_fd;
-struct sg_request { /* SG_MAX_QUEUE requests outstanding per file */
- struct list_head entry; /* list entry */
- struct sg_fd *parentfp; /* NULL -> not in use */
- struct sg_scatter_hold data; /* hold buffer, perhaps scatter list */
- sg_io_hdr_t header; /* scsi command+info, see <scsi/sg.h> */
+struct sg_request { /* active SCSI command or inactive on free list (fl) */
+ struct list_head rq_entry; /* member of rq_list (active cmd) */
+ struct list_head fl_entry; /* member of rq_fl */
+ spinlock_t req_lck;
+ struct sg_scatter_hold sgat_h; /* hold buffer, perhaps scatter list */
+ struct sg_slice_hdr3 s_hdr3; /* subset of sg_io_hdr */
u8 sense_b[SCSI_SENSE_BUFFERSIZE];
- char res_used; /* 1 -> using reserve buffer, 0 -> not ... */
- char orphan; /* 1 -> drop on sight, 0 -> normal */
- char sg_io_owned; /* 1 -> packet belongs to SG_IO */
- /* done protected by rq_list_lock */
- char done; /* 0->before bh, 1->before read, 2->read */
- struct request *rq;
- struct bio *bio;
- struct execute_work ew;
+ u32 duration; /* cmd duration in milliseconds */
+ u32 rq_flags; /* hold user supplied flags */
+ u32 rq_info; /* info supplied by v3 and v4 interfaces */
+ u32 rq_result; /* packed scsi request result from LLD */
+ int in_resid; /* requested-actual byte count on data-in */
+ int pack_id; /* user provided packet identifier field */
+ int sense_len; /* actual sense buffer length (data-in) */
+ atomic_t rq_st; /* request state, holds a enum sg_rq_state */
+ u8 cmd_opcode; /* first byte of SCSI cdb */
+ u64 start_ns; /* starting point of command duration calc */
+ unsigned long frq_bm[1]; /* see SG_FRQ_* defines above */
+ struct sg_fd *parentfp; /* pointer to owning fd, even when on fl */
+ struct request *rq; /* released in sg_rq_end_io(), bio kept */
+ struct bio *bio; /* kept until this req -->SG_RS_INACTIVE */
+ struct execute_work ew_orph; /* harvest orphan request */
};
struct sg_fd { /* holds the state of a file descriptor */
- struct list_head sfd_siblings; /* protected by device's sfd_lock */
+ struct list_head sfd_entry; /* member sg_device::sfds list */
struct sg_device *parentdp; /* owning device */
wait_queue_head_t read_wait; /* queue read until command done */
- rwlock_t rq_list_lock; /* protect access to list in req_arr */
- struct mutex f_mutex; /* protect against changes in this fd */
+ struct mutex f_mutex; /* serialize ioctls on this fd */
+ spinlock_t rq_list_lock;/* for rw-lock on sg_request lists [rcu] */
+ struct list_head rq_list; /* head of inflight sg_request list */
+ struct list_head rq_fl; /* head of sg_request free list */
int timeout; /* defaults to SG_DEFAULT_TIMEOUT */
int timeout_user; /* defaults to SG_DEFAULT_TIMEOUT_USER */
atomic_t submitted; /* number inflight or awaiting read */
atomic_t waiting; /* number of requests awaiting read */
- struct sg_scatter_hold reserve; /* buffer for this file descriptor */
- struct list_head rq_list; /* head of request list */
- struct fasync_struct *async_qp; /* used by asynchronous notification */
- struct sg_request req_arr[SG_MAX_QUEUE];/* use as singly-linked list */
- char force_packid; /* 1 -> pack_id input to read(), 0 -> ignored */
- char cmd_q; /* 1 -> allow command queuing, 0 -> don't */
+ int sgat_elem_sz; /* initialized to scatter_elem_sz */
+ unsigned long ffd_bm[1]; /* see SG_FFD_* defines above */
+ pid_t tid; /* thread id when opened */
u8 next_cmd_len; /* 0: automatic, >0: use on next write() */
- char keep_orphan; /* 0 -> drop orphan (def), 1 -> keep for read() */
- char mmap_called; /* 0 -> mmap() never called on this fd */
- char res_in_use; /* 1 -> 'reserve' array in use */
+ struct sg_request *rsv_srp;/* one reserve request per fd */
+ struct fasync_struct *async_qp; /* used by asynchronous notification */
struct kref f_ref;
- struct execute_work ew;
+ struct execute_work ew_fd; /* harvest all fd resources and lists */
};
struct sg_device { /* holds the state of each scsi generic device */
@@ -165,6 +223,7 @@ struct sg_device { /* holds the state of each scsi generic device */
struct list_head sfds;
rwlock_t sfd_lock; /* protect access to sfd list */
int max_sgat_elems; /* adapter's max sgat number of elements */
+ int max_sgat_sz; /* max number of bytes in sgat list */
u32 index; /* device index number */
atomic_t open_cnt; /* count of opens (perhaps < num(sfds) ) */
unsigned long fdev_bm[1]; /* see SG_FDEV_* defines above */
@@ -173,33 +232,45 @@ struct sg_device { /* holds the state of each scsi generic device */
struct kref d_ref;
};
+struct sg_comm_wr_t { /* arguments to sg_common_write() */
+ int timeout;
+ unsigned long frq_bm[1]; /* see SG_FRQ_* defines above */
+ struct sg_io_hdr *h3p;
+ u8 *cmnd;
+};
+
/* tasklet or soft irq callback */
static void sg_rq_end_io(struct request *rq, blk_status_t status);
/* Declarations of other static functions used before they are defined */
static int sg_proc_init(void);
-static int sg_start_req(struct sg_request *srp, u8 *cmd);
-static int sg_finish_scsi_blk_rq(struct sg_request *srp);
-static int sg_build_indirect(struct sg_scatter_hold *schp, struct sg_fd *sfp,
- int buff_size);
-static ssize_t sg_submit(struct sg_fd *sfp, struct file *filp,
- const char __user *buf, size_t count, bool blocking,
- bool read_only, bool sg_io_owned,
- struct sg_request **o_srp);
-static int sg_common_write(struct sg_fd *sfp, struct sg_request *srp,
- u8 *cmnd, int timeout, int blocking);
+static int sg_start_req(struct sg_request *srp, u8 *cmd, int cmd_len,
+ int dxfer_dir);
+static void sg_finish_scsi_blk_rq(struct sg_request *srp);
+static int sg_mk_sgat(struct sg_request *srp, struct sg_fd *sfp, int minlen);
+static int sg_submit(struct file *filp, struct sg_fd *sfp,
+ struct sg_io_hdr *hp, bool sync,
+ struct sg_request **o_srp);
+static struct sg_request *sg_common_write(struct sg_fd *sfp,
+ struct sg_comm_wr_t *cwp);
static int sg_rd_append(struct sg_request *srp, void __user *outp,
int num_xfer);
-static void sg_remove_scat(struct sg_fd *sfp, struct sg_scatter_hold *schp);
-static void sg_build_reserve(struct sg_fd *sfp, int req_size);
-static void sg_link_reserve(struct sg_fd *sfp, struct sg_request *srp,
- int size);
-static void sg_unlink_reserve(struct sg_fd *sfp, struct sg_request *srp);
+static void sg_remove_sgat(struct sg_request *srp);
static struct sg_fd *sg_add_sfp(struct sg_device *sdp);
static void sg_remove_sfp(struct kref *);
-static struct sg_request *sg_add_request(struct sg_fd *sfp);
-static int sg_remove_request(struct sg_fd *sfp, struct sg_request *srp);
+static struct sg_request *sg_find_srp_by_id(struct sg_fd *sfp, int pack_id);
+static struct sg_request *sg_add_request(struct sg_fd *sfp, int dxfr_len,
+ struct sg_comm_wr_t *cwrp);
+static void sg_deact_request(struct sg_fd *sfp, struct sg_request *srp);
static struct sg_device *sg_get_dev(int dev);
static void sg_device_destroy(struct kref *kref);
+static struct sg_request *sg_mk_srp_sgat(struct sg_fd *sfp, bool first,
+ int db_len);
+static void sg_calc_sgat_param(struct sg_device *sdp);
+static const char *sg_rq_st_str(enum sg_rq_state rq_st, bool long_str);
+static void sg_rep_rq_state_fail(struct sg_fd *sfp,
+ enum sg_rq_state exp_old_st,
+ enum sg_rq_state want_st,
+ enum sg_rq_state act_old_st);
#define SZ_SG_HEADER ((int)sizeof(struct sg_header)) /* v1 and v2 header */
#define SZ_SG_IO_HDR ((int)sizeof(struct sg_io_hdr)) /* v3 header */
@@ -207,6 +278,8 @@ static void sg_device_destroy(struct kref *kref);
#define SG_IS_DETACHING(sdp) test_bit(SG_FDEV_DETACHING, (sdp)->fdev_bm)
#define SG_HAVE_EXCLUDE(sdp) test_bit(SG_FDEV_EXCLUDE, (sdp)->fdev_bm)
+#define SG_RS_ACTIVE(srp) (atomic_read(&(srp)->rq_st) != SG_RS_INACTIVE)
+#define SG_RS_AWAIT_READ(srp) (atomic_read(&(srp)->rq_st) == SG_RS_AWAIT_RD)
/*
* Kernel needs to be built with CONFIG_SCSI_LOGGING to see log messages.
@@ -345,7 +418,6 @@ sg_open(struct inode *inode, struct file *filp)
int min_dev = iminor(inode);
int op_flags = filp->f_flags;
int res;
- struct request_queue *q;
struct sg_device *sdp;
struct sg_fd *sfp;
@@ -371,15 +443,6 @@ sg_open(struct inode *inode, struct file *filp)
res = sg_allow_if_err_recovery(sdp, non_block);
if (res)
goto error_out;
- /* scsi_block_when_processing_errors() may block so bypass
- * check if O_NONBLOCK. Permits SCSI commands to be issued
- * during error recovery. Tread carefully. */
- if (!((op_flags & O_NONBLOCK) ||
- scsi_block_when_processing_errors(sdp->device))) {
- res = -ENXIO;
- /* we are in error recovery for this device */
- goto error_out;
- }
mutex_lock(&sdp->open_rel_lock);
if (op_flags & O_NONBLOCK) {
@@ -404,11 +467,8 @@ sg_open(struct inode *inode, struct file *filp)
if (o_excl)
set_bit(SG_FDEV_EXCLUDE, sdp->fdev_bm);
- if (atomic_read(&sdp->open_cnt) < 1) { /* no existing opens */
- clear_bit(SG_FDEV_LOG_SENSE, sdp->fdev_bm);
- q = sdp->device->request_queue;
- sdp->max_sgat_elems = queue_max_segments(q);
- }
+ if (atomic_read(&sdp->open_cnt) < 1) /* no existing opens */
+ sg_calc_sgat_param(sdp);
sfp = sg_add_sfp(sdp);
if (IS_ERR(sfp)) {
res = PTR_ERR(sfp);
@@ -479,17 +539,19 @@ sg_release(struct inode *inode, struct file *filp)
* of the synchronous ioctl(SG_IO) system call.
*/
static ssize_t
-sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
+sg_write(struct file *filp, const char __user *p, size_t count, loff_t *ppos)
{
- bool blocking = !(filp->f_flags & O_NONBLOCK);
- u8 opcode;
int mxsize, cmd_size, input_size, res;
+ u8 opcode;
struct sg_device *sdp;
struct sg_fd *sfp;
struct sg_request *srp;
- struct sg_header old_hdr;
- sg_io_hdr_t *hp;
u8 cmnd[SG_MAX_CDB_SIZE];
+ struct sg_header ov2hdr;
+ struct sg_io_hdr v3hdr;
+ struct sg_header *ohp = &ov2hdr;
+ struct sg_io_hdr *h3p = &v3hdr;
+ struct sg_comm_wr_t cwr;
res = sg_check_file_access(filp, __func__);
if (res)
@@ -498,461 +560,550 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
sfp = filp->private_data;
sdp = sfp->parentdp;
SG_LOG(3, sfp, "%s: write(3rd arg) count=%d\n", __func__, (int)count);
- res = sg_allow_if_err_recovery(sdp, !blocking);
+ res = sg_allow_if_err_recovery(sdp, !!(filp->f_flags & O_NONBLOCK));
if (res)
return res;
if (count < SZ_SG_HEADER)
return -EIO;
- if (copy_from_user(&old_hdr, buf, SZ_SG_HEADER))
+ if (copy_from_user(ohp, p, SZ_SG_HEADER))
return -EFAULT;
- if (old_hdr.reply_len < 0)
- return sg_submit(sfp, filp, buf, count, blocking, false, false,
- NULL);
- if (count < (SZ_SG_HEADER + 6))
- return -EIO; /* The minimum scsi command length is 6 bytes. */
+ if (ohp->reply_len < 0) { /* assume this is v3 */
+ struct sg_io_hdr *reinter_2p = (struct sg_io_hdr *)ohp;
+ u8 *h3u8p = (u8 *)&v3hdr;
- if (!(srp = sg_add_request(sfp))) {
- SG_LOG(1, sfp, "%s: queue full\n", __func__);
- return -EDOM;
+ if (count < SZ_SG_IO_HDR)
+ return -EIO;
+ if (reinter_2p->interface_id != 'S') {
+ pr_info_once("sg: %s: v3 interface only here\n",
+ __func__);
+ return -EPERM;
+ }
+ memcpy(h3p, ohp, SZ_SG_HEADER);
+ if (__copy_from_user(h3u8p + SZ_SG_HEADER, p + SZ_SG_HEADER,
+ SZ_SG_IO_HDR - SZ_SG_HEADER))
+ return -EFAULT;
+ res = sg_submit(filp, sfp, h3p, false, NULL);
+ return res < 0 ? res : (int)count;
}
- buf += SZ_SG_HEADER;
- __get_user(opcode, buf);
+ /* v1 and v2 interfaces processed below this point */
+ if (count < (SZ_SG_HEADER + 6))
+ return -EIO; /* minimum scsi command length is 6 bytes */
+ p += SZ_SG_HEADER;
+ __get_user(opcode, p);
mutex_lock(&sfp->f_mutex);
if (sfp->next_cmd_len > 0) {
cmd_size = sfp->next_cmd_len;
- sfp->next_cmd_len = 0; /* reset so only this write() effected */
+ sfp->next_cmd_len = 0; /* reset, only this write() effected */
} else {
- cmd_size = COMMAND_SIZE(opcode); /* based on SCSI command group */
- if ((opcode >= 0xc0) && old_hdr.twelve_byte)
+ cmd_size = COMMAND_SIZE(opcode);/* old; SCSI command group */
+ if (opcode >= 0xc0 && ohp->twelve_byte)
cmd_size = 12;
}
mutex_unlock(&sfp->f_mutex);
SG_LOG(4, sfp, "%s: scsi opcode=0x%02x, cmd_size=%d\n", __func__,
(unsigned int)opcode, cmd_size);
input_size = count - cmd_size;
- mxsize = (input_size > old_hdr.reply_len) ? input_size : old_hdr.reply_len;
+ mxsize = max_t(int, input_size, ohp->reply_len);
mxsize -= SZ_SG_HEADER;
input_size -= SZ_SG_HEADER;
- if (input_size < 0) {
- sg_remove_request(sfp, srp);
- return -EIO; /* User did not pass enough bytes for this command. */
- }
- hp = &srp->header;
- hp->interface_id = '\0'; /* indicator of old interface tunnelled */
- hp->cmd_len = (u8) cmd_size;
- hp->iovec_count = 0;
- hp->mx_sb_len = 0;
+ if (input_size < 0)
+ return -EIO; /* Insufficient bytes passed for this command. */
+ memset(h3p, 0, sizeof(*h3p));
+ h3p->interface_id = '\0';/* indicate v1 or v2 interface (tunnelled) */
+ h3p->cmd_len = (u8)cmd_size;
+ h3p->iovec_count = 0;
+ h3p->mx_sb_len = 0;
if (input_size > 0)
- hp->dxfer_direction = (old_hdr.reply_len > SZ_SG_HEADER) ?
+ h3p->dxfer_direction = (ohp->reply_len > SZ_SG_HEADER) ?
SG_DXFER_TO_FROM_DEV : SG_DXFER_TO_DEV;
else
- hp->dxfer_direction = (mxsize > 0) ? SG_DXFER_FROM_DEV : SG_DXFER_NONE;
- hp->dxfer_len = mxsize;
- if ((hp->dxfer_direction == SG_DXFER_TO_DEV) ||
- (hp->dxfer_direction == SG_DXFER_TO_FROM_DEV))
- hp->dxferp = (char __user *)buf + cmd_size;
+ h3p->dxfer_direction = (mxsize > 0) ? SG_DXFER_FROM_DEV :
+ SG_DXFER_NONE;
+ h3p->dxfer_len = mxsize;
+ if (h3p->dxfer_direction == SG_DXFER_TO_DEV ||
+ h3p->dxfer_direction == SG_DXFER_TO_FROM_DEV)
+ h3p->dxferp = (u8 __user *)p + cmd_size;
else
- hp->dxferp = NULL;
- hp->sbp = NULL;
- hp->timeout = old_hdr.reply_len; /* structure abuse ... */
- hp->flags = input_size; /* structure abuse ... */
- hp->pack_id = old_hdr.pack_id;
- hp->usr_ptr = NULL;
- if (copy_from_user(cmnd, buf, cmd_size))
+ h3p->dxferp = NULL;
+ h3p->sbp = NULL;
+ h3p->timeout = ohp->reply_len; /* structure abuse ... */
+ h3p->flags = input_size; /* structure abuse ... */
+ h3p->pack_id = ohp->pack_id;
+ h3p->usr_ptr = NULL;
+ cmnd[0] = opcode;
+ if (__copy_from_user(cmnd + 1, p + 1, cmd_size - 1))
return -EFAULT;
/*
* SG_DXFER_TO_FROM_DEV is functionally equivalent to SG_DXFER_FROM_DEV,
- * but is is possible that the app intended SG_DXFER_TO_DEV, because there
- * is a non-zero input_size, so emit a warning.
+ * but it is possible that the app intended SG_DXFER_TO_DEV, because
+ * there is a non-zero input_size, so emit a warning.
*/
- if (hp->dxfer_direction == SG_DXFER_TO_FROM_DEV) {
+ if (h3p->dxfer_direction == SG_DXFER_TO_FROM_DEV) {
printk_ratelimited(KERN_WARNING
- "sg_write: data in/out %d/%d bytes "
- "for SCSI command 0x%x-- guessing "
- "data in;\n program %s not setting "
- "count and/or reply_len properly\n",
- old_hdr.reply_len - (int)SZ_SG_HEADER,
- input_size, (unsigned int) cmnd[0],
- current->comm);
- }
- res = sg_common_write(sfp, srp, cmnd, sfp->timeout, blocking);
- return (res < 0) ? res : count;
+ "%s: data in/out %d/%d bytes for SCSI command 0x%x-- guessing data in;\n"
+ " program %s not setting count and/or reply_len properly\n",
+ __func__, ohp->reply_len - (int)SZ_SG_HEADER,
+ input_size, (unsigned int)cmnd[0], current->comm);
+ }
+ cwr.frq_bm[0] = 0; /* initial state clear for all req flags */
+ cwr.h3p = h3p;
+ cwr.timeout = sfp->timeout;
+ cwr.cmnd = cmnd;
+ srp = sg_common_write(sfp, &cwr);
+ return (IS_ERR(srp)) ? PTR_ERR(srp) : (int)count;
}
-static int
-sg_allow_access(struct file *filp, u8 *cmd)
+static inline int
+sg_chk_mmap(struct sg_fd *sfp, int rq_flags, int len)
{
- struct sg_fd *sfp = filp->private_data;
-
- if (sfp->parentdp->device->type == TYPE_SCANNER)
- return 0;
+ if (!list_empty(&sfp->rq_list))
+ return -EBUSY; /* already active requests on fd */
+ if (len > sfp->rsv_srp->sgat_h.buflen)
+ return -ENOMEM; /* MMAP_IO size must fit in reserve */
+ if (rq_flags & SG_FLAG_DIRECT_IO)
+ return -EINVAL; /* not both MMAP_IO and DIRECT_IO */
+ return 0;
+}
- return blk_verify_command(cmd, filp->f_mode);
+static int
+sg_fetch_cmnd(struct file *filp, struct sg_fd *sfp, const u8 __user *u_cdbp,
+ int len, u8 *cdbp)
+{
+ if (!u_cdbp || len < 6 || len > SG_MAX_CDB_SIZE)
+ return -EMSGSIZE;
+ if (copy_from_user(cdbp, u_cdbp, len))
+ return -EFAULT;
+ if (O_RDWR != (filp->f_flags & O_ACCMODE)) { /* read-only */
+ switch (sfp->parentdp->device->type) {
+ case TYPE_DISK:
+ case TYPE_RBC:
+ case TYPE_ZBC:
+ return blk_verify_command(cdbp, filp->f_mode);
+ default: /* SSC, SES, etc cbd_s may differ from SBC */
+ break;
+ }
+ }
+ return 0;
}
-static ssize_t
-sg_submit(struct sg_fd *sfp, struct file *filp, const char __user *buf,
- size_t count, bool blocking, bool read_only, bool sg_io_owned,
- struct sg_request **o_srp)
+static int
+sg_submit(struct file *filp, struct sg_fd *sfp, struct sg_io_hdr *hp,
+ bool sync, struct sg_request **o_srp)
{
- int k;
+ int res, timeout;
+ unsigned long ul_timeout;
struct sg_request *srp;
- sg_io_hdr_t *hp;
+ struct sg_comm_wr_t cwr;
u8 cmnd[SG_MAX_CDB_SIZE];
- int timeout;
- unsigned long ul_timeout;
- if (count < SZ_SG_IO_HDR)
- return -EINVAL;
-
- sfp->cmd_q = 1; /* when sg_io_hdr seen, set command queuing on */
- if (!(srp = sg_add_request(sfp))) {
- SG_LOG(1, sfp, "%s: queue full\n", __func__);
- return -EDOM;
- }
- srp->sg_io_owned = sg_io_owned;
- hp = &srp->header;
- if (copy_from_user(hp, buf, SZ_SG_IO_HDR)) {
- sg_remove_request(sfp, srp);
- return -EFAULT;
- }
- if (hp->interface_id != 'S') {
- sg_remove_request(sfp, srp);
- return -ENOSYS;
- }
+ /* now doing v3 blocking (sync) or non-blocking submission */
if (hp->flags & SG_FLAG_MMAP_IO) {
- if (hp->dxfer_len > sfp->reserve.bufflen) {
- sg_remove_request(sfp, srp);
- return -ENOMEM; /* MMAP_IO size must fit in reserve buffer */
- }
- if (hp->flags & SG_FLAG_DIRECT_IO) {
- sg_remove_request(sfp, srp);
- return -EINVAL; /* either MMAP_IO or DIRECT_IO (not both) */
- }
- if (sfp->res_in_use) {
- sg_remove_request(sfp, srp);
- return -EBUSY; /* reserve buffer already being used */
- }
- }
- ul_timeout = msecs_to_jiffies(srp->header.timeout);
- timeout = (ul_timeout < INT_MAX) ? ul_timeout : INT_MAX;
- if ((!hp->cmdp) || (hp->cmd_len < 6) || (hp->cmd_len > sizeof (cmnd))) {
- sg_remove_request(sfp, srp);
- return -EMSGSIZE;
- }
- if (copy_from_user(cmnd, hp->cmdp, hp->cmd_len)) {
- sg_remove_request(sfp, srp);
- return -EFAULT;
- }
- if (read_only && sg_allow_access(filp, cmnd)) {
- sg_remove_request(sfp, srp);
- return -EPERM;
+ res = sg_chk_mmap(sfp, hp->flags, hp->dxfer_len);
+ if (res)
+ return res;
}
- k = sg_common_write(sfp, srp, cmnd, timeout, blocking);
- if (k < 0)
- return k;
+ /* when v3 seen, allow cmd_q on this fd (def: no cmd_q) */
+ set_bit(SG_FFD_CMD_Q, sfp->ffd_bm);
+ ul_timeout = msecs_to_jiffies(hp->timeout);
+ timeout = min_t(unsigned long, ul_timeout, INT_MAX);
+ res = sg_fetch_cmnd(filp, sfp, hp->cmdp, hp->cmd_len, cmnd);
+ if (res)
+ return res;
+ cwr.frq_bm[0] = 0;
+ __assign_bit(SG_FRQ_SYNC_INVOC, cwr.frq_bm, (int)sync);
+ cwr.h3p = hp;
+ cwr.timeout = timeout;
+ cwr.cmnd = cmnd;
+ srp = sg_common_write(sfp, &cwr);
+ if (IS_ERR(srp))
+ return PTR_ERR(srp);
if (o_srp)
*o_srp = srp;
- return count;
+ return 0;
}
-static int
-sg_common_write(struct sg_fd *sfp, struct sg_request *srp,
- u8 *cmnd, int timeout, int blocking)
+/*
+ * All writes and submits converge on this function to launch the SCSI
+ * command/request (via blk_execute_rq_nowait). Returns a pointer to a
+ * sg_request object holding the request just issued or a negated errno
+ * value twisted by ERR_PTR.
+ */
+static struct sg_request *
+sg_common_write(struct sg_fd *sfp, struct sg_comm_wr_t *cwrp)
{
- int k, at_head;
+ bool at_head;
+ int res = 0;
+ int dxfr_len, dir, cmd_len;
+ int pack_id = SG_PACK_ID_WILDCARD;
+ u32 rq_flags;
struct sg_device *sdp = sfp->parentdp;
- sg_io_hdr_t *hp = &srp->header;
-
- srp->data.cmd_opcode = cmnd[0]; /* hold opcode of command */
- hp->status = 0;
- hp->masked_status = 0;
- hp->msg_status = 0;
- hp->info = 0;
- hp->host_status = 0;
- hp->driver_status = 0;
- hp->resid = 0;
- SG_LOG(4, sfp, "%s: opcode=0x%02x, cmd_sz=%d\n", __func__,
- (int)cmnd[0], hp->cmd_len);
-
- if (hp->dxfer_len >= SZ_256M)
- return -EINVAL;
-
- k = sg_start_req(srp, cmnd);
- if (k) {
- SG_LOG(1, sfp, "%s: start_req err=%d\n", __func__, k);
- sg_finish_scsi_blk_rq(srp);
- sg_remove_request(sfp, srp);
- return k; /* probably out of space --> ENOMEM */
+ struct sg_request *srp;
+ struct sg_io_hdr *hi_p;
+
+ hi_p = cwrp->h3p;
+ dir = hi_p->dxfer_direction;
+ dxfr_len = hi_p->dxfer_len;
+ rq_flags = hi_p->flags;
+ pack_id = hi_p->pack_id;
+ if (dxfr_len >= SZ_256M)
+ return ERR_PTR(-EINVAL);
+
+ srp = sg_add_request(sfp, dxfr_len, cwrp);
+ if (IS_ERR(srp))
+ return srp;
+ srp->rq_flags = rq_flags;
+ srp->pack_id = pack_id;
+
+ cmd_len = hi_p->cmd_len;
+ memcpy(&srp->s_hdr3, hi_p, sizeof(srp->s_hdr3));
+ srp->cmd_opcode = cwrp->cmnd[0];/* hold opcode of command for debug */
+ SG_LOG(4, sfp, "%s: opcode=0x%02x, cdb_sz=%d, pack_id=%d\n", __func__,
+ (int)cwrp->cmnd[0], cmd_len, pack_id);
+
+ res = sg_start_req(srp, cwrp->cmnd, cmd_len, dir);
+ if (res < 0) /* probably out of space --> -ENOMEM */
+ goto err_out;
+ if (unlikely(SG_IS_DETACHING(sdp))) {
+ res = -ENODEV;
+ goto err_out;
}
- if (SG_IS_DETACHING(sdp)) {
- if (srp->bio) {
- scsi_req_free_cmd(scsi_req(srp->rq));
- blk_put_request(srp->rq);
- srp->rq = NULL;
- }
-
- sg_finish_scsi_blk_rq(srp);
- sg_remove_request(sfp, srp);
- return -ENODEV;
+ if (unlikely(test_bit(SG_FRQ_BLK_PUT_REQ, srp->frq_bm) || !srp->rq)) {
+ res = -EIDRM; /* this failure unexpected but observed */
+ goto err_out;
}
-
- hp->duration = jiffies_to_msecs(jiffies);
- if (hp->interface_id != '\0' && /* v3 (or later) interface */
- (SG_FLAG_Q_AT_TAIL & hp->flags))
- at_head = 0;
- else
- at_head = 1;
-
- if (!blocking)
- atomic_inc(&sfp->submitted);
- srp->rq->timeout = timeout;
+ srp->rq->timeout = cwrp->timeout;
kref_get(&sfp->f_ref); /* sg_rq_end_io() does kref_put(). */
+ srp->start_ns = ktime_get_boottime_ns();
+ srp->duration = 0;
+
+ if (srp->s_hdr3.interface_id == '\0')
+ at_head = true; /* backward compatibility: v1+v2 interfaces */
+ else if (test_bit(SG_FFD_Q_AT_TAIL, sfp->ffd_bm))
+ /* cmd flags can override sfd setting */
+ at_head = !!(srp->rq_flags & SG_FLAG_Q_AT_HEAD);
+ else /* this sfd is defaulting to head */
+ at_head = !(srp->rq_flags & SG_FLAG_Q_AT_TAIL);
+ if (!test_bit(SG_FRQ_SYNC_INVOC, srp->frq_bm))
+ atomic_inc(&sfp->submitted);
blk_execute_rq_nowait(sdp->device->request_queue, sdp->disk,
srp->rq, at_head, sg_rq_end_io);
- return 0;
+ return srp;
+err_out:
+ sg_finish_scsi_blk_rq(srp);
+ sg_deact_request(sfp, srp);
+ return ERR_PTR(res);
}
+static inline int
+sg_rstate_chg(struct sg_request *srp, enum sg_rq_state old_st,
+ enum sg_rq_state new_st)
+{
+ enum sg_rq_state act_old_st = (enum sg_rq_state)
+ atomic_cmpxchg(&srp->rq_st, old_st, new_st);
+
+ if (act_old_st == old_st)
+ return 0; /* implies new_st --> srp->rq_st */
+ else if (IS_ENABLED(CONFIG_SCSI_LOGGING))
+ sg_rep_rq_state_fail(srp->parentfp, old_st, new_st,
+ act_old_st);
+ return -EPROTOTYPE;
+}
/*
- * read(2) related functions follow. They are shown after write(2) related
- * functions. Apart from read(2) itself, ioctl(SG_IORECEIVE) and the second
- * half of the ioctl(SG_IO) share code with read(2).
+ * This function is called by wait_event_interruptible in sg_read() and
+ * sg_ctl_ioreceive(). wait_event_interruptible will return if this one
+ * returns true (or an event like a signal (e.g. control-C) occurs).
*/
-
-static struct sg_request *
-sg_get_rq_mark(struct sg_fd *sfp, int pack_id)
+static inline bool
+sg_get_ready_srp(struct sg_fd *sfp, struct sg_request **srpp, int pack_id)
{
- struct sg_request *resp;
- unsigned long iflags;
+ struct sg_request *srp;
- write_lock_irqsave(&sfp->rq_list_lock, iflags);
- list_for_each_entry(resp, &sfp->rq_list, entry) {
- /* look for requests that are ready + not SG_IO owned */
- if ((resp->done == 1) && (!resp->sg_io_owned) &&
- ((-1 == pack_id) || (resp->header.pack_id == pack_id))) {
- resp->done = 2; /* guard against other readers */
- write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
- return resp;
- }
+ if (unlikely(SG_IS_DETACHING(sfp->parentdp))) {
+ *srpp = NULL;
+ return true;
}
- write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
- return NULL;
+ srp = sg_find_srp_by_id(sfp, pack_id);
+ *srpp = srp;
+ return !!srp;
}
-static ssize_t
-sg_new_read(struct sg_fd *sfp, char __user *buf, size_t count,
- struct sg_request *srp)
+/*
+ * Returns number of bytes copied to user space provided sense buffer or
+ * negated errno value.
+ */
+static int
+sg_copy_sense(struct sg_request *srp)
{
- sg_io_hdr_t *hp = &srp->header;
- int err = 0, err2;
- int len;
-
- if (count < SZ_SG_IO_HDR) {
- err = -EINVAL;
- goto err_out;
- }
- hp->sb_len_wr = 0;
- if ((hp->mx_sb_len > 0) && hp->sbp) {
- if ((CHECK_CONDITION & hp->masked_status) ||
- (DRIVER_SENSE & hp->driver_status)) {
- int sb_len = SCSI_SENSE_BUFFERSIZE;
-
- sb_len = (hp->mx_sb_len > sb_len) ? sb_len :
- hp->mx_sb_len;
+ int sb_len_wr = 0;
+ int scsi_stat;
+
+ /* If need be, copy the sense buffer to the user space */
+ scsi_stat = srp->rq_result & 0xff;
+ if ((scsi_stat & SAM_STAT_CHECK_CONDITION) ||
+ (driver_byte(srp->rq_result) & DRIVER_SENSE)) {
+ int sb_len = min_t(int, SCSI_SENSE_BUFFERSIZE, srp->sense_len);
+ int mx_sb_len;
+ void __user *up;
+
+ up = (void __user *)srp->s_hdr3.sbp;
+ mx_sb_len = srp->s_hdr3.mx_sb_len;
+ if (up && mx_sb_len > 0) {
+ sb_len = min_t(int, sb_len, mx_sb_len);
/* Additional sense length field */
- len = 8 + (int) srp->sense_b[7];
- len = (len > sb_len) ? sb_len : len;
- if (copy_to_user(hp->sbp, srp->sense_b, len)) {
- err = -EFAULT;
- goto err_out;
- }
- hp->sb_len_wr = len;
+ sb_len_wr = 8 + (int)srp->sense_b[7];
+ sb_len_wr = min_t(int, sb_len, sb_len_wr);
+ if (copy_to_user(up, srp->sense_b, sb_len_wr))
+ sb_len_wr = -EFAULT;
}
}
- if (hp->masked_status || hp->host_status || hp->driver_status)
- hp->info |= SG_INFO_CHECK;
- if (copy_to_user(buf, hp, SZ_SG_IO_HDR)) {
- err = -EFAULT;
- goto err_out;
- }
-err_out:
- err2 = sg_finish_scsi_blk_rq(srp);
- sg_remove_request(sfp, srp);
- return err ? : err2 ? : count;
+ return sb_len_wr;
}
-static int
-srp_done(struct sg_fd *sfp, struct sg_request *srp)
+#if IS_ENABLED(CONFIG_SCSI_LOGGING)
+static void
+sg_rep_rq_state_fail(struct sg_fd *sfp, enum sg_rq_state exp_old_st,
+ enum sg_rq_state want_st, enum sg_rq_state act_old_st)
{
- unsigned long flags;
- int ret;
+ const char *eors = "expected old rq_st: ";
+ const char *aors = "actual old rq_st: ";
- read_lock_irqsave(&sfp->rq_list_lock, flags);
- ret = srp->done;
- read_unlock_irqrestore(&sfp->rq_list_lock, flags);
- return ret;
+ if (IS_ENABLED(CONFIG_SCSI_PROC_FS))
+ SG_LOG(1, sfp, "%s: %s%s, %s%s, wanted rq_st: %s\n", __func__,
+ eors, sg_rq_st_str(exp_old_st, false),
+ aors, sg_rq_st_str(act_old_st, false),
+ sg_rq_st_str(want_st, false));
+ else
+ pr_info("sg: %s: %s%d, %s%d, wanted rq_st: %d\n", __func__,
+ eors, (int)exp_old_st, aors, (int)act_old_st,
+ (int)want_st);
}
-
-static ssize_t
-sg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
+#else
+static void
+sg_rep_rq_state_fail(struct sg_fd *sfp, enum sg_rq_state exp_old_st,
+ enum sg_rq_state want_st, enum sg_rq_state act_old_st)
{
- struct sg_device *sdp;
- struct sg_fd *sfp;
- struct sg_request *srp;
- int req_pack_id = -1;
- int ret = 0;
- sg_io_hdr_t *hp;
- struct sg_header *old_hdr = NULL;
-
- /*
- * This could cause a response to be stranded. Close the associated
- * file descriptor to free up any resources being held.
- */
- ret = sg_check_file_access(filp, __func__);
- if (ret)
- return ret;
+}
+#endif
- sfp = filp->private_data;
- sdp = sfp->parentdp;
- SG_LOG(3, sfp, "%s: read() count=%d\n", __func__, (int)count);
- ret = sg_allow_if_err_recovery(sdp, false);
- if (ret)
- return ret;
+static int
+sg_rec_v3_state(struct sg_fd *sfp, struct sg_request *srp)
+{
+ int err = 0;
+ int sb_len_wr;
+ u32 rq_res = srp->rq_result;
+
+ sb_len_wr = sg_copy_sense(srp);
+ if (sb_len_wr < 0)
+ return sb_len_wr;
+ if (rq_res & SG_ML_RESULT_MSK)
+ srp->rq_info |= SG_INFO_CHECK;
+ if (unlikely(SG_IS_DETACHING(sfp->parentdp)))
+ srp->rq_info |= SG_INFO_DEVICE_DETACHING;
+ return err;
+}
- if (sfp->force_packid && (count >= SZ_SG_HEADER)) {
- old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL);
- if (!old_hdr)
- return -ENOMEM;
- if (copy_from_user(old_hdr, buf, SZ_SG_HEADER)) {
- ret = -EFAULT;
- goto free_old_hdr;
- }
- if (old_hdr->reply_len < 0) {
- if (count >= SZ_SG_IO_HDR) {
- sg_io_hdr_t *new_hdr;
-
- new_hdr = kmalloc(SZ_SG_IO_HDR, GFP_KERNEL);
- if (!new_hdr) {
- ret = -ENOMEM;
- goto free_old_hdr;
- }
- ret = copy_from_user(new_hdr, buf,
- SZ_SG_IO_HDR);
- req_pack_id = new_hdr->pack_id;
- kfree(new_hdr);
- if (ret) {
- ret = -EFAULT;
- goto free_old_hdr;
- }
- }
- } else
- req_pack_id = old_hdr->pack_id;
- }
- srp = sg_get_rq_mark(sfp, req_pack_id);
- if (!srp) { /* now wait on packet to arrive */
- if (SG_IS_DETACHING(sdp)) {
- ret = -ENODEV;
- goto free_old_hdr;
- }
- if (filp->f_flags & O_NONBLOCK) {
- ret = -EAGAIN;
- goto free_old_hdr;
- }
- ret = wait_event_interruptible
- (sfp->read_wait,
- (SG_IS_DETACHING(sdp) ||
- (srp = sg_get_rq_mark(sfp, req_pack_id))));
- if (SG_IS_DETACHING(sdp)) {
- ret = -ENODEV;
- goto free_old_hdr;
- }
- if (ret) {
- /* -ERESTARTSYS as signal hit process */
- goto free_old_hdr;
- }
- }
- if (srp->header.interface_id != '\0') {
- ret = sg_new_read(sfp, buf, count, srp);
- goto free_old_hdr;
- }
+/*
+ * Completes a v3 request/command. Called from sg_read {v2 or v3},
+ * ioctl(SG_IO) {for v3}, or from ioctl(SG_IORECEIVE) when its
+ * completing a v3 request/command.
+ */
+static int
+sg_v3_receive(struct sg_fd *sfp, struct sg_request *srp, void __user *p)
+{
+ int err, err2;
+ int rq_result = srp->rq_result;
+ struct sg_io_hdr hdr3;
+ struct sg_io_hdr *hp = &hdr3;
+
+ SG_LOG(3, sfp, "%s: srp=0x%p\n", __func__, srp);
+ err = sg_rec_v3_state(sfp, srp);
+ memset(hp, 0, sizeof(*hp));
+ memcpy(hp, &srp->s_hdr3, sizeof(srp->s_hdr3));
+ hp->sb_len_wr = srp->sense_len;
+ hp->info = srp->rq_info;
+ hp->resid = srp->in_resid;
+ hp->duration = srp->duration;
+ hp->status = rq_result & 0xff;
+ hp->masked_status = status_byte(rq_result);
+ hp->msg_status = msg_byte(rq_result);
+ hp->host_status = host_byte(rq_result);
+ hp->driver_status = driver_byte(rq_result);
+ /* copy_*_user() [without leading underscores] checks access */
+ if (copy_to_user(p, hp, SZ_SG_IO_HDR))
+ err = err ? err : -EFAULT;
+ err2 = sg_rstate_chg(srp, atomic_read(&srp->rq_st), SG_RS_DONE_RD);
+ if (err2)
+ err = err ? err : err2;
+ sg_finish_scsi_blk_rq(srp);
+ sg_deact_request(sfp, srp);
+ return err ? err : 0;
+}
- hp = &srp->header;
- if (old_hdr == NULL) {
- old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL);
- if (!old_hdr) {
- ret = -ENOMEM;
- goto free_old_hdr;
- }
- }
- memset(old_hdr, 0, SZ_SG_HEADER);
- old_hdr->reply_len = (int) hp->timeout;
- old_hdr->pack_len = old_hdr->reply_len; /* old, strange behaviour */
- old_hdr->pack_id = hp->pack_id;
- old_hdr->twelve_byte =
- ((srp->data.cmd_opcode >= 0xc0) && (hp->cmd_len == 12)) ? 1 : 0;
- old_hdr->target_status = hp->masked_status;
- old_hdr->host_status = hp->host_status;
- old_hdr->driver_status = hp->driver_status;
- if ((hp->masked_status & CHECK_CONDITION) ||
- (hp->driver_status & DRIVER_SENSE))
- memcpy(old_hdr->sense_buffer, srp->sense_b,
- sizeof(old_hdr->sense_buffer));
- switch (hp->host_status) {
+static int
+sg_rd_v1v2(void __user *buf, int count, struct sg_fd *sfp,
+ struct sg_request *srp)
+{
+ int res = 0;
+ u32 rq_result = srp->rq_result;
+ struct sg_header *h2p;
+ struct sg_slice_hdr3 *sh3p;
+ struct sg_header a_v2hdr;
+
+ h2p = &a_v2hdr;
+ memset(h2p, 0, SZ_SG_HEADER);
+ sh3p = &srp->s_hdr3;
+ h2p->reply_len = (int)sh3p->timeout;
+ h2p->pack_len = h2p->reply_len; /* old, strange behaviour */
+ h2p->pack_id = sh3p->pack_id;
+ h2p->twelve_byte = (srp->cmd_opcode >= 0xc0 && sh3p->cmd_len == 12);
+ h2p->target_status = status_byte(rq_result);
+ h2p->host_status = host_byte(rq_result);
+ h2p->driver_status = driver_byte(rq_result);
+ if ((CHECK_CONDITION & status_byte(rq_result)) ||
+ (DRIVER_SENSE & driver_byte(rq_result))) {
+ memcpy(h2p->sense_buffer, srp->sense_b,
+ sizeof(h2p->sense_buffer));
+ }
+ switch (host_byte(rq_result)) {
/*
- * This setup of 'result' is for backward compatibility and is best
- * ignored by the user who should use target, host + driver status
+ * This foolowing setting of 'result' is for backward compatibility
+ * and is best ignored by the user who should use target, host and
+ * driver status.
*/
case DID_OK:
case DID_PASSTHROUGH:
case DID_SOFT_ERROR:
- old_hdr->result = 0;
+ h2p->result = 0;
break;
case DID_NO_CONNECT:
case DID_BUS_BUSY:
case DID_TIME_OUT:
- old_hdr->result = EBUSY;
+ h2p->result = EBUSY;
break;
case DID_BAD_TARGET:
case DID_ABORT:
case DID_PARITY:
case DID_RESET:
case DID_BAD_INTR:
- old_hdr->result = EIO;
+ h2p->result = EIO;
break;
case DID_ERROR:
- old_hdr->result = (srp->sense_b[0] == 0 &&
- hp->masked_status == GOOD) ? 0 : EIO;
+ h2p->result = (status_byte(rq_result) == GOOD) ? 0 : EIO;
break;
default:
- old_hdr->result = EIO;
+ h2p->result = EIO;
break;
}
/* Now copy the result back to the user buffer. */
if (count >= SZ_SG_HEADER) {
- if (copy_to_user(buf, old_hdr, SZ_SG_HEADER)) {
- ret = -EFAULT;
- goto free_old_hdr;
- }
+ if (copy_to_user(buf, h2p, SZ_SG_HEADER))
+ return -EFAULT;
buf += SZ_SG_HEADER;
- if (count > old_hdr->reply_len)
- count = old_hdr->reply_len;
+ if (count > h2p->reply_len)
+ count = h2p->reply_len;
if (count > SZ_SG_HEADER) {
- if (sg_rd_append(srp, buf, count - SZ_SG_HEADER)) {
- ret = -EFAULT;
- goto free_old_hdr;
- }
+ if (sg_rd_append(srp, buf, count - SZ_SG_HEADER))
+ return -EFAULT;
}
} else
- count = (old_hdr->result == 0) ? 0 : -EIO;
+ res = (h2p->result == 0) ? 0 : -EIO;
+ atomic_set(&srp->rq_st, SG_RS_DONE_RD);
sg_finish_scsi_blk_rq(srp);
- sg_remove_request(sfp, srp);
- ret = count;
-free_old_hdr:
- kfree(old_hdr);
- return ret;
+ sg_deact_request(sfp, srp);
+ return res;
+}
+
+/*
+ * This is the read(2) system call entry point (see sg_fops) for this driver.
+ * Accepts v1, v2 or v3 type headers (not v4). Returns count or negated
+ * errno; if count is 0 then v3: returns -EINVAL; v1+v2: 0 when no other
+ * error detected or -EIO.
+ */
+static ssize_t
+sg_read(struct file *filp, char __user *p, size_t count, loff_t *ppos)
+{
+ bool could_be_v3;
+ bool non_block = !!(filp->f_flags & O_NONBLOCK);
+ int want_id = SG_PACK_ID_WILDCARD;
+ int hlen, ret;
+ struct sg_device *sdp = NULL;
+ struct sg_fd *sfp;
+ struct sg_request *srp = NULL;
+ struct sg_header *h2p = NULL;
+ struct sg_io_hdr a_sg_io_hdr;
+
+ /*
+ * This could cause a response to be stranded. Close the associated
+ * file descriptor to free up any resources being held.
+ */
+ ret = sg_check_file_access(filp, __func__);
+ if (ret)
+ return ret;
+
+ sfp = filp->private_data;
+ sdp = sfp->parentdp;
+ SG_LOG(3, sfp, "%s: read() count=%d\n", __func__, (int)count);
+ ret = sg_allow_if_err_recovery(sdp, non_block);
+ if (ret)
+ return ret;
+
+ could_be_v3 = (count >= SZ_SG_IO_HDR);
+ hlen = could_be_v3 ? SZ_SG_IO_HDR : SZ_SG_HEADER;
+ h2p = (struct sg_header *)&a_sg_io_hdr;
+
+ if (test_bit(SG_FFD_FORCE_PACKID, sfp->ffd_bm) && (int)count >= hlen) {
+ /*
+ * Even though this is a user space read() system call, this
+ * code is cheating to fetch the pack_id.
+ * Only need first three 32 bit ints to determine interface.
+ */
+ if (copy_from_user(h2p, p, 3 * sizeof(int)))
+ return -EFAULT;
+ if (h2p->reply_len < 0 && could_be_v3) {
+ struct sg_io_hdr *v3_hdr = (struct sg_io_hdr *)h2p;
+
+ if (v3_hdr->interface_id == 'S') {/* v3, new sanity */
+ struct sg_io_hdr __user *h3_up;
+
+ h3_up = (struct sg_io_hdr __user *)p;
+ ret = get_user(want_id, &h3_up->pack_id);
+ if (ret)
+ return ret;
+ } else {
+ return -EPERM;
+ }
+ } else { /* for v1+v2 interfaces, this is the 3rd integer */
+ want_id = h2p->pack_id;
+ }
+ }
+ srp = sg_find_srp_by_id(sfp, want_id);
+ if (!srp) { /* nothing available so wait on packet to arrive or */
+ if (unlikely(SG_IS_DETACHING(sdp)))
+ return -ENODEV;
+ if (non_block) /* O_NONBLOCK or v3::flags & SGV4_FLAG_IMMED */
+ return -EAGAIN;
+ ret = wait_event_interruptible(sfp->read_wait,
+ sg_get_ready_srp(sfp, &srp,
+ want_id));
+ if (unlikely(SG_IS_DETACHING(sdp)))
+ return -ENODEV;
+ if (ret) /* -ERESTARTSYS as signal hit process */
+ return ret;
+ /* otherwise srp should be valid */
+ }
+ if (srp->s_hdr3.interface_id == '\0') {
+ ret = sg_rd_v1v2(p, (int)count, sfp, srp);
+ } else {
+ if ((int)count < SZ_SG_IO_HDR)
+ return -EINVAL;
+ ret = sg_v3_receive(sfp, srp, p);
+ }
+ if (ret < 0)
+ SG_LOG(1, sfp, "%s: negated errno: %d\n", __func__, ret);
+ return ret < 0 ? ret : (int)count;
}
static int
@@ -961,53 +1112,352 @@ max_sectors_bytes(struct request_queue *q)
unsigned int max_sectors = queue_max_sectors(q);
max_sectors = min_t(unsigned int, max_sectors, INT_MAX >> 9);
-
return max_sectors << 9;
}
+/*
+ * Calculates sg_device::max_sgat_elems and sg_device::max_sgat_sz. It uses
+ * the device's request queue. If q not available sets max_sgat_elems to 1
+ * and max_sgat_sz to PAGE_SIZE. If potential max_sgat_sz is greater than
+ * 2^30 scales down the implied max_segment_size so the product of the
+ * max_segment_size and max_sgat_elems is less than or equal to 2^30 .
+ */
static void
-sg_fill_request_table(struct sg_fd *sfp, struct sg_req_info *rinfo)
+sg_calc_sgat_param(struct sg_device *sdp)
{
- struct sg_request *srp;
- int val;
- unsigned int ms;
+ int sz;
+ u64 m;
+ struct scsi_device *sdev = sdp->device;
+ struct request_queue *q = sdev ? sdev->request_queue : NULL;
+
+ clear_bit(SG_FDEV_LOG_SENSE, sdp->fdev_bm);
+ if (!q) {
+ sdp->max_sgat_elems = 1;
+ sdp->max_sgat_sz = PAGE_SIZE;
+ return;
+ }
+ sdp->max_sgat_elems = queue_max_segments(q);
+ m = (u64)queue_max_segment_size(q) * queue_max_segments(q);
+ if (m < PAGE_SIZE) {
+ sdp->max_sgat_elems = 1;
+ sdp->max_sgat_sz = PAGE_SIZE;
+ return;
+ }
+ sz = (int)min_t(u64, m, 1 << 30);
+ if (sz == (1 << 30)) /* round down so: sz = elems * elem_sz */
+ sz = ((1 << 30) / sdp->max_sgat_elems) * sdp->max_sgat_elems;
+ sdp->max_sgat_sz = sz;
+}
- val = 0;
- list_for_each_entry(srp, &sfp->rq_list, entry) {
- if (val >= SG_MAX_QUEUE)
+static u32
+sg_calc_rq_dur(const struct sg_request *srp)
+{
+ ktime_t ts0 = srp->start_ns;
+ ktime_t now_ts;
+ s64 diff;
+
+ if (ts0 == 0)
+ return 0;
+ if (unlikely(ts0 == U64_MAX)) /* _prior_ to issuing req */
+ return 999999999; /* eye catching */
+ now_ts = ktime_get_boottime_ns();
+ if (unlikely(ts0 > now_ts))
+ return 999999998;
+ /* unlikely req duration will exceed 2**32 milliseconds */
+ diff = ktime_ms_delta(now_ts, ts0);
+ return (diff > (s64)U32_MAX) ? 3999999999U : (u32)diff;
+}
+
+/* Return of U32_MAX means srp is inactive or in slave waiting state */
+static u32
+sg_get_dur(struct sg_request *srp, const enum sg_rq_state *sr_stp,
+ bool *is_durp)
+{
+ bool is_dur = false;
+ u32 res = U32_MAX;
+
+ switch (sr_stp ? *sr_stp : atomic_read(&srp->rq_st)) {
+ case SG_RS_INFLIGHT:
+ case SG_RS_BUSY:
+ res = sg_calc_rq_dur(srp);
+ break;
+ case SG_RS_AWAIT_RD:
+ case SG_RS_DONE_RD:
+ res = srp->duration;
+ is_dur = true; /* completion has occurred, timing finished */
+ break;
+ case SG_RS_INACTIVE:
+ default:
+ break;
+ }
+ if (is_durp)
+ *is_durp = is_dur;
+ return res;
+}
+
+static void
+sg_fill_request_element(struct sg_fd *sfp, struct sg_request *srp,
+ struct sg_req_info *rip)
+{
+ spin_lock(&srp->req_lck);
+ rip->duration = sg_get_dur(srp, NULL, NULL);
+ if (rip->duration == U32_MAX)
+ rip->duration = 0;
+ rip->orphan = test_bit(SG_FRQ_IS_ORPHAN, srp->frq_bm);
+ rip->sg_io_owned = test_bit(SG_FRQ_SYNC_INVOC, srp->frq_bm);
+ rip->problem = !!(srp->rq_result & SG_ML_RESULT_MSK);
+ rip->pack_id = srp->pack_id;
+ rip->usr_ptr = srp->s_hdr3.usr_ptr;
+ spin_unlock(&srp->req_lck);
+}
+
+static inline bool
+sg_rq_landed(struct sg_device *sdp, struct sg_request *srp)
+{
+ return atomic_read(&srp->rq_st) != SG_RS_INFLIGHT ||
+ unlikely(SG_IS_DETACHING(sdp));
+}
+
+/*
+ * This is a blocking wait for a specific srp. When h4p is non-NULL, it is
+ * the blocking multiple request case
+ */
+static int
+sg_wait_event_srp(struct file *filp, struct sg_fd *sfp, void __user *p,
+ struct sg_request *srp)
+{
+ int res;
+ enum sg_rq_state sr_st;
+ struct sg_device *sdp = sfp->parentdp;
+
+ SG_LOG(3, sfp, "%s: about to wait_event...()\n", __func__);
+ /* usually will be woken up by sg_rq_end_io() callback */
+ res = wait_event_interruptible(sfp->read_wait,
+ sg_rq_landed(sdp, srp));
+ if (unlikely(res)) { /* -ERESTARTSYS because signal hit thread */
+ set_bit(SG_FRQ_IS_ORPHAN, srp->frq_bm);
+ /* orphans harvested when sfp->keep_orphan is false */
+ atomic_set(&srp->rq_st, SG_RS_INFLIGHT);
+ SG_LOG(1, sfp, "%s: wait_event_interruptible gave %d\n",
+ __func__, res);
+ return res;
+ }
+ if (unlikely(SG_IS_DETACHING(sdp))) {
+ atomic_set(&srp->rq_st, SG_RS_INACTIVE);
+ return -ENODEV;
+ }
+ sr_st = atomic_read(&srp->rq_st);
+ if (unlikely(sr_st != SG_RS_AWAIT_RD))
+ return -EPROTO; /* Logic error */
+ res = sg_rstate_chg(srp, sr_st, SG_RS_BUSY);
+ if (unlikely(res))
+ return res;
+ res = sg_v3_receive(sfp, srp, p);
+ return (res < 0) ? res : 0;
+}
+
+/*
+ * Handles ioctl(SG_IO) for blocking (sync) usage of v3 or v4 interface.
+ * Returns 0 on success else a negated errno.
+ */
+static int
+sg_ctl_sg_io(struct file *filp, struct sg_device *sdp, struct sg_fd *sfp,
+ void __user *p)
+{
+ int res;
+ struct sg_request *srp = NULL;
+ u8 hu8arr[SZ_SG_IO_HDR];
+ struct sg_io_hdr *h3p = (struct sg_io_hdr *)hu8arr;
+
+ SG_LOG(3, sfp, "%s: SG_IO%s\n", __func__,
+ ((filp->f_flags & O_NONBLOCK) ? " O_NONBLOCK ignored" : ""));
+ res = sg_allow_if_err_recovery(sdp, false);
+ if (res)
+ return res;
+ if (copy_from_user(h3p, p, SZ_SG_IO_HDR))
+ return -EFAULT;
+ if (h3p->interface_id == 'S')
+ res = sg_submit(filp, sfp, h3p, true, &srp);
+ else
+ return -EPERM;
+ if (unlikely(res < 0))
+ return res;
+ if (!srp) /* mrq case: already processed all responses */
+ return res;
+ res = sg_wait_event_srp(filp, sfp, p, srp);
+ if (res) {
+ SG_LOG(1, sfp, "%s: %s=0x%p state: %s\n", __func__,
+ "unexpected srp", srp,
+ sg_rq_st_str(atomic_read(&srp->rq_st), false));
+ }
+ return res;
+}
+
+/*
+ * First normalize want_rsv_sz to be >= sfp->sgat_elem_sz and
+ * <= max_segment_size. Exit if that is the same as old size; otherwise
+ * create a new candidate request of the new size. Then decide whether to
+ * re-use an existing free list request (least buflen >= required size) or
+ * use the new candidate. If new one used, leave old one but it is no longer
+ * the reserved request. Returns 0 on success, else a negated errno value.
+ */
+static int
+sg_set_reserved_sz(struct sg_fd *sfp, int want_rsv_sz)
+{
+ bool use_new_srp = false;
+ int res = 0;
+ int new_sz, blen;
+ unsigned long iflags;
+ struct sg_request *o_srp; /* prior reserve sg_request */
+ struct sg_request *n_srp; /* new sg_request, may be used */
+ struct sg_request *t_srp; /* other fl entries */
+ struct sg_device *sdp = sfp->parentdp;
+
+ rcu_read_lock();
+ o_srp = sfp->rsv_srp;
+ if (!o_srp) {
+ rcu_read_unlock();
+ return -EPROTO;
+ }
+ new_sz = min_t(int, want_rsv_sz, sdp->max_sgat_sz);
+ new_sz = max_t(int, new_sz, sfp->sgat_elem_sz);
+ blen = o_srp->sgat_h.buflen;
+ rcu_read_unlock();
+ SG_LOG(3, sfp, "%s: was=%d, ask=%d, new=%d (sgat_elem_sz=%d)\n",
+ __func__, blen, want_rsv_sz, new_sz, sfp->sgat_elem_sz);
+ if (blen == new_sz)
+ return 0;
+ n_srp = sg_mk_srp_sgat(sfp, true /* can take time */, new_sz);
+ if (IS_ERR(n_srp))
+ return PTR_ERR(n_srp);
+ /* new sg_request object, sized correctly is now available */
+ spin_lock_irqsave(&sfp->rq_list_lock, iflags);
+ o_srp = sfp->rsv_srp;
+ if (!o_srp) {
+ res = -EPROTO;
+ goto wr_unlock;
+ }
+ if (SG_RS_ACTIVE(o_srp) ||
+ test_bit(SG_FFD_MMAP_CALLED, sfp->ffd_bm)) {
+ res = -EBUSY;
+ goto wr_unlock;
+ }
+ use_new_srp = true;
+ list_for_each_entry(t_srp, &sfp->rq_fl, fl_entry) {
+ if (t_srp != o_srp && new_sz <= t_srp->sgat_h.buflen &&
+ !SG_RS_ACTIVE(t_srp)) {
+ /* good candidate on free list, use */
+ use_new_srp = false;
+ sfp->rsv_srp = t_srp;
break;
- rinfo[val].req_state = srp->done + 1;
- rinfo[val].problem =
- srp->header.masked_status &
- srp->header.host_status &
- srp->header.driver_status;
- if (srp->done)
- rinfo[val].duration =
- srp->header.duration;
- else {
- ms = jiffies_to_msecs(jiffies);
- rinfo[val].duration =
- (ms > srp->header.duration) ?
- (ms - srp->header.duration) : 0;
}
- rinfo[val].orphan = srp->orphan;
- rinfo[val].sg_io_owned = srp->sg_io_owned;
- rinfo[val].pack_id = srp->header.pack_id;
- rinfo[val].usr_ptr = srp->header.usr_ptr;
- val++;
}
+ if (use_new_srp) {
+ sfp->rsv_srp = n_srp;
+ /* add to front of free list */
+ list_add_rcu(&n_srp->fl_entry, &sfp->rq_fl);
+ SG_LOG(6, sfp, "%s: new rsv srp=0x%p ++\n", __func__, n_srp);
+ }
+wr_unlock:
+ spin_unlock_irqrestore(&sfp->rq_list_lock, iflags);
+ if (!use_new_srp) {
+ sg_remove_sgat(n_srp);
+ kfree(n_srp); /* no-one else has seen n_srp, so safe */
+ }
+ return res;
+}
+
+/*
+ * For backward compatibility, output SG_MAX_QUEUE sg_req_info objects. First
+ * fetch from the active list then, if there is still room, from the free
+ * list. Some of the trailing elements may be empty which is indicated by all
+ * fields being zero. Any requests beyond SG_MAX_QUEUE are ignored.
+ */
+static int
+sg_ctl_req_tbl(struct sg_fd *sfp, void __user *p)
+{
+ int k, len, result, val, n;
+ struct sg_request *srp;
+ struct sg_req_info *rinfop;
+ struct sg_req_info *rip;
+
+ SG_LOG(3, sfp, "%s: SG_GET_REQUEST_TABLE\n", __func__);
+ k = SG_MAX_QUEUE;
+ len = SZ_SG_REQ_INFO * k;
+ rinfop = kcalloc(k, SZ_SG_REQ_INFO, GFP_KERNEL);
+ if (!rinfop)
+ return -ENOMEM;
+ val = 0;
+ rcu_read_lock();
+ list_for_each_entry_rcu(srp, &sfp->rq_list, rq_entry)
+ ++val;
+
+ if (val > 0) {
+ int max_num = min_t(int, k, val);
+
+ n = 0;
+ list_for_each_entry_rcu(srp, &sfp->rq_list, rq_entry) {
+ if (n >= max_num)
+ break;
+ rip = &rinfop[n];
+ sg_fill_request_element(sfp, srp, rip);
+ n++;
+ }
+ list_for_each_entry_rcu(srp, &sfp->rq_fl, fl_entry) {
+ if (n >= max_num)
+ break;
+ rip = &rinfop[n];
+ sg_fill_request_element(sfp, srp, rip);
+ n++;
+ }
+ }
+ rcu_read_unlock();
+ result = copy_to_user(p, rinfop, len);
+ result = result ? -EFAULT : 0;
+ kfree(rinfop);
+ return result;
+}
+
+static int
+sg_ctl_scsi_id(struct scsi_device *sdev, struct sg_fd *sfp, void __user *p)
+{
+ struct sg_scsi_id __user *sg_idp = p;
+
+ SG_LOG(3, sfp, "%s: SG_GET_SCSI_ID\n", __func__);
+ if (!access_ok(p, sizeof(struct sg_scsi_id)))
+ return -EFAULT;
+
+ if (unlikely(SG_IS_DETACHING(sfp->parentdp)))
+ return -ENODEV;
+ __put_user((int)sdev->host->host_no,
+ &sg_idp->host_no);
+ __put_user((int)sdev->channel, &sg_idp->channel);
+ __put_user((int)sdev->id, &sg_idp->scsi_id);
+ __put_user((int)sdev->lun, &sg_idp->lun);
+ __put_user((int)sdev->type, &sg_idp->scsi_type);
+ __put_user((short)sdev->host->cmd_per_lun,
+ &sg_idp->h_cmd_per_lun);
+ __put_user((short)sdev->queue_depth,
+ &sg_idp->d_queue_depth);
+ __put_user(0, &sg_idp->unused[0]);
+ __put_user(0, &sg_idp->unused[1]);
+ return 0;
}
static long
sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
{
- void __user *p = (void __user *)arg;
+ bool read_only = O_RDWR != (filp->f_flags & O_ACCMODE);
+ bool check_detach = false;
+ int val;
+ int result = 0;
+ void __user *p = uptr64(arg);
int __user *ip = p;
- int result, val, read_only;
struct sg_device *sdp;
struct sg_fd *sfp;
struct sg_request *srp;
- unsigned long iflags;
+ struct scsi_device *sdev;
+ __maybe_unused const char *pmlp = ", pass to mid-level";
sfp = filp->private_data;
sdp = sfp->parentdp;
@@ -1015,220 +1465,212 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
!!(filp->f_flags & O_NONBLOCK));
if (!sdp)
return -ENXIO;
- read_only = (O_RDWR != (filp->f_flags & O_ACCMODE));
+ if (unlikely(SG_IS_DETACHING(sdp)))
+ return -ENODEV;
+ sdev = sdp->device;
switch (cmd_in) {
case SG_IO:
- result = sg_allow_if_err_recovery(sdp, false);
- if (result)
- return result;
- result = sg_submit(sfp, filp, p, SZ_SG_IO_HDR, true, read_only,
- true, &srp);
- if (result < 0)
- return result;
- result = wait_event_interruptible(sfp->read_wait,
- (srp_done(sfp, srp) || SG_IS_DETACHING(sdp)));
- if (SG_IS_DETACHING(sdp))
- return -ENODEV;
- write_lock_irq(&sfp->rq_list_lock);
- if (srp->done) {
- srp->done = 2;
- write_unlock_irq(&sfp->rq_list_lock);
- result = sg_new_read(sfp, p, SZ_SG_IO_HDR, srp);
- return (result < 0) ? result : 0;
- }
- srp->orphan = 1;
- write_unlock_irq(&sfp->rq_list_lock);
- return result; /* -ERESTARTSYS because signal hit process */
- case SG_SET_TIMEOUT:
- result = get_user(val, ip);
- if (result)
- return result;
- if (val < 0)
- return -EIO;
- if (val >= mult_frac((s64)INT_MAX, USER_HZ, HZ))
- val = min_t(s64, mult_frac((s64)INT_MAX, USER_HZ, HZ),
- INT_MAX);
- sfp->timeout_user = val;
- sfp->timeout = mult_frac(val, HZ, USER_HZ);
-
- return 0;
- case SG_GET_TIMEOUT: /* N.B. User receives timeout as return value */
- /* strange ..., for backward compatibility */
- return sfp->timeout_user;
- case SG_SET_FORCE_LOW_DMA:
- /*
- * N.B. This ioctl never worked properly, but failed to
- * return an error value. So returning '0' to keep compability
- * with legacy applications.
- */
- return 0;
- case SG_GET_LOW_DMA:
- return put_user((int) sdp->device->host->unchecked_isa_dma, ip);
+ return sg_ctl_sg_io(filp, sdp, sfp, p);
case SG_GET_SCSI_ID:
- if (!access_ok(p, sizeof (sg_scsi_id_t)))
- return -EFAULT;
- else {
- sg_scsi_id_t __user *sg_idp = p;
-
- if (SG_IS_DETACHING(sdp))
- return -ENODEV;
- __put_user((int) sdp->device->host->host_no,
- &sg_idp->host_no);
- __put_user((int) sdp->device->channel,
- &sg_idp->channel);
- __put_user((int) sdp->device->id, &sg_idp->scsi_id);
- __put_user((int) sdp->device->lun, &sg_idp->lun);
- __put_user((int) sdp->device->type, &sg_idp->scsi_type);
- __put_user((short) sdp->device->host->cmd_per_lun,
- &sg_idp->h_cmd_per_lun);
- __put_user((short) sdp->device->queue_depth,
- &sg_idp->d_queue_depth);
- __put_user(0, &sg_idp->unused[0]);
- __put_user(0, &sg_idp->unused[1]);
- return 0;
- }
+ return sg_ctl_scsi_id(sdev, sfp, p);
case SG_SET_FORCE_PACK_ID:
+ SG_LOG(3, sfp, "%s: SG_SET_FORCE_PACK_ID\n", __func__);
result = get_user(val, ip);
if (result)
return result;
- sfp->force_packid = val ? 1 : 0;
+ assign_bit(SG_FFD_FORCE_PACKID, sfp->ffd_bm, !!val);
return 0;
- case SG_GET_PACK_ID:
- read_lock_irqsave(&sfp->rq_list_lock, iflags);
- list_for_each_entry(srp, &sfp->rq_list, entry) {
- if ((1 == srp->done) && (!srp->sg_io_owned)) {
- read_unlock_irqrestore(&sfp->rq_list_lock,
- iflags);
- put_user(srp->header.pack_id, ip);
- return 0;
+ case SG_GET_PACK_ID: /* or tag of oldest "read"-able, -1 if none */
+ rcu_read_lock();
+ val = -1;
+ list_for_each_entry_rcu(srp, &sfp->rq_list, rq_entry) {
+ if (SG_RS_AWAIT_READ(srp) &&
+ !test_bit(SG_FRQ_SYNC_INVOC, srp->frq_bm)) {
+ val = srp->pack_id;
+ break;
}
}
- read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
- put_user(-1, ip);
- return 0;
+ rcu_read_unlock();
+ SG_LOG(3, sfp, "%s: SG_GET_PACK_ID=%d\n", __func__, val);
+ return put_user(val, ip);
case SG_GET_NUM_WAITING:
return put_user(atomic_read(&sfp->waiting), ip);
case SG_GET_SG_TABLESIZE:
+ SG_LOG(3, sfp, "%s: SG_GET_SG_TABLESIZE=%d\n", __func__,
+ sdp->max_sgat_elems);
return put_user(sdp->max_sgat_elems, ip);
case SG_SET_RESERVED_SIZE:
- result = get_user(val, ip);
- if (result)
- return result;
- if (val < 0)
- return -EINVAL;
- val = min_t(int, val,
- max_sectors_bytes(sdp->device->request_queue));
mutex_lock(&sfp->f_mutex);
- if (val != sfp->reserve.bufflen) {
- if (sfp->mmap_called ||
- sfp->res_in_use) {
- mutex_unlock(&sfp->f_mutex);
- return -EBUSY;
+ result = get_user(val, ip);
+ if (!result) {
+ if (val >= 0 && val <= (1024 * 1024 * 1024)) {
+ result = sg_set_reserved_sz(sfp, val);
+ } else {
+ SG_LOG(3, sfp, "%s: invalid size\n", __func__);
+ result = -EINVAL;
}
-
- sg_remove_scat(sfp, &sfp->reserve);
- sg_build_reserve(sfp, val);
}
mutex_unlock(&sfp->f_mutex);
- return 0;
+ return result;
case SG_GET_RESERVED_SIZE:
- val = min_t(int, sfp->reserve.bufflen,
- max_sectors_bytes(sdp->device->request_queue));
- return put_user(val, ip);
+ mutex_lock(&sfp->f_mutex);
+ val = min_t(int, sfp->rsv_srp->sgat_h.buflen,
+ sdp->max_sgat_sz);
+ SG_LOG(3, sfp, "%s: SG_GET_RESERVED_SIZE=%d\n",
+ __func__, val);
+ result = put_user(val, ip);
+ mutex_unlock(&sfp->f_mutex);
+ return result;
case SG_SET_COMMAND_Q:
+ SG_LOG(3, sfp, "%s: SG_SET_COMMAND_Q\n", __func__);
result = get_user(val, ip);
if (result)
return result;
- sfp->cmd_q = val ? 1 : 0;
+ assign_bit(SG_FFD_CMD_Q, sfp->ffd_bm, !!val);
return 0;
case SG_GET_COMMAND_Q:
- return put_user((int) sfp->cmd_q, ip);
+ SG_LOG(3, sfp, "%s: SG_GET_COMMAND_Q\n", __func__);
+ return put_user(test_bit(SG_FFD_CMD_Q, sfp->ffd_bm), ip);
case SG_SET_KEEP_ORPHAN:
+ SG_LOG(3, sfp, "%s: SG_SET_KEEP_ORPHAN\n", __func__);
result = get_user(val, ip);
if (result)
return result;
- sfp->keep_orphan = val;
+ assign_bit(SG_FFD_KEEP_ORPHAN, sfp->ffd_bm, !!val);
return 0;
case SG_GET_KEEP_ORPHAN:
- return put_user((int) sfp->keep_orphan, ip);
- case SG_NEXT_CMD_LEN:
+ SG_LOG(3, sfp, "%s: SG_GET_KEEP_ORPHAN\n", __func__);
+ return put_user(test_bit(SG_FFD_KEEP_ORPHAN, sfp->ffd_bm),
+ ip);
+ case SG_GET_VERSION_NUM:
+ SG_LOG(3, sfp, "%s: SG_GET_VERSION_NUM\n", __func__);
+ return put_user(sg_version_num, ip);
+ case SG_GET_REQUEST_TABLE:
+ return sg_ctl_req_tbl(sfp, p);
+ case SG_SCSI_RESET:
+ SG_LOG(3, sfp, "%s: SG_SCSI_RESET\n", __func__);
+ check_detach = true;
+ break;
+ case SG_SET_TIMEOUT:
+ SG_LOG(3, sfp, "%s: SG_SET_TIMEOUT\n", __func__);
+ result = get_user(val, ip);
+ if (result)
+ return result;
+ if (val < 0)
+ return -EIO;
+ if (val >= mult_frac((s64)INT_MAX, USER_HZ, HZ))
+ val = min_t(s64, mult_frac((s64)INT_MAX, USER_HZ, HZ),
+ INT_MAX);
+ sfp->timeout_user = val;
+ sfp->timeout = mult_frac(val, HZ, USER_HZ);
+ return 0;
+ case SG_GET_TIMEOUT: /* N.B. User receives timeout as return value */
+ /* strange ..., for backward compatibility */
+ SG_LOG(3, sfp, "%s: SG_GET_TIMEOUT\n", __func__);
+ return sfp->timeout_user;
+ case SG_SET_FORCE_LOW_DMA:
+ /*
+ * N.B. This ioctl never worked properly, but failed to
+ * return an error value. So returning '0' to keep
+ * compatibility with legacy applications.
+ */
+ SG_LOG(3, sfp, "%s: SG_SET_FORCE_LOW_DMA\n", __func__);
+ return 0;
+ case SG_GET_LOW_DMA:
+ SG_LOG(3, sfp, "%s: SG_GET_LOW_DMA\n", __func__);
+ return put_user((int)sdev->host->unchecked_isa_dma, ip);
+ case SG_NEXT_CMD_LEN: /* active only in v2 interface */
+ SG_LOG(3, sfp, "%s: SG_NEXT_CMD_LEN\n", __func__);
result = get_user(val, ip);
if (result)
return result;
if (val > SG_MAX_CDB_SIZE)
return -ENOMEM;
- sfp->next_cmd_len = (val > 0) ? val : 0;
+ mutex_lock(&sfp->f_mutex);
+ sfp->next_cmd_len = max_t(int, val, 0);
+ mutex_unlock(&sfp->f_mutex);
return 0;
- case SG_GET_VERSION_NUM:
- return put_user(sg_version_num, ip);
case SG_GET_ACCESS_COUNT:
+ SG_LOG(3, sfp, "%s: SG_GET_ACCESS_COUNT\n", __func__);
/* faked - we don't have a real access count anymore */
- val = (sdp->device ? 1 : 0);
+ val = (sdev ? 1 : 0);
return put_user(val, ip);
- case SG_GET_REQUEST_TABLE:
- {
- sg_req_info_t *rinfo;
-
- rinfo = kcalloc(SG_MAX_QUEUE, SZ_SG_REQ_INFO,
- GFP_KERNEL);
- if (!rinfo)
- return -ENOMEM;
- read_lock_irqsave(&sfp->rq_list_lock, iflags);
- sg_fill_request_table(sfp, rinfo);
- read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
- result = copy_to_user(p, rinfo,
- SZ_SG_REQ_INFO * SG_MAX_QUEUE);
- result = result ? -EFAULT : 0;
- kfree(rinfo);
- return result;
- }
case SG_EMULATED_HOST:
- if (SG_IS_DETACHING(sdp))
+ SG_LOG(3, sfp, "%s: SG_EMULATED_HOST\n", __func__);
+ if (unlikely(SG_IS_DETACHING(sdp)))
return -ENODEV;
- return put_user(sdp->device->host->hostt->emulated, ip);
+ return put_user(sdev->host->hostt->emulated, ip);
case SCSI_IOCTL_SEND_COMMAND:
- if (SG_IS_DETACHING(sdp))
+ SG_LOG(3, sfp, "%s: SCSI_IOCTL_SEND_COMMAND\n", __func__);
+ if (unlikely(SG_IS_DETACHING(sdp)))
return -ENODEV;
- return sg_scsi_ioctl(sdp->device->request_queue, NULL, filp->f_mode, p);
+ return sg_scsi_ioctl(sdev->request_queue, NULL,
+ filp->f_mode, p);
case SG_SET_DEBUG:
+ SG_LOG(3, sfp, "%s: SG_SET_DEBUG\n", __func__);
result = get_user(val, ip);
if (result)
return result;
- assign_bit(SG_FDEV_LOG_SENSE, sdp->fdev_bm, val);
+ assign_bit(SG_FDEV_LOG_SENSE, sdp->fdev_bm, !!val);
return 0;
case BLKSECTGET:
- return put_user(max_sectors_bytes(sdp->device->request_queue),
- ip);
+ SG_LOG(3, sfp, "%s: BLKSECTGET\n", __func__);
+ return put_user(max_sectors_bytes(sdev->request_queue), ip);
case BLKTRACESETUP:
- return blk_trace_setup(sdp->device->request_queue,
+ SG_LOG(3, sfp, "%s: BLKTRACESETUP\n", __func__);
+ return blk_trace_setup(sdev->request_queue,
sdp->disk->disk_name,
MKDEV(SCSI_GENERIC_MAJOR, sdp->index),
NULL, p);
case BLKTRACESTART:
- return blk_trace_startstop(sdp->device->request_queue, 1);
+ SG_LOG(3, sfp, "%s: BLKTRACESTART\n", __func__);
+ return blk_trace_startstop(sdev->request_queue, 1);
case BLKTRACESTOP:
- return blk_trace_startstop(sdp->device->request_queue, 0);
+ SG_LOG(3, sfp, "%s: BLKTRACESTOP\n", __func__);
+ return blk_trace_startstop(sdev->request_queue, 0);
case BLKTRACETEARDOWN:
- return blk_trace_remove(sdp->device->request_queue);
+ SG_LOG(3, sfp, "%s: BLKTRACETEARDOWN\n", __func__);
+ return blk_trace_remove(sdev->request_queue);
case SCSI_IOCTL_GET_IDLUN:
+ SG_LOG(3, sfp, "%s: SCSI_IOCTL_GET_IDLUN %s\n", __func__,
+ pmlp);
+ check_detach = true;
+ break;
case SCSI_IOCTL_GET_BUS_NUMBER:
+ SG_LOG(3, sfp, "%s: SCSI_IOCTL_GET_BUS_NUMBER%s\n",
+ __func__, pmlp);
+ check_detach = true;
+ break;
case SCSI_IOCTL_PROBE_HOST:
+ SG_LOG(3, sfp, "%s: SCSI_IOCTL_PROBE_HOST%s\n", __func__,
+ pmlp);
+ check_detach = true;
+ break;
case SG_GET_TRANSFORM:
- case SG_SCSI_RESET:
- if (SG_IS_DETACHING(sdp))
- return -ENODEV;
+ SG_LOG(3, sfp, "%s: SG_GET_TRANSFORM%s\n", __func__, pmlp);
+ check_detach = true;
+ break;
+ case SG_SET_TRANSFORM:
+ SG_LOG(3, sfp, "%s: SG_SET_TRANSFORM%s\n", __func__, pmlp);
+ check_detach = true;
break;
default:
+ SG_LOG(3, sfp, "%s: unrecognized ioctl [0x%x]%s\n",
+ __func__, cmd_in, pmlp);
if (read_only)
- return -EPERM; /* don't know so take safe approach */
+ return -EPERM; /* don't know, so take safer approach */
break;
}
- result = sg_allow_if_err_recovery(sdp, filp->f_flags & O_NDELAY);
- if (result)
- return result;
- return scsi_ioctl(sdp->device, cmd_in, p);
+ if (check_detach) {
+ if (unlikely(SG_IS_DETACHING(sdp)))
+ return -ENODEV;
+ }
+ /* ioctl that reach here are forwarded to the mid-level */
+ if (likely(scsi_block_when_processing_errors(sdp->device)))
+ return scsi_ioctl(sdev, cmd_in, p);
+ return -ENXIO;
}
#if IS_ENABLED(CONFIG_COMPAT)
@@ -1273,7 +1715,7 @@ sg_poll(struct file *filp, poll_table * wait)
if (unlikely(SG_IS_DETACHING(sfp->parentdp)))
p_res |= EPOLLHUP;
- else if (likely(sfp->cmd_q))
+ else if (likely(test_bit(SG_FFD_CMD_Q, sfp->ffd_bm)))
p_res |= EPOLLOUT | EPOLLWRNORM;
else if (atomic_read(&sfp->submitted) == 0)
p_res |= EPOLLOUT | EPOLLWRNORM;
@@ -1290,14 +1732,17 @@ sg_fasync(int fd, struct file *filp, int mode)
return fasync_helper(fd, filp, mode, &sfp->async_qp);
}
+/* Note: the error return: VM_FAULT_SIGBUS causes a "bus error" */
static vm_fault_t
sg_vma_fault(struct vm_fault *vmf)
{
+ int k, length;
+ unsigned long offset, len, sa, iflags;
struct vm_area_struct *vma = vmf->vma;
- struct sg_fd *sfp;
- unsigned long offset, len, sa;
struct sg_scatter_hold *rsv_schp;
- int k, length;
+ struct sg_request *srp;
+ struct sg_device *sdp;
+ struct sg_fd *sfp;
const char *nbp = "==NULL, bad";
if (!vma) {
@@ -1309,26 +1754,46 @@ sg_vma_fault(struct vm_fault *vmf)
pr_warn("%s: sfp%s\n", __func__, nbp);
goto out_err;
}
- rsv_schp = &sfp->reserve;
+ sdp = sfp->parentdp;
+ if (sdp && unlikely(SG_IS_DETACHING(sdp))) {
+ SG_LOG(1, sfp, "%s: device detaching\n", __func__);
+ goto out_err;
+ }
+ srp = sfp->rsv_srp;
+ if (!srp) {
+ SG_LOG(1, sfp, "%s: srp%s\n", __func__, nbp);
+ goto out_err;
+ }
+ spin_lock_irqsave(&srp->req_lck, iflags);
+ rsv_schp = &srp->sgat_h;
offset = vmf->pgoff << PAGE_SHIFT;
- if (offset >= rsv_schp->bufflen)
- return VM_FAULT_SIGBUS;
+ if (offset >= (unsigned int)rsv_schp->buflen) {
+ SG_LOG(1, sfp, "%s: offset[%lu] >= rsv.buflen\n", __func__,
+ offset);
+ goto out_err_unlock;
+ }
sa = vma->vm_start;
SG_LOG(3, sfp, "%s: vm_start=0x%lx, off=%lu\n", __func__, sa, offset);
length = 1 << (PAGE_SHIFT + rsv_schp->page_order);
- for (k = 0; k < rsv_schp->k_use_sg && sa < vma->vm_end; k++) {
+ for (k = 0; k < rsv_schp->num_sgat && sa < vma->vm_end; ++k) {
len = vma->vm_end - sa;
- len = (len < length) ? len : length;
+ len = min_t(int, len, (int)length);
if (offset < len) {
- struct page *page = nth_page(rsv_schp->pages[k],
- offset >> PAGE_SHIFT);
- get_page(page); /* increment page count */
+ struct page *page;
+ struct page *pp;
+
+ pp = rsv_schp->pages[k];
+ spin_unlock_irqrestore(&srp->req_lck, iflags);
+ page = nth_page(pp, offset >> PAGE_SHIFT);
+ get_page(page); /* increment page count */
vmf->page = page;
return 0; /* success */
}
sa += len;
offset -= len;
}
+out_err_unlock:
+ spin_unlock_irqrestore(&srp->req_lck, iflags);
out_err:
return VM_FAULT_SIGBUS;
}
@@ -1337,14 +1802,16 @@ static const struct vm_operations_struct sg_mmap_vm_ops = {
.fault = sg_vma_fault,
};
+/* Entry point for mmap(2) system call */
static int
sg_mmap(struct file *filp, struct vm_area_struct *vma)
{
- struct sg_fd *sfp;
- unsigned long req_sz, len, sa;
- struct sg_scatter_hold *rsv_schp;
int k, length;
int ret = 0;
+ unsigned long req_sz, len, sa, iflags;
+ struct sg_scatter_hold *rsv_schp;
+ struct sg_fd *sfp;
+ struct sg_request *srp;
if (!filp || !vma)
return -ENXIO;
@@ -1357,143 +1824,198 @@ sg_mmap(struct file *filp, struct vm_area_struct *vma)
SG_LOG(3, sfp, "%s: vm_start=%p, len=%d\n", __func__,
(void *)vma->vm_start, (int)req_sz);
if (vma->vm_pgoff)
- return -EINVAL; /* want no offset */
- rsv_schp = &sfp->reserve;
+ return -EINVAL; /* only an offset of 0 accepted */
+ /* Check reserve request is inactive and has large enough buffer */
mutex_lock(&sfp->f_mutex);
- if (req_sz > rsv_schp->bufflen) {
- ret = -ENOMEM; /* cannot map more than reserved buffer */
+ srp = sfp->rsv_srp;
+ spin_lock_irqsave(&srp->req_lck, iflags);
+ if (SG_RS_ACTIVE(srp)) {
+ ret = -EBUSY;
+ goto out;
+ }
+ rsv_schp = &srp->sgat_h;
+ if (req_sz > (unsigned long)rsv_schp->buflen) {
+ ret = -ENOMEM;
goto out;
}
-
sa = vma->vm_start;
length = 1 << (PAGE_SHIFT + rsv_schp->page_order);
- for (k = 0; k < rsv_schp->k_use_sg && sa < vma->vm_end; k++) {
+ for (k = 0; k < rsv_schp->num_sgat && sa < vma->vm_end; ++k) {
len = vma->vm_end - sa;
- len = (len < length) ? len : length;
+ len = min_t(unsigned long, len, (unsigned long)length);
sa += len;
}
- sfp->mmap_called = 1;
+ set_bit(SG_FFD_MMAP_CALLED, sfp->ffd_bm);
vma->vm_flags |= VM_IO | VM_DONTEXPAND | VM_DONTDUMP;
vma->vm_private_data = sfp;
vma->vm_ops = &sg_mmap_vm_ops;
out:
+ spin_unlock_irqrestore(&srp->req_lck, iflags);
mutex_unlock(&sfp->f_mutex);
return ret;
}
+/*
+ * This user context function is called from sg_rq_end_io() in 2 situations.
+ * The first case is when a slave was in SWAIT state and sg_rq_end_io() has
+ * just been called on the corresponding master request.
+ * The second case is an orphaned request that needs to be cleaned up (e.g.
+ * when control C is typed while an ioctl(SG_IO) is active).
+ */
static void
sg_rq_end_io_usercontext(struct work_struct *work)
{
- struct sg_request *srp = container_of(work, struct sg_request, ew.work);
- struct sg_fd *sfp = srp->parentfp;
+ struct sg_request *srp = container_of(work, struct sg_request,
+ ew_orph.work);
+ struct sg_fd *sfp;
+
+ if (!srp) {
+ WARN_ONCE("%s: srp unexpectedly NULL\n", __func__);
+ return;
+ }
+ sfp = srp->parentfp;
+ if (!sfp) {
+ WARN_ONCE(1, "%s: sfp unexpectedly NULL\n", __func__);
+ return;
+ }
+ SG_LOG(3, sfp, "%s: srp=0x%p\n", __func__, srp);
+ if (test_bit(SG_FRQ_DEACT_ORPHAN, srp->frq_bm)) {
+ sg_finish_scsi_blk_rq(srp); /* clean up orphan case */
+ sg_deact_request(sfp, srp);
+ }
+ kref_put(&sfp->f_ref, sg_remove_sfp);
+}
+
+static void
+sg_check_sense(struct sg_device *sdp, struct sg_request *srp, int sense_len)
+{
+ int driver_stat;
+ u32 rq_res = srp->rq_result;
+ struct scsi_request *scsi_rp = scsi_req(srp->rq);
+ u8 *sbp = scsi_rp ? scsi_rp->sense : NULL;
+
+ if (!sbp)
+ return;
+ driver_stat = driver_byte(rq_res);
+ if (driver_stat & DRIVER_SENSE) {
+ struct scsi_sense_hdr ssh;
+
+ if (scsi_normalize_sense(sbp, sense_len, &ssh)) {
+ if (!scsi_sense_is_deferred(&ssh)) {
+ if (ssh.sense_key == UNIT_ATTENTION) {
+ if (sdp->device->removable)
+ sdp->device->changed = 1;
+ }
+ }
+ }
+ }
+ if (test_bit(SG_FDEV_LOG_SENSE, sdp->fdev_bm) > 0) {
+ int scsi_stat = rq_res & 0xff;
- sg_finish_scsi_blk_rq(srp);
- sg_remove_request(sfp, srp);
- kref_put(&sfp->f_ref, sg_remove_sfp);
+ if (scsi_stat == SAM_STAT_CHECK_CONDITION ||
+ scsi_stat == SAM_STAT_COMMAND_TERMINATED)
+ __scsi_print_sense(sdp->device, __func__, sbp,
+ sense_len);
+ }
}
/*
- * This function is a "bottom half" handler that is called by the mid
- * level when a command is completed (or has failed).
+ * This "bottom half" (soft interrupt) handler is called by the mid-level
+ * when a request has completed or failed. This callback is registered in a
+ * blk_execute_rq_nowait() call in the sg_common_write(). For ioctl(SG_IO)
+ * (sync) usage, sg_ctl_sg_io() waits to be woken up by this callback.
*/
static void
sg_rq_end_io(struct request *rq, blk_status_t status)
{
+ enum sg_rq_state rqq_state = SG_RS_AWAIT_RD;
+ int a_resid, slen;
struct sg_request *srp = rq->end_io_data;
- struct scsi_request *req = scsi_req(rq);
+ struct scsi_request *scsi_rp = scsi_req(rq);
struct sg_device *sdp;
struct sg_fd *sfp;
- unsigned long iflags;
- unsigned int ms;
- char *sense;
- int result, resid, done = 1;
- if (WARN_ON(srp->done != 0))
+ if (!scsi_rp) {
+ WARN_ONCE("%s: scsi_req(rq) unexpectedly NULL\n", __func__);
return;
-
- sfp = srp->parentfp;
- if (WARN_ON(sfp == NULL))
+ }
+ if (!srp) {
+ WARN_ONCE("%s: srp unexpectedly NULL\n", __func__);
return;
-
+ }
+ /* Expect 0 --> 1 transition, otherwise processed elsewhere */
+ if (unlikely(test_and_set_bit(SG_FRQ_BLK_PUT_REQ, srp->frq_bm))) {
+ pr_info("%s: srp=%p already completed\n", __func__, srp);
+ return;
+ }
+ if (WARN_ON(atomic_read(&srp->rq_st) != SG_RS_INFLIGHT)) {
+ pr_warn("%s: bad rq_st=%d\n", __func__,
+ atomic_read(&srp->rq_st));
+ goto early_err;
+ }
+ sfp = srp->parentfp;
+ if (unlikely(!sfp)) {
+ WARN_ONCE(1, "%s: sfp unexpectedly NULL", __func__);
+ goto early_err;
+ }
sdp = sfp->parentdp;
if (unlikely(SG_IS_DETACHING(sdp)))
pr_info("%s: device detaching\n", __func__);
- sense = req->sense;
- result = req->result;
- resid = req->resid_len;
-
- srp->header.resid = resid;
- SG_LOG(6, sfp, "%s: pack_id=%d, res=0x%x\n", __func__,
- srp->header.pack_id, result);
- ms = jiffies_to_msecs(jiffies);
- srp->header.duration = (ms > srp->header.duration) ?
- (ms - srp->header.duration) : 0;
- if (0 != result) {
- struct scsi_sense_hdr sshdr;
-
- srp->header.status = 0xff & result;
- srp->header.masked_status = status_byte(result);
- srp->header.msg_status = msg_byte(result);
- srp->header.host_status = host_byte(result);
- srp->header.driver_status = driver_byte(result);
- if (test_bit(SG_FDEV_LOG_SENSE, sdp->fdev_bm) &&
- (srp->header.masked_status == CHECK_CONDITION ||
- srp->header.masked_status == COMMAND_TERMINATED))
- __scsi_print_sense(sdp->device, __func__, sense,
- SCSI_SENSE_BUFFERSIZE);
-
- /* Following if statement is a patch supplied by Eric Youngdale */
- if (driver_byte(result) != 0
- && scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr)
- && !scsi_sense_is_deferred(&sshdr)
- && sshdr.sense_key == UNIT_ATTENTION
- && sdp->device->removable) {
- /* Detected possible disc change. Set the bit - this */
- /* may be used if there are filesystems using this device */
- sdp->device->changed = 1;
+ srp->rq_result = scsi_rp->result;
+ slen = min_t(int, scsi_rp->sense_len, SCSI_SENSE_BUFFERSIZE);
+ a_resid = scsi_rp->resid_len;
+
+ if (a_resid)
+ srp->in_resid = a_resid;
+
+ SG_LOG(6, sfp, "%s: pack_id=%d, res=0x%x\n", __func__, srp->pack_id,
+ srp->rq_result);
+ srp->duration = sg_calc_rq_dur(srp);
+ if (unlikely((srp->rq_result & SG_ML_RESULT_MSK) && slen > 0))
+ sg_check_sense(sdp, srp, slen);
+ if (slen > 0)
+ memcpy(srp->sense_b, scsi_rp->sense, slen);
+ srp->sense_len = slen;
+ if (unlikely(test_bit(SG_FRQ_IS_ORPHAN, srp->frq_bm))) {
+ spin_lock(&srp->req_lck);
+ if (test_bit(SG_FFD_KEEP_ORPHAN, sfp->ffd_bm)) {
+ clear_bit(SG_FRQ_SYNC_INVOC, srp->frq_bm);
+ } else {
+ rqq_state = SG_RS_BUSY;
+ set_bit(SG_FRQ_DEACT_ORPHAN, srp->frq_bm);
}
+ spin_unlock(&srp->req_lck);
}
-
- if (req->sense_len)
- memcpy(srp->sense_b, req->sense, SCSI_SENSE_BUFFERSIZE);
-
- /* Rely on write phase to clean out srp status values, so no "else" */
-
- if (!srp->sg_io_owned)
+ if (!test_bit(SG_FRQ_SYNC_INVOC, srp->frq_bm))
atomic_inc(&sfp->waiting);
+ if (unlikely(sg_rstate_chg(srp, SG_RS_INFLIGHT, rqq_state)))
+ pr_warn("%s: can't set rq_st\n", __func__);
/*
- * Free the request as soon as it is complete so that its resources
- * can be reused without waiting for userspace to read() the
- * result. But keep the associated bio (if any) around until
- * blk_rq_unmap_user() can be called from user context.
+ * Free the mid-level resources apart from the bio (if any). The bio's
+ * blk_rq_unmap_user() can be called later from user context.
*/
srp->rq = NULL;
- scsi_req_free_cmd(scsi_req(rq));
+ scsi_req_free_cmd(scsi_rp);
blk_put_request(rq);
- write_lock_irqsave(&sfp->rq_list_lock, iflags);
- if (unlikely(srp->orphan)) {
- if (sfp->keep_orphan)
- srp->sg_io_owned = 0;
- else
- done = 0;
- }
- srp->done = done;
- write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
-
- if (likely(done)) {
- /* Now wake up any sg_read() that is waiting for this
- * packet.
- */
+ if (likely(rqq_state == SG_RS_AWAIT_RD)) {
+ /* Wake any sg_read()/ioctl(SG_IORECEIVE) awaiting this req */
wake_up_interruptible(&sfp->read_wait);
kill_fasync(&sfp->async_qp, SIGPOLL, POLL_IN);
kref_put(&sfp->f_ref, sg_remove_sfp);
- } else {
- INIT_WORK(&srp->ew.work, sg_rq_end_io_usercontext);
- schedule_work(&srp->ew.work);
+ } else { /* clean up orphaned request that aren't being kept */
+ INIT_WORK(&srp->ew_orph.work, sg_rq_end_io_usercontext);
+ schedule_work(&srp->ew_orph.work);
}
+ return;
+
+early_err:
+ srp->rq = NULL;
+ if (scsi_rp)
+ scsi_req_free_cmd(scsi_rp);
+ blk_put_request(rq);
}
static const struct file_operations sg_fops = {
@@ -1514,16 +2036,16 @@ static const struct file_operations sg_fops = {
static struct class *sg_sysfs_class;
-static int sg_sysfs_valid = 0;
+static bool sg_sysfs_valid;
+/* Returns valid pointer to sg_device or negated errno twisted by ERR_PTR */
static struct sg_device *
sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
{
- struct request_queue *q = scsidp->request_queue;
struct sg_device *sdp;
- unsigned long iflags;
int error;
u32 k;
+ unsigned long iflags;
sdp = kzalloc(sizeof(struct sg_device), GFP_KERNEL);
if (!sdp)
@@ -1541,7 +2063,7 @@ sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
error = -ENODEV;
} else {
sdev_printk(KERN_WARNING, scsidp,
- "%s: idr alloc sg_device failure: %d\n",
+ "%s: idr allocation sg_device failure: %d\n",
__func__, error);
}
goto out_unlock;
@@ -1557,9 +2079,8 @@ sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
mutex_init(&sdp->open_rel_lock);
INIT_LIST_HEAD(&sdp->sfds);
init_waitqueue_head(&sdp->open_wait);
- clear_bit(SG_FDEV_DETACHING, sdp->fdev_bm);
rwlock_init(&sdp->sfd_lock);
- sdp->max_sgat_elems = queue_max_segments(q);
+ sg_calc_sgat_param(sdp);
sdp->index = k;
kref_init(&sdp->d_ref);
error = 0;
@@ -1693,7 +2214,7 @@ sg_remove_device(struct device *cl_dev, struct class_interface *cl_intf)
"%s: 0x%p\n", __func__, sdp));
read_lock_irqsave(&sdp->sfd_lock, iflags);
- list_for_each_entry(sfp, &sdp->sfds, sfd_siblings) {
+ list_for_each_entry(sfp, &sdp->sfds, sfd_entry) {
wake_up_interruptible_all(&sfp->read_wait);
kill_fasync(&sfp->async_qp, SIGPOLL, POLL_HUP);
}
@@ -1729,32 +2250,39 @@ init_sg(void)
{
int rc;
- if (scatter_elem_sz < PAGE_SIZE) {
+ /* check scatter_elem_sz module parameter, change if inappropriate */
+ if (scatter_elem_sz < (int)PAGE_SIZE)
scatter_elem_sz = PAGE_SIZE;
- scatter_elem_sz_prev = scatter_elem_sz;
- }
+ else if (scatter_elem_sz != (1 << ilog2(scatter_elem_sz)))
+ scatter_elem_sz = 1 << ilog2(scatter_elem_sz);
+ /* scatter_elem_sz rounded down to power of 2, or PAGE_SIZE */
if (def_reserved_size >= 0)
sg_big_buff = def_reserved_size;
else
def_reserved_size = sg_big_buff;
- rc = register_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0),
+ rc = register_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0),
SG_MAX_DEVS, "sg");
if (rc)
return rc;
- sg_sysfs_class = class_create(THIS_MODULE, "scsi_generic");
- if ( IS_ERR(sg_sysfs_class) ) {
+
+ pr_info("Registered %s[char major=0x%x], version: %s, date: %s\n",
+ "sg device ", SCSI_GENERIC_MAJOR, SG_VERSION_STR,
+ sg_version_date);
+ sg_sysfs_class = class_create(THIS_MODULE, "scsi_generic");
+ if (IS_ERR(sg_sysfs_class)) {
rc = PTR_ERR(sg_sysfs_class);
- goto err_out;
- }
- sg_sysfs_valid = 1;
+ goto err_out_unreg;
+ }
+ sg_sysfs_valid = true;
rc = scsi_register_interface(&sg_interface);
if (0 == rc) {
sg_proc_init();
return 0;
}
class_destroy(sg_sysfs_class);
-err_out:
+
+err_out_unreg:
unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0), SG_MAX_DEVS);
return rc;
}
@@ -1780,32 +2308,66 @@ exit_sg(void)
idr_destroy(&sg_index_idr);
}
+static inline bool
+sg_chk_dio_allowed(struct sg_device *sdp, struct sg_request *srp,
+ int iov_count, int dir)
+{
+ if (sg_allow_dio && (srp->rq_flags & SG_FLAG_DIRECT_IO)) {
+ if (dir != SG_DXFER_UNKNOWN && !iov_count) {
+ if (!sdp->device->host->unchecked_isa_dma)
+ return true;
+ }
+ }
+ return false;
+}
+
+static void
+sg_set_map_data(const struct sg_scatter_hold *schp, bool up_valid,
+ struct rq_map_data *mdp)
+{
+ memset(mdp, 0, sizeof(*mdp));
+ mdp->pages = schp->pages;
+ mdp->page_order = schp->page_order;
+ mdp->nr_entries = schp->num_sgat;
+ mdp->offset = 0;
+ mdp->null_mapped = !up_valid;
+}
+
static int
-sg_start_req(struct sg_request *srp, u8 *cmd)
+sg_start_req(struct sg_request *srp, u8 *cmd, int cmd_len, int dxfer_dir)
{
- int res;
+ bool reserved, us_xfer;
+ int res = 0;
+ int dxfer_len = 0;
+ int r0w = READ;
+ unsigned int iov_count = 0;
+ void __user *up;
struct request *rq;
- struct scsi_request *req;
+ struct scsi_request *scsi_rp;
struct sg_fd *sfp = srp->parentfp;
- sg_io_hdr_t *hp = &srp->header;
- int dxfer_len = (int) hp->dxfer_len;
- int dxfer_dir = hp->dxfer_direction;
- unsigned int iov_count = hp->iovec_count;
- struct sg_scatter_hold *req_schp = &srp->data;
- struct sg_scatter_hold *rsv_schp = &sfp->reserve;
- struct request_queue *q = sfp->parentdp->device->request_queue;
- struct rq_map_data *md, map_data;
- int r0w = hp->dxfer_direction == SG_DXFER_TO_DEV ? WRITE : READ;
+ struct sg_device *sdp;
+ struct sg_scatter_hold *req_schp;
+ struct request_queue *q;
+ struct rq_map_data *md = (void *)srp; /* want any non-NULL value */
u8 *long_cmdp = NULL;
+ __maybe_unused const char *cp = "";
+ struct sg_slice_hdr3 *sh3p = &srp->s_hdr3;
+ struct rq_map_data map_data;
- if (hp->cmd_len > BLK_MAX_CDB) {
- long_cmdp = kzalloc(hp->cmd_len, GFP_KERNEL);
+ sdp = sfp->parentdp;
+ if (cmd_len > BLK_MAX_CDB) { /* for longer SCSI cdb_s */
+ long_cmdp = kzalloc(cmd_len, GFP_KERNEL);
if (!long_cmdp)
return -ENOMEM;
SG_LOG(5, sfp, "%s: long_cmdp=0x%p ++\n", __func__, long_cmdp);
}
+ up = sh3p->dxferp;
+ dxfer_len = (int)sh3p->dxfer_len;
+ iov_count = sh3p->iovec_count;
+ r0w = dxfer_dir == SG_DXFER_TO_DEV ? WRITE : READ;
SG_LOG(4, sfp, "%s: dxfer_len=%d, data-%s\n", __func__, dxfer_len,
(r0w ? "OUT" : "IN"));
+ q = sdp->device->request_queue;
/*
* NOTE
@@ -1818,235 +2380,245 @@ sg_start_req(struct sg_request *srp, u8 *cmd)
* do not want to use BLK_MQ_REQ_NOWAIT here because userspace might
* not expect an EWOULDBLOCK from this condition.
*/
- rq = blk_get_request(q, hp->dxfer_direction == SG_DXFER_TO_DEV ?
- REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
- if (IS_ERR(rq)) {
+ rq = blk_get_request(q, (r0w ? REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN), 0);
+ if (unlikely(IS_ERR(rq))) {
kfree(long_cmdp);
return PTR_ERR(rq);
}
- req = scsi_req(rq);
-
- if (hp->cmd_len > BLK_MAX_CDB)
- req->cmd = long_cmdp;
- memcpy(req->cmd, cmd, hp->cmd_len);
- req->cmd_len = hp->cmd_len;
-
+ /* current sg_request protected by SG_RS_BUSY state */
+ scsi_rp = scsi_req(rq);
srp->rq = rq;
- rq->end_io_data = srp;
- req->retries = SG_DEFAULT_RETRIES;
- if ((dxfer_len <= 0) || (dxfer_dir == SG_DXFER_NONE))
- return 0;
-
- if (sg_allow_dio && hp->flags & SG_FLAG_DIRECT_IO &&
- dxfer_dir != SG_DXFER_UNKNOWN && !iov_count &&
- !sfp->parentdp->device->host->unchecked_isa_dma &&
- blk_rq_aligned(q, (unsigned long)hp->dxferp, dxfer_len))
+ if (cmd_len > BLK_MAX_CDB)
+ scsi_rp->cmd = long_cmdp;
+ memcpy(scsi_rp->cmd, cmd, cmd_len);
+ scsi_rp->cmd_len = cmd_len;
+ us_xfer = !(srp->rq_flags & SG_FLAG_NO_DXFER);
+ assign_bit(SG_FRQ_NO_US_XFER, srp->frq_bm, !us_xfer);
+ reserved = (sfp->rsv_srp == srp);
+ rq->end_io_data = srp;
+ scsi_rp->retries = SG_DEFAULT_RETRIES;
+ req_schp = &srp->sgat_h;
+
+ if (dxfer_len <= 0 || dxfer_dir == SG_DXFER_NONE) {
+ SG_LOG(4, sfp, "%s: no data xfer [0x%p]\n", __func__, srp);
+ set_bit(SG_FRQ_NO_US_XFER, srp->frq_bm);
+ goto fini; /* path of reqs with no din nor dout */
+ } else if (sg_chk_dio_allowed(sdp, srp, iov_count, dxfer_dir) &&
+ blk_rq_aligned(q, (unsigned long)up, dxfer_len)) {
+ set_bit(SG_FRQ_DIO_IN_USE, srp->frq_bm);
+ srp->rq_info |= SG_INFO_DIRECT_IO;
md = NULL;
- else
+ if (IS_ENABLED(CONFIG_SCSI_PROC_FS))
+ cp = "direct_io, ";
+ } else { /* normal IO and failed conditions for dio path */
md = &map_data;
+ }
- if (md) {
- mutex_lock(&sfp->f_mutex);
- if (dxfer_len <= rsv_schp->bufflen &&
- !sfp->res_in_use) {
- sfp->res_in_use = 1;
- sg_link_reserve(sfp, srp, dxfer_len);
- } else if (hp->flags & SG_FLAG_MMAP_IO) {
- res = -EBUSY; /* sfp->res_in_use == 1 */
- if (dxfer_len > rsv_schp->bufflen)
- res = -ENOMEM;
- mutex_unlock(&sfp->f_mutex);
- return res;
- } else {
- res = sg_build_indirect(req_schp, sfp, dxfer_len);
- if (res) {
- mutex_unlock(&sfp->f_mutex);
- return res;
- }
+ if (likely(md)) { /* normal, "indirect" IO */
+ if (unlikely((srp->rq_flags & SG_FLAG_MMAP_IO))) {
+ /* mmap IO must use and fit in reserve request */
+ if (!reserved || dxfer_len > req_schp->buflen)
+ res = reserved ? -ENOMEM : -EBUSY;
+ } else if (req_schp->buflen == 0) {
+ int up_sz = max_t(int, dxfer_len, sfp->sgat_elem_sz);
+
+ res = sg_mk_sgat(srp, sfp, up_sz);
}
- mutex_unlock(&sfp->f_mutex);
+ if (res)
+ goto fini;
- md->pages = req_schp->pages;
- md->page_order = req_schp->page_order;
- md->nr_entries = req_schp->k_use_sg;
- md->offset = 0;
- md->null_mapped = hp->dxferp ? 0 : 1;
- if (dxfer_dir == SG_DXFER_TO_FROM_DEV)
- md->from_user = 1;
- else
- md->from_user = 0;
+ sg_set_map_data(req_schp, !!up, md);
+ md->from_user = (dxfer_dir == SG_DXFER_TO_FROM_DEV);
}
- if (iov_count) {
+ if (unlikely(iov_count)) {
struct iovec *iov = NULL;
struct iov_iter i;
- res = import_iovec(r0w, hp->dxferp, iov_count, 0, &iov, &i);
+ res = import_iovec(r0w, up, iov_count, 0, &iov, &i);
if (res < 0)
- return res;
+ goto fini;
- iov_iter_truncate(&i, hp->dxfer_len);
+ iov_iter_truncate(&i, dxfer_len);
if (!iov_iter_count(&i)) {
kfree(iov);
- return -EINVAL;
+ res = -EINVAL;
+ goto fini;
}
- res = blk_rq_map_user_iov(q, rq, md, &i, GFP_ATOMIC);
+ if (us_xfer)
+ res = blk_rq_map_user_iov(q, rq, md, &i, GFP_ATOMIC);
kfree(iov);
- } else
- res = blk_rq_map_user(q, rq, md, hp->dxferp,
- hp->dxfer_len, GFP_ATOMIC);
-
- if (!res) {
- srp->bio = rq->bio;
-
- if (!md) {
- req_schp->dio_in_use = 1;
- hp->info |= SG_INFO_DIRECT_IO;
+ if (IS_ENABLED(CONFIG_SCSI_PROC_FS))
+ cp = "iov_count > 0";
+ } else if (us_xfer) { /* setup for transfer data to/from user space */
+ res = blk_rq_map_user(q, rq, md, up, dxfer_len, GFP_ATOMIC);
+ if (IS_ENABLED(CONFIG_SCSI_PROC_FS) && res)
+ SG_LOG(1, sfp, "%s: blk_rq_map_user() res=%d\n",
+ __func__, res);
+ }
+fini:
+ if (likely(res == 0)) {
+ res = sg_rstate_chg(srp, SG_RS_BUSY, SG_RS_INFLIGHT);
+ if (likely(res == 0))
+ srp->bio = rq->bio;
+ }
+ if (unlikely(res && rq)) { /* failure, free up resources */
+ scsi_req_free_cmd(scsi_rp);
+ if (likely(!test_and_set_bit(SG_FRQ_BLK_PUT_REQ,
+ srp->frq_bm))) {
+ srp->rq = NULL;
+ blk_put_request(rq);
}
}
+ SG_LOG((res ? 1 : 4), sfp, "%s: %s res=%d [0x%p]\n", __func__, cp,
+ res, srp);
return res;
}
-static int
+/*
+ * Clean up mid-level and block layer resources of finished request. Sometimes
+ * blk_rq_unmap_user() returns -4 (-EINTR) and this is why: "If we're in a
+ * workqueue, the request is orphaned, so don't copy into a random user
+ * address space, just free and return -EINTR so user space doesn't expect
+ * any data." [block/bio.c]
+ */
+static void
sg_finish_scsi_blk_rq(struct sg_request *srp)
{
- int ret = 0;
-
+ int ret;
struct sg_fd *sfp = srp->parentfp;
- struct sg_scatter_hold *req_schp = &srp->data;
SG_LOG(4, sfp, "%s: srp=0x%p%s\n", __func__, srp,
- (srp->res_used) ? " rsv" : "");
- if (!srp->sg_io_owned) {
+ (srp->parentfp->rsv_srp == srp) ? " rsv" : "");
+ if (!test_bit(SG_FRQ_SYNC_INVOC, srp->frq_bm)) {
atomic_dec(&sfp->submitted);
atomic_dec(&sfp->waiting);
}
- if (srp->bio)
- ret = blk_rq_unmap_user(srp->bio);
+ if (srp->bio) {
+ bool us_xfer = !test_bit(SG_FRQ_NO_US_XFER, srp->frq_bm);
- if (srp->rq) {
- scsi_req_free_cmd(scsi_req(srp->rq));
- blk_put_request(srp->rq);
+ if (us_xfer) {
+ ret = blk_rq_unmap_user(srp->bio);
+ if (ret) { /* -EINTR (-4) can be ignored */
+ SG_LOG(6, sfp,
+ "%s: blk_rq_unmap_user() --> %d\n",
+ __func__, ret);
+ }
+ }
+ srp->bio = NULL;
}
+ /* In worst case READ data returned to user space by this point */
- if (srp->res_used)
- sg_unlink_reserve(sfp, srp);
- else
- sg_remove_scat(sfp, req_schp);
-
- return ret;
-}
-
-static int
-sg_build_sgat(struct sg_scatter_hold *schp, const struct sg_fd *sfp,
- int tablesize)
-{
- int sg_bufflen = tablesize * sizeof(struct page *);
- gfp_t gfp_flags = GFP_ATOMIC | __GFP_NOWARN;
+ /* Expect blk_put_request(rq) already called in sg_rq_end_io() */
+ if (unlikely(!test_and_set_bit(SG_FRQ_BLK_PUT_REQ, srp->frq_bm))) {
+ struct request *rq = srp->rq;
- schp->pages = kzalloc(sg_bufflen, gfp_flags);
- if (!schp->pages)
- return -ENOMEM;
- schp->sglist_len = sg_bufflen;
- return tablesize; /* number of scat_gath elements allocated */
+ if (rq) { /* blk_get_request() may have failed */
+ if (scsi_req(rq))
+ scsi_req_free_cmd(scsi_req(rq));
+ srp->rq = NULL;
+ blk_put_request(rq);
+ }
+ }
}
static int
-sg_build_indirect(struct sg_scatter_hold *schp, struct sg_fd *sfp,
- int buff_size)
+sg_mk_sgat(struct sg_request *srp, struct sg_fd *sfp, int minlen)
{
- int ret_sz = 0, i, k, rem_sz, num, mx_sc_elems;
- int max_sgat_elems = sfp->parentdp->max_sgat_elems;
- int blk_size = buff_size, order;
- gfp_t gfp_mask = GFP_ATOMIC | __GFP_COMP | __GFP_NOWARN | __GFP_ZERO;
+ int j, k, rem_sz, order, align_sz;
+ int m_size = minlen;
+ int rup_sz = 0;
+ int mx_sgat_elems = sfp->parentdp->max_sgat_elems;
+ u32 elem_sz;
+ const size_t struct_page_sz = sizeof(struct page *);
+ gfp_t mask_ap = GFP_ATOMIC | __GFP_COMP | __GFP_NOWARN | __GFP_ZERO;
+ gfp_t mask_kz = GFP_ATOMIC | __GFP_NOWARN;
struct sg_device *sdp = sfp->parentdp;
+ struct sg_scatter_hold *schp = &srp->sgat_h;
- if (blk_size < 0)
+ if (unlikely(m_size < 0))
return -EFAULT;
- if (0 == blk_size)
- ++blk_size; /* don't know why */
- /* round request up to next highest SG_SECTOR_SZ byte boundary */
- blk_size = ALIGN(blk_size, SG_SECTOR_SZ);
- SG_LOG(4, sfp, "%s: buff_size=%d, blk_size=%d\n", __func__, buff_size,
- blk_size);
-
- /* N.B. ret_sz carried into this block ... */
- mx_sc_elems = sg_build_sgat(schp, sfp, max_sgat_elems);
- if (mx_sc_elems < 0)
- return mx_sc_elems; /* most likely -ENOMEM */
-
- num = scatter_elem_sz;
- if (unlikely(num != scatter_elem_sz_prev)) {
- if (num < PAGE_SIZE) {
- scatter_elem_sz = PAGE_SIZE;
- scatter_elem_sz_prev = PAGE_SIZE;
- } else
- scatter_elem_sz_prev = num;
- }
-
- if (sdp->device->host->unchecked_isa_dma)
- gfp_mask |= GFP_DMA;
-
- order = get_order(num);
-retry:
- ret_sz = 1 << (PAGE_SHIFT + order);
-
- for (k = 0, rem_sz = blk_size; rem_sz > 0 && k < mx_sc_elems;
- k++, rem_sz -= ret_sz) {
-
- num = (rem_sz > scatter_elem_sz_prev) ?
- scatter_elem_sz_prev : rem_sz;
+ if (unlikely(m_size == 0))
+ ++m_size; /* don't remember why */
+ /* round request up to next highest SG_DEF_SECTOR_SZ byte boundary */
+ align_sz = ALIGN(m_size, SG_DEF_SECTOR_SZ);
+
+ schp->pages = kcalloc(mx_sgat_elems, struct_page_sz, mask_kz);
+ SG_LOG(4, sfp, "%s: minlen=%d, align_sz=%d [sz=%zu, 0x%p ++]\n",
+ __func__, minlen, align_sz, mx_sgat_elems * struct_page_sz,
+ schp->pages);
+ if (unlikely(!schp->pages))
+ return -ENOMEM;
- schp->pages[k] = alloc_pages(gfp_mask, order);
+ elem_sz = sfp->sgat_elem_sz; /* power of 2 and >= PAGE_SIZE */
+ if (sdp && unlikely(sdp->device->host->unchecked_isa_dma))
+ mask_ap |= GFP_DMA;
+ /* PAGE_SIZE == (1 << PAGE_SHIFT) == (2 ** PAGE_SHIFT) */
+ order = get_order(elem_sz); /* --> ilog2(1+((elem_sz-1)/PAGE_SIZE)) */
+again:
+ rup_sz = 1 << (PAGE_SHIFT + order); /* round up size */
+
+ for (k = 0, rem_sz = align_sz; rem_sz > 0 && k < mx_sgat_elems;
+ ++k, rem_sz -= rup_sz) {
+ schp->pages[k] = alloc_pages(mask_ap, order);
if (!schp->pages[k])
- goto out;
-
- if (num == scatter_elem_sz_prev) {
- if (unlikely(ret_sz > scatter_elem_sz_prev)) {
- scatter_elem_sz = ret_sz;
- scatter_elem_sz_prev = ret_sz;
- }
- }
- SG_LOG(5, sfp, "%s: k=%d, num=%d, ret_sz=%d\n", __func__, k,
- num, ret_sz);
- } /* end of for loop */
-
+ goto err_out;
+ SG_LOG(5, sfp, "%s: k=%d, rup_sz=%d [0x%p ++]\n", __func__, k,
+ rup_sz, schp->pages[k]);
+ }
schp->page_order = order;
- schp->k_use_sg = k;
- SG_LOG(5, sfp, "%s: k_use_sg=%d, order=%d\n", __func__, k, order);
- schp->bufflen = blk_size;
- if (rem_sz > 0) /* must have failed */
+ schp->num_sgat = k;
+ SG_LOG(5, sfp, "%s: num_sgat=%d, order=%d\n", __func__, k, order);
+ if (unlikely(rem_sz > 0)) /* must have failed */
return -ENOMEM;
+ schp->buflen = align_sz;
return 0;
-out:
- for (i = 0; i < k; i++)
- __free_pages(schp->pages[i], order);
+err_out:
+ for (j = 0; j < k; ++j)
+ __free_pages(schp->pages[j], order);
if (--order >= 0)
- goto retry;
-
+ goto again;
+ kfree(schp->pages);
return -ENOMEM;
}
static void
-sg_remove_scat(struct sg_fd *sfp, struct sg_scatter_hold *schp)
+sg_remove_sgat_helper(struct sg_fd *sfp, struct sg_scatter_hold *schp)
+{
+ int k;
+ void *p;
+
+ if (!schp->pages)
+ return;
+ for (k = 0; k < schp->num_sgat; ++k) {
+ p = schp->pages[k];
+ SG_LOG(5, sfp, "%s: pg[%d]=0x%p --\n", __func__, k, p);
+ if (unlikely(!p))
+ continue;
+ __free_pages(p, schp->page_order);
+ }
+ SG_LOG(5, sfp, "%s: pg_order=%u, free pgs=0x%p --\n", __func__,
+ schp->page_order, schp->pages);
+ kfree(schp->pages);
+}
+
+/* Remove the data (possibly a sgat list) held by srp, not srp itself */
+static void
+sg_remove_sgat(struct sg_request *srp)
{
- SG_LOG(4, sfp, "%s: num_sgat=%d\n", __func__, schp->k_use_sg);
- if (schp->pages && schp->sglist_len > 0) {
- if (!schp->dio_in_use) {
- int k;
+ struct sg_scatter_hold *schp = &srp->sgat_h; /* care: remove own data */
+ struct sg_fd *sfp = srp->parentfp;
- for (k = 0; k < schp->k_use_sg && schp->pages[k]; k++) {
- SG_LOG(5, sfp, "%s: pg[%d]=0x%p --\n",
- __func__, k, schp->pages[k]);
- __free_pages(schp->pages[k], schp->page_order);
- }
- kfree(schp->pages);
- }
- }
- memset(schp, 0, sizeof (*schp));
+ SG_LOG(4, sfp, "%s: num_sgat=%d%s\n", __func__, schp->num_sgat,
+ ((srp->parentfp ? (sfp->rsv_srp == srp) : false) ?
+ " [rsv]" : ""));
+ if (!test_bit(SG_FRQ_DIO_IN_USE, srp->frq_bm))
+ sg_remove_sgat_helper(sfp, schp);
+
+ memset(schp, 0, sizeof(*schp)); /* zeros buflen and dlen */
}
/*
@@ -2057,239 +2629,504 @@ sg_remove_scat(struct sg_fd *sfp, struct sg_scatter_hold *schp)
static int
sg_rd_append(struct sg_request *srp, void __user *outp, int num_xfer)
{
- struct sg_scatter_hold *schp = &srp->data;
- int k, num;
+ int k, num, res;
+ struct page *pgp;
+ struct sg_scatter_hold *schp = &srp->sgat_h;
SG_LOG(4, srp->parentfp, "%s: num_xfer=%d\n", __func__, num_xfer);
- if (!outp || num_xfer <= 0)
- return 0;
+ if (unlikely(!outp || num_xfer <= 0))
+ return (num_xfer == 0 && outp) ? 0 : -EINVAL;
num = 1 << (PAGE_SHIFT + schp->page_order);
- for (k = 0; k < schp->k_use_sg && schp->pages[k]; k++) {
+ for (k = 0, res = 0; k < schp->num_sgat; ++k) {
+ pgp = schp->pages[k];
+ if (unlikely(!pgp)) {
+ res = -ENXIO;
+ break;
+ }
if (num > num_xfer) {
- if (copy_to_user(outp, page_address(schp->pages[k]),
- num_xfer))
- return -EFAULT;
+ if (__copy_to_user(outp, page_address(pgp), num_xfer))
+ res = -EFAULT;
break;
} else {
- if (copy_to_user(outp, page_address(schp->pages[k]),
- num))
- return -EFAULT;
+ if (__copy_to_user(outp, page_address(pgp), num)) {
+ res = -EFAULT;
+ break;
+ }
num_xfer -= num;
if (num_xfer <= 0)
break;
outp += num;
}
}
- return 0;
+ return res;
}
-static void
-sg_build_reserve(struct sg_fd *sfp, int req_size)
+/*
+ * If there are multiple requests outstanding, the speed of this function is
+ * important. SG_PACK_ID_WILDCARD is -1 and that case is typically
+ * the fast path. This function is only used in the non-blocking cases.
+ * Returns pointer to (first) matching sg_request or NULL. If found,
+ * sg_request state is moved from SG_RS_AWAIT_RD to SG_RS_BUSY.
+ */
+static struct sg_request *
+sg_find_srp_by_id(struct sg_fd *sfp, int pack_id)
{
- struct sg_scatter_hold *schp = &sfp->reserve;
-
- SG_LOG(3, sfp, "%s: buflen=%d\n", __func__, req_size);
- do {
- if (req_size < PAGE_SIZE)
- req_size = PAGE_SIZE;
- if (0 == sg_build_indirect(schp, sfp, req_size))
- return;
- else
- sg_remove_scat(sfp, schp);
- req_size >>= 1; /* divide by 2 */
- } while (req_size > (PAGE_SIZE / 2));
+ __maybe_unused bool is_bad_st = false;
+ __maybe_unused enum sg_rq_state bad_sr_st;
+ bool search_for_1 = (pack_id != SG_PACK_ID_WILDCARD);
+ enum sg_rq_state sr_st;
+ int res;
+ struct sg_request *srp = NULL;
+
+ rcu_read_lock();
+ if (unlikely(search_for_1)) {
+ list_for_each_entry_rcu(srp, &sfp->rq_list, rq_entry) {
+ if (test_bit(SG_FRQ_SYNC_INVOC, srp->frq_bm))
+ continue;
+ if (srp->pack_id != pack_id)
+ continue;
+ sr_st = atomic_read(&srp->rq_st);
+ switch (sr_st) {
+ case SG_RS_AWAIT_RD:
+ res = sg_rstate_chg(srp, sr_st, SG_RS_BUSY);
+ if (likely(res == 0))
+ goto good;
+ /* else another caller got it, move on */
+ if (IS_ENABLED(CONFIG_SCSI_PROC_FS)) {
+ is_bad_st = true;
+ bad_sr_st = atomic_read(&srp->rq_st);
+ }
+ break;
+ case SG_RS_INFLIGHT:
+ break;
+ default:
+ if (IS_ENABLED(CONFIG_SCSI_PROC_FS)) {
+ is_bad_st = true;
+ bad_sr_st = sr_st;
+ }
+ break;
+ }
+ break; /* problem if same id on > 1 requests */
+ }
+ } else { /* search for any request is more likely */
+ list_for_each_entry_rcu(srp, &sfp->rq_list, rq_entry) {
+ if (test_bit(SG_FRQ_SYNC_INVOC, srp->frq_bm))
+ continue;
+ sr_st = atomic_read(&srp->rq_st);
+ if (sr_st == SG_RS_AWAIT_RD) {
+ if (likely(sg_rstate_chg(srp, sr_st,
+ SG_RS_BUSY) == 0))
+ goto good;
+ }
+ }
+ }
+ /* here if one of above loops does _not_ find a match */
+ rcu_read_unlock();
+ if (IS_ENABLED(CONFIG_SCSI_PROC_FS)) {
+ if (search_for_1) {
+ const char *cptp = "pack_id=";
+
+ if (is_bad_st)
+ SG_LOG(1, sfp, "%s: %s%d wrong state: %s\n",
+ __func__, cptp, pack_id,
+ sg_rq_st_str(bad_sr_st, true));
+ else
+ SG_LOG(6, sfp, "%s: %s%d not awaiting read\n",
+ __func__, cptp, pack_id);
+ }
+ }
+ return NULL;
+good:
+ rcu_read_unlock();
+ if (search_for_1) {
+ SG_LOG(6, sfp, "%s: %s%d found [srp=0x%p]\n", __func__,
+ "pack_id=", pack_id, srp);
+ }
+ return srp;
}
-static void
-sg_link_reserve(struct sg_fd *sfp, struct sg_request *srp, int size)
+/*
+ * Makes a new sg_request object. If 'first' is set then use GFP_KERNEL which
+ * may take time but has improved chance of success, otherwise use GFP_ATOMIC.
+ * Note that basic initialization is done but srp is not added to either sfp
+ * list. On error returns twisted negated errno value (not NULL).
+ */
+static struct sg_request *
+sg_mk_srp(struct sg_fd *sfp, bool first)
{
- struct sg_scatter_hold *req_schp = &srp->data;
- struct sg_scatter_hold *rsv_schp = &sfp->reserve;
- int k, num, rem;
-
- srp->res_used = 1;
- SG_LOG(4, sfp, "%s: size=%d\n", __func__, size);
- rem = size;
-
- num = 1 << (PAGE_SHIFT + rsv_schp->page_order);
- for (k = 0; k < rsv_schp->k_use_sg; k++) {
- if (rem <= num) {
- req_schp->k_use_sg = k + 1;
- req_schp->sglist_len = rsv_schp->sglist_len;
- req_schp->pages = rsv_schp->pages;
+ struct sg_request *srp;
+ int gfp = __GFP_NOWARN;
- req_schp->bufflen = size;
- req_schp->page_order = rsv_schp->page_order;
- break;
- } else
- rem -= num;
+ if (first) /* prepared to wait if none already outstanding */
+ srp = kzalloc(sizeof(*srp), gfp | GFP_KERNEL);
+ else
+ srp = kzalloc(sizeof(*srp), gfp | GFP_ATOMIC);
+ if (srp) {
+ spin_lock_init(&srp->req_lck);
+ atomic_set(&srp->rq_st, SG_RS_INACTIVE);
+ srp->parentfp = sfp;
+ return srp;
+ } else {
+ return ERR_PTR(-ENOMEM);
}
+}
- if (k >= rsv_schp->k_use_sg)
- SG_LOG(1, sfp, "%s: BAD size\n", __func__);
+static struct sg_request *
+sg_mk_srp_sgat(struct sg_fd *sfp, bool first, int db_len)
+{
+ int res;
+ struct sg_request *n_srp = sg_mk_srp(sfp, first);
+
+ if (IS_ERR(n_srp))
+ return n_srp;
+ if (db_len > 0) {
+ res = sg_mk_sgat(n_srp, sfp, db_len);
+ if (res) {
+ kfree(n_srp);
+ return ERR_PTR(res);
+ }
+ }
+ return n_srp;
}
-static void
-sg_unlink_reserve(struct sg_fd *sfp, struct sg_request *srp)
+/*
+ * Irrespective of the given reserve request size, the minimum size requested
+ * will be PAGE_SIZE (often 4096 bytes). Returns a pointer to reserve object or
+ * a negated errno value twisted by ERR_PTR() macro. The actual number of bytes
+ * allocated (maybe less than buflen) is in srp->sgat_h.buflen . Note that this
+ * function is only called in contexts where locking is not required.
+ */
+static struct sg_request *
+sg_build_reserve(struct sg_fd *sfp, int buflen)
{
- struct sg_scatter_hold *req_schp = &srp->data;
+ bool go_out = false;
+ int res;
+ struct sg_request *srp;
- SG_LOG(4, srp->parentfp, "%s: req->k_use_sg=%d\n", __func__,
- (int)req_schp->k_use_sg);
- req_schp->k_use_sg = 0;
- req_schp->bufflen = 0;
- req_schp->pages = NULL;
- req_schp->page_order = 0;
- req_schp->sglist_len = 0;
- srp->res_used = 0;
- /* Called without mutex lock to avoid deadlock */
- sfp->res_in_use = 0;
+ SG_LOG(3, sfp, "%s: buflen=%d\n", __func__, buflen);
+ srp = sg_mk_srp(sfp, list_empty(&sfp->rq_fl));
+ if (IS_ERR(srp))
+ return srp;
+ sfp->rsv_srp = srp;
+ do {
+ if (buflen < (int)PAGE_SIZE) {
+ buflen = PAGE_SIZE;
+ go_out = true;
+ }
+ res = sg_mk_sgat(srp, sfp, buflen);
+ if (res == 0) {
+ SG_LOG(4, sfp, "%s: final buflen=%d, srp=0x%p ++\n",
+ __func__, buflen, srp);
+ return srp;
+ }
+ if (go_out)
+ return ERR_PTR(res);
+ /* failed so remove, halve buflen, try again */
+ sg_remove_sgat(srp);
+ buflen >>= 1; /* divide by 2 */
+ } while (true);
}
-/* always adds to end of list */
+/*
+ * Adds an active request (soon to carry a SCSI command) to the current file
+ * descriptor by creating a new one or re-using a request from the free
+ * list (fl). If successful returns a valid pointer in SG_RS_BUSY state. On
+ * failure returns a negated errno value twisted by ERR_PTR() macro.
+ */
static struct sg_request *
-sg_add_request(struct sg_fd *sfp)
+sg_add_request(struct sg_fd *sfp, int dxfr_len, struct sg_comm_wr_t *cwrp)
{
- int k;
+ bool act_empty = false;
+ bool mk_new_srp = true;
unsigned long iflags;
- struct sg_request *rp = sfp->req_arr;
+ enum sg_rq_state sr_st;
+ struct sg_request *r_srp = NULL; /* request to return */
+ struct sg_request *rsv_srp; /* current fd's reserve request */
+ __maybe_unused const char *cp;
+
+ spin_lock_irqsave(&sfp->rq_list_lock, iflags);
+ rsv_srp = sfp->rsv_srp;
+ cp = "";
+ /*
+ * Check the free list (fl) for candidates. Pick zero data length
+ * requests from the back of the fl, the rest from the front.
+ */
+ if (list_empty(&sfp->rq_fl)) {
+ act_empty = true;
+ } else if (dxfr_len < 1) { /* 0 data length requests at back of fl */
+ list_for_each_entry_reverse(r_srp, &sfp->rq_fl, fl_entry) {
+ sr_st = atomic_read(&r_srp->rq_st);
+ if (sr_st == SG_RS_INACTIVE) {
+ if (likely(sg_rstate_chg(r_srp, sr_st,
+ SG_RS_BUSY) == 0)) {
+ cp = "from back of fl";
+ mk_new_srp = false;
+ break;
+ }
+ }
+ }
+ } else { /* find request with large enough dlen */
+ list_for_each_entry(r_srp, &sfp->rq_fl, fl_entry) {
+ sr_st = atomic_read(&r_srp->rq_st);
+ if (sr_st == SG_RS_INACTIVE &&
+ r_srp->sgat_h.buflen >= dxfr_len) {
+ if (likely(sg_rstate_chg(r_srp, sr_st,
+ SG_RS_BUSY) == 0)) {
+ cp = "from front of fl";
+ mk_new_srp = false;
+ break;
+ } /* else other got it, move on */
+ }
+ }
+ }
- write_lock_irqsave(&sfp->rq_list_lock, iflags);
- if (!list_empty(&sfp->rq_list)) {
- if (!sfp->cmd_q)
- goto out_unlock;
+ if (mk_new_srp) { /* Need new sg_request object */
+ bool allow_cmd_q = test_bit(SG_FFD_CMD_Q, sfp->ffd_bm);
- for (k = 0; k < SG_MAX_QUEUE; ++k, ++rp) {
- if (!rp->parentfp)
- break;
+ r_srp = NULL;
+ if (!allow_cmd_q && !list_empty(&sfp->rq_list)) {
+ r_srp = ERR_PTR(-EDOM);
+ SG_LOG(6, sfp, "%s: trying 2nd req but cmd_q=false\n",
+ __func__);
}
- if (k >= SG_MAX_QUEUE)
- goto out_unlock;
- }
- memset(rp, 0, sizeof(struct sg_request));
- rp->parentfp = sfp;
- rp->header.duration = jiffies_to_msecs(jiffies);
- list_add_tail(&rp->entry, &sfp->rq_list);
- write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
- return rp;
-out_unlock:
- write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
- return NULL;
+ spin_unlock_irqrestore(&sfp->rq_list_lock, iflags);
+ if (IS_ERR(r_srp)) /* NULL is not an ERR here */
+ goto err_no_lock;
+ /* releasing rq_list_lock because next line could take time */
+ r_srp = sg_mk_srp_sgat(sfp, act_empty, dxfr_len);
+ if (IS_ERR(r_srp))
+ goto err_no_lock;
+ cp = "new";
+ SG_LOG(4, sfp, "%s: mk_new_srp=0x%p ++\n", __func__, r_srp);
+ atomic_set(&r_srp->rq_st, SG_RS_BUSY);
+ } else { /* otherwise found srp is on fl, remove from fl */
+ list_del_rcu(&r_srp->fl_entry);
+ r_srp->in_resid = 0;
+ r_srp->rq_info = 0;
+ r_srp->sense_len = 0;
+ }
+ if (!mk_new_srp)
+ spin_lock(&r_srp->req_lck);
+ r_srp->frq_bm[0] = cwrp->frq_bm[0]; /* assumes <= 32 req flags */
+ r_srp->sgat_h.dlen = dxfr_len;/* must be <= r_srp->sgat_h.buflen */
+ r_srp->cmd_opcode = 0xff; /* set invalid opcode (VS), 0x0 is TUR */
+ if (mk_new_srp)
+ spin_lock_irqsave(&sfp->rq_list_lock, iflags);
+ list_add_tail_rcu(&r_srp->rq_entry, &sfp->rq_list);
+ if (!mk_new_srp)
+ spin_unlock(&r_srp->req_lck);
+ spin_unlock_irqrestore(&sfp->rq_list_lock, iflags);
+err_no_lock:
+ if (IS_ERR(r_srp))
+ SG_LOG(1, sfp, "%s: err=%ld\n", __func__, PTR_ERR(r_srp));
+ if (!IS_ERR(r_srp))
+ SG_LOG(4, sfp, "%s: %s %sr_srp=0x%p\n", __func__, cp,
+ ((r_srp == rsv_srp) ? "[rsv] " : ""), r_srp);
+ return r_srp;
}
-/* Return of 1 for found; 0 for not found */
-static int
-sg_remove_request(struct sg_fd *sfp, struct sg_request *srp)
+/*
+ * Moves a completed sg_request object to the free list and sets it to
+ * SG_RS_INACTIVE which makes it available for re-use. Requests with no data
+ * associated are appended to the tail of the free list while other requests
+ * are prepended to the head of the free list.
+ */
+static void
+sg_deact_request(struct sg_fd *sfp, struct sg_request *srp)
{
+ bool on_fl = false;
+ int dlen, buflen;
unsigned long iflags;
- int res = 0;
+ struct sg_request *t_srp;
+ struct sg_scatter_hold *schp;
+ const char *cp = "head";
- if (!sfp || !srp || list_empty(&sfp->rq_list))
- return res;
- write_lock_irqsave(&sfp->rq_list_lock, iflags);
- if (!list_empty(&srp->entry)) {
- list_del(&srp->entry);
- srp->parentfp = NULL;
- res = 1;
+ if (WARN_ON(!sfp || !srp))
+ return;
+ schp = &srp->sgat_h; /* make sure it is own data buffer */
+ spin_lock_irqsave(&sfp->rq_list_lock, iflags);
+ atomic_set(&srp->rq_st, SG_RS_BUSY);
+ list_del_rcu(&srp->rq_entry);
+ /*
+ * N.B. sg_request object is not de-allocated (freed). The contents
+ * of the rq_list and rq_fl lists are de-allocated (freed) when
+ * the owning file descriptor is closed. The free list acts as a LIFO
+ * for same size (buflen) sg_request objects. This can improve the
+ * chance of a cache hit when the sg_request object is re-used.
+ */
+ dlen = schp->dlen;
+ buflen = schp->buflen;
+ /* want ascending free list by dlen, but dlen==0 at end */
+ if (dlen > 0) {
+ list_for_each_entry(t_srp, &sfp->rq_fl, fl_entry) {
+ if (buflen <= t_srp->sgat_h.buflen ||
+ t_srp->sgat_h.buflen == 0) {
+ /* add srp _before_ t_srp on fl */
+ list_add_tail_rcu(&srp->fl_entry,
+ &t_srp->fl_entry);
+ on_fl = true;
+ cp = "ascending pos";
+ break;
+ }
+ }
}
- write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
- return res;
+ if (!on_fl) { /* either empty list, dlen=0 or buflen highest */
+ list_add_tail_rcu(&srp->fl_entry, &sfp->rq_fl);
+ cp = "tail";
+ }
+ SG_LOG(5, sfp, "%s: %ssrp=0x%p move to fl %s\n", __func__,
+ ((sfp->rsv_srp == srp) ? "rsv " : ""), srp, cp);
+ spin_unlock_irqrestore(&sfp->rq_list_lock, iflags);
+ atomic_set(&srp->rq_st, SG_RS_INACTIVE);
}
+/* Returns pointer to sg_fd object or negated errno twisted by ERR_PTR */
static struct sg_fd *
sg_add_sfp(struct sg_device *sdp)
{
- struct sg_fd *sfp;
+ bool reduced = false;
+ int rbuf_len;
unsigned long iflags;
- int bufflen;
+ long err;
+ struct sg_fd *sfp;
+ struct sg_request *srp;
sfp = kzalloc(sizeof(*sfp), GFP_ATOMIC | __GFP_NOWARN);
if (!sfp)
return ERR_PTR(-ENOMEM);
-
init_waitqueue_head(&sfp->read_wait);
- rwlock_init(&sfp->rq_list_lock);
+ spin_lock_init(&sfp->rq_list_lock);
INIT_LIST_HEAD(&sfp->rq_list);
+ INIT_LIST_HEAD(&sfp->rq_fl);
kref_init(&sfp->f_ref);
mutex_init(&sfp->f_mutex);
sfp->timeout = SG_DEFAULT_TIMEOUT;
sfp->timeout_user = SG_DEFAULT_TIMEOUT_USER;
- sfp->force_packid = SG_DEF_FORCE_PACK_ID;
- sfp->cmd_q = SG_DEF_COMMAND_Q;
- sfp->keep_orphan = SG_DEF_KEEP_ORPHAN;
+ /* other bits in sfp->ffd_bm[1] cleared by kzalloc() above */
+ __assign_bit(SG_FFD_FORCE_PACKID, sfp->ffd_bm, SG_DEF_FORCE_PACK_ID);
+ __assign_bit(SG_FFD_CMD_Q, sfp->ffd_bm, SG_DEF_COMMAND_Q);
+ __assign_bit(SG_FFD_KEEP_ORPHAN, sfp->ffd_bm, SG_DEF_KEEP_ORPHAN);
+ __assign_bit(SG_FFD_Q_AT_TAIL, sfp->ffd_bm, SG_DEFAULT_Q_AT);
+ /*
+ * SG_SCATTER_SZ initializes scatter_elem_sz but different value may
+ * be given as driver/module parameter (e.g. 'scatter_elem_sz=8192').
+ * Any user provided number will be changed to be PAGE_SIZE as a
+ * minimum, otherwise it will be rounded down (if required) to a
+ * power of 2. So it will always be a power of 2.
+ */
+ sfp->sgat_elem_sz = scatter_elem_sz;
sfp->parentdp = sdp;
- atomic_set(&sfp->submitted, 0);
- atomic_set(&sfp->waiting, 0);
-
- write_lock_irqsave(&sdp->sfd_lock, iflags);
- if (SG_IS_DETACHING(sdp)) {
- write_unlock_irqrestore(&sdp->sfd_lock, iflags);
+ if (unlikely(SG_IS_DETACHING(sdp))) {
+ SG_LOG(1, sfp, "%s: detaching\n", __func__);
kfree(sfp);
return ERR_PTR(-ENODEV);
}
- list_add_tail(&sfp->sfd_siblings, &sdp->sfds);
- write_unlock_irqrestore(&sdp->sfd_lock, iflags);
- SG_LOG(3, sfp, "%s: sfp=0x%p\n", __func__, sfp);
if (unlikely(sg_big_buff != def_reserved_size))
sg_big_buff = def_reserved_size;
- bufflen = min_t(int, sg_big_buff,
- max_sectors_bytes(sdp->device->request_queue));
- sg_build_reserve(sfp, bufflen);
- SG_LOG(3, sfp, "%s: bufflen=%d, k_use_sg=%d\n", __func__,
- sfp->reserve.bufflen, sfp->reserve.k_use_sg);
-
+ rbuf_len = min_t(int, sg_big_buff, sdp->max_sgat_sz);
+ if (rbuf_len > 0) {
+ srp = sg_build_reserve(sfp, rbuf_len);
+ if (IS_ERR(srp)) {
+ kfree(sfp);
+ err = PTR_ERR(srp);
+ SG_LOG(1, sfp, "%s: build reserve err=%ld\n", __func__,
+ -err);
+ return ERR_PTR(err);
+ }
+ if (srp->sgat_h.buflen < rbuf_len) {
+ reduced = true;
+ SG_LOG(2, sfp,
+ "%s: reserve reduced from %d to buflen=%d\n",
+ __func__, rbuf_len, srp->sgat_h.buflen);
+ }
+ /* will be first element so head or tail doesn't matter */
+ list_add_tail_rcu(&srp->fl_entry, &sfp->rq_fl);
+ }
+ if (!reduced) {
+ SG_LOG(4, sfp, "%s: built reserve buflen=%d\n", __func__,
+ rbuf_len);
+ }
+ write_lock_irqsave(&sdp->sfd_lock, iflags);
+ list_add_tail(&sfp->sfd_entry, &sdp->sfds);
kref_get(&sdp->d_ref);
__module_get(THIS_MODULE);
+ write_unlock_irqrestore(&sdp->sfd_lock, iflags);
+ SG_LOG(3, sfp, "%s: success, sfp=0x%p ++\n", __func__, sfp);
return sfp;
}
+/*
+ * A successful call to sg_release() will result, at some later time, to this
+ * function being invoked. All requests associated with this file descriptor
+ * should be completed or cancelled when this function is called (due to
+ * sfp->f_ref). Also the file descriptor itself has not been accessible since
+ * it was list_del()-ed by the preceding sg_remove_sfp() call. So no locking
+ * is required. sdp should never be NULL but to make debugging more robust,
+ * this function will not blow up in that case.
+ */
static void
sg_remove_sfp_usercontext(struct work_struct *work)
{
- struct sg_fd *sfp = container_of(work, struct sg_fd, ew.work);
- struct sg_device *sdp = sfp->parentdp;
+ struct sg_fd *sfp = container_of(work, struct sg_fd, ew_fd.work);
+ struct sg_device *sdp;
struct sg_request *srp;
- unsigned long iflags;
+ __maybe_unused const char *cp = " srp=0x";
+
+ if (!sfp) {
+ pr_warn("sg: %s: sfp is NULL\n", __func__);
+ return;
+ }
+ sdp = sfp->parentdp;
/* Cleanup any responses which were never read(). */
- write_lock_irqsave(&sfp->rq_list_lock, iflags);
while (!list_empty(&sfp->rq_list)) {
- srp = list_first_entry(&sfp->rq_list, struct sg_request, entry);
+ srp = list_last_entry(&sfp->rq_list, struct sg_request,
+ rq_entry);
+ if (!srp)
+ continue;
sg_finish_scsi_blk_rq(srp);
- list_del(&srp->entry);
- srp->parentfp = NULL;
- }
- write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
-
- if (sfp->reserve.bufflen > 0) {
- SG_LOG(6, sfp, "%s: bufflen=%d, k_use_sg=%d\n", __func__,
- (int)sfp->reserve.bufflen, (int)sfp->reserve.k_use_sg);
- sg_remove_scat(sfp, &sfp->reserve);
- }
-
- SG_LOG(6, sfp, "%s: sfp=0x%p\n", __func__, sfp);
+ list_del(&srp->rq_entry);
+ if (srp->sgat_h.buflen > 0)
+ sg_remove_sgat(srp);
+ SG_LOG(6, sfp, "%s:%s%p --\n", __func__, cp, srp);
+ kfree(srp);
+ }
+ while (!list_empty(&sfp->rq_fl)) {
+ srp = list_last_entry(&sfp->rq_fl, struct sg_request,
+ fl_entry);
+ if (!srp)
+ continue;
+ list_del(&srp->fl_entry);
+ if (srp->sgat_h.buflen > 0)
+ sg_remove_sgat(srp);
+ SG_LOG(6, sfp, "%s: fl%s%p --\n", __func__, cp, srp);
+ kfree(srp);
+ }
+ SG_LOG(3, sfp, "%s: kfree: sfp=0x%p --\n", __func__, sfp);
kfree(sfp);
- scsi_device_put(sdp->device);
- kref_put(&sdp->d_ref, sg_device_destroy);
+ if (sdp) {
+ scsi_device_put(sdp->device);
+ kref_put(&sdp->d_ref, sg_device_destroy);
+ }
module_put(THIS_MODULE);
}
static void
sg_remove_sfp(struct kref *kref)
{
+ unsigned long iflags;
struct sg_fd *sfp = container_of(kref, struct sg_fd, f_ref);
struct sg_device *sdp = sfp->parentdp;
- unsigned long iflags;
write_lock_irqsave(&sdp->sfd_lock, iflags);
- list_del(&sfp->sfd_siblings);
+ list_del(&sfp->sfd_entry);
write_unlock_irqrestore(&sdp->sfd_lock, iflags);
- INIT_WORK(&sfp->ew.work, sg_remove_sfp_usercontext);
- schedule_work(&sfp->ew.work);
+ INIT_WORK(&sfp->ew_fd.work, sg_remove_sfp_usercontext);
+ schedule_work(&sfp->ew_fd.work);
}
static int
@@ -2332,6 +3169,33 @@ sg_get_dev(int dev)
return sdp;
}
+#if IS_ENABLED(CONFIG_SCSI_PROC_FS)
+static const char *
+sg_rq_st_str(enum sg_rq_state rq_st, bool long_str)
+{
+ switch (rq_st) { /* request state */
+ case SG_RS_INACTIVE:
+ return long_str ? "inactive" : "ina";
+ case SG_RS_INFLIGHT:
+ return long_str ? "inflight" : "act";
+ case SG_RS_AWAIT_RD:
+ return long_str ? "await_read" : "rcv";
+ case SG_RS_DONE_RD:
+ return long_str ? "done_read" : "fin";
+ case SG_RS_BUSY:
+ return long_str ? "busy" : "bsy";
+ default:
+ return long_str ? "unknown" : "unk";
+ }
+}
+#else
+static const char *
+sg_rq_st_str(enum sg_rq_state rq_st, bool long_str)
+{
+ return "";
+}
+#endif
+
#if IS_ENABLED(CONFIG_SCSI_PROC_FS) /* long, almost to end of file */
static int sg_proc_seq_show_int(struct seq_file *s, void *v);
@@ -2492,12 +3356,13 @@ sg_proc_seq_show_devhdr(struct seq_file *s, void *v)
struct sg_proc_deviter {
loff_t index;
size_t max;
+ int fd_index;
};
static void *
dev_seq_start(struct seq_file *s, loff_t *pos)
{
- struct sg_proc_deviter * it = kmalloc(sizeof(*it), GFP_KERNEL);
+ struct sg_proc_deviter *it = kzalloc(sizeof(*it), GFP_KERNEL);
s->private = it;
if (! it)
@@ -2575,67 +3440,67 @@ sg_proc_seq_show_devstrs(struct seq_file *s, void *v)
static void
sg_proc_debug_helper(struct seq_file *s, struct sg_device *sdp)
{
- int k, new_interface, blen, usg;
+ int k;
struct sg_request *srp;
struct sg_fd *fp;
- const sg_io_hdr_t *hp;
const char * cp;
unsigned int ms;
k = 0;
- list_for_each_entry(fp, &sdp->sfds, sfd_siblings) {
+ list_for_each_entry(fp, &sdp->sfds, sfd_entry) {
k++;
- read_lock(&fp->rq_list_lock); /* irqs already disabled */
+ spin_lock(&fp->rq_list_lock); /* irqs already disabled */
seq_printf(s, " FD(%d): timeout=%dms bufflen=%d "
"(res)sgat=%d low_dma=%d\n", k,
jiffies_to_msecs(fp->timeout),
- fp->reserve.bufflen,
- (int) fp->reserve.k_use_sg,
+ fp->rsv_srp->sgat_h.buflen,
+ (int)fp->rsv_srp->sgat_h.num_sgat,
(int) sdp->device->host->unchecked_isa_dma);
seq_printf(s, " cmd_q=%d f_packid=%d k_orphan=%d closed=0\n",
- (int) fp->cmd_q, (int) fp->force_packid,
- (int) fp->keep_orphan);
+ (int)test_bit(SG_FFD_CMD_Q, fp->ffd_bm),
+ (int)test_bit(SG_FFD_FORCE_PACKID, fp->ffd_bm),
+ (int)test_bit(SG_FFD_KEEP_ORPHAN, fp->ffd_bm));
seq_printf(s, " submitted=%d waiting=%d\n",
atomic_read(&fp->submitted),
atomic_read(&fp->waiting));
- list_for_each_entry(srp, &fp->rq_list, entry) {
- hp = &srp->header;
- new_interface = (hp->interface_id == '\0') ? 0 : 1;
- if (srp->res_used) {
- if (new_interface &&
- (SG_FLAG_MMAP_IO & hp->flags))
+ list_for_each_entry(srp, &fp->rq_list, rq_entry) {
+ const struct sg_slice_hdr3 *sh3p = &srp->s_hdr3;
+ bool is_v3 = (sh3p->interface_id != '\0');
+ enum sg_rq_state rq_st = atomic_read(&srp->rq_st);
+
+ if (srp->parentfp->rsv_srp == srp) {
+ if (is_v3 && (SG_FLAG_MMAP_IO & sh3p->flags))
cp = " mmap>> ";
else
cp = " rb>> ";
} else {
- if (SG_INFO_DIRECT_IO_MASK & hp->info)
+ if (SG_INFO_DIRECT_IO_MASK & srp->rq_info)
cp = " dio>> ";
else
cp = " ";
}
seq_puts(s, cp);
- blen = srp->data.bufflen;
- usg = srp->data.k_use_sg;
- seq_puts(s, srp->done ?
- ((1 == srp->done) ? "rcv:" : "fin:")
- : "act:");
- seq_printf(s, " id=%d blen=%d",
- srp->header.pack_id, blen);
- if (srp->done)
- seq_printf(s, " dur=%d", hp->duration);
- else {
- ms = jiffies_to_msecs(jiffies);
- seq_printf(s, " t_o/elap=%d/%d",
- (new_interface ? hp->timeout :
- jiffies_to_msecs(fp->timeout)),
- (ms > hp->duration ? ms - hp->duration : 0));
+ seq_puts(s, sg_rq_st_str(rq_st, false));
+ seq_printf(s, ": id=%d len/blen=%d/%d",
+ srp->pack_id, srp->sgat_h.dlen,
+ srp->sgat_h.buflen);
+ if (rq_st == SG_RS_AWAIT_RD || rq_st == SG_RS_DONE_RD) {
+ seq_printf(s, " dur=%d", srp->duration);
+ goto fin_line;
}
- seq_printf(s, "ms sgat=%d op=0x%02x\n", usg,
- (int) srp->data.cmd_opcode);
+ ms = jiffies_to_msecs(jiffies);
+ seq_printf(s, " t_o/elap=%d/%d",
+ (is_v3 ? sh3p->timeout :
+ jiffies_to_msecs(fp->timeout)),
+ (ms > srp->duration ? ms - srp->duration :
+ 0));
+fin_line:
+ seq_printf(s, "ms sgat=%d op=0x%02x\n",
+ srp->sgat_h.num_sgat, (int)srp->cmd_opcode);
}
if (list_empty(&fp->rq_list))
seq_puts(s, " No requests active\n");
- read_unlock(&fp->rq_list_lock);
+ spin_unlock(&fp->rq_list_lock);
}
}
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 11/20] sg: replace rq array with lists
2019-08-07 11:42 ` [PATCH v3 11/20] sg: replace rq array with lists Douglas Gilbert
@ 2019-08-12 14:35 ` Christoph Hellwig
2019-08-13 23:46 ` Douglas Gilbert
0 siblings, 1 reply; 63+ messages in thread
From: Christoph Hellwig @ 2019-08-12 14:35 UTC (permalink / raw)
To: Douglas Gilbert
Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche, Matthew Wilcox
On Wed, Aug 07, 2019 at 01:42:43PM +0200, Douglas Gilbert wrote:
> Remove the fixed size array of 16 request elements per file
> descriptor and replace with two linked lists per file descriptor.
> One list is for active commands, the other list is a free list.
> sg_request objects are now kept, available for re-use, until
> their owning file descriptor is closed. The sg_request deletions
> are now in sg_remove_sfp_usercontext(). Each active sg_request
> has associated block request and scsi_request objects which are
> released much earlier; their lifetime is the same as it was in
> the v3 sg driver. The lifetime of the bio is also the same (but
> is stretched in a later patch).
Willy would probably want you to use an xarray.
> Add an enum for request state (sg_rq_state) and collect
> various flags into bit maps: one for requests (SG_FRQ_*) and
> the other for file descriptors (SG_FFD_*). They join a
> per sg_device bit map (SG_FDEV_*) added in an earlier
> patch.
>
> Prior to a new sg_request object being (re-)built, information
> that will be placed in it uses a new struct sg_comm_wr_t
> object.
>
> Since the above changes touch almost every function and low
> level structures, this patch is big. With so many changes, the
> diff utility that generates the patch sometimes loses track.
There seem to be a lot of rather unrelated changes here. Also
please don't use __put_user/__get_user for that same reason that
drivers should not use __copy_to_user/__copy_from_user.
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 11/20] sg: replace rq array with lists
2019-08-12 14:35 ` Christoph Hellwig
@ 2019-08-13 23:46 ` Douglas Gilbert
0 siblings, 0 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-13 23:46 UTC (permalink / raw)
To: Christoph Hellwig
Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche, Matthew Wilcox
On 2019-08-12 10:35 a.m., Christoph Hellwig wrote:
> On Wed, Aug 07, 2019 at 01:42:43PM +0200, Douglas Gilbert wrote:
>> Remove the fixed size array of 16 request elements per file
>> descriptor and replace with two linked lists per file descriptor.
>> One list is for active commands, the other list is a free list.
>> sg_request objects are now kept, available for re-use, until
>> their owning file descriptor is closed. The sg_request deletions
>> are now in sg_remove_sfp_usercontext(). Each active sg_request
>> has associated block request and scsi_request objects which are
>> released much earlier; their lifetime is the same as it was in
>> the v3 sg driver. The lifetime of the bio is also the same (but
>> is stretched in a later patch).
>
> Willy would probably want you to use an xarray.
The new code spends little time scanning the active request
list so I see very little benefit from the O(1) random access
capability that I assume xarray would offer. It might be useful
if my code could access the active request list/array by pack_id.
That would require sparse array support, but even that is not
sufficient because the pack_id is user supplied and there has never
been a requirement in the sg driver that the pack_id be unique.
If they search responses by pack_id and its not unique then the
first found on the list is given back. That will typically be the
oldest.
BTW I have added a per file descriptor soft limit on the sum
of data-in and data-out buffers in use (sg_fd::sum_fd_dlens).
That is meant to trip up a malformed user space app (e.g. with
ioctl(SG_IOSUBMIT) in an infinite loop) from eating up all the
kernel's memory.
>> Add an enum for request state (sg_rq_state) and collect
>> various flags into bit maps: one for requests (SG_FRQ_*) and
>> the other for file descriptors (SG_FFD_*). They join a
>> per sg_device bit map (SG_FDEV_*) added in an earlier
>> patch.
>>
>> Prior to a new sg_request object being (re-)built, information
>> that will be placed in it uses a new struct sg_comm_wr_t
>> object.
>>
>> Since the above changes touch almost every function and low
>> level structures, this patch is big. With so many changes, the
>> diff utility that generates the patch sometimes loses track.
>
> There seem to be a lot of rather unrelated changes here. Also
> please don't use __put_user/__get_user for that same reason that
> drivers should not use __copy_to_user/__copy_from_user.
>
They are all in one place ***:
static int
sg_ctl_scsi_id(struct scsi_device *sdev, struct sg_fd *sfp, void __user *p)
{
struct sg_scsi_id __user *sg_idp = p;
struct scsi_lun lun8b;
SG_LOG(3, sfp, "%s: SG_GET_SCSI_ID\n", __func__);
if (unlikely(!access_ok(p, sizeof(struct sg_scsi_id))))
return -EFAULT;
if (unlikely(SG_IS_DETACHING(sfp->parentdp)))
return -ENODEV;
__put_user((int)sdev->host->host_no,
&sg_idp->host_no);
__put_user((int)sdev->channel, &sg_idp->channel);
__put_user((int)sdev->id, &sg_idp->scsi_id);
__put_user((int)sdev->lun, &sg_idp->lun);
__put_user((int)sdev->type, &sg_idp->scsi_type);
__put_user((short)sdev->host->cmd_per_lun,
&sg_idp->h_cmd_per_lun);
__put_user((short)sdev->queue_depth,
&sg_idp->d_queue_depth);
int_to_scsilun(sdev->lun, &lun8b);
__copy_to_user(sg_idp->scsi_lun, lun8b.scsi_lun, 8);
return 0;
}
So its an optimization with a (pretty small) risk that the user
space process disappears after the access_ok() and before the
final __copy_to_user() completes.
Obviously a better way is to build the output in a kernel based object
and copy_to_user() the lot in one shot.
Doug Gilbert
*** which you would now if you had been applying the patches to the
in kernel driver as you went. Reviewing a big patch set (in this
case: on about 3000 lines, changing half of them and ending up with
4500 lines) without reference to the effect they have on the
existing code (by applying them) is 'impressive'. Like doing
analysis on a chess match when you can't see the board but instead
have a long list of moves from a starting position that you only
have a fuzzy recollection of.
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 12/20] sg: sense buffer rework
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (10 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 11/20] sg: replace rq array with lists Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-12 14:37 ` Christoph Hellwig
2019-08-07 11:42 ` [PATCH v3 13/20] sg: add sg v4 interface support Douglas Gilbert
` (8 subsequent siblings)
20 siblings, 1 reply; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
The biggest single item in the sg_request object is the sense
buffer array which is SCSI_SENSE_BUFFERSIZE bytes long. That
constant started out at 18 bytes 20 years ago and is 96 bytes
now and might grow in the future. On the other hand the sense
buffer is only used by a small number of SCSI commands: those
that fail and those that want to return more information
other than a SCSI status of GOOD.
Set up a small mempool called "sg_sense" that is only used as
required and released back to the mempool as soon as practical.
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
-
The scsi_lib.c file in the scsi mid-level maintains two sense
buffer caches but declares them and their access functions
static so they can't use by the sg driver. Perhaps the fastest
option would be to transfer ownership of a (non-empty) sense
buffer from the scsi_lib.c file to the sg driver. This technique
may be useful to ther ULDs.
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 86 ++++++++++++++++++++++++++++++++++++++++-------
1 file changed, 73 insertions(+), 13 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 75f515b3fc8c..8c80661b8196 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -72,6 +72,10 @@ static char *sg_version_date = "20190606";
*/
#define SG_MAX_CDB_SIZE 252
+static struct kmem_cache *sg_sense_cache;
+#define SG_MEMPOOL_MIN_NR 4
+static mempool_t *sg_sense_pool;
+
#define uptr64(val) ((void __user *)(uintptr_t)(val))
#define cuptr64(val) ((const void __user *)(uintptr_t)(val))
@@ -176,7 +180,6 @@ struct sg_request { /* active SCSI command or inactive on free list (fl) */
spinlock_t req_lck;
struct sg_scatter_hold sgat_h; /* hold buffer, perhaps scatter list */
struct sg_slice_hdr3 s_hdr3; /* subset of sg_io_hdr */
- u8 sense_b[SCSI_SENSE_BUFFERSIZE];
u32 duration; /* cmd duration in milliseconds */
u32 rq_flags; /* hold user supplied flags */
u32 rq_info; /* info supplied by v3 and v4 interfaces */
@@ -188,6 +191,7 @@ struct sg_request { /* active SCSI command or inactive on free list (fl) */
u8 cmd_opcode; /* first byte of SCSI cdb */
u64 start_ns; /* starting point of command duration calc */
unsigned long frq_bm[1]; /* see SG_FRQ_* defines above */
+ u8 *sense_bp; /* mempool alloc-ed sense buffer, as needed */
struct sg_fd *parentfp; /* pointer to owning fd, even when on fl */
struct request *rq; /* released in sg_rq_end_io(), bio kept */
struct bio *bio; /* kept until this req -->SG_RS_INACTIVE */
@@ -845,18 +849,21 @@ sg_copy_sense(struct sg_request *srp)
(driver_byte(srp->rq_result) & DRIVER_SENSE)) {
int sb_len = min_t(int, SCSI_SENSE_BUFFERSIZE, srp->sense_len);
int mx_sb_len;
+ u8 *sbp = srp->sense_bp;
void __user *up;
+ srp->sense_bp = NULL;
up = (void __user *)srp->s_hdr3.sbp;
mx_sb_len = srp->s_hdr3.mx_sb_len;
- if (up && mx_sb_len > 0) {
+ if (up && mx_sb_len > 0 && sbp) {
sb_len = min_t(int, sb_len, mx_sb_len);
/* Additional sense length field */
- sb_len_wr = 8 + (int)srp->sense_b[7];
+ sb_len_wr = 8 + (int)sbp[7];
sb_len_wr = min_t(int, sb_len, sb_len_wr);
- if (copy_to_user(up, srp->sense_b, sb_len_wr))
+ if (copy_to_user(up, sbp, sb_len_wr))
sb_len_wr = -EFAULT;
}
+ mempool_free(sbp, sg_sense_pool);
}
return sb_len_wr;
}
@@ -963,8 +970,14 @@ sg_rd_v1v2(void __user *buf, int count, struct sg_fd *sfp,
h2p->driver_status = driver_byte(rq_result);
if ((CHECK_CONDITION & status_byte(rq_result)) ||
(DRIVER_SENSE & driver_byte(rq_result))) {
- memcpy(h2p->sense_buffer, srp->sense_b,
- sizeof(h2p->sense_buffer));
+ if (srp->sense_bp) {
+ u8 *sbp = srp->sense_bp;
+
+ srp->sense_bp = NULL;
+ memcpy(h2p->sense_buffer, sbp,
+ sizeof(h2p->sense_buffer));
+ mempool_free(sbp, sg_sense_pool);
+ }
}
switch (host_byte(rq_result)) {
/*
@@ -999,17 +1012,21 @@ sg_rd_v1v2(void __user *buf, int count, struct sg_fd *sfp,
/* Now copy the result back to the user buffer. */
if (count >= SZ_SG_HEADER) {
- if (copy_to_user(buf, h2p, SZ_SG_HEADER))
- return -EFAULT;
+ if (copy_to_user(buf, h2p, SZ_SG_HEADER)) {
+ res = -EFAULT;
+ goto fini;
+ }
buf += SZ_SG_HEADER;
if (count > h2p->reply_len)
count = h2p->reply_len;
if (count > SZ_SG_HEADER) {
- if (sg_rd_append(srp, buf, count - SZ_SG_HEADER))
- return -EFAULT;
+ res = sg_rd_append(srp, buf, count - SZ_SG_HEADER);
+ if (res)
+ goto fini;
}
} else
res = (h2p->result == 0) ? 0 : -EIO;
+fini:
atomic_set(&srp->rq_st, SG_RS_DONE_RD);
sg_finish_scsi_blk_rq(srp);
sg_deact_request(sfp, srp);
@@ -1975,8 +1992,17 @@ sg_rq_end_io(struct request *rq, blk_status_t status)
srp->duration = sg_calc_rq_dur(srp);
if (unlikely((srp->rq_result & SG_ML_RESULT_MSK) && slen > 0))
sg_check_sense(sdp, srp, slen);
- if (slen > 0)
- memcpy(srp->sense_b, scsi_rp->sense, slen);
+ if (slen > 0) {
+ if (scsi_rp->sense) {
+ srp->sense_bp = mempool_alloc(sg_sense_pool,
+ GFP_ATOMIC);
+ if (srp->sense_bp)
+ memcpy(srp->sense_bp, scsi_rp->sense, slen);
+ } else {
+ pr_warn("%s: scsi_request::sense==NULL\n", __func__);
+ slen = 0;
+ }
+ }
srp->sense_len = slen;
if (unlikely(test_bit(SG_FRQ_IS_ORPHAN, srp->frq_bm))) {
spin_lock(&srp->req_lck);
@@ -2266,13 +2292,28 @@ init_sg(void)
if (rc)
return rc;
+ sg_sense_cache = kmem_cache_create("sg_sense", SCSI_SENSE_BUFFERSIZE,
+ 0, 0, NULL);
+ if (!sg_sense_cache) {
+ pr_err("sg: can't init sense cache\n");
+ rc = -ENOMEM;
+ goto err_out_unreg;
+ }
+ sg_sense_pool = mempool_create_slab_pool(SG_MEMPOOL_MIN_NR,
+ sg_sense_cache);
+ if (!sg_sense_pool) {
+ pr_err("sg: can't init sense pool\n");
+ rc = -ENOMEM;
+ goto err_out_cache;
+ }
+
pr_info("Registered %s[char major=0x%x], version: %s, date: %s\n",
"sg device ", SCSI_GENERIC_MAJOR, SG_VERSION_STR,
sg_version_date);
sg_sysfs_class = class_create(THIS_MODULE, "scsi_generic");
if (IS_ERR(sg_sysfs_class)) {
rc = PTR_ERR(sg_sysfs_class);
- goto err_out_unreg;
+ goto err_out_pool;
}
sg_sysfs_valid = true;
rc = scsi_register_interface(&sg_interface);
@@ -2282,6 +2323,10 @@ init_sg(void)
}
class_destroy(sg_sysfs_class);
+err_out_pool:
+ mempool_destroy(sg_sense_pool);
+err_out_cache:
+ kmem_cache_destroy(sg_sense_cache);
err_out_unreg:
unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0), SG_MAX_DEVS);
return rc;
@@ -2301,6 +2346,8 @@ exit_sg(void)
if (IS_ENABLED(CONFIG_SCSI_PROC_FS))
remove_proc_subtree("scsi/sg", NULL);
scsi_unregister_interface(&sg_interface);
+ mempool_destroy(sg_sense_pool);
+ kmem_cache_destroy(sg_sense_cache);
class_destroy(sg_sysfs_class);
sg_sysfs_valid = 0;
unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0),
@@ -2938,6 +2985,7 @@ sg_deact_request(struct sg_fd *sfp, struct sg_request *srp)
bool on_fl = false;
int dlen, buflen;
unsigned long iflags;
+ u8 *sbp;
struct sg_request *t_srp;
struct sg_scatter_hold *schp;
const char *cp = "head";
@@ -2946,8 +2994,12 @@ sg_deact_request(struct sg_fd *sfp, struct sg_request *srp)
return;
schp = &srp->sgat_h; /* make sure it is own data buffer */
spin_lock_irqsave(&sfp->rq_list_lock, iflags);
+ sbp = srp->sense_bp;
+ srp->sense_bp = NULL;
atomic_set(&srp->rq_st, SG_RS_BUSY);
list_del_rcu(&srp->rq_entry);
+ /* maybe orphaned req, thus never read */
+ mempool_free(sbp, sg_sense_pool);
/*
* N.B. sg_request object is not de-allocated (freed). The contents
* of the rq_list and rq_fl lists are de-allocated (freed) when
@@ -3090,6 +3142,10 @@ sg_remove_sfp_usercontext(struct work_struct *work)
list_del(&srp->rq_entry);
if (srp->sgat_h.buflen > 0)
sg_remove_sgat(srp);
+ if (srp->sense_bp) {
+ mempool_free(srp->sense_bp, sg_sense_pool);
+ srp->sense_bp = NULL;
+ }
SG_LOG(6, sfp, "%s:%s%p --\n", __func__, cp, srp);
kfree(srp);
}
@@ -3101,6 +3157,10 @@ sg_remove_sfp_usercontext(struct work_struct *work)
list_del(&srp->fl_entry);
if (srp->sgat_h.buflen > 0)
sg_remove_sgat(srp);
+ if (srp->sense_bp) {
+ mempool_free(srp->sense_bp, sg_sense_pool);
+ srp->sense_bp = NULL;
+ }
SG_LOG(6, sfp, "%s: fl%s%p --\n", __func__, cp, srp);
kfree(srp);
}
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 12/20] sg: sense buffer rework
2019-08-07 11:42 ` [PATCH v3 12/20] sg: sense buffer rework Douglas Gilbert
@ 2019-08-12 14:37 ` Christoph Hellwig
2019-08-12 16:26 ` Douglas Gilbert
0 siblings, 1 reply; 63+ messages in thread
From: Christoph Hellwig @ 2019-08-12 14:37 UTC (permalink / raw)
To: Douglas Gilbert; +Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche
On Wed, Aug 07, 2019 at 01:42:44PM +0200, Douglas Gilbert wrote:
> The biggest single item in the sg_request object is the sense
> buffer array which is SCSI_SENSE_BUFFERSIZE bytes long. That
> constant started out at 18 bytes 20 years ago and is 96 bytes
> now and might grow in the future. On the other hand the sense
> buffer is only used by a small number of SCSI commands: those
> that fail and those that want to return more information
> other than a SCSI status of GOOD.
>
> Set up a small mempool called "sg_sense" that is only used as
> required and released back to the mempool as soon as practical.
>
> Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
>
> -
>
> The scsi_lib.c file in the scsi mid-level maintains two sense
> buffer caches but declares them and their access functions
> static so they can't use by the sg driver. Perhaps the fastest
> option would be to transfer ownership of a (non-empty) sense
> buffer from the scsi_lib.c file to the sg driver. This technique
> may be useful to ther ULDs.
Why do you need your own storage for the sense buffer? As soon
as you have allocate the request/scsi_request you can use its
sense buffer. There shouldn't really be a need to keep a copy
around.
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 12/20] sg: sense buffer rework
2019-08-12 14:37 ` Christoph Hellwig
@ 2019-08-12 16:26 ` Douglas Gilbert
0 siblings, 0 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-12 16:26 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: linux-scsi, martin.petersen, jejb, hare, bvanassche
On 2019-08-12 10:37 a.m., Christoph Hellwig wrote:
> On Wed, Aug 07, 2019 at 01:42:44PM +0200, Douglas Gilbert wrote:
>> The biggest single item in the sg_request object is the sense
>> buffer array which is SCSI_SENSE_BUFFERSIZE bytes long. That
>> constant started out at 18 bytes 20 years ago and is 96 bytes
>> now and might grow in the future. On the other hand the sense
>> buffer is only used by a small number of SCSI commands: those
>> that fail and those that want to return more information
>> other than a SCSI status of GOOD.
>>
>> Set up a small mempool called "sg_sense" that is only used as
>> required and released back to the mempool as soon as practical.
>>
>> Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
>>
>> -
>>
>> The scsi_lib.c file in the scsi mid-level maintains two sense
>> buffer caches but declares them and their access functions
>> static so they can't use by the sg driver. Perhaps the fastest
>> option would be to transfer ownership of a (non-empty) sense
>> buffer from the scsi_lib.c file to the sg driver. This technique
>> may be useful to ther ULDs.
>
> Why do you need your own storage for the sense buffer? As soon
> as you have allocate the request/scsi_request you can use its
> sense buffer. There shouldn't really be a need to keep a copy
> around.
Different lifetimes between the corresponding struct request and
struct scsi_request objects, on one hand, and a sg_request object on
the other. The former are freed in sg_rq_end_io() (i.e. the callback
from the mid-level) while sg_request object must keep them until the
user space completion (e.g. calls to read() or ioctl(SG_IORECEIVE)).
This comment was left by you (?) or Jens in sg_rq_end_io():
/*
* Free the mid-level resources apart from the bio (if any). The bio's
* blk_rq_unmap_user() can be called later from user context.
*/
I certainly didn't put it there.
Anyway Hannes didn't like a kmalloc(GFP_ATOMIC) in the callback
and suggested a mempool. Given that the sense buffer is not
required very often, I felt pre-allocating space in a
sg_request object was wasteful. Got any better ideas?
One idea I floated was making these guys in scsi_lib:
static struct kmem_cache *scsi_sense_cache;
static struct kmem_cache *scsi_sense_isadma_cache;
... accessible to ULDs (because the st driver may benefit also) to
transfer ownership and free it when it was no longer needed. This
would allow the sg driver to transfer ownership of the sense
buffer in scsi_request before that scsi_request was "freed". Then
the sg_request could free up that sense_buffer when it was no
longer needed. No-one responded to that idea.
Doug Gilbert
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 13/20] sg: add sg v4 interface support
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (11 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 12/20] sg: sense buffer rework Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-09 23:12 ` James Bottomley
2019-08-07 11:42 ` [PATCH v3 14/20] sg: rework debug info Douglas Gilbert
` (7 subsequent siblings)
20 siblings, 1 reply; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
Add support for the sg v4 interface based on struct sg_io_v4 found
in include/uapi/linux/bsg.h and only previously supported by the
bsg driver. Add ioctl(SG_IOSUBMIT) and ioctl(SG_IORECEIVE) for
async (non-blocking) usage of the sg v4 interface. Do not accept
the v3 interface with these ioctls. Do not accept the v4
interface with this driver's existing write() and read()
system calls.
For sync (blocking) usage expand the existing ioctl(SG_IO)
to additionally accept the sg v4 interface object.
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 487 ++++++++++++++++++++++++++++++++---------
include/uapi/scsi/sg.h | 37 +++-
2 files changed, 418 insertions(+), 106 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 8c80661b8196..b12f53851078 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -7,8 +7,9 @@
*
* Original driver (sg.c):
* Copyright (C) 1992 Lawrence Foard
- * Version 2 and 3 extensions to driver:
+ * Version 2, 3 and 4 extensions to driver:
* Copyright (C) 1998 - 2019 Douglas Gilbert
+ *
*/
static int sg_version_num = 30901; /* [x]xyyzz where [x] empty when x=0 */
@@ -40,10 +41,11 @@ static char *sg_version_date = "20190606";
#include <linux/atomic.h>
#include <linux/ratelimit.h>
#include <linux/uio.h>
-#include <linux/cred.h> /* for sg_check_file_access() */
+#include <linux/cred.h> /* for sg_check_file_access() */
#include <linux/proc_fs.h>
-#include "scsi.h"
+#include <scsi/scsi.h>
+#include <scsi/scsi_eh.h>
#include <scsi/scsi_dbg.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_driver.h>
@@ -103,6 +105,7 @@ enum sg_rq_state {
#define SG_ADD_RQ_MAX_RETRIES 40 /* to stop infinite _trylock(s) */
/* Bit positions (flags) for sg_request::frq_bm bitmask follow */
+#define SG_FRQ_IS_V4I 0 /* true (set) when is v4 interface */
#define SG_FRQ_IS_ORPHAN 1 /* owner of request gone */
#define SG_FRQ_SYNC_INVOC 2 /* synchronous (blocking) invocation */
#define SG_FRQ_DIO_IN_USE 3 /* false->indirect_IO,mmap; 1->dio */
@@ -163,6 +166,15 @@ struct sg_slice_hdr3 {
void __user *usr_ptr;
};
+struct sg_slice_hdr4 { /* parts of sg_io_v4 object needed in async usage */
+ void __user *sbp; /* derived from sg_io_v4::response */
+ u64 usr_ptr; /* hold sg_io_v4::usr_ptr as given (u64) */
+ int out_resid;
+ s16 dir; /* data xfer direction; SG_DXFER_* */
+ u16 cmd_len; /* truncated of sg_io_v4::request_len */
+ u16 max_sb_len; /* truncated of sg_io_v4::max_response_len */
+};
+
struct sg_scatter_hold { /* holding area for scsi scatter gather info */
struct page **pages; /* num_sgat element array of struct page* */
int buflen; /* capacity in bytes (dlen<=buflen) */
@@ -179,7 +191,10 @@ struct sg_request { /* active SCSI command or inactive on free list (fl) */
struct list_head fl_entry; /* member of rq_fl */
spinlock_t req_lck;
struct sg_scatter_hold sgat_h; /* hold buffer, perhaps scatter list */
- struct sg_slice_hdr3 s_hdr3; /* subset of sg_io_hdr */
+ union {
+ struct sg_slice_hdr3 s_hdr3; /* subset of sg_io_hdr */
+ struct sg_slice_hdr4 s_hdr4; /* reduced size struct sg_io_v4 */
+ };
u32 duration; /* cmd duration in milliseconds */
u32 rq_flags; /* hold user supplied flags */
u32 rq_info; /* info supplied by v3 and v4 interfaces */
@@ -239,7 +254,10 @@ struct sg_device { /* holds the state of each scsi generic device */
struct sg_comm_wr_t { /* arguments to sg_common_write() */
int timeout;
unsigned long frq_bm[1]; /* see SG_FRQ_* defines above */
- struct sg_io_hdr *h3p;
+ union { /* selector is frq_bm.SG_FRQ_IS_V4I */
+ struct sg_io_hdr *h3p;
+ struct sg_io_v4 *h4p;
+ };
u8 *cmnd;
};
@@ -248,12 +266,12 @@ static void sg_rq_end_io(struct request *rq, blk_status_t status);
/* Declarations of other static functions used before they are defined */
static int sg_proc_init(void);
static int sg_start_req(struct sg_request *srp, u8 *cmd, int cmd_len,
- int dxfer_dir);
+ struct sg_io_v4 *h4p, int dxfer_dir);
static void sg_finish_scsi_blk_rq(struct sg_request *srp);
static int sg_mk_sgat(struct sg_request *srp, struct sg_fd *sfp, int minlen);
-static int sg_submit(struct file *filp, struct sg_fd *sfp,
- struct sg_io_hdr *hp, bool sync,
- struct sg_request **o_srp);
+static int sg_v3_submit(struct file *filp, struct sg_fd *sfp,
+ struct sg_io_hdr *hp, bool sync,
+ struct sg_request **o_srp);
static struct sg_request *sg_common_write(struct sg_fd *sfp,
struct sg_comm_wr_t *cwp);
static int sg_rd_append(struct sg_request *srp, void __user *outp,
@@ -261,11 +279,11 @@ static int sg_rd_append(struct sg_request *srp, void __user *outp,
static void sg_remove_sgat(struct sg_request *srp);
static struct sg_fd *sg_add_sfp(struct sg_device *sdp);
static void sg_remove_sfp(struct kref *);
-static struct sg_request *sg_find_srp_by_id(struct sg_fd *sfp, int pack_id);
+static struct sg_request *sg_find_srp_by_id(struct sg_fd *sfp, int id);
static struct sg_request *sg_add_request(struct sg_fd *sfp, int dxfr_len,
struct sg_comm_wr_t *cwrp);
static void sg_deact_request(struct sg_fd *sfp, struct sg_request *srp);
-static struct sg_device *sg_get_dev(int dev);
+static struct sg_device *sg_get_dev(int min_dev);
static void sg_device_destroy(struct kref *kref);
static struct sg_request *sg_mk_srp_sgat(struct sg_fd *sfp, bool first,
int db_len);
@@ -278,8 +296,11 @@ static void sg_rep_rq_state_fail(struct sg_fd *sfp,
#define SZ_SG_HEADER ((int)sizeof(struct sg_header)) /* v1 and v2 header */
#define SZ_SG_IO_HDR ((int)sizeof(struct sg_io_hdr)) /* v3 header */
+#define SZ_SG_IO_V4 ((int)sizeof(struct sg_io_v4)) /* v4 header (in bsg.h) */
#define SZ_SG_REQ_INFO ((int)sizeof(struct sg_req_info))
+/* There is a assert that SZ_SG_IO_V4 >= SZ_SG_IO_HDR in first function */
+
#define SG_IS_DETACHING(sdp) test_bit(SG_FDEV_DETACHING, (sdp)->fdev_bm)
#define SG_HAVE_EXCLUDE(sdp) test_bit(SG_FDEV_EXCLUDE, (sdp)->fdev_bm)
#define SG_RS_ACTIVE(srp) (atomic_read(&(srp)->rq_st) != SG_RS_INACTIVE)
@@ -299,6 +320,7 @@ static void sg_rep_rq_state_fail(struct sg_fd *sfp,
#if IS_ENABLED(CONFIG_SCSI_LOGGING) && IS_ENABLED(SG_DEBUG)
#define SG_LOG_BUFF_SZ 48
+#define SG_LOG_ACTIVE 1
#define SG_LOG(depth, sfp, fmt, a...) \
do { \
@@ -336,6 +358,10 @@ static void sg_rep_rq_state_fail(struct sg_fd *sfp,
static int
sg_check_file_access(struct file *filp, const char *caller)
{
+ /* can't put following in declarations where it belongs */
+ compiletime_assert(SZ_SG_IO_V4 >= SZ_SG_IO_HDR,
+ "struct sg_io_v4 should be larger than sg_io_hdr");
+
if (filp->f_cred != current_real_cred()) {
pr_err_once("%s: process %d (%s) changed security contexts after opening file descriptor, this is not allowed.\n",
caller, task_tgid_vnr(current), current->comm);
@@ -354,7 +380,7 @@ sg_wait_open_event(struct sg_device *sdp, bool o_excl)
{
int res = 0;
- if (o_excl) {
+ if (unlikely(o_excl)) {
while (atomic_read(&sdp->open_cnt) > 0) {
mutex_unlock(&sdp->open_rel_lock);
res = wait_event_interruptible
@@ -363,13 +389,13 @@ sg_wait_open_event(struct sg_device *sdp, bool o_excl)
atomic_read(&sdp->open_cnt) == 0));
mutex_lock(&sdp->open_rel_lock);
- if (res) /* -ERESTARTSYS */
+ if (unlikely(res)) /* -ERESTARTSYS */
return res;
- if (SG_IS_DETACHING(sdp))
+ if (unlikely(SG_IS_DETACHING(sdp)))
return -ENODEV;
}
} else {
- while (SG_HAVE_EXCLUDE(sdp)) {
+ while (unlikely(SG_HAVE_EXCLUDE(sdp))) {
mutex_unlock(&sdp->open_rel_lock);
res = wait_event_interruptible
(sdp->open_wait,
@@ -377,13 +403,12 @@ sg_wait_open_event(struct sg_device *sdp, bool o_excl)
!SG_HAVE_EXCLUDE(sdp)));
mutex_lock(&sdp->open_rel_lock);
- if (res) /* -ERESTARTSYS */
+ if (unlikely(res)) /* -ERESTARTSYS */
return res;
- if (SG_IS_DETACHING(sdp))
+ if (unlikely(SG_IS_DETACHING(sdp)))
return -ENODEV;
}
}
-
return res;
}
@@ -397,9 +422,9 @@ sg_wait_open_event(struct sg_device *sdp, bool o_excl)
static inline int
sg_allow_if_err_recovery(struct sg_device *sdp, bool non_block)
{
- if (!sdp)
+ if (unlikely(!sdp))
return -EPROTO;
- if (SG_IS_DETACHING(sdp))
+ if (unlikely(SG_IS_DETACHING(sdp)))
return -ENODEV;
if (non_block)
return 0;
@@ -429,21 +454,18 @@ sg_open(struct inode *inode, struct file *filp)
o_excl = !!(op_flags & O_EXCL);
non_block = !!(op_flags & O_NONBLOCK);
if (o_excl && ((op_flags & O_ACCMODE) == O_RDONLY))
- return -EPERM; /* Can't lock it with read only access */
+ return -EPERM;/* not permitted, need write access for O_EXCL */
sdp = sg_get_dev(min_dev);
if (IS_ERR(sdp))
return PTR_ERR(sdp);
- /* This driver's module count bumped by fops_get in <linux/fs.h> */
/* Prevent the device driver from vanishing while we sleep */
res = scsi_device_get(sdp->device);
if (res)
goto sg_put;
-
res = scsi_autopm_get_device(sdp->device);
if (res)
goto sdp_put;
-
res = sg_allow_if_err_recovery(sdp, non_block);
if (res)
goto error_out;
@@ -480,6 +502,7 @@ sg_open(struct inode *inode, struct file *filp)
}
filp->private_data = sfp;
+ sfp->tid = (current ? current->pid : -1);
atomic_inc(&sdp->open_cnt);
mutex_unlock(&sdp->open_rel_lock);
SG_LOG(3, sfp, "%s: minor=%d, op_flags=0x%x; %s count prior=%d%s\n",
@@ -506,8 +529,13 @@ sg_open(struct inode *inode, struct file *filp)
goto sg_put;
}
-/* Release resources associated with a successful sg_open()
- * Returns 0 on success, else a negated errno value */
+/*
+ * Release resources associated with a prior, successful sg_open(). It can be
+ * seen as the (final) close() call on a sg device file descriptor in the user
+ * space. The real work releasing all resources associated with this file
+ * descriptor is done by sg_remove_sfp_usercontext() which is scheduled by
+ * sg_remove_sfp().
+ */
static int
sg_release(struct inode *inode, struct file *filp)
{
@@ -587,7 +615,7 @@ sg_write(struct file *filp, const char __user *p, size_t count, loff_t *ppos)
if (__copy_from_user(h3u8p + SZ_SG_HEADER, p + SZ_SG_HEADER,
SZ_SG_IO_HDR - SZ_SG_HEADER))
return -EFAULT;
- res = sg_submit(filp, sfp, h3p, false, NULL);
+ res = sg_v3_submit(filp, sfp, h3p, false, NULL);
return res < 0 ? res : (int)count;
}
/* v1 and v2 interfaces processed below this point */
@@ -658,18 +686,6 @@ sg_write(struct file *filp, const char __user *p, size_t count, loff_t *ppos)
return (IS_ERR(srp)) ? PTR_ERR(srp) : (int)count;
}
-static inline int
-sg_chk_mmap(struct sg_fd *sfp, int rq_flags, int len)
-{
- if (!list_empty(&sfp->rq_list))
- return -EBUSY; /* already active requests on fd */
- if (len > sfp->rsv_srp->sgat_h.buflen)
- return -ENOMEM; /* MMAP_IO size must fit in reserve */
- if (rq_flags & SG_FLAG_DIRECT_IO)
- return -EINVAL; /* not both MMAP_IO and DIRECT_IO */
- return 0;
-}
-
static int
sg_fetch_cmnd(struct file *filp, struct sg_fd *sfp, const u8 __user *u_cdbp,
int len, u8 *cdbp)
@@ -692,8 +708,8 @@ sg_fetch_cmnd(struct file *filp, struct sg_fd *sfp, const u8 __user *u_cdbp,
}
static int
-sg_submit(struct file *filp, struct sg_fd *sfp, struct sg_io_hdr *hp,
- bool sync, struct sg_request **o_srp)
+sg_v3_submit(struct file *filp, struct sg_fd *sfp, struct sg_io_hdr *hp,
+ bool sync, struct sg_request **o_srp)
{
int res, timeout;
unsigned long ul_timeout;
@@ -703,9 +719,12 @@ sg_submit(struct file *filp, struct sg_fd *sfp, struct sg_io_hdr *hp,
/* now doing v3 blocking (sync) or non-blocking submission */
if (hp->flags & SG_FLAG_MMAP_IO) {
- res = sg_chk_mmap(sfp, hp->flags, hp->dxfer_len);
- if (res)
- return res;
+ if (!list_empty(&sfp->rq_list))
+ return -EBUSY; /* already active requests on fd */
+ if (hp->dxfer_len > sfp->rsv_srp->sgat_h.buflen)
+ return -ENOMEM; /* MMAP_IO size must fit in reserve */
+ if (hp->flags & SG_FLAG_DIRECT_IO)
+ return -EINVAL; /* not both MMAP_IO and DIRECT_IO */
}
/* when v3 seen, allow cmd_q on this fd (def: no cmd_q) */
set_bit(SG_FFD_CMD_Q, sfp->ffd_bm);
@@ -727,16 +746,124 @@ sg_submit(struct file *filp, struct sg_fd *sfp, struct sg_io_hdr *hp,
return 0;
}
+static int
+sg_v4_submit(struct file *filp, struct sg_fd *sfp, void __user *p,
+ struct sg_io_v4 *h4p, bool sync, struct sg_request **o_srp)
+{
+ int timeout, res;
+ unsigned long ul_timeout;
+ struct sg_request *srp;
+ struct sg_comm_wr_t cwr;
+ u8 cmnd[SG_MAX_CDB_SIZE];
+
+ if (h4p->flags & SG_FLAG_MMAP_IO) {
+ int len = 0;
+
+ if (h4p->din_xferp)
+ len = h4p->din_xfer_len;
+ else if (h4p->dout_xferp)
+ len = h4p->dout_xfer_len;
+ if (!list_empty(&sfp->rq_list))
+ return -EBUSY; /* already active requests on fd */
+ if (len > sfp->rsv_srp->sgat_h.buflen)
+ return -ENOMEM; /* MMAP_IO size must fit in reserve */
+ if (h4p->flags & SG_FLAG_DIRECT_IO)
+ return -EINVAL; /* not both MMAP_IO and DIRECT_IO */
+ }
+ /* once v4 (or v3) seen, allow cmd_q on this fd (def: no cmd_q) */
+ set_bit(SG_FFD_CMD_Q, sfp->ffd_bm);
+ ul_timeout = msecs_to_jiffies(h4p->timeout);
+ timeout = min_t(unsigned long, ul_timeout, INT_MAX);
+ res = sg_fetch_cmnd(filp, sfp, cuptr64(h4p->request), h4p->request_len,
+ cmnd);
+ if (res)
+ return res;
+ cwr.frq_bm[0] = 0;
+ assign_bit(SG_FRQ_SYNC_INVOC, cwr.frq_bm, (int)sync);
+ set_bit(SG_FRQ_IS_V4I, cwr.frq_bm);
+ cwr.h4p = h4p;
+ cwr.timeout = timeout;
+ cwr.cmnd = cmnd;
+ srp = sg_common_write(sfp, &cwr);
+ if (IS_ERR(srp))
+ return PTR_ERR(srp);
+ if (o_srp)
+ *o_srp = srp;
+ return res;
+}
+
+static int
+sg_ctl_iosubmit(struct file *filp, struct sg_fd *sfp, void __user *p)
+{
+ int res;
+ u8 hdr_store[SZ_SG_IO_V4];
+ struct sg_io_v4 *h4p = (struct sg_io_v4 *)hdr_store;
+ struct sg_device *sdp = sfp->parentdp;
+
+ res = sg_allow_if_err_recovery(sdp, (filp->f_flags & O_NONBLOCK));
+ if (res)
+ return res;
+ if (copy_from_user(hdr_store, p, SZ_SG_IO_V4))
+ return -EFAULT;
+ if (h4p->guard == 'Q')
+ return sg_v4_submit(filp, sfp, p, h4p, false, NULL);
+ return -EPERM;
+}
+
+static void
+sg_execute_cmd(struct sg_fd *sfp, struct sg_request *srp)
+{
+ bool at_head, is_v4h, sync;
+ struct sg_device *sdp = sfp->parentdp;
+
+ is_v4h = test_bit(SG_FRQ_IS_V4I, srp->frq_bm);
+ sync = test_bit(SG_FRQ_SYNC_INVOC, srp->frq_bm);
+ SG_LOG(3, sfp, "%s: is_v4h=%d\n", __func__, (int)is_v4h);
+ srp->start_ns = ktime_get_boottime_ns();
+ srp->duration = 0;
+
+ if (!is_v4h && srp->s_hdr3.interface_id == '\0')
+ at_head = true; /* backward compatibility: v1+v2 interfaces */
+ else if (test_bit(SG_FFD_Q_AT_TAIL, sfp->ffd_bm))
+ /* cmd flags can override sfd setting */
+ at_head = !!(srp->rq_flags & SG_FLAG_Q_AT_HEAD);
+ else /* this sfd is defaulting to head */
+ at_head = !(srp->rq_flags & SG_FLAG_Q_AT_TAIL);
+
+ kref_get(&sfp->f_ref); /* sg_rq_end_io() does kref_put(). */
+
+ /* >>>>>>> send cmd/req off to other levels <<<<<<<< */
+ if (!sync)
+ atomic_inc(&sfp->submitted);
+ blk_execute_rq_nowait(sdp->device->request_queue, sdp->disk,
+ srp->rq, (int)at_head, sg_rq_end_io);
+}
+
+static inline int
+sg_rstate_chg(struct sg_request *srp, enum sg_rq_state old_st,
+ enum sg_rq_state new_st)
+{
+ enum sg_rq_state act_old_st = (enum sg_rq_state)
+ atomic_cmpxchg(&srp->rq_st, old_st, new_st);
+
+ if (act_old_st == old_st)
+ return 0; /* implies new_st --> srp->rq_st */
+ else if (IS_ENABLED(SG_LOG_ACTIVE))
+ sg_rep_rq_state_fail(srp->parentfp, old_st, new_st,
+ act_old_st);
+ return -EPROTOTYPE;
+}
+
/*
* All writes and submits converge on this function to launch the SCSI
* command/request (via blk_execute_rq_nowait). Returns a pointer to a
* sg_request object holding the request just issued or a negated errno
* value twisted by ERR_PTR.
+ * N.B. pack_id placed in sg_io_v4::request_extra field.
*/
static struct sg_request *
sg_common_write(struct sg_fd *sfp, struct sg_comm_wr_t *cwrp)
{
- bool at_head;
int res = 0;
int dxfr_len, dir, cmd_len;
int pack_id = SG_PACK_ID_WILDCARD;
@@ -744,12 +871,32 @@ sg_common_write(struct sg_fd *sfp, struct sg_comm_wr_t *cwrp)
struct sg_device *sdp = sfp->parentdp;
struct sg_request *srp;
struct sg_io_hdr *hi_p;
-
- hi_p = cwrp->h3p;
- dir = hi_p->dxfer_direction;
- dxfr_len = hi_p->dxfer_len;
- rq_flags = hi_p->flags;
- pack_id = hi_p->pack_id;
+ struct sg_io_v4 *h4p;
+
+ if (test_bit(SG_FRQ_IS_V4I, cwrp->frq_bm)) {
+ h4p = cwrp->h4p;
+ hi_p = NULL;
+ dxfr_len = 0;
+ dir = SG_DXFER_NONE;
+ rq_flags = h4p->flags;
+ pack_id = h4p->request_extra;
+ if (h4p->din_xfer_len && h4p->dout_xfer_len) {
+ return ERR_PTR(-EOPNOTSUPP);
+ } else if (h4p->din_xfer_len) {
+ dxfr_len = h4p->din_xfer_len;
+ dir = SG_DXFER_FROM_DEV;
+ } else if (h4p->dout_xfer_len) {
+ dxfr_len = h4p->dout_xfer_len;
+ dir = SG_DXFER_TO_DEV;
+ }
+ } else { /* sg v3 interface so hi_p valid */
+ h4p = NULL;
+ hi_p = cwrp->h3p;
+ dir = hi_p->dxfer_direction;
+ dxfr_len = hi_p->dxfer_len;
+ rq_flags = hi_p->flags;
+ pack_id = hi_p->pack_id;
+ }
if (dxfr_len >= SZ_256M)
return ERR_PTR(-EINVAL);
@@ -759,13 +906,23 @@ sg_common_write(struct sg_fd *sfp, struct sg_comm_wr_t *cwrp)
srp->rq_flags = rq_flags;
srp->pack_id = pack_id;
- cmd_len = hi_p->cmd_len;
- memcpy(&srp->s_hdr3, hi_p, sizeof(srp->s_hdr3));
+ if (h4p) {
+ memset(&srp->s_hdr4, 0, sizeof(srp->s_hdr4));
+ srp->s_hdr4.usr_ptr = h4p->usr_ptr;
+ srp->s_hdr4.sbp = uptr64(h4p->response);
+ srp->s_hdr4.max_sb_len = h4p->max_response_len;
+ srp->s_hdr4.cmd_len = h4p->request_len;
+ srp->s_hdr4.dir = dir;
+ cmd_len = h4p->request_len;
+ } else { /* v3 interface active */
+ cmd_len = hi_p->cmd_len;
+ memcpy(&srp->s_hdr3, hi_p, sizeof(srp->s_hdr3));
+ }
srp->cmd_opcode = cwrp->cmnd[0];/* hold opcode of command for debug */
SG_LOG(4, sfp, "%s: opcode=0x%02x, cdb_sz=%d, pack_id=%d\n", __func__,
(int)cwrp->cmnd[0], cmd_len, pack_id);
- res = sg_start_req(srp, cwrp->cmnd, cmd_len, dir);
+ res = sg_start_req(srp, cwrp->cmnd, cmd_len, h4p, dir);
if (res < 0) /* probably out of space --> -ENOMEM */
goto err_out;
if (unlikely(SG_IS_DETACHING(sdp))) {
@@ -777,21 +934,7 @@ sg_common_write(struct sg_fd *sfp, struct sg_comm_wr_t *cwrp)
goto err_out;
}
srp->rq->timeout = cwrp->timeout;
- kref_get(&sfp->f_ref); /* sg_rq_end_io() does kref_put(). */
- srp->start_ns = ktime_get_boottime_ns();
- srp->duration = 0;
-
- if (srp->s_hdr3.interface_id == '\0')
- at_head = true; /* backward compatibility: v1+v2 interfaces */
- else if (test_bit(SG_FFD_Q_AT_TAIL, sfp->ffd_bm))
- /* cmd flags can override sfd setting */
- at_head = !!(srp->rq_flags & SG_FLAG_Q_AT_HEAD);
- else /* this sfd is defaulting to head */
- at_head = !(srp->rq_flags & SG_FLAG_Q_AT_TAIL);
- if (!test_bit(SG_FRQ_SYNC_INVOC, srp->frq_bm))
- atomic_inc(&sfp->submitted);
- blk_execute_rq_nowait(sdp->device->request_queue, sdp->disk,
- srp->rq, at_head, sg_rq_end_io);
+ sg_execute_cmd(sfp, srp);
return srp;
err_out:
sg_finish_scsi_blk_rq(srp);
@@ -799,21 +942,6 @@ sg_common_write(struct sg_fd *sfp, struct sg_comm_wr_t *cwrp)
return ERR_PTR(res);
}
-static inline int
-sg_rstate_chg(struct sg_request *srp, enum sg_rq_state old_st,
- enum sg_rq_state new_st)
-{
- enum sg_rq_state act_old_st = (enum sg_rq_state)
- atomic_cmpxchg(&srp->rq_st, old_st, new_st);
-
- if (act_old_st == old_st)
- return 0; /* implies new_st --> srp->rq_st */
- else if (IS_ENABLED(CONFIG_SCSI_LOGGING))
- sg_rep_rq_state_fail(srp->parentfp, old_st, new_st,
- act_old_st);
- return -EPROTOTYPE;
-}
-
/*
* This function is called by wait_event_interruptible in sg_read() and
* sg_ctl_ioreceive(). wait_event_interruptible will return if this one
@@ -838,7 +966,7 @@ sg_get_ready_srp(struct sg_fd *sfp, struct sg_request **srpp, int pack_id)
* negated errno value.
*/
static int
-sg_copy_sense(struct sg_request *srp)
+sg_copy_sense(struct sg_request *srp, bool v4_active)
{
int sb_len_wr = 0;
int scsi_stat;
@@ -853,8 +981,13 @@ sg_copy_sense(struct sg_request *srp)
void __user *up;
srp->sense_bp = NULL;
- up = (void __user *)srp->s_hdr3.sbp;
- mx_sb_len = srp->s_hdr3.mx_sb_len;
+ if (v4_active) {
+ up = uptr64(srp->s_hdr4.sbp);
+ mx_sb_len = srp->s_hdr4.max_sb_len;
+ } else {
+ up = (void __user *)srp->s_hdr3.sbp;
+ mx_sb_len = srp->s_hdr3.mx_sb_len;
+ }
if (up && mx_sb_len > 0 && sbp) {
sb_len = min_t(int, sb_len, mx_sb_len);
/* Additional sense length field */
@@ -895,13 +1028,13 @@ sg_rep_rq_state_fail(struct sg_fd *sfp, enum sg_rq_state exp_old_st,
#endif
static int
-sg_rec_v3_state(struct sg_fd *sfp, struct sg_request *srp)
+sg_rec_v3v4_state(struct sg_fd *sfp, struct sg_request *srp, bool v4_active)
{
int err = 0;
int sb_len_wr;
u32 rq_res = srp->rq_result;
- sb_len_wr = sg_copy_sense(srp);
+ sb_len_wr = sg_copy_sense(srp, v4_active);
if (sb_len_wr < 0)
return sb_len_wr;
if (rq_res & SG_ML_RESULT_MSK)
@@ -925,7 +1058,7 @@ sg_v3_receive(struct sg_fd *sfp, struct sg_request *srp, void __user *p)
struct sg_io_hdr *hp = &hdr3;
SG_LOG(3, sfp, "%s: srp=0x%p\n", __func__, srp);
- err = sg_rec_v3_state(sfp, srp);
+ err = sg_rec_v3v4_state(sfp, srp, false);
memset(hp, 0, sizeof(*hp));
memcpy(hp, &srp->s_hdr3, sizeof(srp->s_hdr3));
hp->sb_len_wr = srp->sense_len;
@@ -948,6 +1081,102 @@ sg_v3_receive(struct sg_fd *sfp, struct sg_request *srp, void __user *p)
return err ? err : 0;
}
+static int
+sg_v4_receive(struct sg_fd *sfp, struct sg_request *srp, void __user *p,
+ struct sg_io_v4 *h4p)
+{
+ int err, err2;
+ u32 rq_result = srp->rq_result;
+
+ SG_LOG(3, sfp, "%s: p=%s, h4p=%s\n", __func__,
+ (p ? "given" : "NULL"), (h4p ? "given" : "NULL"));
+ err = sg_rec_v3v4_state(sfp, srp, true);
+ h4p->guard = 'Q';
+ h4p->protocol = 0;
+ h4p->subprotocol = 0;
+ h4p->device_status = rq_result & 0xff;
+ h4p->driver_status = driver_byte(rq_result);
+ h4p->transport_status = host_byte(rq_result);
+ h4p->response_len = srp->sense_len;
+ h4p->info = srp->rq_info;
+ h4p->flags = srp->rq_flags;
+ h4p->duration = srp->duration;
+ switch (srp->s_hdr4.dir) {
+ case SG_DXFER_FROM_DEV:
+ h4p->din_xfer_len = srp->sgat_h.dlen;
+ break;
+ case SG_DXFER_TO_DEV:
+ h4p->dout_xfer_len = srp->sgat_h.dlen;
+ break;
+ default:
+ break;
+ }
+ h4p->din_resid = srp->in_resid;
+ h4p->dout_resid = srp->s_hdr4.out_resid;
+ h4p->usr_ptr = srp->s_hdr4.usr_ptr;
+ h4p->response = (u64)srp->s_hdr4.sbp;
+ h4p->request_extra = srp->pack_id;
+ if (p) {
+ if (copy_to_user(p, h4p, SZ_SG_IO_V4))
+ err = err ? err : -EFAULT;
+ }
+ err2 = sg_rstate_chg(srp, atomic_read(&srp->rq_st), SG_RS_DONE_RD);
+ if (err2)
+ err = err ? err : err2;
+ sg_finish_scsi_blk_rq(srp);
+ sg_deact_request(sfp, srp);
+ return err < 0 ? err : 0;
+}
+
+/*
+ * Called when ioctl(SG_IORECEIVE) received. Expects a v4 interface object.
+ * Checks if O_NONBLOCK file flag given, if not checks given 'flags' field
+ * to see if SGV4_FLAG_IMMED is set. Either of these implies non blocking.
+ * When non-blocking and there is no request waiting, yields EAGAIN;
+ * otherwise it waits (i.e. it "blocks").
+ */
+static int
+sg_ctl_ioreceive(struct file *filp, struct sg_fd *sfp, void __user *p)
+{
+ bool non_block = !!(filp->f_flags & O_NONBLOCK);
+ int res, id;
+ int pack_id = SG_PACK_ID_WILDCARD;
+ u8 v4_holder[SZ_SG_IO_V4];
+ struct sg_io_v4 *h4p = (struct sg_io_v4 *)v4_holder;
+ struct sg_device *sdp = sfp->parentdp;
+ struct sg_request *srp;
+
+ res = sg_allow_if_err_recovery(sdp, non_block);
+ if (res)
+ return res;
+ /* Get first three 32 bit integers: guard, proto+subproto */
+ if (copy_from_user(h4p, p, SZ_SG_IO_V4))
+ return -EFAULT;
+ /* for v4: protocol=0 --> SCSI; subprotocol=0 --> SPC++ */
+ if (h4p->guard != 'Q' || h4p->protocol != 0 || h4p->subprotocol != 0)
+ return -EPERM;
+ if (h4p->flags & SGV4_FLAG_IMMED)
+ non_block = true; /* set by either this or O_NONBLOCK */
+ SG_LOG(3, sfp, "%s: non_block(+IMMED)=%d\n", __func__, non_block);
+ /* read in part of v3 or v4 header for pack_id or tag based find */
+ id = pack_id;
+ srp = sg_find_srp_by_id(sfp, id);
+ if (!srp) { /* nothing available so wait on packet or */
+ if (unlikely(SG_IS_DETACHING(sdp)))
+ return -ENODEV;
+ if (non_block)
+ return -EAGAIN;
+ res = wait_event_interruptible(sfp->read_wait,
+ sg_get_ready_srp(sfp, &srp,
+ id));
+ if (unlikely(SG_IS_DETACHING(sdp)))
+ return -ENODEV;
+ if (res) /* -ERESTARTSYS as signal hit process */
+ return res;
+ } /* now srp should be valid */
+ return sg_v4_receive(sfp, srp, p, h4p);
+}
+
static int
sg_rd_v1v2(void __user *buf, int count, struct sg_fd *sfp,
struct sg_request *srp)
@@ -1224,6 +1453,8 @@ sg_fill_request_element(struct sg_fd *sfp, struct sg_request *srp,
rip->sg_io_owned = test_bit(SG_FRQ_SYNC_INVOC, srp->frq_bm);
rip->problem = !!(srp->rq_result & SG_ML_RESULT_MSK);
rip->pack_id = srp->pack_id;
+ rip->usr_ptr = test_bit(SG_FRQ_IS_V4I, srp->frq_bm) ?
+ uptr64(srp->s_hdr4.usr_ptr) : srp->s_hdr3.usr_ptr;
rip->usr_ptr = srp->s_hdr3.usr_ptr;
spin_unlock(&srp->req_lck);
}
@@ -1241,7 +1472,7 @@ sg_rq_landed(struct sg_device *sdp, struct sg_request *srp)
*/
static int
sg_wait_event_srp(struct file *filp, struct sg_fd *sfp, void __user *p,
- struct sg_request *srp)
+ struct sg_io_v4 *h4p, struct sg_request *srp)
{
int res;
enum sg_rq_state sr_st;
@@ -1269,7 +1500,10 @@ sg_wait_event_srp(struct file *filp, struct sg_fd *sfp, void __user *p,
res = sg_rstate_chg(srp, sr_st, SG_RS_BUSY);
if (unlikely(res))
return res;
- res = sg_v3_receive(sfp, srp, p);
+ if (test_bit(SG_FRQ_IS_V4I, srp->frq_bm))
+ res = sg_v4_receive(sfp, srp, p, h4p);
+ else
+ res = sg_v3_receive(sfp, srp, p);
return (res < 0) ? res : 0;
}
@@ -1283,8 +1517,9 @@ sg_ctl_sg_io(struct file *filp, struct sg_device *sdp, struct sg_fd *sfp,
{
int res;
struct sg_request *srp = NULL;
- u8 hu8arr[SZ_SG_IO_HDR];
+ u8 hu8arr[SZ_SG_IO_V4];
struct sg_io_hdr *h3p = (struct sg_io_hdr *)hu8arr;
+ struct sg_io_v4 *h4p = (struct sg_io_v4 *)hu8arr;
SG_LOG(3, sfp, "%s: SG_IO%s\n", __func__,
((filp->f_flags & O_NONBLOCK) ? " O_NONBLOCK ignored" : ""));
@@ -1293,15 +1528,25 @@ sg_ctl_sg_io(struct file *filp, struct sg_device *sdp, struct sg_fd *sfp,
return res;
if (copy_from_user(h3p, p, SZ_SG_IO_HDR))
return -EFAULT;
- if (h3p->interface_id == 'S')
- res = sg_submit(filp, sfp, h3p, true, &srp);
- else
+ if (h3p->interface_id == 'Q') {
+ /* copy in rest of sg_io_v4 object */
+ if (copy_from_user(hu8arr + SZ_SG_IO_HDR,
+ ((u8 __user *)p) + SZ_SG_IO_HDR,
+ SZ_SG_IO_V4 - SZ_SG_IO_HDR))
+ return -EFAULT;
+ res = sg_v4_submit(filp, sfp, p, h4p, true, &srp);
+ } else if (h3p->interface_id == 'S') {
+ res = sg_v3_submit(filp, sfp, h3p, true, &srp);
+ } else {
+ pr_info_once("sg: %s: v3 or v4 interface only here\n",
+ __func__);
return -EPERM;
+ }
if (unlikely(res < 0))
return res;
if (!srp) /* mrq case: already processed all responses */
return res;
- res = sg_wait_event_srp(filp, sfp, p, srp);
+ res = sg_wait_event_srp(filp, sfp, p, h4p, srp);
if (res) {
SG_LOG(1, sfp, "%s: %s=0x%p state: %s\n", __func__,
"unexpected srp", srp,
@@ -1489,6 +1734,12 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
switch (cmd_in) {
case SG_IO:
return sg_ctl_sg_io(filp, sdp, sfp, p);
+ case SG_IOSUBMIT:
+ SG_LOG(3, sfp, "%s: SG_IOSUBMIT\n", __func__);
+ return sg_ctl_iosubmit(filp, sfp, p);
+ case SG_IORECEIVE:
+ SG_LOG(3, sfp, "%s: SG_IORECEIVE\n", __func__);
+ return sg_ctl_ioreceive(filp, sfp, p);
case SG_GET_SCSI_ID:
return sg_ctl_scsi_id(sdev, sfp, p);
case SG_SET_FORCE_PACK_ID:
@@ -1984,8 +2235,16 @@ sg_rq_end_io(struct request *rq, blk_status_t status)
slen = min_t(int, scsi_rp->sense_len, SCSI_SENSE_BUFFERSIZE);
a_resid = scsi_rp->resid_len;
- if (a_resid)
- srp->in_resid = a_resid;
+ if (a_resid) {
+ if (test_bit(SG_FRQ_IS_V4I, srp->frq_bm)) {
+ if (rq_data_dir(rq) == READ)
+ srp->in_resid = a_resid;
+ else
+ srp->s_hdr4.out_resid = a_resid;
+ } else {
+ srp->in_resid = a_resid;
+ }
+ }
SG_LOG(6, sfp, "%s: pack_id=%d, res=0x%x\n", __func__, srp->pack_id,
srp->rq_result);
@@ -2381,7 +2640,8 @@ sg_set_map_data(const struct sg_scatter_hold *schp, bool up_valid,
}
static int
-sg_start_req(struct sg_request *srp, u8 *cmd, int cmd_len, int dxfer_dir)
+sg_start_req(struct sg_request *srp, u8 *cmd, int cmd_len,
+ struct sg_io_v4 *h4p, int dxfer_dir)
{
bool reserved, us_xfer;
int res = 0;
@@ -2398,7 +2658,6 @@ sg_start_req(struct sg_request *srp, u8 *cmd, int cmd_len, int dxfer_dir)
struct rq_map_data *md = (void *)srp; /* want any non-NULL value */
u8 *long_cmdp = NULL;
__maybe_unused const char *cp = "";
- struct sg_slice_hdr3 *sh3p = &srp->s_hdr3;
struct rq_map_data map_data;
sdp = sfp->parentdp;
@@ -2408,10 +2667,28 @@ sg_start_req(struct sg_request *srp, u8 *cmd, int cmd_len, int dxfer_dir)
return -ENOMEM;
SG_LOG(5, sfp, "%s: long_cmdp=0x%p ++\n", __func__, long_cmdp);
}
- up = sh3p->dxferp;
- dxfer_len = (int)sh3p->dxfer_len;
- iov_count = sh3p->iovec_count;
- r0w = dxfer_dir == SG_DXFER_TO_DEV ? WRITE : READ;
+ if (h4p) {
+ if (dxfer_dir == SG_DXFER_TO_DEV) {
+ r0w = WRITE;
+ up = uptr64(h4p->dout_xferp);
+ dxfer_len = (int)h4p->dout_xfer_len;
+ iov_count = h4p->dout_iovec_count;
+ } else if (dxfer_dir == SG_DXFER_FROM_DEV) {
+ r0w = READ;
+ up = uptr64(h4p->din_xferp);
+ dxfer_len = (int)h4p->din_xfer_len;
+ iov_count = h4p->din_iovec_count;
+ } else {
+ up = NULL;
+ }
+ } else {
+ struct sg_slice_hdr3 *sh3p = &srp->s_hdr3;
+
+ up = sh3p->dxferp;
+ dxfer_len = (int)sh3p->dxfer_len;
+ iov_count = sh3p->iovec_count;
+ r0w = dxfer_dir == SG_DXFER_TO_DEV ? WRITE : READ;
+ }
SG_LOG(4, sfp, "%s: dxfer_len=%d, data-%s\n", __func__, dxfer_len,
(r0w ? "OUT" : "IN"));
q = sdp->device->request_queue;
diff --git a/include/uapi/scsi/sg.h b/include/uapi/scsi/sg.h
index 072b45bd732f..47eefe731a84 100644
--- a/include/uapi/scsi/sg.h
+++ b/include/uapi/scsi/sg.h
@@ -98,6 +98,18 @@ typedef struct sg_io_hdr {
#define SG_FLAG_Q_AT_TAIL 0x10
#define SG_FLAG_Q_AT_HEAD 0x20
+/*
+ * Flags used by ioctl(SG_IOSUBMIT) [abbrev: SG_IOS] and ioctl(SG_IORECEIVE)
+ * [abbrev: SG_IOR] OR-ed into sg_io_v4::flags. The sync v4 interface uses
+ * ioctl(SG_IO) and can take these new flags, as can the v3 interface.
+ * These flags apply for SG_IOS unless otherwise noted. May be OR-ed together.
+ */
+#define SGV4_FLAG_DIRECT_IO SG_FLAG_DIRECT_IO
+#define SGV4_FLAG_MMAP_IO SG_FLAG_MMAP_IO
+#define SGV4_FLAG_Q_AT_TAIL SG_FLAG_Q_AT_TAIL
+#define SGV4_FLAG_Q_AT_HEAD SG_FLAG_Q_AT_HEAD
+#define SGV4_FLAG_IMMED 0x400 /* for polling with SG_IOR, ignored in SG_IOS */
+
/* Output (potentially OR-ed together) in v3::info or v4::info field */
#define SG_INFO_OK_MASK 0x1
#define SG_INFO_OK 0x0 /* no sense, host nor driver "noise" */
@@ -133,7 +145,6 @@ typedef struct sg_req_info { /* used by SG_GET_REQUEST_TABLE ioctl() */
/* sg_io_owned set imples synchronous, clear implies asynchronous */
char sg_io_owned;/* 0 -> complete with read(), 1 -> owned by SG_IO */
char problem; /* 0 -> no problem detected, 1 -> error to report */
- /* If SG_CTL_FLAGM_TAG_FOR_PACK_ID set on fd then next field is tag */
int pack_id; /* pack_id, in v4 driver may be tag instead */
void __user *usr_ptr; /* user provided pointer in v3+v4 interface */
unsigned int duration;
@@ -162,6 +173,13 @@ typedef struct sg_req_info { /* used by SG_GET_REQUEST_TABLE ioctl() */
#define SG_SET_RESERVED_SIZE 0x2275 /* request new reserved buffer size */
#define SG_GET_RESERVED_SIZE 0x2272 /* actual size of reserved buffer */
+/*
+ * Historically the scsi/sg driver has used 0x22 as it ioctl base number.
+ * Add a define for that value and use it for several new ioctls added in
+ * version 4.0.01 sg driver and later.
+ */
+#define SG_IOCTL_MAGIC_NUM 0x22
+
/* The following ioctl has a 'sg_scsi_id_t *' object as its 3rd argument. */
#define SG_GET_SCSI_ID 0x2276 /* Yields fd's bus, chan, dev, lun + type */
/* SCSI id information can also be obtained from SCSI_IOCTL_GET_IDLUN */
@@ -318,6 +336,23 @@ struct sg_header {
*/
#define SG_NEXT_CMD_LEN 0x2283
+/*
+ * New ioctls to replace async (non-blocking) write()/read() interface.
+ * Present in version 4 and later of the sg driver [>20190427]. The
+ * SG_IOSUBMIT and SG_IORECEIVE ioctls accept the sg_v4 interface based on
+ * struct sg_io_v4 found in <include/uapi/linux/bsg.h>. These objects are
+ * passed by a pointer in the third argument of the ioctl.
+ *
+ * Data may be transferred both from the user space to the driver by these
+ * ioctls. Hence the _IOWR macro is used here to generate the ioctl number
+ * rather than _IOW or _IOR.
+ */
+/* Submits a v4 interface object to driver, optionally receive tag back */
+#define SG_IOSUBMIT _IOWR(SG_IOCTL_MAGIC_NUM, 0x41, struct sg_io_v4)
+
+/* Gives some v4 identifying info to driver, receives associated response */
+#define SG_IORECEIVE _IOWR(SG_IOCTL_MAGIC_NUM, 0x42, struct sg_io_v4)
+
/* command queuing is always on when the v3 or v4 interface is used */
#define SG_DEF_COMMAND_Q 0
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 13/20] sg: add sg v4 interface support
2019-08-07 11:42 ` [PATCH v3 13/20] sg: add sg v4 interface support Douglas Gilbert
@ 2019-08-09 23:12 ` James Bottomley
2019-08-11 19:21 ` Douglas Gilbert
0 siblings, 1 reply; 63+ messages in thread
From: James Bottomley @ 2019-08-09 23:12 UTC (permalink / raw)
To: Douglas Gilbert, linux-scsi; +Cc: martin.petersen, hare, bvanassche
On Wed, 2019-08-07 at 13:42 +0200, Douglas Gilbert wrote:
> Add support for the sg v4 interface based on struct sg_io_v4 found
> in include/uapi/linux/bsg.h and only previously supported by the
> bsg driver. Add ioctl(SG_IOSUBMIT) and ioctl(SG_IORECEIVE) for
> async (non-blocking) usage of the sg v4 interface. Do not accept
> the v3 interface with these ioctls. Do not accept the v4
> interface with this driver's existing write() and read()
> system calls.
>
> For sync (blocking) usage expand the existing ioctl(SG_IO)
> to additionally accept the sg v4 interface object.
First the meta comments:
Since this is effectively a new interface for sg, we're not constrained
by what happened before. Specifically, we don't want to support the
read/write interface for v4, that should remain only for legacy v3.
We're already discussing what the correct async interface should look
like, I won't comment on the IOSUBMIT/IORECEIVE parts.
Given that we want to unify the v4 code paths, I think this:
> @@ -1293,15 +1528,25 @@ sg_ctl_sg_io(struct file *filp, struct
> sg_device *sdp, struct sg_fd *sfp,
> return res;
> if (copy_from_user(h3p, p, SZ_SG_IO_HDR))
> return -EFAULT;
> - if (h3p->interface_id == 'S')
> - res = sg_submit(filp, sfp, h3p, true, &srp);
> - else
> + if (h3p->interface_id == 'Q') {
> + /* copy in rest of sg_io_v4 object */
> + if (copy_from_user(hu8arr + SZ_SG_IO_HDR,
> + ((u8 __user *)p) + SZ_SG_IO_HDR,
> + SZ_SG_IO_V4 - SZ_SG_IO_HDR))
> + return -EFAULT;
> + res = sg_v4_submit(filp, sfp, p, h4p, true, &srp);
Can simply become
if (h3p->interface_id == 'Q')
return bsg_sg_io(sdp->request_queue, filp->file_mode, p);
And all the duplicate code could then be eliminated. Of course, we
have to export bsg_sg_io, but that should be a trivial addition.
James
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 13/20] sg: add sg v4 interface support
2019-08-09 23:12 ` James Bottomley
@ 2019-08-11 19:21 ` Douglas Gilbert
0 siblings, 0 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-11 19:21 UTC (permalink / raw)
To: James Bottomley, linux-scsi; +Cc: martin.petersen, hare, bvanassche
On 2019-08-10 1:12 a.m., James Bottomley wrote:
> On Wed, 2019-08-07 at 13:42 +0200, Douglas Gilbert wrote:
>> Add support for the sg v4 interface based on struct sg_io_v4 found
>> in include/uapi/linux/bsg.h and only previously supported by the
>> bsg driver. Add ioctl(SG_IOSUBMIT) and ioctl(SG_IORECEIVE) for
>> async (non-blocking) usage of the sg v4 interface. Do not accept
>> the v3 interface with these ioctls. Do not accept the v4
>> interface with this driver's existing write() and read()
>> system calls.
>>
>> For sync (blocking) usage expand the existing ioctl(SG_IO)
>> to additionally accept the sg v4 interface object.
>
> First the meta comments:
>
> Since this is effectively a new interface for sg, we're not constrained
> by what happened before. Specifically, we don't want to support the
> read/write interface for v4, that should remain only for legacy v3.
Yes, and I don't want to support the bsg sync v4 interface which I
consider to be a subset of the existing sg v3 interface (and
its implementation). See further details below.
> We're already discussing what the correct async interface should look
> like, I won't comment on the IOSUBMIT/IORECEIVE parts.
If the kernel had an API mapping layer that was sensitive file
descriptors of a "special file" (e.g. "/dev/bsg/0:0:0:1") then it
could map:
write(bsg_fd, &sg_io_v4_obj, sizeof(sg_io_v4_obj))
to
ioctl(corresponding_sg_fd, SG_IOSUBMIT, &sg_io_v4_obj)
Plus a similar mapping for read() to ioctl(SG_IORECEIVE).
Obviously a pipe dream, but useful IMO for what I am trying to
achieve.
> Given that we want to unify the v4 code paths, I think this:
>
>> @@ -1293,15 +1528,25 @@ sg_ctl_sg_io(struct file *filp, struct
>> sg_device *sdp, struct sg_fd *sfp,
>> return res;
>> if (copy_from_user(h3p, p, SZ_SG_IO_HDR))
>> return -EFAULT;
>> - if (h3p->interface_id == 'S')
>> - res = sg_submit(filp, sfp, h3p, true, &srp);
>> - else
>> + if (h3p->interface_id == 'Q') {
>> + /* copy in rest of sg_io_v4 object */
>> + if (copy_from_user(hu8arr + SZ_SG_IO_HDR,
>> + ((u8 __user *)p) + SZ_SG_IO_HDR,
>> + SZ_SG_IO_V4 - SZ_SG_IO_HDR))
>> + return -EFAULT;
>> + res = sg_v4_submit(filp, sfp, p, h4p, true, &srp);
>
> Can simply become
>
> if (h3p->interface_id == 'Q')
> return bsg_sg_io(sdp->request_queue, filp->file_mode, p);
>
> And all the duplicate code could then be eliminated. Of course, we
> have to export bsg_sg_io, but that should be a trivial addition.
Interesting idea. As always, the devil is in the detail, and in this
case, in the interface.
First, when I defined the sg v4 interface it was a superset of
the existing sg v3 interface (and implementation). This meant that
the sg v4 interface supported the flags and info fields of the
existing sg v3 driver interface according to my design document. There
are also SG_* ioctls that effectively hold metadata at file descriptor,
device and, in some cases, driver scope. The bsg implementation of the
sg v4 interface either ignores or dummies out all of the above.
Amongst other things this led to the fatal flaw in the bsg async
implementation in which two SCSI commands issued through the bsg
driver in different processes on the same device (i.e. independent
operations from the users' point of view) could receive one another's
responses. Reason: no effective file scope.
Incredible, but that has been solved by removing the async interface
from the bsg driver!
The bsg v4 interface implementation did introduce two flags:
BSG_FLAG_Q_AT_TAIL and BSG_FLAG_Q_AT_HEAD and they were duly
backported into the sg driver over 5 years ago. No backporting
of pre-existing sg characteristics was ever done on the bsg driver
that I am aware of, certainly not recently, say the last 10 years.
And when you also remove bidi support from the whole kernel, and
thus from the bsg driver, why have a SCSI command interface in
the bsg driver at all??
After all, one can already issue sync SCSI commands with
ioctl(SG_IO, &sg_v3_obj) on all SCSI devices via /dev/sd<letter*>,
/dev/sr, etc. This would turn your suggestion on its head. Don't
call bsg_sg_io(), instead get rid of the bsg _sync_ SCSI interface!
If your suggestion was implemented the sg v4 interface in the sg
driver would become a significant regression on what the sg driver
offers at the moment. IMO that would be perverse. In my
documentation at http://sg.danny.cz/sg/sg_v40.html the flags
and info fields are now listed in sections 2.2 and 2.3 . I would
need to add on almost all entries: "not implemented in the
v4 sync interface but available in the v4 async interface". A
diligent reader might wonder what the author was smoking?
And the reserve buffer: originally added in the late nineties
when the sg driver could fail to get RAM during a CD write.
Complete crap, so the bsg driver implementation threw it
out (and dummied out the ioctl()s that supported it). Now
look at sections 6 and 8 (request sharing) in the above document
and specifically the diagram in section 8. The data carrier
between the READ and the WRITE is the master side's reserve
buffer. So new life for the reserve buffer concept. Notice
also in that diagram both the READ and WRITE invocations
use ioctl(SG_IO) (i.e. they are sync) and thus would not work
with your suggestion in the case of the v4 interface (but would
work with the v3 interface).
And while on the the subject of request sharing I challenge Bart
to show us how his better API (hinted at but not presented) would
be faster than request sharing for a disk to disk copy.
ioctl(SG_IO) can also be used for a multiple requests invocation
in my proposed second patchset. See "ordered blocking" in the
second table of section 10 on Multiple requests. That would need
some "smoke and mirrors" to work as defined in the presence
of your suggestion.
Also notice that "variable blocking" in that table would give the
user a very simple and fast READ GATHERED capability. [READ GATHERED
is the non-existent t10.org SCSI command that would pair with one
they have defined: WRITE SCATTERED command.] This could have been
done with the multiple submission capability of write() in the bsg
driver, that is before it was removed. That "variable blocking" is
slightly better because it is "sync" seen from the user's
perspective.
Finally I don't regard the sg v3 interface as legacy. Without my
two proposed patchsets *** the bsg driver is well on the way to
making the v4 interface legacy, at least in terms of the number
of users. The removal of bidi also partially undermines the
argument of why the v4 interface was better than the v3 interface.
I want to, and am prepared to do the associated work, to support
both the v3 and v4 interfaces in the sg driver. That said, some
completely new proposals, such as multiple request invocations,
are only supported with the v4 interface. All proposed (new)
ioctls comply with the spirit and the letter of what the _IOR(W)
macros are trying to achieve: (somewhat) structured ioctls.
Doug Gilbert
*** This tarball (http://sg.danny.cz/sg/p/sgv4_20190808.tgz) contains
a 36 part patchset where patches 1 through 20 are the same as sent
to this list on 20190807, the first of which was titled:
[PATCH v3 00/20] sg: add v4 interface
The remaining 16 patches implement the extra features and bring the
driver implementation into line with the description in:
http://sg.danny.cz/sg/sg_v40.html
So that 36 part patchset rolls the two patchsets I have been
referring to, into one.
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 14/20] sg: rework debug info
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (12 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 13/20] sg: add sg v4 interface support Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-07 11:42 ` [PATCH v3 15/20] sg: add 8 byte SCSI LUN to sg_scsi_id Douglas Gilbert
` (6 subsequent siblings)
20 siblings, 0 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
Since the version 2 driver, the state of the driver can be found
with 'cat /proc/scsi/sg/debug'. As the driver becomes more
threaded and IO faster (e.g. scsi_debug with a command timer
of 5 microseconds), the existing state dump can become
misleading as the state can change during the "snapshot". The
new approach in this patch is to allocate a buffer of
SG_PROC_DEBUG_SZ bytes and use scnprintf() to populate it. Only
when the whole state is captured (or the buffer fills) is the
output to the caller's terminal performed. The previous
approach was line based: assemble a line of information and
then output it.
Locks are taken as required for short periods and should not
interfere with a disk IO intensive program. Operations
such as closing a sg file descriptor or removing a sg device
may be held up for a short while (microseconds).
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 235 +++++++++++++++++++++++++++++++---------------
1 file changed, 157 insertions(+), 78 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index b12f53851078..694a2f50063b 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -3773,115 +3773,194 @@ sg_proc_seq_show_devstrs(struct seq_file *s, void *v)
return 0;
}
-/* must be called while holding sg_index_lock */
-static void
-sg_proc_debug_helper(struct seq_file *s, struct sg_device *sdp)
+/* Writes debug info for one sg_request in obp buffer */
+static int
+sg_proc_debug_sreq(struct sg_request *srp, int to, char *obp, int len)
{
- int k;
+ bool is_v3v4, v4, is_dur;
+ int n = 0;
+ u32 dur;
+ enum sg_rq_state rq_st;
+ const char *cp;
+
+ if (len < 1)
+ return 0;
+ v4 = test_bit(SG_FRQ_IS_V4I, srp->frq_bm);
+ is_v3v4 = v4 ? true : (srp->s_hdr3.interface_id != '\0');
+ if (srp->parentfp->rsv_srp == srp)
+ cp = (is_v3v4 && (srp->rq_flags & SG_FLAG_MMAP_IO)) ?
+ " mmap>> " : " rsv>> ";
+ else
+ cp = (srp->rq_info & SG_INFO_DIRECT_IO_MASK) ?
+ " dio>> " : " ";
+ rq_st = atomic_read(&srp->rq_st);
+ dur = sg_get_dur(srp, &rq_st, &is_dur);
+ n += scnprintf(obp + n, len - n, "%s%s: dlen=%d/%d id=%d", cp,
+ sg_rq_st_str(rq_st, false), srp->sgat_h.dlen,
+ srp->sgat_h.buflen, (int)srp->pack_id);
+ if (is_dur) /* cmd/req has completed, waiting for ... */
+ n += scnprintf(obp + n, len - n, " dur=%ums", dur);
+ else if (dur < U32_MAX) /* in-flight or busy (so ongoing) */
+ n += scnprintf(obp + n, len - n, " t_o/elap=%us/%ums",
+ to / 1000, dur);
+ n += scnprintf(obp + n, len - n, " sgat=%d op=0x%02x\n",
+ srp->sgat_h.num_sgat, srp->cmd_opcode);
+ return n;
+}
+
+/* Writes debug info for one sg fd (including its sg requests) in obp buffer */
+static int
+sg_proc_debug_fd(struct sg_fd *fp, char *obp, int len)
+{
+ bool first_fl;
+ int n = 0;
+ int to;
struct sg_request *srp;
- struct sg_fd *fp;
- const char * cp;
- unsigned int ms;
- k = 0;
- list_for_each_entry(fp, &sdp->sfds, sfd_entry) {
- k++;
- spin_lock(&fp->rq_list_lock); /* irqs already disabled */
- seq_printf(s, " FD(%d): timeout=%dms bufflen=%d "
- "(res)sgat=%d low_dma=%d\n", k,
- jiffies_to_msecs(fp->timeout),
- fp->rsv_srp->sgat_h.buflen,
- (int)fp->rsv_srp->sgat_h.num_sgat,
- (int) sdp->device->host->unchecked_isa_dma);
- seq_printf(s, " cmd_q=%d f_packid=%d k_orphan=%d closed=0\n",
- (int)test_bit(SG_FFD_CMD_Q, fp->ffd_bm),
- (int)test_bit(SG_FFD_FORCE_PACKID, fp->ffd_bm),
- (int)test_bit(SG_FFD_KEEP_ORPHAN, fp->ffd_bm));
- seq_printf(s, " submitted=%d waiting=%d\n",
- atomic_read(&fp->submitted),
- atomic_read(&fp->waiting));
- list_for_each_entry(srp, &fp->rq_list, rq_entry) {
- const struct sg_slice_hdr3 *sh3p = &srp->s_hdr3;
- bool is_v3 = (sh3p->interface_id != '\0');
- enum sg_rq_state rq_st = atomic_read(&srp->rq_st);
-
- if (srp->parentfp->rsv_srp == srp) {
- if (is_v3 && (SG_FLAG_MMAP_IO & sh3p->flags))
- cp = " mmap>> ";
- else
- cp = " rb>> ";
- } else {
- if (SG_INFO_DIRECT_IO_MASK & srp->rq_info)
- cp = " dio>> ";
- else
- cp = " ";
- }
- seq_puts(s, cp);
- seq_puts(s, sg_rq_st_str(rq_st, false));
- seq_printf(s, ": id=%d len/blen=%d/%d",
- srp->pack_id, srp->sgat_h.dlen,
- srp->sgat_h.buflen);
- if (rq_st == SG_RS_AWAIT_RD || rq_st == SG_RS_DONE_RD) {
- seq_printf(s, " dur=%d", srp->duration);
- goto fin_line;
- }
- ms = jiffies_to_msecs(jiffies);
- seq_printf(s, " t_o/elap=%d/%d",
- (is_v3 ? sh3p->timeout :
- jiffies_to_msecs(fp->timeout)),
- (ms > srp->duration ? ms - srp->duration :
- 0));
-fin_line:
- seq_printf(s, "ms sgat=%d op=0x%02x\n",
- srp->sgat_h.num_sgat, (int)srp->cmd_opcode);
+ /* sgat=-1 means unavailable */
+ to = jiffies_to_msecs(fp->timeout);
+ if (to % 1000)
+ n += scnprintf(obp + n, len - n, "timeout=%dms rs", to);
+ else
+ n += scnprintf(obp + n, len - n, "timeout=%ds rs", to / 1000);
+ n += scnprintf(obp + n, len - n, "v_buflen=%d\n cmd_q=%d ",
+ fp->rsv_srp->sgat_h.buflen,
+ (int)test_bit(SG_FFD_CMD_Q, fp->ffd_bm));
+ n += scnprintf(obp + n, len - n,
+ "f_packid=%d k_orphan=%d ffd_bm=0x%lx\n",
+ (int)test_bit(SG_FFD_FORCE_PACKID, fp->ffd_bm),
+ (int)test_bit(SG_FFD_KEEP_ORPHAN, fp->ffd_bm),
+ fp->ffd_bm[0]);
+ n += scnprintf(obp + n, len - n, " mmap_called=%d\n",
+ test_bit(SG_FFD_MMAP_CALLED, fp->ffd_bm));
+ n += scnprintf(obp + n, len - n,
+ " submitted=%d waiting=%d open thr_id=%d\n",
+ atomic_read(&fp->submitted),
+ atomic_read(&fp->waiting), fp->tid);
+ list_for_each_entry_rcu(srp, &fp->rq_list, rq_entry) {
+ spin_lock(&srp->req_lck);
+ n += sg_proc_debug_sreq(srp, fp->timeout, obp + n, len - n);
+ spin_unlock(&srp->req_lck);
+ }
+ if (list_empty(&fp->rq_list))
+ n += scnprintf(obp + n, len - n, " No requests active\n");
+ first_fl = true;
+ list_for_each_entry_rcu(srp, &fp->rq_fl, fl_entry) {
+ if (first_fl) {
+ n += scnprintf(obp + n, len - n, " Free list:\n");
+ first_fl = false;
}
- if (list_empty(&fp->rq_list))
- seq_puts(s, " No requests active\n");
- spin_unlock(&fp->rq_list_lock);
+ spin_lock(&srp->req_lck);
+ n += sg_proc_debug_sreq(srp, fp->timeout, obp + n, len - n);
+ spin_unlock(&srp->req_lck);
+ }
+ return n;
+}
+
+/* Writes debug info for one sg device (including its sg fds) in obp buffer */
+static int
+sg_proc_debug_sdev(struct sg_device *sdp, char *obp, int len, int *fd_counterp)
+{
+ int n = 0;
+ int my_count = 0;
+ struct scsi_device *ssdp = sdp->device;
+ struct sg_fd *fp;
+ char *disk_name;
+ int *countp;
+
+ countp = fd_counterp ? fd_counterp : &my_count;
+ disk_name = (sdp->disk ? sdp->disk->disk_name : "?_?");
+ n += scnprintf(obp + n, len - n, " >>> device=%s ", disk_name);
+ n += scnprintf(obp + n, len - n, "%d:%d:%d:%llu ", ssdp->host->host_no,
+ ssdp->channel, ssdp->id, ssdp->lun);
+ n += scnprintf(obp + n, len - n,
+ " max_sgat_sz,elems=2^%d,%d excl=%d open_cnt=%d\n",
+ ilog2(sdp->max_sgat_sz), sdp->max_sgat_elems,
+ SG_HAVE_EXCLUDE(sdp), atomic_read(&sdp->open_cnt));
+ list_for_each_entry(fp, &sdp->sfds, sfd_entry) {
+ ++*countp;
+ rcu_read_lock(); /* assume irqs disabled */
+ n += scnprintf(obp + n, len - n, " FD(%d): ", *countp);
+ n += sg_proc_debug_fd(fp, obp + n, len - n);
+ rcu_read_unlock();
}
+ return n;
}
+/* Called via dbg_seq_ops once for each sg device */
static int
sg_proc_seq_show_debug(struct seq_file *s, void *v)
{
+ bool found = false;
+ bool trunc = false;
+ const int bp_len = SG_PROC_DEBUG_SZ;
+ int n = 0;
+ int k = 0;
+ unsigned long iflags;
struct sg_proc_deviter *it = (struct sg_proc_deviter *)v;
struct sg_device *sdp;
- unsigned long iflags;
+ int *fdi_p;
+ char *bp;
+ char *disk_name;
+ char b1[128];
+ b1[0] = '\0';
if (it && (0 == it->index))
seq_printf(s, "max_active_device=%d def_reserved_size=%d\n",
- (int)it->max, sg_big_buff);
-
+ (int)it->max, def_reserved_size);
+ fdi_p = it ? &it->fd_index : &k;
+ bp = kzalloc(bp_len, __GFP_NOWARN | GFP_KERNEL);
+ if (!bp) {
+ seq_printf(s, "%s: Unable to allocate %d on heap, finish\n",
+ __func__, bp_len);
+ return -1;
+ }
read_lock_irqsave(&sg_index_lock, iflags);
sdp = it ? sg_lookup_dev(it->index) : NULL;
if (NULL == sdp)
goto skip;
read_lock(&sdp->sfd_lock);
if (!list_empty(&sdp->sfds)) {
- seq_printf(s, " >>> device=%s ", sdp->disk->disk_name);
+ found = true;
+ disk_name = (sdp->disk ? sdp->disk->disk_name : "?_?");
if (SG_IS_DETACHING(sdp))
- seq_puts(s, "detaching pending close ");
+ snprintf(b1, sizeof(b1), " >>> device=%s %s\n",
+ disk_name, "detaching pending close\n");
else if (sdp->device) {
- struct scsi_device *scsidp = sdp->device;
-
- seq_printf(s, "%d:%d:%d:%llu em=%d",
- scsidp->host->host_no,
- scsidp->channel, scsidp->id,
- scsidp->lun,
- scsidp->host->hostt->emulated);
+ n = sg_proc_debug_sdev(sdp, bp, bp_len, fdi_p);
+ if (n >= bp_len - 1) {
+ trunc = true;
+ if (bp[bp_len - 2] != '\n')
+ bp[bp_len - 2] = '\n';
+ }
+ } else {
+ snprintf(b1, sizeof(b1), " >>> device=%s %s\n",
+ disk_name, "sdp->device==NULL, skip");
}
- seq_printf(s, " max_sgat_elems=%d excl=%d open_cnt=%d\n",
- sdp->max_sgat_elems, SG_HAVE_EXCLUDE(sdp),
- atomic_read(&sdp->open_cnt));
- sg_proc_debug_helper(s, sdp);
}
read_unlock(&sdp->sfd_lock);
skip:
read_unlock_irqrestore(&sg_index_lock, iflags);
+ if (found) {
+ if (n > 0) {
+ seq_puts(s, bp);
+ if (seq_has_overflowed(s))
+ goto s_ovfl;
+ if (trunc)
+ seq_printf(s, " >> Output truncated %s\n",
+ "due to buffer size");
+ } else if (b1[0]) {
+ seq_puts(s, b1);
+ if (seq_has_overflowed(s))
+ goto s_ovfl;
+ }
+ }
+s_ovfl:
+ kfree(bp);
return 0;
}
-#endif /* CONFIG_SCSI_PROC_FS (~300 lines back) */
+#endif /* CONFIG_SCSI_PROC_FS (~400 lines back) */
module_init(init_sg);
module_exit(exit_sg);
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 15/20] sg: add 8 byte SCSI LUN to sg_scsi_id
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (13 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 14/20] sg: rework debug info Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-07 11:42 ` [PATCH v3 16/20] sg: expand sg_comm_wr_t Douglas Gilbert
` (5 subsequent siblings)
20 siblings, 0 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
The existing ioctl(SG_GET_SCSI_ID) fills a object of type
struct sg_scsi_id whose last field is int unused[2]. Add
an anonymous union with u8 scsi_lun[8] sharing those last
8 bytes. This patch will place the current device's full
LUN in the scsi_lun array using T10's preferred LUN
format (i.e. an array of 8 bytes) when
ioctl(SG_GET_SCSI_ID) is called.
Note that structure already contains a 'lun' field but that
is a 32 bit integer. Users of this upgrade should choose
the scsi_lun array field henceforth but existing code
can remain as it is and will get the same 'lun' value with
the version 3 or version 4 driver.
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 5 +++--
include/uapi/scsi/sg.h | 5 ++++-
2 files changed, 7 insertions(+), 3 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 694a2f50063b..fb7eeafff801 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -1684,6 +1684,7 @@ static int
sg_ctl_scsi_id(struct scsi_device *sdev, struct sg_fd *sfp, void __user *p)
{
struct sg_scsi_id __user *sg_idp = p;
+ struct scsi_lun lun8b;
SG_LOG(3, sfp, "%s: SG_GET_SCSI_ID\n", __func__);
if (!access_ok(p, sizeof(struct sg_scsi_id)))
@@ -1701,8 +1702,8 @@ sg_ctl_scsi_id(struct scsi_device *sdev, struct sg_fd *sfp, void __user *p)
&sg_idp->h_cmd_per_lun);
__put_user((short)sdev->queue_depth,
&sg_idp->d_queue_depth);
- __put_user(0, &sg_idp->unused[0]);
- __put_user(0, &sg_idp->unused[1]);
+ int_to_scsilun(sdev->lun, &lun8b);
+ __copy_to_user(sg_idp->scsi_lun, lun8b.scsi_lun, 8);
return 0;
}
diff --git a/include/uapi/scsi/sg.h b/include/uapi/scsi/sg.h
index 47eefe731a84..0d6fbf976e5c 100644
--- a/include/uapi/scsi/sg.h
+++ b/include/uapi/scsi/sg.h
@@ -135,7 +135,10 @@ typedef struct sg_scsi_id {
int scsi_type; /* TYPE_... defined in scsi/scsi.h */
short h_cmd_per_lun;/* host (adapter) maximum commands per lun */
short d_queue_depth;/* device (or adapter) maximum queue length */
- int unused[2];
+ union {
+ int unused[2]; /* as per version 3 driver */
+ __u8 scsi_lun[8]; /* full 8 byte SCSI LUN [in v4 driver] */
+ };
} sg_scsi_id_t;
/* For backward compatibility v4 driver yields at most SG_MAX_QUEUE of these */
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 16/20] sg: expand sg_comm_wr_t
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (14 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 15/20] sg: add 8 byte SCSI LUN to sg_scsi_id Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-07 11:42 ` [PATCH v3 17/20] sg: add sg_iosubmit_v3 and sg_ioreceive_v3 ioctls Douglas Gilbert
` (4 subsequent siblings)
20 siblings, 0 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
The internal struct sg_comm_wr_t was added when the number of
arguments to sg_common_write() became excessive. Expand this idea
so multiple calls to sg_fetch_cmnd() can be deferred until a
scsi_request object is ready to receive the command. This saves
a 252 byte stack allocation on every submit path. Prior to this
and a few other changes, the kernel infrastructure was warning
about excessive stack usage.
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 178 ++++++++++++++++++++++++----------------------
1 file changed, 92 insertions(+), 86 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index fb7eeafff801..a60c2bcc5430 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -253,35 +253,37 @@ struct sg_device { /* holds the state of each scsi generic device */
struct sg_comm_wr_t { /* arguments to sg_common_write() */
int timeout;
+ int cmd_len;
unsigned long frq_bm[1]; /* see SG_FRQ_* defines above */
union { /* selector is frq_bm.SG_FRQ_IS_V4I */
struct sg_io_hdr *h3p;
struct sg_io_v4 *h4p;
};
- u8 *cmnd;
+ struct sg_fd *sfp;
+ struct file *filp;
+ const u8 __user *u_cmdp;
};
/* tasklet or soft irq callback */
static void sg_rq_end_io(struct request *rq, blk_status_t status);
/* Declarations of other static functions used before they are defined */
static int sg_proc_init(void);
-static int sg_start_req(struct sg_request *srp, u8 *cmd, int cmd_len,
- struct sg_io_v4 *h4p, int dxfer_dir);
+static int sg_start_req(struct sg_request *srp, struct sg_comm_wr_t *cwrp,
+ int dxfer_dir);
static void sg_finish_scsi_blk_rq(struct sg_request *srp);
static int sg_mk_sgat(struct sg_request *srp, struct sg_fd *sfp, int minlen);
static int sg_v3_submit(struct file *filp, struct sg_fd *sfp,
struct sg_io_hdr *hp, bool sync,
struct sg_request **o_srp);
-static struct sg_request *sg_common_write(struct sg_fd *sfp,
- struct sg_comm_wr_t *cwp);
+static struct sg_request *sg_common_write(struct sg_comm_wr_t *cwp);
static int sg_rd_append(struct sg_request *srp, void __user *outp,
int num_xfer);
static void sg_remove_sgat(struct sg_request *srp);
static struct sg_fd *sg_add_sfp(struct sg_device *sdp);
static void sg_remove_sfp(struct kref *);
static struct sg_request *sg_find_srp_by_id(struct sg_fd *sfp, int id);
-static struct sg_request *sg_add_request(struct sg_fd *sfp, int dxfr_len,
- struct sg_comm_wr_t *cwrp);
+static struct sg_request *sg_add_request(struct sg_comm_wr_t *cwrp,
+ int dxfr_len);
static void sg_deact_request(struct sg_fd *sfp, struct sg_request *srp);
static struct sg_device *sg_get_dev(int min_dev);
static void sg_device_destroy(struct kref *kref);
@@ -578,7 +580,6 @@ sg_write(struct file *filp, const char __user *p, size_t count, loff_t *ppos)
struct sg_device *sdp;
struct sg_fd *sfp;
struct sg_request *srp;
- u8 cmnd[SG_MAX_CDB_SIZE];
struct sg_header ov2hdr;
struct sg_io_hdr v3hdr;
struct sg_header *ohp = &ov2hdr;
@@ -663,9 +664,6 @@ sg_write(struct file *filp, const char __user *p, size_t count, loff_t *ppos)
h3p->flags = input_size; /* structure abuse ... */
h3p->pack_id = ohp->pack_id;
h3p->usr_ptr = NULL;
- cmnd[0] = opcode;
- if (__copy_from_user(cmnd + 1, p + 1, cmd_size - 1))
- return -EFAULT;
/*
* SG_DXFER_TO_FROM_DEV is functionally equivalent to SG_DXFER_FROM_DEV,
* but it is possible that the app intended SG_DXFER_TO_DEV, because
@@ -676,13 +674,16 @@ sg_write(struct file *filp, const char __user *p, size_t count, loff_t *ppos)
"%s: data in/out %d/%d bytes for SCSI command 0x%x-- guessing data in;\n"
" program %s not setting count and/or reply_len properly\n",
__func__, ohp->reply_len - (int)SZ_SG_HEADER,
- input_size, (unsigned int)cmnd[0], current->comm);
+ input_size, (unsigned int)opcode, current->comm);
}
- cwr.frq_bm[0] = 0; /* initial state clear for all req flags */
+ memset(&cwr, 0, sizeof(cwr));
cwr.h3p = h3p;
cwr.timeout = sfp->timeout;
- cwr.cmnd = cmnd;
- srp = sg_common_write(sfp, &cwr);
+ cwr.cmd_len = cmd_size;
+ cwr.filp = filp;
+ cwr.sfp = sfp;
+ cwr.u_cmdp = p;
+ srp = sg_common_write(&cwr);
return (IS_ERR(srp)) ? PTR_ERR(srp) : (int)count;
}
@@ -711,11 +712,9 @@ static int
sg_v3_submit(struct file *filp, struct sg_fd *sfp, struct sg_io_hdr *hp,
bool sync, struct sg_request **o_srp)
{
- int res, timeout;
unsigned long ul_timeout;
struct sg_request *srp;
struct sg_comm_wr_t cwr;
- u8 cmnd[SG_MAX_CDB_SIZE];
/* now doing v3 blocking (sync) or non-blocking submission */
if (hp->flags & SG_FLAG_MMAP_IO) {
@@ -729,16 +728,15 @@ sg_v3_submit(struct file *filp, struct sg_fd *sfp, struct sg_io_hdr *hp,
/* when v3 seen, allow cmd_q on this fd (def: no cmd_q) */
set_bit(SG_FFD_CMD_Q, sfp->ffd_bm);
ul_timeout = msecs_to_jiffies(hp->timeout);
- timeout = min_t(unsigned long, ul_timeout, INT_MAX);
- res = sg_fetch_cmnd(filp, sfp, hp->cmdp, hp->cmd_len, cmnd);
- if (res)
- return res;
- cwr.frq_bm[0] = 0;
+ memset(&cwr, 0, sizeof(cwr));
__assign_bit(SG_FRQ_SYNC_INVOC, cwr.frq_bm, (int)sync);
cwr.h3p = hp;
- cwr.timeout = timeout;
- cwr.cmnd = cmnd;
- srp = sg_common_write(sfp, &cwr);
+ cwr.timeout = min_t(unsigned long, ul_timeout, INT_MAX);
+ cwr.cmd_len = hp->cmd_len;
+ cwr.filp = filp;
+ cwr.sfp = sfp;
+ cwr.u_cmdp = hp->cmdp;
+ srp = sg_common_write(&cwr);
if (IS_ERR(srp))
return PTR_ERR(srp);
if (o_srp)
@@ -750,12 +748,15 @@ static int
sg_v4_submit(struct file *filp, struct sg_fd *sfp, void __user *p,
struct sg_io_v4 *h4p, bool sync, struct sg_request **o_srp)
{
- int timeout, res;
+ int res = 0;
unsigned long ul_timeout;
struct sg_request *srp;
struct sg_comm_wr_t cwr;
- u8 cmnd[SG_MAX_CDB_SIZE];
+ memset(&cwr, 0, sizeof(cwr));
+ cwr.filp = filp;
+ cwr.sfp = sfp;
+ cwr.h4p = h4p;
if (h4p->flags & SG_FLAG_MMAP_IO) {
int len = 0;
@@ -773,18 +774,13 @@ sg_v4_submit(struct file *filp, struct sg_fd *sfp, void __user *p,
/* once v4 (or v3) seen, allow cmd_q on this fd (def: no cmd_q) */
set_bit(SG_FFD_CMD_Q, sfp->ffd_bm);
ul_timeout = msecs_to_jiffies(h4p->timeout);
- timeout = min_t(unsigned long, ul_timeout, INT_MAX);
- res = sg_fetch_cmnd(filp, sfp, cuptr64(h4p->request), h4p->request_len,
- cmnd);
- if (res)
- return res;
- cwr.frq_bm[0] = 0;
- assign_bit(SG_FRQ_SYNC_INVOC, cwr.frq_bm, (int)sync);
- set_bit(SG_FRQ_IS_V4I, cwr.frq_bm);
+ __assign_bit(SG_FRQ_SYNC_INVOC, cwr.frq_bm, (int)sync);
+ __set_bit(SG_FRQ_IS_V4I, cwr.frq_bm);
cwr.h4p = h4p;
- cwr.timeout = timeout;
- cwr.cmnd = cmnd;
- srp = sg_common_write(sfp, &cwr);
+ cwr.timeout = min_t(unsigned long, ul_timeout, INT_MAX);
+ cwr.cmd_len = h4p->request_len;
+ cwr.u_cmdp = cuptr64(h4p->request);
+ srp = sg_common_write(&cwr);
if (IS_ERR(srp))
return PTR_ERR(srp);
if (o_srp)
@@ -862,13 +858,14 @@ sg_rstate_chg(struct sg_request *srp, enum sg_rq_state old_st,
* N.B. pack_id placed in sg_io_v4::request_extra field.
*/
static struct sg_request *
-sg_common_write(struct sg_fd *sfp, struct sg_comm_wr_t *cwrp)
+sg_common_write(struct sg_comm_wr_t *cwrp)
{
int res = 0;
- int dxfr_len, dir, cmd_len;
+ int dxfr_len, dir;
int pack_id = SG_PACK_ID_WILDCARD;
u32 rq_flags;
- struct sg_device *sdp = sfp->parentdp;
+ struct sg_fd *fp = cwrp->sfp;
+ struct sg_device *sdp = fp->parentdp;
struct sg_request *srp;
struct sg_io_hdr *hi_p;
struct sg_io_v4 *h4p;
@@ -900,7 +897,7 @@ sg_common_write(struct sg_fd *sfp, struct sg_comm_wr_t *cwrp)
if (dxfr_len >= SZ_256M)
return ERR_PTR(-EINVAL);
- srp = sg_add_request(sfp, dxfr_len, cwrp);
+ srp = sg_add_request(cwrp, dxfr_len);
if (IS_ERR(srp))
return srp;
srp->rq_flags = rq_flags;
@@ -913,18 +910,14 @@ sg_common_write(struct sg_fd *sfp, struct sg_comm_wr_t *cwrp)
srp->s_hdr4.max_sb_len = h4p->max_response_len;
srp->s_hdr4.cmd_len = h4p->request_len;
srp->s_hdr4.dir = dir;
- cmd_len = h4p->request_len;
} else { /* v3 interface active */
- cmd_len = hi_p->cmd_len;
memcpy(&srp->s_hdr3, hi_p, sizeof(srp->s_hdr3));
}
- srp->cmd_opcode = cwrp->cmnd[0];/* hold opcode of command for debug */
- SG_LOG(4, sfp, "%s: opcode=0x%02x, cdb_sz=%d, pack_id=%d\n", __func__,
- (int)cwrp->cmnd[0], cmd_len, pack_id);
-
- res = sg_start_req(srp, cwrp->cmnd, cmd_len, h4p, dir);
+ res = sg_start_req(srp, cwrp, dir);
if (res < 0) /* probably out of space --> -ENOMEM */
goto err_out;
+ SG_LOG(4, fp, "%s: opcode=0x%02x, cdb_sz=%d, pack_id=%d\n", __func__,
+ srp->cmd_opcode, cwrp->cmd_len, pack_id);
if (unlikely(SG_IS_DETACHING(sdp))) {
res = -ENODEV;
goto err_out;
@@ -934,11 +927,11 @@ sg_common_write(struct sg_fd *sfp, struct sg_comm_wr_t *cwrp)
goto err_out;
}
srp->rq->timeout = cwrp->timeout;
- sg_execute_cmd(sfp, srp);
+ sg_execute_cmd(fp, srp);
return srp;
err_out:
sg_finish_scsi_blk_rq(srp);
- sg_deact_request(sfp, srp);
+ sg_deact_request(fp, srp);
return ERR_PTR(res);
}
@@ -1171,8 +1164,8 @@ sg_ctl_ioreceive(struct file *filp, struct sg_fd *sfp, void __user *p)
id));
if (unlikely(SG_IS_DETACHING(sdp)))
return -ENODEV;
- if (res) /* -ERESTARTSYS as signal hit process */
- return res;
+ if (res)
+ return res; /* signal --> -ERESTARTSYS */
} /* now srp should be valid */
return sg_v4_receive(sfp, srp, p, h4p);
}
@@ -2577,7 +2570,7 @@ init_sg(void)
}
sg_sysfs_valid = true;
rc = scsi_register_interface(&sg_interface);
- if (0 == rc) {
+ if (rc == 0) {
sg_proc_init();
return 0;
}
@@ -2641,8 +2634,7 @@ sg_set_map_data(const struct sg_scatter_hold *schp, bool up_valid,
}
static int
-sg_start_req(struct sg_request *srp, u8 *cmd, int cmd_len,
- struct sg_io_v4 *h4p, int dxfer_dir)
+sg_start_req(struct sg_request *srp, struct sg_comm_wr_t *cwrp, int dxfer_dir)
{
bool reserved, us_xfer;
int res = 0;
@@ -2652,7 +2644,7 @@ sg_start_req(struct sg_request *srp, u8 *cmd, int cmd_len,
void __user *up;
struct request *rq;
struct scsi_request *scsi_rp;
- struct sg_fd *sfp = srp->parentfp;
+ struct sg_fd *sfp = cwrp->sfp;
struct sg_device *sdp;
struct sg_scatter_hold *req_schp;
struct request_queue *q;
@@ -2662,20 +2654,21 @@ sg_start_req(struct sg_request *srp, u8 *cmd, int cmd_len,
struct rq_map_data map_data;
sdp = sfp->parentdp;
- if (cmd_len > BLK_MAX_CDB) { /* for longer SCSI cdb_s */
- long_cmdp = kzalloc(cmd_len, GFP_KERNEL);
+ if (cwrp->cmd_len > BLK_MAX_CDB) { /* for longer SCSI cdb_s */
+ long_cmdp = kzalloc(cwrp->cmd_len, GFP_KERNEL);
if (!long_cmdp)
return -ENOMEM;
SG_LOG(5, sfp, "%s: long_cmdp=0x%p ++\n", __func__, long_cmdp);
}
- if (h4p) {
+ if (test_bit(SG_FRQ_IS_V4I, srp->frq_bm)) {
+ struct sg_io_v4 *h4p = cwrp->h4p;
+
if (dxfer_dir == SG_DXFER_TO_DEV) {
r0w = WRITE;
up = uptr64(h4p->dout_xferp);
dxfer_len = (int)h4p->dout_xfer_len;
iov_count = h4p->dout_iovec_count;
} else if (dxfer_dir == SG_DXFER_FROM_DEV) {
- r0w = READ;
up = uptr64(h4p->din_xferp);
dxfer_len = (int)h4p->din_xfer_len;
iov_count = h4p->din_iovec_count;
@@ -2706,7 +2699,7 @@ sg_start_req(struct sg_request *srp, u8 *cmd, int cmd_len,
* not expect an EWOULDBLOCK from this condition.
*/
rq = blk_get_request(q, (r0w ? REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN), 0);
- if (unlikely(IS_ERR(rq))) {
+ if (IS_ERR(rq)) {
kfree(long_cmdp);
return PTR_ERR(rq);
}
@@ -2714,10 +2707,19 @@ sg_start_req(struct sg_request *srp, u8 *cmd, int cmd_len,
scsi_rp = scsi_req(rq);
srp->rq = rq;
- if (cmd_len > BLK_MAX_CDB)
+ if (cwrp->cmd_len > BLK_MAX_CDB)
scsi_rp->cmd = long_cmdp;
- memcpy(scsi_rp->cmd, cmd, cmd_len);
- scsi_rp->cmd_len = cmd_len;
+ if (cwrp->u_cmdp)
+ res = sg_fetch_cmnd(cwrp->filp, sfp, cwrp->u_cmdp,
+ cwrp->cmd_len, scsi_rp->cmd);
+ else
+ res = -EPROTO;
+ if (res) {
+ kfree(long_cmdp);
+ return res;
+ }
+ scsi_rp->cmd_len = cwrp->cmd_len;
+ srp->cmd_opcode = scsi_rp->cmd[0];
us_xfer = !(srp->rq_flags & SG_FLAG_NO_DXFER);
assign_bit(SG_FRQ_NO_US_XFER, srp->frq_bm, !us_xfer);
reserved = (sfp->rsv_srp == srp);
@@ -2741,7 +2743,7 @@ sg_start_req(struct sg_request *srp, u8 *cmd, int cmd_len,
}
if (likely(md)) { /* normal, "indirect" IO */
- if (unlikely((srp->rq_flags & SG_FLAG_MMAP_IO))) {
+ if (unlikely(srp->rq_flags & SG_FLAG_MMAP_IO)) {
/* mmap IO must use and fit in reserve request */
if (!reserved || dxfer_len > req_schp->buflen)
res = reserved ? -ENOMEM : -EBUSY;
@@ -2750,7 +2752,7 @@ sg_start_req(struct sg_request *srp, u8 *cmd, int cmd_len,
res = sg_mk_sgat(srp, sfp, up_sz);
}
- if (res)
+ if (unlikely(res))
goto fini;
sg_set_map_data(req_schp, !!up, md);
@@ -3107,7 +3109,7 @@ sg_mk_srp_sgat(struct sg_fd *sfp, bool first, int db_len)
return n_srp;
if (db_len > 0) {
res = sg_mk_sgat(n_srp, sfp, db_len);
- if (res) {
+ if (unlikely(res)) {
kfree(n_srp);
return ERR_PTR(res);
}
@@ -3160,27 +3162,28 @@ sg_build_reserve(struct sg_fd *sfp, int buflen)
* failure returns a negated errno value twisted by ERR_PTR() macro.
*/
static struct sg_request *
-sg_add_request(struct sg_fd *sfp, int dxfr_len, struct sg_comm_wr_t *cwrp)
+sg_add_request(struct sg_comm_wr_t *cwrp, int dxfr_len)
{
bool act_empty = false;
bool mk_new_srp = true;
unsigned long iflags;
enum sg_rq_state sr_st;
+ struct sg_fd *fp = cwrp->sfp;
struct sg_request *r_srp = NULL; /* request to return */
struct sg_request *rsv_srp; /* current fd's reserve request */
__maybe_unused const char *cp;
- spin_lock_irqsave(&sfp->rq_list_lock, iflags);
- rsv_srp = sfp->rsv_srp;
+ spin_lock_irqsave(&fp->rq_list_lock, iflags);
+ rsv_srp = fp->rsv_srp;
cp = "";
/*
* Check the free list (fl) for candidates. Pick zero data length
* requests from the back of the fl, the rest from the front.
*/
- if (list_empty(&sfp->rq_fl)) {
+ if (list_empty(&fp->rq_fl)) {
act_empty = true;
} else if (dxfr_len < 1) { /* 0 data length requests at back of fl */
- list_for_each_entry_reverse(r_srp, &sfp->rq_fl, fl_entry) {
+ list_for_each_entry_reverse(r_srp, &fp->rq_fl, fl_entry) {
sr_st = atomic_read(&r_srp->rq_st);
if (sr_st == SG_RS_INACTIVE) {
if (likely(sg_rstate_chg(r_srp, sr_st,
@@ -3192,7 +3195,7 @@ sg_add_request(struct sg_fd *sfp, int dxfr_len, struct sg_comm_wr_t *cwrp)
}
}
} else { /* find request with large enough dlen */
- list_for_each_entry(r_srp, &sfp->rq_fl, fl_entry) {
+ list_for_each_entry(r_srp, &fp->rq_fl, fl_entry) {
sr_st = atomic_read(&r_srp->rq_st);
if (sr_st == SG_RS_INACTIVE &&
r_srp->sgat_h.buflen >= dxfr_len) {
@@ -3207,23 +3210,23 @@ sg_add_request(struct sg_fd *sfp, int dxfr_len, struct sg_comm_wr_t *cwrp)
}
if (mk_new_srp) { /* Need new sg_request object */
- bool allow_cmd_q = test_bit(SG_FFD_CMD_Q, sfp->ffd_bm);
+ bool allow_cmd_q = test_bit(SG_FFD_CMD_Q, fp->ffd_bm);
r_srp = NULL;
- if (!allow_cmd_q && !list_empty(&sfp->rq_list)) {
+ if (!allow_cmd_q && !list_empty(&fp->rq_list)) {
r_srp = ERR_PTR(-EDOM);
- SG_LOG(6, sfp, "%s: trying 2nd req but cmd_q=false\n",
+ SG_LOG(6, fp, "%s: trying 2nd req but cmd_q=false\n",
__func__);
}
- spin_unlock_irqrestore(&sfp->rq_list_lock, iflags);
+ spin_unlock_irqrestore(&fp->rq_list_lock, iflags);
if (IS_ERR(r_srp)) /* NULL is not an ERR here */
goto err_no_lock;
/* releasing rq_list_lock because next line could take time */
- r_srp = sg_mk_srp_sgat(sfp, act_empty, dxfr_len);
+ r_srp = sg_mk_srp_sgat(fp, act_empty, dxfr_len);
if (IS_ERR(r_srp))
goto err_no_lock;
cp = "new";
- SG_LOG(4, sfp, "%s: mk_new_srp=0x%p ++\n", __func__, r_srp);
+ SG_LOG(4, fp, "%s: mk_new_srp=0x%p ++\n", __func__, r_srp);
atomic_set(&r_srp->rq_st, SG_RS_BUSY);
} else { /* otherwise found srp is on fl, remove from fl */
list_del_rcu(&r_srp->fl_entry);
@@ -3233,20 +3236,21 @@ sg_add_request(struct sg_fd *sfp, int dxfr_len, struct sg_comm_wr_t *cwrp)
}
if (!mk_new_srp)
spin_lock(&r_srp->req_lck);
- r_srp->frq_bm[0] = cwrp->frq_bm[0]; /* assumes <= 32 req flags */
+ /* following copes with unlikely case where frq_bm > one ulong */
+ memcpy(r_srp->frq_bm, cwrp->frq_bm, sizeof(r_srp->frq_bm));
r_srp->sgat_h.dlen = dxfr_len;/* must be <= r_srp->sgat_h.buflen */
r_srp->cmd_opcode = 0xff; /* set invalid opcode (VS), 0x0 is TUR */
if (mk_new_srp)
- spin_lock_irqsave(&sfp->rq_list_lock, iflags);
- list_add_tail_rcu(&r_srp->rq_entry, &sfp->rq_list);
+ spin_lock_irqsave(&fp->rq_list_lock, iflags);
+ list_add_tail_rcu(&r_srp->rq_entry, &fp->rq_list);
if (!mk_new_srp)
spin_unlock(&r_srp->req_lck);
- spin_unlock_irqrestore(&sfp->rq_list_lock, iflags);
+ spin_unlock_irqrestore(&fp->rq_list_lock, iflags);
err_no_lock:
if (IS_ERR(r_srp))
- SG_LOG(1, sfp, "%s: err=%ld\n", __func__, PTR_ERR(r_srp));
+ SG_LOG(1, fp, "%s: err=%ld\n", __func__, PTR_ERR(r_srp));
if (!IS_ERR(r_srp))
- SG_LOG(4, sfp, "%s: %s %sr_srp=0x%p\n", __func__, cp,
+ SG_LOG(4, fp, "%s: %s %sr_srp=0x%p\n", __func__, cp,
((r_srp == rsv_srp) ? "[rsv] " : ""), r_srp);
return r_srp;
}
@@ -3338,6 +3342,8 @@ sg_add_sfp(struct sg_device *sdp)
__assign_bit(SG_FFD_CMD_Q, sfp->ffd_bm, SG_DEF_COMMAND_Q);
__assign_bit(SG_FFD_KEEP_ORPHAN, sfp->ffd_bm, SG_DEF_KEEP_ORPHAN);
__assign_bit(SG_FFD_Q_AT_TAIL, sfp->ffd_bm, SG_DEFAULT_Q_AT);
+ atomic_set(&sfp->submitted, 0);
+ atomic_set(&sfp->waiting, 0);
/*
* SG_SCATTER_SZ initializes scatter_elem_sz but different value may
* be given as driver/module parameter (e.g. 'scatter_elem_sz=8192').
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 17/20] sg: add sg_iosubmit_v3 and sg_ioreceive_v3 ioctls
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (15 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 16/20] sg: expand sg_comm_wr_t Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-09 23:15 ` James Bottomley
2019-08-07 11:42 ` [PATCH v3 18/20] sg: add some __must_hold macros Douglas Gilbert
` (3 subsequent siblings)
20 siblings, 1 reply; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche, kbuild test robot
Add ioctl(SG_IOSUBMIT_V3) and ioctl(SG_IORECEIVE_V3). These ioctls
are meant to be (almost) drop-in replacements for the write()/read()
async version 3 interface. They only accept the version 3 interface.
See the webpage at: http://sg.danny.cz/sg/sg_v40.html
specifically the table in the section titled: "12 SG interface
support changes".
If sgv3 is a struct sg_io_hdr object, suitably configured, then
res = write(sg_fd, &sgv3, sizeof(sgv3));
and
res = ioctl(sg_fd, SG_IOSUBMIT_V3, &sgv3);
are equivalent. Dito for read() and ioctl(SG_IORECEIVE_V3).
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
Reported-by: kbuild test robot <lkp@intel.com>
-
kbuild had two complaints about this commit:
- casting a pointer to u64: add intermediate cast to
unsigned long. Would only seem to be a problem if
a pointer couldn't fit in u64 in which case the
sg v4 interface would be broken and lots of other
things besides ...
- a possible uninitialized variable:
__maybe_unused bool is_bad_st = false;
__maybe_unused enum sg_rq_state bad_sr_st; /* <-- here */
The boolean (is_bad_st) tracks whether it has a "valid"
string or not. kbuild doesn't undrstand that. Give bad_sr_st
an initial value to keep kbuild quiet at the expense of a
machine cycle or two.
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 79 ++++++++++++++++++++++++++++++++++++++++--
include/uapi/scsi/sg.h | 6 ++++
2 files changed, 83 insertions(+), 2 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index a60c2bcc5430..aa3512b2cb4f 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -806,6 +806,24 @@ sg_ctl_iosubmit(struct file *filp, struct sg_fd *sfp, void __user *p)
return -EPERM;
}
+static int
+sg_ctl_iosubmit_v3(struct file *filp, struct sg_fd *sfp, void __user *p)
+{
+ int res;
+ u8 hdr_store[SZ_SG_IO_V4]; /* max(v3interface, v4interface) */
+ struct sg_io_hdr *h3p = (struct sg_io_hdr *)hdr_store;
+ struct sg_device *sdp = sfp->parentdp;
+
+ res = sg_allow_if_err_recovery(sdp, (filp->f_flags & O_NONBLOCK));
+ if (unlikely(res))
+ return res;
+ if (copy_from_user(h3p, p, SZ_SG_IO_HDR))
+ return -EFAULT;
+ if (h3p->interface_id == 'S')
+ return sg_v3_submit(filp, sfp, h3p, false, NULL);
+ return -EPERM;
+}
+
static void
sg_execute_cmd(struct sg_fd *sfp, struct sg_request *srp)
{
@@ -1107,7 +1125,7 @@ sg_v4_receive(struct sg_fd *sfp, struct sg_request *srp, void __user *p,
h4p->din_resid = srp->in_resid;
h4p->dout_resid = srp->s_hdr4.out_resid;
h4p->usr_ptr = srp->s_hdr4.usr_ptr;
- h4p->response = (u64)srp->s_hdr4.sbp;
+ h4p->response = (u64)(unsigned long)srp->s_hdr4.sbp;
h4p->request_extra = srp->pack_id;
if (p) {
if (copy_to_user(p, h4p, SZ_SG_IO_V4))
@@ -1170,6 +1188,57 @@ sg_ctl_ioreceive(struct file *filp, struct sg_fd *sfp, void __user *p)
return sg_v4_receive(sfp, srp, p, h4p);
}
+/*
+ * Called when ioctl(SG_IORECEIVE_V3) received. Expects a v3 interface.
+ * Checks if O_NONBLOCK file flag given, if not checks given flags field
+ * to see if SGV4_FLAG_IMMED is set. Either of these implies non blocking.
+ * When non-blocking and there is no request waiting, yields EAGAIN;
+ * otherwise it waits.
+ */
+static int
+sg_ctl_ioreceive_v3(struct file *filp, struct sg_fd *sfp, void __user *p)
+{
+ bool non_block = !!(filp->f_flags & O_NONBLOCK);
+ int res;
+ int pack_id = SG_PACK_ID_WILDCARD;
+ u8 v3_holder[SZ_SG_IO_HDR];
+ struct sg_io_hdr *h3p = (struct sg_io_hdr *)v3_holder;
+ struct sg_device *sdp = sfp->parentdp;
+ struct sg_request *srp;
+
+ res = sg_allow_if_err_recovery(sdp, non_block);
+ if (unlikely(res))
+ return res;
+ /* Get first three 32 bit integers: guard, proto+subproto */
+ if (copy_from_user(h3p, p, SZ_SG_IO_HDR))
+ return -EFAULT;
+ /* for v3: interface_id=='S' (in a 32 bit int) */
+ if (h3p->interface_id != 'S')
+ return -EPERM;
+ if (h3p->flags & SGV4_FLAG_IMMED)
+ non_block = true; /* set by either this or O_NONBLOCK */
+ SG_LOG(3, sfp, "%s: non_block(+IMMED)=%d\n", __func__, non_block);
+
+ if (test_bit(SG_FFD_FORCE_PACKID, sfp->ffd_bm))
+ pack_id = h3p->pack_id;
+
+ srp = sg_find_srp_by_id(sfp, pack_id);
+ if (!srp) { /* nothing available so wait on packet or */
+ if (unlikely(SG_IS_DETACHING(sdp)))
+ return -ENODEV;
+ if (non_block)
+ return -EAGAIN;
+ res = wait_event_interruptible
+ (sfp->read_wait,
+ sg_get_ready_srp(sfp, &srp, pack_id));
+ if (unlikely(SG_IS_DETACHING(sdp)))
+ return -ENODEV;
+ if (unlikely(res))
+ return res; /* signal --> -ERESTARTSYS */
+ } /* now srp should be valid */
+ return sg_v3_receive(sfp, srp, p);
+}
+
static int
sg_rd_v1v2(void __user *buf, int count, struct sg_fd *sfp,
struct sg_request *srp)
@@ -1731,9 +1800,15 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
case SG_IOSUBMIT:
SG_LOG(3, sfp, "%s: SG_IOSUBMIT\n", __func__);
return sg_ctl_iosubmit(filp, sfp, p);
+ case SG_IOSUBMIT_V3:
+ SG_LOG(3, sfp, "%s: SG_IOSUBMIT_V3\n", __func__);
+ return sg_ctl_iosubmit_v3(filp, sfp, p);
case SG_IORECEIVE:
SG_LOG(3, sfp, "%s: SG_IORECEIVE\n", __func__);
return sg_ctl_ioreceive(filp, sfp, p);
+ case SG_IORECEIVE_V3:
+ SG_LOG(3, sfp, "%s: SG_IORECEIVE_V3\n", __func__);
+ return sg_ctl_ioreceive_v3(filp, sfp, p);
case SG_GET_SCSI_ID:
return sg_ctl_scsi_id(sdev, sfp, p);
case SG_SET_FORCE_PACK_ID:
@@ -3000,7 +3075,7 @@ static struct sg_request *
sg_find_srp_by_id(struct sg_fd *sfp, int pack_id)
{
__maybe_unused bool is_bad_st = false;
- __maybe_unused enum sg_rq_state bad_sr_st;
+ __maybe_unused enum sg_rq_state bad_sr_st = SG_RS_INACTIVE;
bool search_for_1 = (pack_id != SG_PACK_ID_WILDCARD);
enum sg_rq_state sr_st;
int res;
diff --git a/include/uapi/scsi/sg.h b/include/uapi/scsi/sg.h
index 0d6fbf976e5c..f2f898a57ce8 100644
--- a/include/uapi/scsi/sg.h
+++ b/include/uapi/scsi/sg.h
@@ -356,6 +356,12 @@ struct sg_header {
/* Gives some v4 identifying info to driver, receives associated response */
#define SG_IORECEIVE _IOWR(SG_IOCTL_MAGIC_NUM, 0x42, struct sg_io_v4)
+/* Submits a v3 interface object to driver */
+#define SG_IOSUBMIT_V3 _IOWR(SG_IOCTL_MAGIC_NUM, 0x45, struct sg_io_hdr)
+
+/* Gives some v3 identifying info to driver, receives associated response */
+#define SG_IORECEIVE_V3 _IOWR(SG_IOCTL_MAGIC_NUM, 0x46, struct sg_io_hdr)
+
/* command queuing is always on when the v3 or v4 interface is used */
#define SG_DEF_COMMAND_Q 0
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 17/20] sg: add sg_iosubmit_v3 and sg_ioreceive_v3 ioctls
2019-08-07 11:42 ` [PATCH v3 17/20] sg: add sg_iosubmit_v3 and sg_ioreceive_v3 ioctls Douglas Gilbert
@ 2019-08-09 23:15 ` James Bottomley
2019-08-12 15:37 ` Douglas Gilbert
0 siblings, 1 reply; 63+ messages in thread
From: James Bottomley @ 2019-08-09 23:15 UTC (permalink / raw)
To: Douglas Gilbert, linux-scsi
Cc: martin.petersen, hare, bvanassche, kbuild test robot
On Wed, 2019-08-07 at 13:42 +0200, Douglas Gilbert wrote:
> Add ioctl(SG_IOSUBMIT_V3) and ioctl(SG_IORECEIVE_V3). These ioctls
> are meant to be (almost) drop-in replacements for the write()/read()
> async version 3 interface. They only accept the version 3 interface.
I don't think we should do this at all. Anyone who wants to use the
new async interfaces should use the v4 headers. As Tony Battersby
already said, the legacy v3 users aren't going to update, so there's no
point at all introducing new interfaces for v3. We simply keep the v3
only read/write interface until there are no users left and it can be
eliminated.
James
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 17/20] sg: add sg_iosubmit_v3 and sg_ioreceive_v3 ioctls
2019-08-09 23:15 ` James Bottomley
@ 2019-08-12 15:37 ` Douglas Gilbert
2019-08-12 16:14 ` Tony Battersby
0 siblings, 1 reply; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-12 15:37 UTC (permalink / raw)
To: James Bottomley, linux-scsi
Cc: martin.petersen, hare, bvanassche, kbuild test robot,
Arnd Bergmann, Tony Battersby
On 2019-08-09 7:15 p.m., James Bottomley wrote:
> On Wed, 2019-08-07 at 13:42 +0200, Douglas Gilbert wrote:
>> Add ioctl(SG_IOSUBMIT_V3) and ioctl(SG_IORECEIVE_V3). These ioctls
>> are meant to be (almost) drop-in replacements for the write()/read()
>> async version 3 interface. They only accept the version 3 interface.
>
> I don't think we should do this at all. Anyone who wants to use the
> new async interfaces should use the v4 headers. As Tony Battersby
> already said, the legacy v3 users aren't going to update, so there's no
> point at all introducing new interfaces for v3. We simply keep the v3
> only read/write interface until there are no users left and it can be
> eliminated.
Tony Battersby wrote [20190809]:
"Actually I used the asynchronous write()/read()/poll() sg interface to
implement RAID-like functionality for tape drives and medium changers,
in a commercial product that has been around since 2002. These days our
products use a lot more disk I/O than tape I/O, so I don't write much
new code using the sg interface anymore, although that code is still
there and has to be maintained as needed. So I don't have any immediate
plans to use any of the new sgv4 features being introduced, and
unfortunately I am way too busy to even give it a good review..."
That is quoted in full his post. And here is the only other post from
Tony I can find on this subject, again quoted in full [20190808]:
"One of the reasons ioctls have a bad reputation is because they can be
used to implement poorly-thought-out interfaces. So kernel maintainers
push back on adding new ioctls. But the push back isn't about the
number of ioctls, it is about the poor interfaces. My advice was that
in general, to implement a given API, it would be better to add more
ioctls with a simple interface for each one rather than to add fewer
extremely complex multiplexing ioctls."
Call me biased but I believe that taken together those posts support
what I am proposing. And I can _not_ see how you deduce: "so there's
no point at all introducing new interfaces for v3" in reference to
Tony's posts.
As I stated in a previous post, I do not consider the sg v3 interface
as legacy. Where simply implemented, I am prepared to implement new
features on both the sg v3 and v4 interfaces. One example of this is
doing command timing in nanoseconds rather than the current default,
which is timing in milliseconds. There is also the new option of not
doing any command timing at all. In my current implementation it would
actually be more code to implement that for the v4 interface but not
for the v3 interface.
Replicating my argument from a previous post:
If the kernel had an API mapping layer that was sensitive to file
descriptors of a "special file" (e.g. "/dev/sg3") then it could map:
write(sg_fd, &sg_io_v3_obj, sizeof(sg_io_v3_obj))
to
ioctl(sg_fd, SG_IOSUBMIT_V3, &sg_io_v3_obj)
Plus a similar mapping for read() to ioctl(SG_IORECEIVE_V3). If such
a mapping did exist and was transparent to the user then write()
and read() could be retired from the sg driver. And I assume that
would get a thumbs up from the kernel security folk.
It was Arnd Bergmann who didn't want ioctl(SG_IOSUBMIT) handling
_both_ the sg v3 and v4 interface objects. That breaks the way
_IOR(W) encodes the object length pointed to by the 3rd argument.
It also makes his 32/64 compatibility ioctl layer more difficult.
Hence SG_IOSUBMIT_V3 was introduced to take the sg v3 interface
leaving ioctl(SG_IOSUBMIT) to handle only the v4 interface. That
change had the added benefit of simplifying and speeding my code
with no further need for this type of ugliness:
/* copy in rest of sg_io_v4 object */
if (copy_from_user(hu8arr + SZ_SG_IO_HDR,
((u8 __user *)p) + SZ_SG_IO_HDR,
SZ_SG_IO_V4 - SZ_SG_IO_HDR))
return -EFAULT;
The ioctl(SG_IO) implementation still needs that because it will
accept both the v3 and v4 interfaces for backward compatibility.
Doug Gilbert
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 17/20] sg: add sg_iosubmit_v3 and sg_ioreceive_v3 ioctls
2019-08-12 15:37 ` Douglas Gilbert
@ 2019-08-12 16:14 ` Tony Battersby
2019-08-12 18:46 ` James Bottomley
0 siblings, 1 reply; 63+ messages in thread
From: Tony Battersby @ 2019-08-12 16:14 UTC (permalink / raw)
To: dgilbert, James Bottomley, linux-scsi
Cc: martin.petersen, hare, bvanassche, kbuild test robot, Arnd Bergmann
On 8/12/19 11:37 AM, Douglas Gilbert wrote:
> On 2019-08-09 7:15 p.m., James Bottomley wrote:
>> On Wed, 2019-08-07 at 13:42 +0200, Douglas Gilbert wrote:
>>> Add ioctl(SG_IOSUBMIT_V3) and ioctl(SG_IORECEIVE_V3). These ioctls
>>> are meant to be (almost) drop-in replacements for the write()/read()
>>> async version 3 interface. They only accept the version 3 interface.
>> I don't think we should do this at all. Anyone who wants to use the
>> new async interfaces should use the v4 headers. As Tony Battersby
>> already said, the legacy v3 users aren't going to update, so there's no
>> point at all introducing new interfaces for v3. We simply keep the v3
>> only read/write interface until there are no users left and it can be
>> eliminated.
> Tony Battersby wrote [20190809]:
> "Actually I used the asynchronous write()/read()/poll() sg interface to
> implement RAID-like functionality for tape drives and medium changers,
> in a commercial product that has been around since 2002. These days our
> products use a lot more disk I/O than tape I/O, so I don't write much
> new code using the sg interface anymore, although that code is still
> there and has to be maintained as needed. So I don't have any immediate
> plans to use any of the new sgv4 features being introduced, and
> unfortunately I am way too busy to even give it a good review..."
>
> That is quoted in full his post. And here is the only other post from
> Tony I can find on this subject, again quoted in full [20190808]:
>
> "One of the reasons ioctls have a bad reputation is because they can be
> used to implement poorly-thought-out interfaces. So kernel maintainers
> push back on adding new ioctls. But the push back isn't about the
> number of ioctls, it is about the poor interfaces. My advice was that
> in general, to implement a given API, it would be better to add more
> ioctls with a simple interface for each one rather than to add fewer
> extremely complex multiplexing ioctls."
>
> Call me biased but I believe that taken together those posts support
> what I am proposing. And I can _not_ see how you deduce: "so there's
> no point at all introducing new interfaces for v3" in reference to
> Tony's posts.
>
>
> As I stated in a previous post, I do not consider the sg v3 interface
> as legacy. Where simply implemented, I am prepared to implement new
> features on both the sg v3 and v4 interfaces. One example of this is
> doing command timing in nanoseconds rather than the current default,
> which is timing in milliseconds. There is also the new option of not
> doing any command timing at all. In my current implementation it would
> actually be more code to implement that for the v4 interface but not
> for the v3 interface.
>
> Replicating my argument from a previous post:
> If the kernel had an API mapping layer that was sensitive to file
> descriptors of a "special file" (e.g. "/dev/sg3") then it could map:
> write(sg_fd, &sg_io_v3_obj, sizeof(sg_io_v3_obj))
> to
> ioctl(sg_fd, SG_IOSUBMIT_V3, &sg_io_v3_obj)
>
> Plus a similar mapping for read() to ioctl(SG_IORECEIVE_V3). If such
> a mapping did exist and was transparent to the user then write()
> and read() could be retired from the sg driver. And I assume that
> would get a thumbs up from the kernel security folk.
>
FWIW, my employer will probably continue to use the async sg v3
interface for a long time. If the read/write syscalls are a security
problem, and if we had ioctl()s that are mostly a drop-in replacement
for them, then we could convert our products over to the new ioctl()s on
our next kernel upgrade without too much work (our products are embedded
devices, so we control the whole software stack). So if you plan to
deprecate the read/write syscall interface anytime soon, then having
drop-in replacement ioctl()s would be beneficial, even if it can't be
done transparently as Doug suggests.
Tony Battersby
Cybernetics
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 17/20] sg: add sg_iosubmit_v3 and sg_ioreceive_v3 ioctls
2019-08-12 16:14 ` Tony Battersby
@ 2019-08-12 18:46 ` James Bottomley
2019-08-12 19:37 ` Tony Battersby
0 siblings, 1 reply; 63+ messages in thread
From: James Bottomley @ 2019-08-12 18:46 UTC (permalink / raw)
To: Tony Battersby, dgilbert, linux-scsi
Cc: martin.petersen, hare, bvanassche, kbuild test robot, Arnd Bergmann
On Mon, 2019-08-12 at 12:14 -0400, Tony Battersby wrote:
> On 8/12/19 11:37 AM, Douglas Gilbert wrote:
> > On 2019-08-09 7:15 p.m., James Bottomley wrote:
> > > On Wed, 2019-08-07 at 13:42 +0200, Douglas Gilbert wrote:
> > > > Add ioctl(SG_IOSUBMIT_V3) and ioctl(SG_IORECEIVE_V3). These
> > > > ioctls
> > > > are meant to be (almost) drop-in replacements for the
> > > > write()/read()
> > > > async version 3 interface. They only accept the version 3
> > > > interface.
> > >
> > > I don't think we should do this at all. Anyone who wants to use
> > > the
> > > new async interfaces should use the v4 headers. As Tony
> > > Battersby
> > > already said, the legacy v3 users aren't going to update, so
> > > there's no
> > > point at all introducing new interfaces for v3. We simply keep
> > > the v3
> > > only read/write interface until there are no users left and it
> > > can be
> > > eliminated.
> >
> > Tony Battersby wrote [20190809]:
> > "Actually I used the asynchronous write()/read()/poll() sg
> > interface to
> > implement RAID-like functionality for tape drives and medium
> > changers,
> > in a commercial product that has been around since 2002. These
> > days our
> > products use a lot more disk I/O than tape I/O, so I don't write
> > much
> > new code using the sg interface anymore, although that code is
> > still
> > there and has to be maintained as needed. So I don't have any
> > immediate
> > plans to use any of the new sgv4 features being introduced, and
> > unfortunately I am way too busy to even give it a good
> > review..."
> >
> > That is quoted in full his post. And here is the only other post
> > from
> > Tony I can find on this subject, again quoted in full [20190808]:
> >
> > "One of the reasons ioctls have a bad reputation is because they
> > can be
> > used to implement poorly-thought-out interfaces. So kernel
> > maintainers
> > push back on adding new ioctls. But the push back isn't about
> > the
> > number of ioctls, it is about the poor interfaces. My advice
> > was that
> > in general, to implement a given API, it would be better to add
> > more
> > ioctls with a simple interface for each one rather than to add
> > fewer
> > extremely complex multiplexing ioctls."
> >
> > Call me biased but I believe that taken together those posts
> > support
> > what I am proposing. And I can _not_ see how you deduce: "so
> > there's
> > no point at all introducing new interfaces for v3" in reference to
> > Tony's posts.
> >
> >
> > As I stated in a previous post, I do not consider the sg v3
> > interface
> > as legacy. Where simply implemented, I am prepared to implement new
> > features on both the sg v3 and v4 interfaces. One example of this
> > is
> > doing command timing in nanoseconds rather than the current
> > default,
> > which is timing in milliseconds. There is also the new option of
> > not
> > doing any command timing at all. In my current implementation it
> > would
> > actually be more code to implement that for the v4 interface but
> > not
> > for the v3 interface.
> >
> > Replicating my argument from a previous post:
> > If the kernel had an API mapping layer that was sensitive to file
> > descriptors of a "special file" (e.g. "/dev/sg3") then it could
> > map:
> > write(sg_fd, &sg_io_v3_obj, sizeof(sg_io_v3_obj))
> > to
> > ioctl(sg_fd, SG_IOSUBMIT_V3, &sg_io_v3_obj)
> >
> > Plus a similar mapping for read() to ioctl(SG_IORECEIVE_V3). If
> > such
> > a mapping did exist and was transparent to the user then write()
> > and read() could be retired from the sg driver. And I assume that
> > would get a thumbs up from the kernel security folk.
> >
>
> FWIW, my employer will probably continue to use the async sg v3
> interface for a long time. If the read/write syscalls are a security
> problem, and if we had ioctl()s that are mostly a drop-in replacement
> for them, then we could convert our products over to the new ioctl()s
> on our next kernel upgrade without too much work (our products are
> embedded devices, so we control the whole software stack). So if you
> plan to deprecate the read/write syscall interface anytime soon, then
> having drop-in replacement ioctl()s would be beneficial, even if it
> can't be done transparently as Doug suggests.
So far we've mitigated the security threat by withdrawing the v4
r/w interface which you don't use and keeping the sg nodes root only
for v3 r/w. Unless we get another security incident based on them, as
long as the use case doesn't expand, I think the prior issue is pretty
nasty but contained to root who should know what they're doing, so
there's no pressing need to remove it.
Given that shifting to ioctls or a different async interface would be
development anyway, is there a solid reason you couldn't also shift to
v4 if you do that? I know all the field names changed but for a
standard SCSI command it should be very similar to v3.
James
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 17/20] sg: add sg_iosubmit_v3 and sg_ioreceive_v3 ioctls
2019-08-12 18:46 ` James Bottomley
@ 2019-08-12 19:37 ` Tony Battersby
0 siblings, 0 replies; 63+ messages in thread
From: Tony Battersby @ 2019-08-12 19:37 UTC (permalink / raw)
To: James Bottomley, dgilbert, linux-scsi
Cc: martin.petersen, hare, bvanassche, kbuild test robot, Arnd Bergmann
On 8/12/19 2:46 PM, James Bottomley wrote:
>
> So far we've mitigated the security threat by withdrawing the v4
> r/w interface which you don't use and keeping the sg nodes root only
> for v3 r/w. Unless we get another security incident based on them, as
> long as the use case doesn't expand, I think the prior issue is pretty
> nasty but contained to root who should know what they're doing, so
> there's no pressing need to remove it.
So if there is no plan to remove read/write from sg v3 for root, then I
don't see a need for the new ioctl()s to replace them.
> Given that shifting to ioctls or a different async interface would be
> development anyway, is there a solid reason you couldn't also shift to
> v4 if you do that? I know all the field names changed but for a
> standard SCSI command it should be very similar to v3.
>
>
I suppose we could move our codebase to sg v4 eventually. Right now we
don't need any new features from it, so there is no compelling case to
make the move. Besides, we are pretty far behind in the kernel version
that we are shipping due to lack of developer time, so it may be a long
time before I can update to a kernel version with these patches anyway.
Tony Battersby
Cybernetics
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 18/20] sg: add some __must_hold macros
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (16 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 17/20] sg: add sg_iosubmit_v3 and sg_ioreceive_v3 ioctls Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-07 11:42 ` [PATCH v3 19/20] sg: first debugfs support Douglas Gilbert
` (2 subsequent siblings)
20 siblings, 0 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
In the case of sg_wait_open_event() which calls mutex_unlock on
sdp->open_rel_lock and later calls mutex_lock on the same
lock; this macro is needed to stop sparse complaining. In
other cases it is a reminder to the coder (a precondition).
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 7 +++++++
1 file changed, 7 insertions(+)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index aa3512b2cb4f..fe79f5f354f2 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -379,6 +379,7 @@ sg_check_file_access(struct file *filp, const char *caller)
static int
sg_wait_open_event(struct sg_device *sdp, bool o_excl)
+ __must_hold(&sdp->open_rel_lock)
{
int res = 0;
@@ -1506,6 +1507,7 @@ sg_get_dur(struct sg_request *srp, const enum sg_rq_state *sr_stp,
static void
sg_fill_request_element(struct sg_fd *sfp, struct sg_request *srp,
struct sg_req_info *rip)
+ __must_hold(&sfp->rq_list_lock)
{
spin_lock(&srp->req_lck);
rip->duration = sg_get_dur(srp, NULL, NULL);
@@ -1627,6 +1629,7 @@ sg_ctl_sg_io(struct file *filp, struct sg_device *sdp, struct sg_fd *sfp,
*/
static int
sg_set_reserved_sz(struct sg_fd *sfp, int want_rsv_sz)
+ __must_hold(&sfp->f_mutex)
{
bool use_new_srp = false;
int res = 0;
@@ -3550,6 +3553,7 @@ sg_remove_sfp(struct kref *kref)
static int
sg_idr_max_id(int id, void *p, void *data)
+ __must_hold(&sg_index_lock)
{
int *k = data;
@@ -3858,6 +3862,7 @@ sg_proc_seq_show_devstrs(struct seq_file *s, void *v)
/* Writes debug info for one sg_request in obp buffer */
static int
sg_proc_debug_sreq(struct sg_request *srp, int to, char *obp, int len)
+ __must_hold(&sfp->rq_list_lock)
{
bool is_v3v4, v4, is_dur;
int n = 0;
@@ -3893,6 +3898,7 @@ sg_proc_debug_sreq(struct sg_request *srp, int to, char *obp, int len)
/* Writes debug info for one sg fd (including its sg requests) in obp buffer */
static int
sg_proc_debug_fd(struct sg_fd *fp, char *obp, int len)
+ __must_hold(&sfp->rq_list_lock)
{
bool first_fl;
int n = 0;
@@ -3942,6 +3948,7 @@ sg_proc_debug_fd(struct sg_fd *fp, char *obp, int len)
/* Writes debug info for one sg device (including its sg fds) in obp buffer */
static int
sg_proc_debug_sdev(struct sg_device *sdp, char *obp, int len, int *fd_counterp)
+ __must_hold(&sdp->sfd_lock)
{
int n = 0;
int my_count = 0;
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 19/20] sg: first debugfs support
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (17 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 18/20] sg: add some __must_hold macros Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-07 11:42 ` [PATCH v3 20/20] sg: bump version to 4.0.03 Douglas Gilbert
2019-08-08 19:10 ` [PATCH v3 00/20] sg: add v4 interface James Bottomley
20 siblings, 0 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
Duplicate the semantics of 'cat /proc/scsi/sg/debug' on
'cat /sys/kernel/debug/scsi_generic/snapshot'. Make code
that generates the snapshot conditional on either
CONFIG_SCSI_PROC_FS or CONFIG_DEBUG_FS being defined.
-
Use "scsi_generic" in the debugfs path as "sg" may be
confused with scatter gather in the wider kernel.
As implemented, the snapshot is on all sg devices. If many sg
devices are in use, restricting the output to one (or a list)
of sg device numbers may declutter the output. Perhaps a
writable snapshot_devs attribute could be added that takes a
single integer, a comma separated list or integers, or '*'
which maps to -1 which is the default and means all devices.
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 207 ++++++++++++++++++++++++++++++----------------
1 file changed, 136 insertions(+), 71 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index fe79f5f354f2..82c4147ba4f1 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -43,6 +43,7 @@ static char *sg_version_date = "20190606";
#include <linux/uio.h>
#include <linux/cred.h> /* for sg_check_file_access() */
#include <linux/proc_fs.h>
+#include <linux/debugfs.h>
#include <scsi/scsi.h>
#include <scsi/scsi_eh.h>
@@ -68,6 +69,10 @@ static char *sg_version_date = "20190606";
#endif
#endif
+#if IS_ENABLED(CONFIG_SCSI_PROC_FS) || IS_ENABLED(CONFIG_DEBUG_FS)
+#define SG_PROC_OR_DEBUG_FS 1
+#endif
+
/* SG_MAX_CDB_SIZE should be 260 (spc4r37 section 3.1.30) however the type
* of sg_io_hdr::cmd_len can only represent 255. All SCSI commands greater
* than 16 bytes are "variable length" whose length is a multiple of 4, so:
@@ -268,6 +273,8 @@ struct sg_comm_wr_t { /* arguments to sg_common_write() */
static void sg_rq_end_io(struct request *rq, blk_status_t status);
/* Declarations of other static functions used before they are defined */
static int sg_proc_init(void);
+static void sg_dfs_init(void);
+static void sg_dfs_exit(void);
static int sg_start_req(struct sg_request *srp, struct sg_comm_wr_t *cwrp,
int dxfer_dir);
static void sg_finish_scsi_blk_rq(struct sg_request *srp);
@@ -341,7 +348,7 @@ static void sg_rep_rq_state_fail(struct sg_fd *sfp,
pr_info("sg: sdp or sfp NULL, " fmt, ##a); \
} while (0)
#else
-#define SG_LOG(depth, sfp, fmt, a...)
+#define SG_LOG(depth, sfp, fmt, a...) do { } while (0)
#endif /* end of CONFIG_SCSI_LOGGING && SG_DEBUG conditional */
@@ -2650,6 +2657,7 @@ init_sg(void)
rc = scsi_register_interface(&sg_interface);
if (rc == 0) {
sg_proc_init();
+ sg_dfs_init();
return 0;
}
class_destroy(sg_sysfs_class);
@@ -2674,6 +2682,7 @@ sg_proc_init(void)
static void __exit
exit_sg(void)
{
+ sg_dfs_exit();
if (IS_ENABLED(CONFIG_SCSI_PROC_FS))
remove_proc_subtree("scsi/sg", NULL);
scsi_unregister_interface(&sg_interface);
@@ -3130,7 +3139,7 @@ sg_find_srp_by_id(struct sg_fd *sfp, int pack_id)
rcu_read_unlock();
if (IS_ENABLED(CONFIG_SCSI_PROC_FS)) {
if (search_for_1) {
- const char *cptp = "pack_id=";
+ __maybe_unused const char *cptp = "pack_id=";
if (is_bad_st)
SG_LOG(1, sfp, "%s: %s%d wrong state: %s\n",
@@ -3248,7 +3257,7 @@ sg_add_request(struct sg_comm_wr_t *cwrp, int dxfr_len)
enum sg_rq_state sr_st;
struct sg_fd *fp = cwrp->sfp;
struct sg_request *r_srp = NULL; /* request to return */
- struct sg_request *rsv_srp; /* current fd's reserve request */
+ __maybe_unused struct sg_request *rsv_srp;
__maybe_unused const char *cp;
spin_lock_irqsave(&fp->rq_list_lock, iflags);
@@ -3348,7 +3357,7 @@ sg_deact_request(struct sg_fd *sfp, struct sg_request *srp)
u8 *sbp;
struct sg_request *t_srp;
struct sg_scatter_hold *schp;
- const char *cp = "head";
+ __maybe_unused const char *cp = "head";
if (WARN_ON(!sfp || !srp))
return;
@@ -3551,18 +3560,6 @@ sg_remove_sfp(struct kref *kref)
schedule_work(&sfp->ew_fd.work);
}
-static int
-sg_idr_max_id(int id, void *p, void *data)
- __must_hold(&sg_index_lock)
-{
- int *k = data;
-
- if (*k < id)
- *k = id;
-
- return 0;
-}
-
/* must be called with sg_index_lock held */
static struct sg_device *
sg_lookup_dev(int dev)
@@ -3592,7 +3589,7 @@ sg_get_dev(int dev)
return sdp;
}
-#if IS_ENABLED(CONFIG_SCSI_PROC_FS)
+#if IS_ENABLED(SG_PROC_OR_DEBUG_FS)
static const char *
sg_rq_st_str(enum sg_rq_state rq_st, bool long_str)
{
@@ -3619,7 +3616,72 @@ sg_rq_st_str(enum sg_rq_state rq_st, bool long_str)
}
#endif
-#if IS_ENABLED(CONFIG_SCSI_PROC_FS) /* long, almost to end of file */
+#if IS_ENABLED(SG_PROC_OR_DEBUG_FS)
+
+struct sg_proc_deviter {
+ loff_t index;
+ size_t max;
+ int fd_index;
+};
+
+static int
+sg_idr_max_id(int id, void *p, void *data)
+ __must_hold(&sg_index_lock)
+{
+ int *k = data;
+
+ if (*k < id)
+ *k = id;
+ return 0;
+}
+
+static int
+sg_last_dev(void)
+{
+ int k = -1;
+ unsigned long iflags;
+
+ read_lock_irqsave(&sg_index_lock, iflags);
+ idr_for_each(&sg_index_idr, sg_idr_max_id, &k);
+ read_unlock_irqrestore(&sg_index_lock, iflags);
+ return k + 1; /* origin 1 */
+}
+
+static void *
+dev_seq_start(struct seq_file *s, loff_t *pos)
+{
+ struct sg_proc_deviter *it = kzalloc(sizeof(*it), GFP_KERNEL);
+
+ s->private = it;
+ if (!it)
+ return NULL;
+
+ it->index = *pos;
+ it->max = sg_last_dev();
+ if (it->index >= it->max)
+ return NULL;
+ return it;
+}
+
+static void *
+dev_seq_next(struct seq_file *s, void *v, loff_t *pos)
+{
+ struct sg_proc_deviter *it = s->private;
+
+ *pos = ++it->index;
+ return (it->index < it->max) ? it : NULL;
+}
+
+static void
+dev_seq_stop(struct seq_file *s, void *v)
+{
+ kfree(s->private);
+}
+
+#endif /* SG_PROC_OR_DEBUG_FS */
+
+#if IS_ENABLED(CONFIG_SCSI_PROC_FS) /* long, around 200 lines */
+
static int sg_proc_seq_show_int(struct seq_file *s, void *v);
static int sg_proc_single_open_adio(struct inode *inode, struct file *filp);
@@ -3649,9 +3711,6 @@ static const struct file_operations dressz_fops = {
static int sg_proc_seq_show_version(struct seq_file *s, void *v);
static int sg_proc_seq_show_devhdr(struct seq_file *s, void *v);
static int sg_proc_seq_show_dev(struct seq_file *s, void *v);
-static void * dev_seq_start(struct seq_file *s, loff_t *pos);
-static void * dev_seq_next(struct seq_file *s, void *v, loff_t *pos);
-static void dev_seq_stop(struct seq_file *s, void *v);
static const struct seq_operations dev_seq_ops = {
.start = dev_seq_start,
.next = dev_seq_next,
@@ -3694,18 +3753,6 @@ sg_proc_init(void)
return 0;
}
-static int
-sg_last_dev(void)
-{
- int k = -1;
- unsigned long iflags;
-
- read_lock_irqsave(&sg_index_lock, iflags);
- idr_for_each(&sg_index_idr, sg_idr_max_id, &k);
- read_unlock_irqrestore(&sg_index_lock, iflags);
- return k + 1; /* origin 1 */
-}
-
static int
sg_proc_seq_show_int(struct seq_file *s, void *v)
{
@@ -3776,43 +3823,6 @@ sg_proc_seq_show_devhdr(struct seq_file *s, void *v)
return 0;
}
-struct sg_proc_deviter {
- loff_t index;
- size_t max;
- int fd_index;
-};
-
-static void *
-dev_seq_start(struct seq_file *s, loff_t *pos)
-{
- struct sg_proc_deviter *it = kzalloc(sizeof(*it), GFP_KERNEL);
-
- s->private = it;
- if (! it)
- return NULL;
-
- it->index = *pos;
- it->max = sg_last_dev();
- if (it->index >= it->max)
- return NULL;
- return it;
-}
-
-static void *
-dev_seq_next(struct seq_file *s, void *v, loff_t *pos)
-{
- struct sg_proc_deviter *it = s->private;
-
- *pos = ++it->index;
- return (it->index < it->max) ? it : NULL;
-}
-
-static void
-dev_seq_stop(struct seq_file *s, void *v)
-{
- kfree(s->private);
-}
-
static int
sg_proc_seq_show_dev(struct seq_file *s, void *v)
{
@@ -3859,6 +3869,10 @@ sg_proc_seq_show_devstrs(struct seq_file *s, void *v)
return 0;
}
+#endif /* CONFIG_SCSI_PROC_FS (~200 lines back) */
+
+#if IS_ENABLED(SG_PROC_OR_DEBUG_FS)
+
/* Writes debug info for one sg_request in obp buffer */
static int
sg_proc_debug_sreq(struct sg_request *srp, int to, char *obp, int len)
@@ -4049,7 +4063,58 @@ sg_proc_seq_show_debug(struct seq_file *s, void *v)
return 0;
}
-#endif /* CONFIG_SCSI_PROC_FS (~400 lines back) */
+#endif /* SG_PROC_OR_DEBUG_FS */
+
+#if IS_ENABLED(CONFIG_DEBUG_FS)
+
+static int
+sg_dfs_snapshot_show(struct seq_file *s, void *v)
+{
+ int res = 0;
+ loff_t my_pos = 0;
+ void *it;
+
+ it = dev_seq_start(s, &my_pos);
+ while (it) {
+ res = sg_proc_seq_show_debug(s, it);
+ if (res)
+ break;
+ it = dev_seq_next(s, it, &my_pos);
+ }
+ dev_seq_stop(s, it);
+ return res;
+}
+DEFINE_SHOW_ATTRIBUTE(sg_dfs_snapshot);
+
+static struct dentry *sg_dfs_rootdir;
+static struct dentry *sg_dfs_snapshot;
+
+static void
+sg_dfs_init(void)
+{
+ /* /sys/kernel/debug/scsi_generic/ */
+ if (!sg_dfs_rootdir)
+ sg_dfs_rootdir = debugfs_create_dir("scsi_generic", NULL);
+
+ sg_dfs_snapshot = debugfs_create_file("snapshot", S_IFREG | 0444,
+ sg_dfs_rootdir, NULL,
+ &sg_dfs_snapshot_fops);
+}
+
+static void
+sg_dfs_exit(void)
+{
+ debugfs_remove(sg_dfs_snapshot);
+ debugfs_remove(sg_dfs_rootdir);
+}
+
+#else /* not defined: CONFIG_DEBUG_FS */
+
+static void sg_dfs_init(void) {}
+static void sg_dfs_exit(void) {}
+
+#endif /* CONFIG_DEBUG_FS */
+
module_init(init_sg);
module_exit(exit_sg);
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 20/20] sg: bump version to 4.0.03
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (18 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 19/20] sg: first debugfs support Douglas Gilbert
@ 2019-08-07 11:42 ` Douglas Gilbert
2019-08-08 19:10 ` [PATCH v3 00/20] sg: add v4 interface James Bottomley
20 siblings, 0 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-07 11:42 UTC (permalink / raw)
To: linux-scsi; +Cc: martin.petersen, jejb, hare, bvanassche
Now that the sg version 4 interface is supported:
- with ioctl(SG_IO) for synchronous/blocking use
- with ioctl(SG_IOSUBMIT) and ioctl(SG_IORECEIVE) for
async/non-blocking use
Plus new ioctl(SG_IOSUBMIT_V3) and ioctl(SG_IORECEIVE_V3)
potentially replace write() and read() for the sg
version 3 interface. Bump major driver version number
from 3 to 4.
The main new feature is the removal of the fixed 16 element
array of requests per file descriptor. It is replaced by
two lists: one for active (inflight) requests and a free
list. Also sg_requests objects are not freed until the
owning file descriptor is closed; rather these objects
are re-used when multiple commands are sent to the same
file descriptor.
Signed-off-by: Douglas Gilbert <dgilbert@interlog.com>
---
drivers/scsi/sg.c | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 82c4147ba4f1..3ad88e18a5ac 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -12,9 +12,9 @@
*
*/
-static int sg_version_num = 30901; /* [x]xyyzz where [x] empty when x=0 */
-#define SG_VERSION_STR "3.9.01" /* [x]x.[y]y.zz */
-static char *sg_version_date = "20190606";
+static int sg_version_num = 40003; /* [x]xyyzz where [x] empty when x=0 */
+#define SG_VERSION_STR "4.0.03" /* [x]x.[y]y.zz */
+static char *sg_version_date = "20190612";
#include <linux/module.h>
--
2.22.0
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 00/20] sg: add v4 interface
2019-08-07 11:42 [PATCH v3 00/20] sg: add v4 interface Douglas Gilbert
` (19 preceding siblings ...)
2019-08-07 11:42 ` [PATCH v3 20/20] sg: bump version to 4.0.03 Douglas Gilbert
@ 2019-08-08 19:10 ` James Bottomley
2019-08-08 21:08 ` Douglas Gilbert
2019-08-12 15:23 ` Christoph Hellwig
20 siblings, 2 replies; 63+ messages in thread
From: James Bottomley @ 2019-08-08 19:10 UTC (permalink / raw)
To: Douglas Gilbert, linux-scsi, linux-block, linux-api
Cc: martin.petersen, hare, bvanassche
On Wed, 2019-08-07 at 13:42 +0200, Douglas Gilbert wrote:
> This patchset extends the SCSI generic (sg) driver found in
> lk 5.3 . The sg driver has a version number which is visible
> via ioctl(SG_GET_VERSION_NUM) and is bumped from 3.5.36 to
> 4.0.03 by this patchset. The additions and changes are
> described in some detail in this long webpage:
> http://sg.danny.cz/sg/sg_v40.html
>
> Most new features described in the above webpage are not
> implemented in this patchset.
Since this will be an extension of something that exists both in your
sg driver and in the block bsg interface (and thus needs an
implementation there), I added both linux-block and linux-api to the cc
(the latter because you're adding to an API).
Simply extending sg to use the v4 header protocol in uapi/linux/bsg.h
is fine modulo the code being in the right form. The problems are the
new ioctls you want to add that would need to be present there as well.
The specific question being how we support async or non-blocking I/O
on the sg and bsg interfaces. The standard way we add asynchronous I/O
is supposed to be via .poll on the file descriptor. you already use
read and write in sg and bsg doesn't have a polling interface, but it
looks like we could use MSG to signal an ioctl is ready to be serviced
for both. Would shifting to a non-blocking poll based interface for
ioctls remove the need to add these SG_IOSUBMIT/SG_IORECEIVE ioctls
since we could now do everything over blocking or non-blocking SG_IO?
James
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 00/20] sg: add v4 interface
2019-08-08 19:10 ` [PATCH v3 00/20] sg: add v4 interface James Bottomley
@ 2019-08-08 21:08 ` Douglas Gilbert
2019-08-08 21:37 ` Tony Battersby
2019-08-08 23:00 ` James Bottomley
2019-08-12 15:23 ` Christoph Hellwig
1 sibling, 2 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-08 21:08 UTC (permalink / raw)
To: James Bottomley, linux-scsi, linux-block, linux-api
Cc: martin.petersen, hare, bvanassche, Arnd Bergmann, Tony Battersby
On 2019-08-08 9:10 p.m., James Bottomley wrote:
> On Wed, 2019-08-07 at 13:42 +0200, Douglas Gilbert wrote:
>> This patchset extends the SCSI generic (sg) driver found in
>> lk 5.3 . The sg driver has a version number which is visible
>> via ioctl(SG_GET_VERSION_NUM) and is bumped from 3.5.36 to
>> 4.0.03 by this patchset. The additions and changes are
>> described in some detail in this long webpage:
>> http://sg.danny.cz/sg/sg_v40.html
>>
>> Most new features described in the above webpage are not
>> implemented in this patchset.
>
> Since this will be an extension of something that exists both in your
> sg driver and in the block bsg interface (and thus needs an
> implementation there), I added both linux-block and linux-api to the cc
> (the latter because you're adding to an API).
The SG_IO ioctl has been the synchronous SCSI pass-through interface
for over 15 years. Its quirk is that it takes two different formats
depending on the character device its file descriptor belongs to:
- sg device file descriptor: sg v3 interface (struct sg_io_hdr)
- bsg device file descriptor: sg v4 interface (struct sg_io_v4)
I'm only proposing one change in the synchronous interface based
on the SG_IO ioctl: to additionally accept the sg v4 interface in
the sg driver.
Arnd Bergmann considers two interface structures through one ioctl
as undesirable but is prepared to accept SG_IO. His POV is as the
maintainer of 32/64 bit compatibility ioctls. The case of SG_IO
is a well established exception to his rules (i.e. a known evil).
I don't believe extending ioctl SG_IO for asynchronous work is a
good idea. As pointed out above, it is already overloaded too
much. Additionally it would need further flags to differentiate
these cases:
- sync/async
- if async: submission or reception
- and optionally if async: abort (an inflight request)
- and do you want to add multiple requests in there too?
So are you looking at reducing the number of ioctl to the absolute
minimum? If so I don't think the SG_IO ioctl is the correct vehicle
for that. It doesn't use the _IOR(W) macros, instead it is hard
coded at 0x2285 ***. And the size checking offered by the _IOR(W)
macro (on the object pointed to by the 3rd argument) is useless with
SG_IO because it takes two different sized objects. Worse, one of
those objects changes size between 32 and 64 bits, while the other
does not.
Stepping back, this started about 18 months ago when security janitors
got upset about the bsg driver's use of write()/read() for its async
interface. Linus Torvalds suggested SG_IOSUBMIT and SG_IORECEIVE to
replace write() and read() respectively in bsg. Instead the write()/
read() interface was removed from the bsg driver. With it went the
ability to submit multiple requests in one write() call (by passing
an array of sg_io_v4 objects rather than just one). My intention is
to re-add that capability in the sg driver, using the ioctls that
Linus suggested.
Initially I had both the sg v3 and v4 interfaces passing through the
two ioctls. Arnd Bergmann preferred that a separate pair of ioctls
be used for each interface. Hence SG_IOSUBMIT_V3 and SG_IORECEIVE_V3
were added for the v3 interface. And thus SG_IOSUBMIT and SG_IORECEIVE
only use the v4 interface. This cleaned up my code and documentation.
As a bonus, all four ioctls use the _IORW macros and can check the
fixed size of the third argument to each ioctl invocation.
> Simply extending sg to use the v4 header protocol in uapi/linux/bsg.h
> is fine modulo the code being in the right form. The problems are the
> new ioctls you want to add that would need to be present there as well.
Why? The bsg driver has never accepted the sg v3 interface. It has also
removed functionality that I'm trying to re-add in this, and a follow-on
patchset. The bsg driver has reduced its functionality as a generalized
SCSI pass-through, but it has more than enough other roles to justify
its existence, for example as a SMP (SAS) pass-through and a
driver/transport specific pass-through to various LLDs. I don't see the
need for the sg and bsg driver to move forward in lockstep.
> The specific question being how we support async or non-blocking I/O
> on the sg and bsg interfaces. The standard way we add asynchronous I/O
> is supposed to be via .poll on the file descriptor. you already use
> read and write in sg and bsg doesn't have a polling interface,
It is hard to parse that last sentence; the sg driver has always
supported select/poll/epoll (and SIGIO plus RT signals). sg_poll()
will work just as well irrespective of whether a request is submitted
by write(), ioctl(SG_IOSUBMIT) or ioctl(SG_IOSUBMIT_V3).
but it
> looks like we could use MSG to signal an ioctl is ready to be serviced
> for both. Would shifting to a non-blocking poll based interface for
> ioctls remove the need to add these SG_IOSUBMIT/SG_IORECEIVE ioctls
> since we could now do everything over blocking or non-blocking SG_IO?
Not sure what the MSG is you refer to. The sg driver has had
ioctl(SG_GET_NUM_WAITING) for a long time. And it is made even
more lightweight in this patchset: it takes no locks, just reads one
atomic (a counter obviously) and returns. My guess is its faster the
select()/poll()/epoll() but doesn't have the ability to monitor
multiple file descriptors.
Here is the full set of extra ioctls I have, or will be proposing:
SG_IOSUBMIT
SG_IOSUBMIT_V3
SG_IORECEIVE
SG_IORECEIVE_V3
SG_IOABORT
SG_SG_SET_GET_EXTENDED
They are all new style ioctls using the _IOR(W) macros with fixed size
objects referenced by the ioctl's third argument. ioctls have been
referred to as the "garbage bin of Unix". Well that last one is a garbage
bin within a garbage bin :-) On the plus side, it keeps that list
relatively short.
Doug Gilbert
*** Tony Battersby is a sg driver power user. He has lamented wading through
very large logs looking for some hint of why the sg driver is playing
up. He has stated the strong preference for more, not less, ioctls.
BTW the write()/read() interface still remains in the sg driver after
these patchsets. It will continue to only support the sg v3 interface.
Perhaps calling it should cause a "deprecated" log message once for
each kernel run to annoy maintainers of old code.
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 00/20] sg: add v4 interface
2019-08-08 21:08 ` Douglas Gilbert
@ 2019-08-08 21:37 ` Tony Battersby
2019-08-08 22:25 ` Bart Van Assche
2019-08-08 23:00 ` James Bottomley
1 sibling, 1 reply; 63+ messages in thread
From: Tony Battersby @ 2019-08-08 21:37 UTC (permalink / raw)
To: dgilbert, James Bottomley, linux-scsi, linux-block, linux-api
Cc: martin.petersen, hare, bvanassche, Arnd Bergmann
On 8/8/19 5:08 PM, Douglas Gilbert wrote:
>
> Here is the full set of extra ioctls I have, or will be proposing:
> SG_IOSUBMIT
> SG_IOSUBMIT_V3
> SG_IORECEIVE
> SG_IORECEIVE_V3
> SG_IOABORT
> SG_SG_SET_GET_EXTENDED
>
> They are all new style ioctls using the _IOR(W) macros with fixed size
> objects referenced by the ioctl's third argument. ioctls have been
> referred to as the "garbage bin of Unix". Well that last one is a garbage
> bin within a garbage bin :-) On the plus side, it keeps that list
> relatively short.
>
> Doug Gilbert
>
>
> *** Tony Battersby is a sg driver power user. He has lamented wading through
> very large logs looking for some hint of why the sg driver is playing
> up. He has stated the strong preference for more, not less, ioctls.
>
One of the reasons ioctls have a bad reputation is because they can be
used to implement poorly-thought-out interfaces. So kernel maintainers
push back on adding new ioctls. But the push back isn't about the
number of ioctls, it is about the poor interfaces. My advice was that
in general, to implement a given API, it would be better to add more
ioctls with a simple interface for each one rather than to add fewer
extremely complex multiplexing ioctls.
Tony Battersby
Cybernetics
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 00/20] sg: add v4 interface
2019-08-08 21:37 ` Tony Battersby
@ 2019-08-08 22:25 ` Bart Van Assche
2019-08-09 13:28 ` Tony Battersby
0 siblings, 1 reply; 63+ messages in thread
From: Bart Van Assche @ 2019-08-08 22:25 UTC (permalink / raw)
To: Tony Battersby, dgilbert, James Bottomley, linux-scsi,
linux-block, linux-api
Cc: martin.petersen, hare, Arnd Bergmann
On 8/8/19 2:37 PM, Tony Battersby wrote:
> On 8/8/19 5:08 PM, Douglas Gilbert wrote:
>> *** Tony Battersby is a sg driver power user. He has lamented wading through
>> very large logs looking for some hint of why the sg driver is playing
>> up. He has stated the strong preference for more, not less, ioctls.
>>
> One of the reasons ioctls have a bad reputation is because they can be
> used to implement poorly-thought-out interfaces. So kernel maintainers
> push back on adding new ioctls. But the push back isn't about the
> number of ioctls, it is about the poor interfaces. My advice was that
> in general, to implement a given API, it would be better to add more
> ioctls with a simple interface for each one rather than to add fewer
> extremely complex multiplexing ioctls.
Hi Tony,
What is your motivation to use the SG_IO API? Is it controlling SMR
drives or are you using SG_IO for another reason? I'm asking because
depending on the use case there may be a better solution than using the
SG_IO API.
Thanks,
Bart.
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 00/20] sg: add v4 interface
2019-08-08 22:25 ` Bart Van Assche
@ 2019-08-09 13:28 ` Tony Battersby
0 siblings, 0 replies; 63+ messages in thread
From: Tony Battersby @ 2019-08-09 13:28 UTC (permalink / raw)
To: Bart Van Assche, dgilbert, James Bottomley, linux-scsi,
linux-block, linux-api
Cc: martin.petersen, hare, Arnd Bergmann
On 8/8/19 6:25 PM, Bart Van Assche wrote:
> On 8/8/19 2:37 PM, Tony Battersby wrote:
>> On 8/8/19 5:08 PM, Douglas Gilbert wrote:
>>> *** Tony Battersby is a sg driver power user. He has lamented wading through
>>> very large logs looking for some hint of why the sg driver is playing
>>> up. He has stated the strong preference for more, not less, ioctls.
>>>
>> One of the reasons ioctls have a bad reputation is because they can be
>> used to implement poorly-thought-out interfaces. So kernel maintainers
>> push back on adding new ioctls. But the push back isn't about the
>> number of ioctls, it is about the poor interfaces. My advice was that
>> in general, to implement a given API, it would be better to add more
>> ioctls with a simple interface for each one rather than to add fewer
>> extremely complex multiplexing ioctls.
> Hi Tony,
>
> What is your motivation to use the SG_IO API? Is it controlling SMR
> drives or are you using SG_IO for another reason? I'm asking because
> depending on the use case there may be a better solution than using the
> SG_IO API.
>
> Thanks,
>
> Bart.
>
Actually I used the asynchronous write()/read()/poll() sg interface to
implement RAID-like functionality for tape drives and medium changers,
in a commercial product that has been around since 2002. These days our
products use a lot more disk I/O than tape I/O, so I don't write much
new code using the sg interface anymore, although that code is still
there and has to be maintained as needed. So I don't have any immediate
plans to use any of the new sgv4 features being introduced, and
unfortunately I am way too busy to even give it a good review...
Tony Battersby
Cybernetics
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 00/20] sg: add v4 interface
2019-08-08 21:08 ` Douglas Gilbert
2019-08-08 21:37 ` Tony Battersby
@ 2019-08-08 23:00 ` James Bottomley
2019-08-14 4:19 ` Douglas Gilbert
1 sibling, 1 reply; 63+ messages in thread
From: James Bottomley @ 2019-08-08 23:00 UTC (permalink / raw)
To: dgilbert, linux-scsi, linux-block, linux-api
Cc: martin.petersen, hare, bvanassche, Arnd Bergmann, Tony Battersby
On Thu, 2019-08-08 at 23:08 +0200, Douglas Gilbert wrote:
> On 2019-08-08 9:10 p.m., James Bottomley wrote:
> > On Wed, 2019-08-07 at 13:42 +0200, Douglas Gilbert wrote:
> > > This patchset extends the SCSI generic (sg) driver found in
> > > lk 5.3 . The sg driver has a version number which is visible
> > > via ioctl(SG_GET_VERSION_NUM) and is bumped from 3.5.36 to
> > > 4.0.03 by this patchset. The additions and changes are
> > > described in some detail in this long webpage:
> > > http://sg.danny.cz/sg/sg_v40.html
> > >
> > > Most new features described in the above webpage are not
> > > implemented in this patchset.
> >
> > Since this will be an extension of something that exists both in
> > your sg driver and in the block bsg interface (and thus needs an
> > implementation there), I added both linux-block and linux-api to
> > the cc (the latter because you're adding to an API).
>
> The SG_IO ioctl has been the synchronous SCSI pass-through interface
> for over 15 years. Its quirk is that it takes two different formats
> depending on the character device its file descriptor belongs to:
> - sg device file descriptor: sg v3 interface (struct sg_io_hdr)
> - bsg device file descriptor: sg v4 interface (struct sg_io_v4)
>
> I'm only proposing one change in the synchronous interface based
> on the SG_IO ioctl: to additionally accept the sg v4 interface in
> the sg driver.
Right, as I said below, adding v4 to sg looks to be fine. We don't
need v3 in BSG since v4 is a superset.
> Arnd Bergmann considers two interface structures through one ioctl
> as undesirable but is prepared to accept SG_IO. His POV is as the
> maintainer of 32/64 bit compatibility ioctls. The case of SG_IO
> is a well established exception to his rules (i.e. a known evil).
>
> I don't believe extending ioctl SG_IO for asynchronous work is a
> good idea. As pointed out above, it is already overloaded too
> much. Additionally it would need further flags to differentiate
> these cases:
> - sync/async
> - if async: submission or reception
> - and optionally if async: abort (an inflight request)
> - and do you want to add multiple requests in there too?
>
> So are you looking at reducing the number of ioctl to the absolute
> minimum? If so I don't think the SG_IO ioctl is the correct vehicle
> for that. It doesn't use the _IOR(W) macros, instead it is hard
> coded at 0x2285 ***. And the size checking offered by the _IOR(W)
> macro (on the object pointed to by the 3rd argument) is useless with
> SG_IO because it takes two different sized objects. Worse, one of
> those objects changes size between 32 and 64 bits, while the other
> does not.
OK, so this is where interface design is important. It's perfectly
possible to design an async interface using the current v4 BSG SG_IO.
You simply open the device O_NONBLOCK and send the ioctl which will
return immediately. To find out when it returns you poll (we'd
obviously need to add polling in bsg, but that's fairly simple). Since
poll/select/epoll is our standard async event handling mechanism, we
should at least try it and have a good reason why it doesn't work
before inventing our own equivalent.
> Stepping back, this started about 18 months ago when security
> janitors got upset about the bsg driver's use of write()/read() for
> its async interface. Linus Torvalds suggested SG_IOSUBMIT and
> SG_IORECEIVE to replace write() and read() respectively in bsg.
> Instead the write()/read() interface was removed from the bsg driver.
> With it went the ability to submit multiple requests in one write()
> call (by passing an array of sg_io_v4 objects rather than just one).
> My intention is to re-add that capability in the sg driver, using the
> ioctls that Linus suggested.
What I'm saying is let's discuss the interface design before we add it.
the submit/receive interface is essentially a packet one. The problem
with a packet one is that we're request/response where the response
likely altered some user memory area, so each response has to be
matched with the outbound request to find out what happened ... how is
that done?
One way to do it simply with existing SG_IO is to allow only one
outstanding request per FD, so if you want five requests, you open five
FDs and then poll all of them to see which one returns. I'm not saying
it's the best because FDs are a somewhat precious commodity, but it is
possible and it's a simple extension of what exists today.
> Initially I had both the sg v3 and v4 interfaces passing through the
> two ioctls. Arnd Bergmann preferred that a separate pair of ioctls
> be used for each interface. Hence SG_IOSUBMIT_V3 and SG_IORECEIVE_V3
> were added for the v3 interface. And thus SG_IOSUBMIT and
> SG_IORECEIVE only use the v4 interface. This cleaned up my code and
> documentation. As a bonus, all four ioctls use the _IORW macros and
> can check the fixed size of the third argument to each ioctl
> invocation.
Can we talk first about how the interface should work. We can get into
assigning ioctls and what extensions are needed later.
> > Simply extending sg to use the v4 header protocol in
> > uapi/linux/bsg.h is fine modulo the code being in the right
> > form. The problems are the new ioctls you want to add that would
> > need to be present there as well.
>
> Why? The bsg driver has never accepted the sg v3 interface. It has
> also removed functionality that I'm trying to re-add in this, and a
> follow-on patchset. The bsg driver has reduced its functionality as a
> generalized SCSI pass-through, but it has more than enough other
> roles to justify its existence, for example as a SMP (SAS) pass-
> through and a driver/transport specific pass-through to various LLDs.
> I don't see the need for the sg and bsg driver to move forward in
> lockstep.
You quote Linus a lot above, but he also said "I wonder if we could at
least try to unify the bsg/sg code - possibly by making sg use the
prettier bsg code (but definitely have to add all the security
measures)". It's in the interests of unity that we need to make the
code paths look the same as possible, so eventually one could call the
other. ideally sg would call bsg for v4 and we'd add async to bsg so
it would work for both.
> > The specific question being how we support async or non-blocking
> > I/O on the sg and bsg interfaces. The standard way we add
> > asynchronous I/O is supposed to be via .poll on the file
> > descriptor. you already use read and write in sg and bsg doesn't
> > have a polling interface,
>
> It is hard to parse that last sentence; the sg driver has always
> supported select/poll/epoll (and SIGIO plus RT signals). sg_poll()
> will work just as well irrespective of whether a request is submitted
> by write(), ioctl(SG_IOSUBMIT) or ioctl(SG_IOSUBMIT_V3).
The way I read how the interface works, it only works when the fd is
ready for read (i.e. a packet submitted with read has returned). We
need to extend it to make it work with ioctl. Since ioctl returns
isn't either a 'ready to read' or 'ready to write' event on the fd I
was suggesting using 'msg ready' event for it.
> > but it looks like we could use MSG to signal an ioctl is ready to
> > be serviced for both. Would shifting to a non-blocking poll based
> > interface for ioctls remove the need to add these
> > SG_IOSUBMIT/SG_IORECEIVE ioctls since we could now do everything
> > over blocking or non-blocking SG_IO?
>
> Not sure what the MSG is you refer to. The sg driver has had
> ioctl(SG_GET_NUM_WAITING) for a long time. And it is made even
> more lightweight in this patchset: it takes no locks, just reads one
> atomic (a counter obviously) and returns. My guess is its faster the
> select()/poll()/epoll() but doesn't have the ability to monitor
> multiple file descriptors.
the poll interfaces don't tell you how many outstanding request you
have, they tell you when some event happened on the fd. The event
we're looking for with async packets is an indication of what
completed.
> Here is the full set of extra ioctls I have, or will be proposing:
> SG_IOSUBMIT
> SG_IOSUBMIT_V3
> SG_IORECEIVE
> SG_IORECEIVE_V3
> SG_IOABORT
> SG_SG_SET_GET_EXTENDED
Well, i/o cancellation is another huge can of worms, but let's get the
submit interface sorted out first before worrying about how
cancellation works.
> They are all new style ioctls using the _IOR(W) macros with fixed
> size objects referenced by the ioctl's third argument. ioctls have
> been referred to as the "garbage bin of Unix". Well that last one is
> a garbage bin within a garbage bin :-) On the plus side, it keeps
> that list relatively short.
>
> Doug Gilbert
>
>
> *** Tony Battersby is a sg driver power user. He has lamented wading
> through very large logs looking for some hint of why the sg driver is
> playing up he has stated the strong preference for more, not less,
> ioctls.
I'm not really bothered about the number of ioctls; I'm bothered about
getting the interface right.
> BTW the write()/read() interface still remains in the sg driver after
> these patchsets. It will continue to only support the sg v3
> interface. Perhaps calling it should cause a "deprecated" log message
> once for each kernel run to annoy maintainers of old code.
That would be ideal given all the security complaints we have about it.
James
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 00/20] sg: add v4 interface
2019-08-08 23:00 ` James Bottomley
@ 2019-08-14 4:19 ` Douglas Gilbert
2019-08-15 17:30 ` Bart Van Assche
0 siblings, 1 reply; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-14 4:19 UTC (permalink / raw)
To: James Bottomley, linux-scsi, linux-block, linux-api
Cc: martin.petersen, hare, bvanassche, Arnd Bergmann, Tony Battersby
On 2019-08-09 1:00 a.m., James Bottomley wrote:
> On Thu, 2019-08-08 at 23:08 +0200, Douglas Gilbert wrote:
>> On 2019-08-08 9:10 p.m., James Bottomley wrote:
>>> On Wed, 2019-08-07 at 13:42 +0200, Douglas Gilbert wrote:
>>>> This patchset extends the SCSI generic (sg) driver found in
>>>> lk 5.3 . The sg driver has a version number which is visible
>>>> via ioctl(SG_GET_VERSION_NUM) and is bumped from 3.5.36 to
>>>> 4.0.03 by this patchset. The additions and changes are
>>>> described in some detail in this long webpage:
>>>> http://sg.danny.cz/sg/sg_v40.html
>>>>
>>>> Most new features described in the above webpage are not
>>>> implemented in this patchset.
>>>
>>> Since this will be an extension of something that exists both in
>>> your sg driver and in the block bsg interface (and thus needs an
>>> implementation there), I added both linux-block and linux-api to
>>> the cc (the latter because you're adding to an API).
>>
>> The SG_IO ioctl has been the synchronous SCSI pass-through interface
>> for over 15 years. Its quirk is that it takes two different formats
>> depending on the character device its file descriptor belongs to:
>> - sg device file descriptor: sg v3 interface (struct sg_io_hdr)
>> - bsg device file descriptor: sg v4 interface (struct sg_io_v4)
>>
>> I'm only proposing one change in the synchronous interface based
>> on the SG_IO ioctl: to additionally accept the sg v4 interface in
>> the sg driver.
>
> Right, as I said below, adding v4 to sg looks to be fine. We don't
> need v3 in BSG since v4 is a superset.
>
>> Arnd Bergmann considers two interface structures through one ioctl
>> as undesirable but is prepared to accept SG_IO. His POV is as the
>> maintainer of 32/64 bit compatibility ioctls. The case of SG_IO
>> is a well established exception to his rules (i.e. a known evil).
>>
>> I don't believe extending ioctl SG_IO for asynchronous work is a
>> good idea. As pointed out above, it is already overloaded too
>> much. Additionally it would need further flags to differentiate
>> these cases:
>> - sync/async
>> - if async: submission or reception
>> - and optionally if async: abort (an inflight request)
>> - and do you want to add multiple requests in there too?
>>
>> So are you looking at reducing the number of ioctl to the absolute
>> minimum? If so I don't think the SG_IO ioctl is the correct vehicle
>> for that. It doesn't use the _IOR(W) macros, instead it is hard
>> coded at 0x2285 ***. And the size checking offered by the _IOR(W)
>> macro (on the object pointed to by the 3rd argument) is useless with
>> SG_IO because it takes two different sized objects. Worse, one of
>> those objects changes size between 32 and 64 bits, while the other
>> does not.
>
> OK, so this is where interface design is important. It's perfectly
> possible to design an async interface using the current v4 BSG SG_IO.
> You simply open the device O_NONBLOCK and send the ioctl which will
> return immediately. To find out when it returns you poll (we'd
> obviously need to add polling in bsg, but that's fairly simple). Since
> poll/select/epoll is our standard async event handling mechanism, we
> should at least try it and have a good reason why it doesn't work
> before inventing our own equivalent.
I don't see much new interface design here over what was done by
Lawrence Foard 27 years ago. Linux cleverness has broken the
classic use of read() and write() in char drivers. Hard to hold that
against the original design. The design works if the last 27 years
is any guide and maps reasonably closely to how the mid-level
(or the block layer) issues SCSI commands. All other general
purpose OSes that I am aware of, with the exception of Darwin,
have a similar SCSI pass-through, at least on the sync side.
>> Stepping back, this started about 18 months ago when security
>> janitors got upset about the bsg driver's use of write()/read() for
>> its async interface. Linus Torvalds suggested SG_IOSUBMIT and
>> SG_IORECEIVE to replace write() and read() respectively in bsg.
>> Instead the write()/read() interface was removed from the bsg driver.
>> With it went the ability to submit multiple requests in one write()
>> call (by passing an array of sg_io_v4 objects rather than just one).
>> My intention is to re-add that capability in the sg driver, using the
>> ioctls that Linus suggested.
>
> What I'm saying is let's discuss the interface design before we add it.
> the submit/receive interface is essentially a packet one. The problem
> with a packet one is that we're request/response where the response
> likely altered some user memory area, so each response has to be
> matched with the outbound request to find out what happened ... how is
> that done?
Well this has been fundamental to the sg driver design. There are
now three mechanisms, described below with the oldest first:
1) pack_id: an identifying integer supplied by the user in the
submit that can be given as input to the receive call so
it either yields the (first) matching response, or waits (sync
action) or returns saying nothing was found (async action).
pack_id was present in the sg driver in version 1.0 of Linux
in 1992. It still works fine.
2) usr_ptr: sometimes described as a "closure pointer". User
provided, untouched by the driver, and placed in the
corresponding response. Present in sg v3 and v4 interfaces.
In place over 15 years.
3) tag: like pack_id but issued by the block layer so it is
_output_ by the submit call. In practice it does not work
reliably *** due to questionable design in the block layer. After
blk_execute_rq_nowait() is called the tag is picked out of
its data structure. However that command may not have started
(so no valid tag) or could have already finished (a stale tag).
Tag is a new feature in the proposed patchsets.
> One way to do it simply with existing SG_IO is to allow only one
> outstanding request per FD, so if you want five requests, you open five
> FDs and then poll all of them to see which one returns. I'm not saying
> it's the best because FDs are a somewhat precious commodity, but it is
> possible and it's a simple extension of what exists today.
I believe this is adequately covered by the mechanisms above.
>> Initially I had both the sg v3 and v4 interfaces passing through the
>> two ioctls. Arnd Bergmann preferred that a separate pair of ioctls
>> be used for each interface. Hence SG_IOSUBMIT_V3 and SG_IORECEIVE_V3
>> were added for the v3 interface. And thus SG_IOSUBMIT and
>> SG_IORECEIVE only use the v4 interface. This cleaned up my code and
>> documentation. As a bonus, all four ioctls use the _IORW macros and
>> can check the fixed size of the third argument to each ioctl
>> invocation.
>
> Can we talk first about how the interface should work. We can get into
> assigning ioctls and what extensions are needed later.
I have been trying for 9 months to get some feedback on
the current design. The attitude seems to be present some
patches; no, those ones are too big, etc. As for my design
document at:
http://sg.danny.cz/sg/sg_v40.html
tl;dr ?
Evidently write() and read() system calls have special features
that could be exploited by an attack via the bsg or sg drivers.
ioctl(SG_IOSUBMIT) is just write(sg_fd, ...) that is less
exploitable. There is a similar relationship between
ioctl(SG_IORECEIVE) an read(sg_fd, ...). Otherwise the async
interface design remains the same in the sg driver as it was
when introduced 27 years ago. ^^^
Bart Van Assche hinted at a better API design but didn't present
it. If he did, that would be the first time an alternate API
design was presented for async usage in the 20 years that I have
been associated with the driver.
>>> Simply extending sg to use the v4 header protocol in
>>> uapi/linux/bsg.h is fine modulo the code being in the right
>>> form. The problems are the new ioctls you want to add that would
>>> need to be present there as well.
>>
>> Why? The bsg driver has never accepted the sg v3 interface. It has
>> also removed functionality that I'm trying to re-add in this, and a
>> follow-on patchset. The bsg driver has reduced its functionality as a
>> generalized SCSI pass-through, but it has more than enough other
>> roles to justify its existence, for example as a SMP (SAS) pass-
>> through and a driver/transport specific pass-through to various LLDs.
>> I don't see the need for the sg and bsg driver to move forward in
>> lockstep.
>
> You quote Linus a lot above, but he also said "I wonder if we could at
twice
> least try to unify the bsg/sg code - possibly by making sg use the
> prettier bsg code (but definitely have to add all the security
> measures)". It's in the interests of unity that we need to make the
> code paths look the same as possible, so eventually one could call the
> other. ideally sg would call bsg for v4 and we'd add async to bsg so
> it would work for both.
The bsg driver needs to be rewritten. Ah, no need since by removing the
async (including multiple requests) part, the broken implementation is
no more. Its implementation is sufficient to issue synchronous
SCSI commands, not much more +++. The bsg v4 interface implementation
was only a superset of the sg driver's v3 interface while the Linux
kernel supported bidi. That has unwisely been (completely) removed
from the kernel. So now I would regard the bsg v4 implementation
as a subset of the functionality in the sg v3 implementation which
itself is a subset of the proposed sg v4 implementation. So I see
no reason to use the bsg v4 implementation or handicap the proposed
sg v4 implementation.
>>> The specific question being how we support async or non-blocking
>>> I/O on the sg and bsg interfaces. The standard way we add
>>> asynchronous I/O is supposed to be via .poll on the file
>>> descriptor. you already use read and write in sg and bsg doesn't
>>> have a polling interface,
>>
>> It is hard to parse that last sentence; the sg driver has always
>> supported select/poll/epoll (and SIGIO plus RT signals). sg_poll()
>> will work just as well irrespective of whether a request is submitted
>> by write(), ioctl(SG_IOSUBMIT) or ioctl(SG_IOSUBMIT_V3).
>
> The way I read how the interface works, it only works when the fd is
> ready for read (i.e. a packet submitted with read has returned). We
> need to extend it to make it work with ioctl. Since ioctl returns
> isn't either a 'ready to read' or 'ready to write' event on the fd I
> was suggesting using 'msg ready' event for it.
A ready response causes a POLL_IN event. POLL_OUT is only cleared when
the command queueing on a fd is turned off and a request is inflight or
awaiting a ioctl(SG_IORECEIVE) (a.k.a. read()). So the existing POLL
events map quite well. As a bonus, if there is a surprise removal of
a sg device, then a SIG_HUP is generated.
As I noted, if an app doesn't need to monitor multiple file
descriptors, then ioctl(SG_GET_NUM_WAITING) is an option. It been in
place for 20 years and is sped up by this patchset. I clocked it at
500 nanoconds per call (i.e. 2 million could be issued in one thread
in 1 second) on my laptop. And since you then find out how many are
waiting to be processed, the user could issue a multiple requests
ioctl(SG_IORECEIVE) and pick them all up in one system call invocation.
>>> but it looks like we could use MSG to signal an ioctl is ready to
>>> be serviced for both. Would shifting to a non-blocking poll based
>>> interface for ioctls remove the need to add these
>>> SG_IOSUBMIT/SG_IORECEIVE ioctls since we could now do everything
>>> over blocking or non-blocking SG_IO?
>>
>> Not sure what the MSG is you refer to. The sg driver has had
>> ioctl(SG_GET_NUM_WAITING) for a long time. And it is made even
>> more lightweight in this patchset: it takes no locks, just reads one
>> atomic (a counter obviously) and returns. My guess is its faster the
>> select()/poll()/epoll() but doesn't have the ability to monitor
>> multiple file descriptors.
>
> the poll interfaces don't tell you how many outstanding request you
> have, they tell you when some event happened on the fd. The event
> we're looking for with async packets is an indication of what
> completed.
As well as ioctl(SG_GET_NUM_WAITING) described above there is also
ioctl(SG_GET_PACK_ID) which will return the pack_id (or tag) of the
response that has been waiting the longest to be processed (or -1
if nothing is waiting).
In the area of async polling the existing sg driver supports both
standard Unix techniques and driver-specific techniques that convey
extra information.
>> Here is the full set of extra ioctls I have, or will be proposing:
>> SG_IOSUBMIT
>> SG_IOSUBMIT_V3
>> SG_IORECEIVE
>> SG_IORECEIVE_V3
>> SG_IOABORT
>> SG_SG_SET_GET_EXTENDED
>
> Well, i/o cancellation is another huge can of worms, but let's get the
> submit interface sorted out first before worrying about how
> cancellation works.
Yes, and its a great way to test code. The sgh_dd utility (sg3_utils
package, testing folder) has a ae=AEN option for "abort every n
commands". When it decides to abort a command it sets up another
(killer) thread that waits a random amount of time (within bounds)
then issues ioctl(SG_IOABORT). Great fun. For even more fun there
is ae=AEN,MAEN where the extra MAEN parameter is for "abort every
n multiple requests invocations". There are a lot more corner cases
when aborting a multiple requests invocation. Testing with these
found several problems with my code.
It seems to me we are not actually on the same page when it comes
to where this project stands.
>> They are all new style ioctls using the _IOR(W) macros with fixed
>> size objects referenced by the ioctl's third argument. ioctls have
>> been referred to as the "garbage bin of Unix". Well that last one is
>> a garbage bin within a garbage bin :-) On the plus side, it keeps
>> that list relatively short.
>>
>> Doug Gilbert
>>
>>
>> *** Tony Battersby is a sg driver power user. He has lamented wading
>> through very large logs looking for some hint of why the sg driver is
>> playing up he has stated the strong preference for more, not less,
>> ioctls.
>
> I'm not really bothered about the number of ioctls; I'm bothered about
> getting the interface right.
Great. Then please leave ioctl(SG_IO) as is (i.e. sync only).
>> BTW the write()/read() interface still remains in the sg driver after
>> these patchsets. It will continue to only support the sg v3
>> interface. Perhaps calling it should cause a "deprecated" log message
>> once for each kernel run to annoy maintainers of old code.
>
> That would be ideal given all the security complaints we have about it.
That is easily done.
Doug Gilbert
*** at least with scsi_debug with a command delay set at 5000 nanoseconds.
With real storage devices with latencies around 50 microseconds or higher
it may be more reliable. Some sort of handle or the tag itself back from
blk_execute_rq_nowait() is the real solution.
+++ but the bsg driver can do much more than issue SCSI commands. Question
is, given the removal of its SCSI async functionality, should it be
generating SCSI commands at all? Just the general ioctl(SG_IO) as
supported by sd, sr and st devices should suffice.
^^^ another approach to the write()/read() security problems would be for
their implementation to check if the given file descriptor was to a
char (and maybe block) device and if so reduce its exploitable behaviour
accordingly.
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 00/20] sg: add v4 interface
2019-08-14 4:19 ` Douglas Gilbert
@ 2019-08-15 17:30 ` Bart Van Assche
2019-08-16 15:59 ` Douglas Gilbert
0 siblings, 1 reply; 63+ messages in thread
From: Bart Van Assche @ 2019-08-15 17:30 UTC (permalink / raw)
To: dgilbert, James Bottomley, linux-scsi, linux-block, linux-api
Cc: martin.petersen, hare, Arnd Bergmann, Tony Battersby, Christoph Hellwig
On 8/13/19 9:19 PM, Douglas Gilbert wrote:
> Bart Van Assche hinted at a better API design but didn't present
> it. If he did, that would be the first time an alternate API
> design was presented for async usage in the 20 years that I have
> been associated with the driver.
I would like to start from the use cases instead of the implementation
of a new SG/IO interface. My employer uses the SG/IO interface for
controlling SMR and HSMR disks. What we need is the ability to discover,
read, write and configure such disks, support for the non-standard HSMR
flex protocol, the ability to give certain users or groups access to a
subset of the LBAs and also the ability to make that information
persistent. I think that such functionality could be implemented by
extending LVM and by adding support for all ZBC commands we need in the
block layer, device mapper layer and also in the asynchronous I/O layer.
The block, dm and aio layers already support submitting commands
asynchronously but do not yet support all the ZBC commands that we use.
Are there any SG/IO use cases that have not yet been mentioned in this
e-mail thread? If SMR and HSMR are the primary use cases for SG/IO,
should asynchronous command support be added in the SG/IO layer or
should rather ZBC support in the block, dm and aio layers be improved?
Thanks,
Bart.
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 00/20] sg: add v4 interface
2019-08-15 17:30 ` Bart Van Assche
@ 2019-08-16 15:59 ` Douglas Gilbert
2019-08-16 17:19 ` Greg KH
2019-08-16 18:10 ` Bart Van Assche
0 siblings, 2 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-16 15:59 UTC (permalink / raw)
To: Bart Van Assche, James Bottomley, linux-scsi, linux-block, linux-api
Cc: martin.petersen, hare, Arnd Bergmann, Tony Battersby, Christoph Hellwig
On 2019-08-15 1:30 p.m., Bart Van Assche wrote:
> On 8/13/19 9:19 PM, Douglas Gilbert wrote:
>> Bart Van Assche hinted at a better API design but didn't present
>> it. If he did, that would be the first time an alternate API
>> design was presented for async usage in the 20 years that I have
>> been associated with the driver.
>
> I would like to start from the use cases instead of the implementation of a new
> SG/IO interface. My employer uses the SG/IO interface for controlling SMR and
There is no "new" SG/IO interface. Linux has broken the ability of char
drivers to safely use the read() and write() system calls. This
adversely impacts the bsg and sg drivers. In response the following
replacement mappings have been suggested in my first sg patchset:
1) For sg driver currently in production, its async interface:
write(sg_fd, &sg_v3_obj, sizeof(sg_v3_obj))
-----> ioctl(sg_fd, SG_IOSUBMIT_V3, &sg_v3_obj)
and
read(sg_fd, &sg_v3_obj, sizeof(sg_v3_obj))
-----> ioctl(sg_fd, SG_RECEIVE_V3, &sg_v3_obj)
And send out a WARN_ONCE when write(sg_fd, &sg_v3_obj,...) is used.
2) For the async portion of the bsg driver that was removed last
year, the following, slightly more complex mapping is proposed:
write(bsg_fd, &sg_v4_obj, sizeof(sg_v4_obj))
-----> ioctl(sg_fd_equiv_bsg, SG_IOSUBMIT, &sg_v4_obj)
and
read(bsg_fd, &sg_v4_obj, sizeof(sg_v4_obj))
-----> ioctl(sg_fd_equiv_bsg, SG_RECEIVE, &sg_v4_obj)
The bsg_fd --> sg_fd_equiv_bsg mapping can be done with the help
of sysfs.
There is another case with the bsg async interface where the third
argument to write() and read() is a multiple of the size of a sg_v4_obj.
I call that a multiple requests invocation. That is handled in my second
patchset with an extra level of indirection. Yes, that is a change in
the API, but it is more on the syntax side rather than the semantics side.
The ioctls have another advantage over the write()/read() interface.
The reader will notice the both SG_IOSUBMIT and SG_IORECEIVE are defined
with the _IOWR() macro indicating bi-directional dataflow. The "reverse"
direction dataflow for the submit side is when a tag is sent back from
the block layer. For the receive side the reverse flow is when matching
either by pack_id or tag.
Also some longstanding features of the sg async API such as
ioctl(SG_GET_NUM_WAITING) can lead to a reduction in API traffic. Say
we have 20 SCSI commands that don't depend on one another (e.g. READ
GATHERED). They could be submitted asynchronously with a single
multiple requests invocation by ioctl(SG_IOSUBMIT) with the flag
SGV4_FLAG_IMMED set. The user code could then wait for one (any one)
to finish and process it (so that is two API calls so far). Now an
ioctl(SG_GET_NUM_WAITING) could be issued and say it gets 3 then a
multiple requests invocation of ioctl(SG_IORECEIVE) for those 3
could be sent and complete promptly. Now the tally of API calls is
up to 4. If another ioctl(SG_GET_NUM_WAITING) was issued and say
it yielded 16 then a multiple requests invocation of
ioctl(SG_IORECEIVE) for those 16 would complete the originally
submitted 20 SCSI commands. The total tally of API calls is 6 with
only 1 of those waiting. The wait could be made fully async by
using a polling loop or a signal to replace that (and any other)
wait.
If the user space didn't mind blocking then the whole 20 SCSI commands
could be processed efficiently with a single multiple requests
invocation using ioctl(SG_IOSUBMIT) with the SGV4_FLAG_IMMED flag
cleared. It would first issue all 20 command then return after all 20
commands were complete. That is an extension of the removed bsg async
SCSI API, but a pretty good one IMO.
The sg driver's async model remains basically the same as when the
driver first appeared in 1992. Naturally there have been enhancements
along the way, such as that last example.
> HSMR disks. What we need is the ability to discover, read, write and configure
> such disks, support for the non-standard HSMR flex protocol, the ability to give
> certain users or groups access to a subset of the LBAs and also the ability to
> make that information persistent. I think that such functionality could be
> implemented by extending LVM and by adding support for all ZBC commands we need
> in the block layer, device mapper layer and also in the asynchronous I/O layer.
> The block, dm and aio layers already support submitting commands asynchronously
> but do not yet support all the ZBC commands that we use.
I believe that you will find that the more layers of abstraction that are
placed between the actual device and the OS level API, the more difficult
the discovery process will be. And in some cases you will need to get to
a management layer to let those management functions "pass-through" those
layers. Some RAID card drivers take advantage of the no_uld_attach flag in
scsi_device to expose real devices, but only to the sg/bsg interface for
management purposes (for utilities like smartmontools) and do not produce
sd device nodes.
> Are there any SG/IO use cases that have not yet been mentioned in this e-mail
> thread? If SMR and HSMR are the primary use cases for SG/IO, should asynchronous
> command support be added in the SG/IO layer or should rather ZBC support in the
> block, dm and aio layers be improved?
My guess is quite a few, and the companies involved don't want to talk about
their use publicly. For example when a big computer company starts reporting
errors, I believe my role is to try and fix the errors, not to interrogate
them about how and why they are using the driver. On the other hand, Tony
Battersby has been relatively active on this list and produced patches for
the sg driver over several years. Tony is well positioned to know the
driver's strengths and weaknesses but has said that he has little time to
review these patchsets. I appreciate any feedback I can get from him.
Doug Gilbert
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 00/20] sg: add v4 interface
2019-08-16 15:59 ` Douglas Gilbert
@ 2019-08-16 17:19 ` Greg KH
2019-08-16 18:10 ` Bart Van Assche
1 sibling, 0 replies; 63+ messages in thread
From: Greg KH @ 2019-08-16 17:19 UTC (permalink / raw)
To: Douglas Gilbert
Cc: Bart Van Assche, James Bottomley, linux-scsi, linux-block,
linux-api, martin.petersen, hare, Arnd Bergmann, Tony Battersby,
Christoph Hellwig
On Fri, Aug 16, 2019 at 11:59:04AM -0400, Douglas Gilbert wrote:
> On 2019-08-15 1:30 p.m., Bart Van Assche wrote:
> > On 8/13/19 9:19 PM, Douglas Gilbert wrote:
> > > Bart Van Assche hinted at a better API design but didn't present
> > > it. If he did, that would be the first time an alternate API
> > > design was presented for async usage in the 20 years that I have
> > > been associated with the driver.
> >
> > I would like to start from the use cases instead of the implementation
> > of a new SG/IO interface. My employer uses the SG/IO interface for
> > controlling SMR and
>
> There is no "new" SG/IO interface. Linux has broken the ability of char
> drivers to safely use the read() and write() system calls. This
> adversely impacts the bsg and sg drivers. In response the following
> replacement mappings have been suggested in my first sg patchset:
I don't understand what you mean by "broken the ability of char drivers
to use the read() and write() system calls."
What changed, when did it change, what broke, and why can't we "fix" it
if it really is broken?
thanks,
greg k-h
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 00/20] sg: add v4 interface
2019-08-16 15:59 ` Douglas Gilbert
2019-08-16 17:19 ` Greg KH
@ 2019-08-16 18:10 ` Bart Van Assche
2019-08-16 18:44 ` Douglas Gilbert
1 sibling, 1 reply; 63+ messages in thread
From: Bart Van Assche @ 2019-08-16 18:10 UTC (permalink / raw)
To: dgilbert, James Bottomley, linux-scsi, linux-block, linux-api
Cc: martin.petersen, hare, Arnd Bergmann, Tony Battersby, Christoph Hellwig
On 8/16/19 8:59 AM, Douglas Gilbert wrote:
> On 2019-08-15 1:30 p.m., Bart Van Assche wrote:
>> HSMR disks. What we need is the ability to discover, read, write and
>> configure such disks, support for the non-standard HSMR flex protocol,
>> the ability to give certain users or groups access to a subset of the
>> LBAs and also the ability to make that information persistent. I think
>> that such functionality could be implemented by extending LVM and by
>> adding support for all ZBC commands we need in the block layer, device
>> mapper layer and also in the asynchronous I/O layer. The block, dm and
>> aio layers already support submitting commands asynchronously but do
>> not yet support all the ZBC commands that we use.
>
> I believe that you will find that the more layers of abstraction that are
> placed between the actual device and the OS level API, the more difficult
> the discovery process will be. And in some cases you will need to get to
> a management layer to let those management functions "pass-through" those
> layers. Some RAID card drivers take advantage of the no_uld_attach flag in
> scsi_device to expose real devices, but only to the sg/bsg interface for
> management purposes (for utilities like smartmontools) and do not produce
> sd device nodes.
Isn't the very purpose of an operating system to provide device drivers
and other abstraction layers such that not every application has to
implement these?
My opinion is that using SG/IO to control SMR disks is suboptimal. A
very powerful feature of the Linux block layer is the ability to stack
block drivers. SG/IO is fundamentally incompatible with stacking block
drivers. Stacking requires having access to the LBA, request size and
other block layer request attributes. I don't think that we want to add
code for parsing SCSI, NVMe pass-through commands etc. in block drivers
as the device mapper.
Hence my proposal to improve support in the block layer for ZBC instead
of using SG/IO to control SMR disks.
Bart.
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 00/20] sg: add v4 interface
2019-08-16 18:10 ` Bart Van Assche
@ 2019-08-16 18:44 ` Douglas Gilbert
0 siblings, 0 replies; 63+ messages in thread
From: Douglas Gilbert @ 2019-08-16 18:44 UTC (permalink / raw)
To: Bart Van Assche, James Bottomley, linux-scsi, linux-block, linux-api
Cc: martin.petersen, hare, Arnd Bergmann, Tony Battersby,
Christoph Hellwig, Christian Franke
On 2019-08-16 2:10 p.m., Bart Van Assche wrote:
> On 8/16/19 8:59 AM, Douglas Gilbert wrote:
>> On 2019-08-15 1:30 p.m., Bart Van Assche wrote:
>>> HSMR disks. What we need is the ability to discover, read, write and
>>> configure such disks, support for the non-standard HSMR flex protocol, the
>>> ability to give certain users or groups access to a subset of the LBAs and
>>> also the ability to make that information persistent. I think that such
>>> functionality could be implemented by extending LVM and by adding support for
>>> all ZBC commands we need in the block layer, device mapper layer and also in
>>> the asynchronous I/O layer. The block, dm and aio layers already support
>>> submitting commands asynchronously but do not yet support all the ZBC
>>> commands that we use.
>>
>> I believe that you will find that the more layers of abstraction that are
>> placed between the actual device and the OS level API, the more difficult
>> the discovery process will be. And in some cases you will need to get to
>> a management layer to let those management functions "pass-through" those
>> layers. Some RAID card drivers take advantage of the no_uld_attach flag in
>> scsi_device to expose real devices, but only to the sg/bsg interface for
>> management purposes (for utilities like smartmontools) and do not produce
>> sd device nodes.
>
> Isn't the very purpose of an operating system to provide device drivers and
> other abstraction layers such that not every application has to implement these?
>
> My opinion is that using SG/IO to control SMR disks is suboptimal. A very
> powerful feature of the Linux block layer is the ability to stack block drivers.
> SG/IO is fundamentally incompatible with stacking block drivers. Stacking
> requires having access to the LBA, request size and other block layer request
> attributes. I don't think that we want to add code for parsing SCSI, NVMe
> pass-through commands etc. in block drivers as the device mapper.
>
> Hence my proposal to improve support in the block layer for ZBC instead of using
> SG/IO to control SMR disks.
Please go right ahead. I just don't see why it should be at the expense
of this patchset or the sg pass-through in general.
Wearing another hat as the smartmontools SCSI maintainer, I know of no
supported OS or RAID product that has the infrastructure you talk about
for SMART information. The industry assumption seems to be that the
information will be pulled out at the real device level by a command set
pass-through. And RAID products present an issue if they don't support
a "no_uld_attach" type mechanism. The issue is that they then need to
offer a proprietary pass-through mechanism *** to bypass the virtual
device presented to the OS in order to get to the individual _real_
storage devices holding the SMART information. Sub-optimal maybe, but
still effective.
Doug Gilbert
*** and to their credit (IMO) several RAID "big boys" have sent the
smartmontools project working code to navigate their proprietary
pass-through mechanisms. Better that than us needing to beg for it.
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 00/20] sg: add v4 interface
2019-08-08 19:10 ` [PATCH v3 00/20] sg: add v4 interface James Bottomley
2019-08-08 21:08 ` Douglas Gilbert
@ 2019-08-12 15:23 ` Christoph Hellwig
1 sibling, 0 replies; 63+ messages in thread
From: Christoph Hellwig @ 2019-08-12 15:23 UTC (permalink / raw)
To: James Bottomley
Cc: Douglas Gilbert, linux-scsi, linux-block, linux-api,
martin.petersen, hare, bvanassche
On Thu, Aug 08, 2019 at 12:10:55PM -0700, James Bottomley wrote:
> Since this will be an extension of something that exists both in your
> sg driver and in the block bsg interface (and thus needs an
> implementation there), I added both linux-block and linux-api to the cc
> (the latter because you're adding to an API).
>
> Simply extending sg to use the v4 header protocol in uapi/linux/bsg.h
> is fine modulo the code being in the right form. The problems are the
> new ioctls you want to add that would need to be present there as well.
> The specific question being how we support async or non-blocking I/O
> on the sg and bsg interfaces. The standard way we add asynchronous I/O
> is supposed to be via .poll on the file descriptor. you already use
> read and write in sg and bsg doesn't have a polling interface, but it
> looks like we could use MSG to signal an ioctl is ready to be serviced
> for both. Would shifting to a non-blocking poll based interface for
> ioctls remove the need to add these SG_IOSUBMIT/SG_IORECEIVE ioctls
> since we could now do everything over blocking or non-blocking SG_IO?
I've spent some wading through this patchset, and it is huge. I thing
we need to stage it a bit better and split it into multiple.
1) One (or maybe even multiple) with all the cleanups and minor
speedups. That alone is a lot of changes, and will take a while
to settle
2) extending the bsg/v4 API to /dev/sg. I think that is very useful,
although I need to look at the details a bit more
3) adding a new async API. While this seems very useful from the
theoretical perspective, I really thing the guts need to be in
common code and then be used by sg and the block device nodes
(if it happens to be an ioctl). What worries me a bit there
is that we have another way to deal with async I/O. I wonder
if we can fit this into aio/io_uring somehow. But I'd rather
not even thing about that much until we've done all the groundwork.
^ permalink raw reply [flat|nested] 63+ messages in thread