source: src/linux/universal/linux-3.18/drivers/scsi/sg.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 2 months ago

update

File size: 73.8 KB
Line 
1/*
2 *  History:
3 *  Started: Aug 9 by Lawrence Foard (entropy@world.std.com),
4 *           to allow user process control of SCSI devices.
5 *  Development Sponsored by Killy Corp. NY NY
6 *
7 * Original driver (sg.c):
8 *        Copyright (C) 1992 Lawrence Foard
9 * Version 2 and 3 extensions to driver:
10 *        Copyright (C) 1998 - 2014 Douglas Gilbert
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2, or (at your option)
15 * any later version.
16 *
17 */
18
19static int sg_version_num = 30536;      /* 2 digits for each component */
20#define SG_VERSION_STR "3.5.36"
21
22/*
23 *  D. P. Gilbert (dgilbert@interlog.com), notes:
24 *      - scsi logging is available via SCSI_LOG_TIMEOUT macros. First
25 *        the kernel/module needs to be built with CONFIG_SCSI_LOGGING
26 *        (otherwise the macros compile to empty statements).
27 *
28 */
29#include <linux/module.h>
30
31#include <linux/fs.h>
32#include <linux/kernel.h>
33#include <linux/sched.h>
34#include <linux/string.h>
35#include <linux/mm.h>
36#include <linux/aio.h>
37#include <linux/errno.h>
38#include <linux/mtio.h>
39#include <linux/ioctl.h>
40#include <linux/slab.h>
41#include <linux/fcntl.h>
42#include <linux/init.h>
43#include <linux/poll.h>
44#include <linux/moduleparam.h>
45#include <linux/cdev.h>
46#include <linux/idr.h>
47#include <linux/seq_file.h>
48#include <linux/blkdev.h>
49#include <linux/delay.h>
50#include <linux/blktrace_api.h>
51#include <linux/mutex.h>
52#include <linux/atomic.h>
53#include <linux/ratelimit.h>
54
55#include "scsi.h"
56#include <scsi/scsi_dbg.h>
57#include <scsi/scsi_host.h>
58#include <scsi/scsi_driver.h>
59#include <scsi/scsi_ioctl.h>
60#include <scsi/sg.h>
61
62#include "scsi_logging.h"
63
64#ifdef CONFIG_SCSI_PROC_FS
65#include <linux/proc_fs.h>
66static char *sg_version_date = "20140603";
67
68static int sg_proc_init(void);
69static void sg_proc_cleanup(void);
70#endif
71
72#define SG_ALLOW_DIO_DEF 0
73
74#define SG_MAX_DEVS 32768
75
76/* SG_MAX_CDB_SIZE should be 260 (spc4r37 section 3.1.30) however the type
77 * of sg_io_hdr::cmd_len can only represent 255. All SCSI commands greater
78 * than 16 bytes are "variable length" whose length is a multiple of 4
79 */
80#define SG_MAX_CDB_SIZE 252
81
82/*
83 * Suppose you want to calculate the formula muldiv(x,m,d)=int(x * m / d)
84 * Then when using 32 bit integers x * m may overflow during the calculation.
85 * Replacing muldiv(x) by muldiv(x)=((x % d) * m) / d + int(x / d) * m
86 * calculates the same, but prevents the overflow when both m and d
87 * are "small" numbers (like HZ and USER_HZ).
88 * Of course an overflow is inavoidable if the result of muldiv doesn't fit
89 * in 32 bits.
90 */
91#define MULDIV(X,MUL,DIV) ((((X % DIV) * MUL) / DIV) + ((X / DIV) * MUL))
92
93#define SG_DEFAULT_TIMEOUT MULDIV(SG_DEFAULT_TIMEOUT_USER, HZ, USER_HZ)
94
95int sg_big_buff = SG_DEF_RESERVED_SIZE;
96/* N.B. This variable is readable and writeable via
97   /proc/scsi/sg/def_reserved_size . Each time sg_open() is called a buffer
98   of this size (or less if there is not enough memory) will be reserved
99   for use by this file descriptor. [Deprecated usage: this variable is also
100   readable via /proc/sys/kernel/sg-big-buff if the sg driver is built into
101   the kernel (i.e. it is not a module).] */
102static int def_reserved_size = -1;      /* picks up init parameter */
103static int sg_allow_dio = SG_ALLOW_DIO_DEF;
104
105static int scatter_elem_sz = SG_SCATTER_SZ;
106static int scatter_elem_sz_prev = SG_SCATTER_SZ;
107
108#define SG_SECTOR_SZ 512
109
110static int sg_add_device(struct device *, struct class_interface *);
111static void sg_remove_device(struct device *, struct class_interface *);
112
113static DEFINE_IDR(sg_index_idr);
114static DEFINE_RWLOCK(sg_index_lock);    /* Also used to lock
115                                                           file descriptor list for device */
116
117static struct class_interface sg_interface = {
118        .add_dev        = sg_add_device,
119        .remove_dev     = sg_remove_device,
120};
121
122typedef struct sg_scatter_hold { /* holding area for scsi scatter gather info */
123        unsigned short k_use_sg; /* Count of kernel scatter-gather pieces */
124        unsigned sglist_len; /* size of malloc'd scatter-gather list ++ */
125        unsigned bufflen;       /* Size of (aggregate) data buffer */
126        struct page **pages;
127        int page_order;
128        char dio_in_use;        /* 0->indirect IO (or mmap), 1->dio */
129        unsigned char cmd_opcode; /* first byte of command */
130} Sg_scatter_hold;
131
132struct sg_device;               /* forward declarations */
133struct sg_fd;
134
135typedef struct sg_request {     /* SG_MAX_QUEUE requests outstanding per file */
136        struct sg_request *nextrp;      /* NULL -> tail request (slist) */
137        struct sg_fd *parentfp; /* NULL -> not in use */
138        Sg_scatter_hold data;   /* hold buffer, perhaps scatter list */
139        sg_io_hdr_t header;     /* scsi command+info, see <scsi/sg.h> */
140        unsigned char sense_b[SCSI_SENSE_BUFFERSIZE];
141        char res_used;          /* 1 -> using reserve buffer, 0 -> not ... */
142        char orphan;            /* 1 -> drop on sight, 0 -> normal */
143        char sg_io_owned;       /* 1 -> packet belongs to SG_IO */
144        /* done protected by rq_list_lock */
145        char done;              /* 0->before bh, 1->before read, 2->read */
146        struct request *rq;
147        struct bio *bio;
148        struct execute_work ew;
149} Sg_request;
150
151typedef struct sg_fd {          /* holds the state of a file descriptor */
152        struct list_head sfd_siblings;  /* protected by device's sfd_lock */
153        struct sg_device *parentdp;     /* owning device */
154        wait_queue_head_t read_wait;    /* queue read until command done */
155        rwlock_t rq_list_lock;  /* protect access to list in req_arr */
156        int timeout;            /* defaults to SG_DEFAULT_TIMEOUT      */
157        int timeout_user;       /* defaults to SG_DEFAULT_TIMEOUT_USER */
158        Sg_scatter_hold reserve;        /* buffer held for this file descriptor */
159        unsigned save_scat_len; /* original length of trunc. scat. element */
160        Sg_request *headrp;     /* head of request slist, NULL->empty */
161        struct fasync_struct *async_qp; /* used by asynchronous notification */
162        Sg_request req_arr[SG_MAX_QUEUE];       /* used as singly-linked list */
163        char low_dma;           /* as in parent but possibly overridden to 1 */
164        char force_packid;      /* 1 -> pack_id input to read(), 0 -> ignored */
165        char cmd_q;             /* 1 -> allow command queuing, 0 -> don't */
166        unsigned char next_cmd_len; /* 0: automatic, >0: use on next write() */
167        char keep_orphan;       /* 0 -> drop orphan (def), 1 -> keep for read() */
168        char mmap_called;       /* 0 -> mmap() never called on this fd */
169        struct kref f_ref;
170        struct execute_work ew;
171} Sg_fd;
172
173typedef struct sg_device { /* holds the state of each scsi generic device */
174        struct scsi_device *device;
175        wait_queue_head_t open_wait;    /* queue open() when O_EXCL present */
176        struct mutex open_rel_lock;     /* held when in open() or release() */
177        int sg_tablesize;       /* adapter's max scatter-gather table size */
178        u32 index;              /* device index number */
179        struct list_head sfds;
180        rwlock_t sfd_lock;      /* protect access to sfd list */
181        atomic_t detaching;     /* 0->device usable, 1->device detaching */
182        bool exclude;           /* 1->open(O_EXCL) succeeded and is active */
183        int open_cnt;           /* count of opens (perhaps < num(sfds) ) */
184        char sgdebug;           /* 0->off, 1->sense, 9->dump dev, 10-> all devs */
185        struct gendisk *disk;
186        struct cdev * cdev;     /* char_dev [sysfs: /sys/cdev/major/sg<n>] */
187        struct kref d_ref;
188} Sg_device;
189
190/* tasklet or soft irq callback */
191static void sg_rq_end_io(struct request *rq, int uptodate);
192static int sg_start_req(Sg_request *srp, unsigned char *cmd);
193static int sg_finish_rem_req(Sg_request * srp);
194static int sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size);
195static ssize_t sg_new_read(Sg_fd * sfp, char __user *buf, size_t count,
196                           Sg_request * srp);
197static ssize_t sg_new_write(Sg_fd *sfp, struct file *file,
198                        const char __user *buf, size_t count, int blocking,
199                        int read_only, int sg_io_owned, Sg_request **o_srp);
200static int sg_common_write(Sg_fd * sfp, Sg_request * srp,
201                           unsigned char *cmnd, int timeout, int blocking);
202static int sg_read_oxfer(Sg_request * srp, char __user *outp, int num_read_xfer);
203static void sg_remove_scat(Sg_fd * sfp, Sg_scatter_hold * schp);
204static void sg_build_reserve(Sg_fd * sfp, int req_size);
205static void sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size);
206static void sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp);
207static Sg_fd *sg_add_sfp(Sg_device * sdp);
208static void sg_remove_sfp(struct kref *);
209static Sg_request *sg_get_rq_mark(Sg_fd * sfp, int pack_id);
210static Sg_request *sg_add_request(Sg_fd * sfp);
211static int sg_remove_request(Sg_fd * sfp, Sg_request * srp);
212static int sg_res_in_use(Sg_fd * sfp);
213static Sg_device *sg_get_dev(int dev);
214static void sg_device_destroy(struct kref *kref);
215
216#define SZ_SG_HEADER sizeof(struct sg_header)
217#define SZ_SG_IO_HDR sizeof(sg_io_hdr_t)
218#define SZ_SG_IOVEC sizeof(sg_iovec_t)
219#define SZ_SG_REQ_INFO sizeof(sg_req_info_t)
220
221#define sg_printk(prefix, sdp, fmt, a...) \
222        sdev_printk(prefix, (sdp)->device, "[%s] " fmt, \
223                    (sdp)->disk->disk_name, ##a)
224
225static int sg_allow_access(struct file *filp, unsigned char *cmd)
226{
227        struct sg_fd *sfp = filp->private_data;
228
229        if (sfp->parentdp->device->type == TYPE_SCANNER)
230                return 0;
231
232        return blk_verify_command(cmd, filp->f_mode & FMODE_WRITE);
233}
234
235static int
236open_wait(Sg_device *sdp, int flags)
237{
238        int retval = 0;
239
240        if (flags & O_EXCL) {
241                while (sdp->open_cnt > 0) {
242                        mutex_unlock(&sdp->open_rel_lock);
243                        retval = wait_event_interruptible(sdp->open_wait,
244                                        (atomic_read(&sdp->detaching) ||
245                                         !sdp->open_cnt));
246                        mutex_lock(&sdp->open_rel_lock);
247
248                        if (retval) /* -ERESTARTSYS */
249                                return retval;
250                        if (atomic_read(&sdp->detaching))
251                                return -ENODEV;
252                }
253        } else {
254                while (sdp->exclude) {
255                        mutex_unlock(&sdp->open_rel_lock);
256                        retval = wait_event_interruptible(sdp->open_wait,
257                                        (atomic_read(&sdp->detaching) ||
258                                         !sdp->exclude));
259                        mutex_lock(&sdp->open_rel_lock);
260
261                        if (retval) /* -ERESTARTSYS */
262                                return retval;
263                        if (atomic_read(&sdp->detaching))
264                                return -ENODEV;
265                }
266        }
267
268        return retval;
269}
270
271/* Returns 0 on success, else a negated errno value */
272static int
273sg_open(struct inode *inode, struct file *filp)
274{
275        int dev = iminor(inode);
276        int flags = filp->f_flags;
277        struct request_queue *q;
278        Sg_device *sdp;
279        Sg_fd *sfp;
280        int retval;
281
282        nonseekable_open(inode, filp);
283        if ((flags & O_EXCL) && (O_RDONLY == (flags & O_ACCMODE)))
284                return -EPERM; /* Can't lock it with read only access */
285        sdp = sg_get_dev(dev);
286        if (IS_ERR(sdp))
287                return PTR_ERR(sdp);
288
289        SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
290                                      "sg_open: flags=0x%x\n", flags));
291
292        /* This driver's module count bumped by fops_get in <linux/fs.h> */
293        /* Prevent the device driver from vanishing while we sleep */
294        retval = scsi_device_get(sdp->device);
295        if (retval)
296                goto sg_put;
297
298        retval = scsi_autopm_get_device(sdp->device);
299        if (retval)
300                goto sdp_put;
301
302        /* scsi_block_when_processing_errors() may block so bypass
303         * check if O_NONBLOCK. Permits SCSI commands to be issued
304         * during error recovery. Tread carefully. */
305        if (!((flags & O_NONBLOCK) ||
306              scsi_block_when_processing_errors(sdp->device))) {
307                retval = -ENXIO;
308                /* we are in error recovery for this device */
309                goto error_out;
310        }
311
312        mutex_lock(&sdp->open_rel_lock);
313        if (flags & O_NONBLOCK) {
314                if (flags & O_EXCL) {
315                        if (sdp->open_cnt > 0) {
316                                retval = -EBUSY;
317                                goto error_mutex_locked;
318                        }
319                } else {
320                        if (sdp->exclude) {
321                                retval = -EBUSY;
322                                goto error_mutex_locked;
323                        }
324                }
325        } else {
326                retval = open_wait(sdp, flags);
327                if (retval) /* -ERESTARTSYS or -ENODEV */
328                        goto error_mutex_locked;
329        }
330
331        /* N.B. at this point we are holding the open_rel_lock */
332        if (flags & O_EXCL)
333                sdp->exclude = true;
334
335        if (sdp->open_cnt < 1) {  /* no existing opens */
336                sdp->sgdebug = 0;
337                q = sdp->device->request_queue;
338                sdp->sg_tablesize = queue_max_segments(q);
339        }
340        sfp = sg_add_sfp(sdp);
341        if (IS_ERR(sfp)) {
342                retval = PTR_ERR(sfp);
343                goto out_undo;
344        }
345
346        filp->private_data = sfp;
347        sdp->open_cnt++;
348        mutex_unlock(&sdp->open_rel_lock);
349
350        retval = 0;
351sg_put:
352        kref_put(&sdp->d_ref, sg_device_destroy);
353        return retval;
354
355out_undo:
356        if (flags & O_EXCL) {
357                sdp->exclude = false;   /* undo if error */
358                wake_up_interruptible(&sdp->open_wait);
359        }
360error_mutex_locked:
361        mutex_unlock(&sdp->open_rel_lock);
362error_out:
363        scsi_autopm_put_device(sdp->device);
364sdp_put:
365        scsi_device_put(sdp->device);
366        goto sg_put;
367}
368
369/* Release resources associated with a successful sg_open()
370 * Returns 0 on success, else a negated errno value */
371static int
372sg_release(struct inode *inode, struct file *filp)
373{
374        Sg_device *sdp;
375        Sg_fd *sfp;
376
377        if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
378                return -ENXIO;
379        SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp, "sg_release\n"));
380
381        mutex_lock(&sdp->open_rel_lock);
382        scsi_autopm_put_device(sdp->device);
383        kref_put(&sfp->f_ref, sg_remove_sfp);
384        sdp->open_cnt--;
385
386        /* possibly many open()s waiting on exlude clearing, start many;
387         * only open(O_EXCL)s wait on 0==open_cnt so only start one */
388        if (sdp->exclude) {
389                sdp->exclude = false;
390                wake_up_interruptible_all(&sdp->open_wait);
391        } else if (0 == sdp->open_cnt) {
392                wake_up_interruptible(&sdp->open_wait);
393        }
394        mutex_unlock(&sdp->open_rel_lock);
395        return 0;
396}
397
398static ssize_t
399sg_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
400{
401        Sg_device *sdp;
402        Sg_fd *sfp;
403        Sg_request *srp;
404        int req_pack_id = -1;
405        sg_io_hdr_t *hp;
406        struct sg_header *old_hdr = NULL;
407        int retval = 0;
408
409        if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
410                return -ENXIO;
411        SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
412                                      "sg_read: count=%d\n", (int) count));
413
414        if (!access_ok(VERIFY_WRITE, buf, count))
415                return -EFAULT;
416        if (sfp->force_packid && (count >= SZ_SG_HEADER)) {
417                old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL);
418                if (!old_hdr)
419                        return -ENOMEM;
420                if (__copy_from_user(old_hdr, buf, SZ_SG_HEADER)) {
421                        retval = -EFAULT;
422                        goto free_old_hdr;
423                }
424                if (old_hdr->reply_len < 0) {
425                        if (count >= SZ_SG_IO_HDR) {
426                                sg_io_hdr_t *new_hdr;
427                                new_hdr = kmalloc(SZ_SG_IO_HDR, GFP_KERNEL);
428                                if (!new_hdr) {
429                                        retval = -ENOMEM;
430                                        goto free_old_hdr;
431                                }
432                                retval =__copy_from_user
433                                    (new_hdr, buf, SZ_SG_IO_HDR);
434                                req_pack_id = new_hdr->pack_id;
435                                kfree(new_hdr);
436                                if (retval) {
437                                        retval = -EFAULT;
438                                        goto free_old_hdr;
439                                }
440                        }
441                } else
442                        req_pack_id = old_hdr->pack_id;
443        }
444        srp = sg_get_rq_mark(sfp, req_pack_id);
445        if (!srp) {             /* now wait on packet to arrive */
446                if (atomic_read(&sdp->detaching)) {
447                        retval = -ENODEV;
448                        goto free_old_hdr;
449                }
450                if (filp->f_flags & O_NONBLOCK) {
451                        retval = -EAGAIN;
452                        goto free_old_hdr;
453                }
454                retval = wait_event_interruptible(sfp->read_wait,
455                        (atomic_read(&sdp->detaching) ||
456                        (srp = sg_get_rq_mark(sfp, req_pack_id))));
457                if (atomic_read(&sdp->detaching)) {
458                        retval = -ENODEV;
459                        goto free_old_hdr;
460                }
461                if (retval) {
462                        /* -ERESTARTSYS as signal hit process */
463                        goto free_old_hdr;
464                }
465        }
466        if (srp->header.interface_id != '\0') {
467                retval = sg_new_read(sfp, buf, count, srp);
468                goto free_old_hdr;
469        }
470
471        hp = &srp->header;
472        if (old_hdr == NULL) {
473                old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL);
474                if (! old_hdr) {
475                        retval = -ENOMEM;
476                        goto free_old_hdr;
477                }
478        }
479        memset(old_hdr, 0, SZ_SG_HEADER);
480        old_hdr->reply_len = (int) hp->timeout;
481        old_hdr->pack_len = old_hdr->reply_len; /* old, strange behaviour */
482        old_hdr->pack_id = hp->pack_id;
483        old_hdr->twelve_byte =
484            ((srp->data.cmd_opcode >= 0xc0) && (12 == hp->cmd_len)) ? 1 : 0;
485        old_hdr->target_status = hp->masked_status;
486        old_hdr->host_status = hp->host_status;
487        old_hdr->driver_status = hp->driver_status;
488        if ((CHECK_CONDITION & hp->masked_status) ||
489            (DRIVER_SENSE & hp->driver_status))
490                memcpy(old_hdr->sense_buffer, srp->sense_b,
491                       sizeof (old_hdr->sense_buffer));
492        switch (hp->host_status) {
493        /* This setup of 'result' is for backward compatibility and is best
494           ignored by the user who should use target, host + driver status */
495        case DID_OK:
496        case DID_PASSTHROUGH:
497        case DID_SOFT_ERROR:
498                old_hdr->result = 0;
499                break;
500        case DID_NO_CONNECT:
501        case DID_BUS_BUSY:
502        case DID_TIME_OUT:
503                old_hdr->result = EBUSY;
504                break;
505        case DID_BAD_TARGET:
506        case DID_ABORT:
507        case DID_PARITY:
508        case DID_RESET:
509        case DID_BAD_INTR:
510                old_hdr->result = EIO;
511                break;
512        case DID_ERROR:
513                old_hdr->result = (srp->sense_b[0] == 0 &&
514                                  hp->masked_status == GOOD) ? 0 : EIO;
515                break;
516        default:
517                old_hdr->result = EIO;
518                break;
519        }
520
521        /* Now copy the result back to the user buffer.  */
522        if (count >= SZ_SG_HEADER) {
523                if (__copy_to_user(buf, old_hdr, SZ_SG_HEADER)) {
524                        retval = -EFAULT;
525                        goto free_old_hdr;
526                }
527                buf += SZ_SG_HEADER;
528                if (count > old_hdr->reply_len)
529                        count = old_hdr->reply_len;
530                if (count > SZ_SG_HEADER) {
531                        if (sg_read_oxfer(srp, buf, count - SZ_SG_HEADER)) {
532                                retval = -EFAULT;
533                                goto free_old_hdr;
534                        }
535                }
536        } else
537                count = (old_hdr->result == 0) ? 0 : -EIO;
538        sg_finish_rem_req(srp);
539        retval = count;
540free_old_hdr:
541        kfree(old_hdr);
542        return retval;
543}
544
545static ssize_t
546sg_new_read(Sg_fd * sfp, char __user *buf, size_t count, Sg_request * srp)
547{
548        sg_io_hdr_t *hp = &srp->header;
549        int err = 0, err2;
550        int len;
551
552        if (count < SZ_SG_IO_HDR) {
553                err = -EINVAL;
554                goto err_out;
555        }
556        hp->sb_len_wr = 0;
557        if ((hp->mx_sb_len > 0) && hp->sbp) {
558                if ((CHECK_CONDITION & hp->masked_status) ||
559                    (DRIVER_SENSE & hp->driver_status)) {
560                        int sb_len = SCSI_SENSE_BUFFERSIZE;
561                        sb_len = (hp->mx_sb_len > sb_len) ? sb_len : hp->mx_sb_len;
562                        len = 8 + (int) srp->sense_b[7];        /* Additional sense length field */
563                        len = (len > sb_len) ? sb_len : len;
564                        if (copy_to_user(hp->sbp, srp->sense_b, len)) {
565                                err = -EFAULT;
566                                goto err_out;
567                        }
568                        hp->sb_len_wr = len;
569                }
570        }
571        if (hp->masked_status || hp->host_status || hp->driver_status)
572                hp->info |= SG_INFO_CHECK;
573        if (copy_to_user(buf, hp, SZ_SG_IO_HDR)) {
574                err = -EFAULT;
575                goto err_out;
576        }
577err_out:
578        err2 = sg_finish_rem_req(srp);
579        return err ? : err2 ? : count;
580}
581
582static ssize_t
583sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
584{
585        int mxsize, cmd_size, k;
586        int input_size, blocking;
587        unsigned char opcode;
588        Sg_device *sdp;
589        Sg_fd *sfp;
590        Sg_request *srp;
591        struct sg_header old_hdr;
592        sg_io_hdr_t *hp;
593        unsigned char cmnd[SG_MAX_CDB_SIZE];
594
595        if (unlikely(segment_eq(get_fs(), KERNEL_DS)))
596                return -EINVAL;
597
598        if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
599                return -ENXIO;
600        SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
601                                      "sg_write: count=%d\n", (int) count));
602        if (atomic_read(&sdp->detaching))
603                return -ENODEV;
604        if (!((filp->f_flags & O_NONBLOCK) ||
605              scsi_block_when_processing_errors(sdp->device)))
606                return -ENXIO;
607
608        if (!access_ok(VERIFY_READ, buf, count))
609                return -EFAULT; /* protects following copy_from_user()s + get_user()s */
610        if (count < SZ_SG_HEADER)
611                return -EIO;
612        if (__copy_from_user(&old_hdr, buf, SZ_SG_HEADER))
613                return -EFAULT;
614        blocking = !(filp->f_flags & O_NONBLOCK);
615        if (old_hdr.reply_len < 0)
616                return sg_new_write(sfp, filp, buf, count,
617                                    blocking, 0, 0, NULL);
618        if (count < (SZ_SG_HEADER + 6))
619                return -EIO;    /* The minimum scsi command length is 6 bytes. */
620
621        if (!(srp = sg_add_request(sfp))) {
622                SCSI_LOG_TIMEOUT(1, sg_printk(KERN_INFO, sdp,
623                                              "sg_write: queue full\n"));
624                return -EDOM;
625        }
626        buf += SZ_SG_HEADER;
627        __get_user(opcode, buf);
628        if (sfp->next_cmd_len > 0) {
629                cmd_size = sfp->next_cmd_len;
630                sfp->next_cmd_len = 0;  /* reset so only this write() effected */
631        } else {
632                cmd_size = COMMAND_SIZE(opcode);        /* based on SCSI command group */
633                if ((opcode >= 0xc0) && old_hdr.twelve_byte)
634                        cmd_size = 12;
635        }
636        SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sdp,
637                "sg_write:   scsi opcode=0x%02x, cmd_size=%d\n", (int) opcode, cmd_size));
638/* Determine buffer size.  */
639        input_size = count - cmd_size;
640        mxsize = (input_size > old_hdr.reply_len) ? input_size : old_hdr.reply_len;
641        mxsize -= SZ_SG_HEADER;
642        input_size -= SZ_SG_HEADER;
643        if (input_size < 0) {
644                sg_remove_request(sfp, srp);
645                return -EIO;    /* User did not pass enough bytes for this command. */
646        }
647        hp = &srp->header;
648        hp->interface_id = '\0';        /* indicator of old interface tunnelled */
649        hp->cmd_len = (unsigned char) cmd_size;
650        hp->iovec_count = 0;
651        hp->mx_sb_len = 0;
652        if (input_size > 0)
653                hp->dxfer_direction = (old_hdr.reply_len > SZ_SG_HEADER) ?
654                    SG_DXFER_TO_FROM_DEV : SG_DXFER_TO_DEV;
655        else
656                hp->dxfer_direction = (mxsize > 0) ? SG_DXFER_FROM_DEV : SG_DXFER_NONE;
657        hp->dxfer_len = mxsize;
658        if ((hp->dxfer_direction == SG_DXFER_TO_DEV) ||
659            (hp->dxfer_direction == SG_DXFER_TO_FROM_DEV))
660                hp->dxferp = (char __user *)buf + cmd_size;
661        else
662                hp->dxferp = NULL;
663        hp->sbp = NULL;
664        hp->timeout = old_hdr.reply_len;        /* structure abuse ... */
665        hp->flags = input_size; /* structure abuse ... */
666        hp->pack_id = old_hdr.pack_id;
667        hp->usr_ptr = NULL;
668        if (__copy_from_user(cmnd, buf, cmd_size))
669                return -EFAULT;
670        /*
671         * SG_DXFER_TO_FROM_DEV is functionally equivalent to SG_DXFER_FROM_DEV,
672         * but is is possible that the app intended SG_DXFER_TO_DEV, because there
673         * is a non-zero input_size, so emit a warning.
674         */
675        if (hp->dxfer_direction == SG_DXFER_TO_FROM_DEV) {
676                static char cmd[TASK_COMM_LEN];
677                if (strcmp(current->comm, cmd)) {
678                        printk_ratelimited(KERN_WARNING
679                                           "sg_write: data in/out %d/%d bytes "
680                                           "for SCSI command 0x%x-- guessing "
681                                           "data in;\n   program %s not setting "
682                                           "count and/or reply_len properly\n",
683                                           old_hdr.reply_len - (int)SZ_SG_HEADER,
684                                           input_size, (unsigned int) cmnd[0],
685                                           current->comm);
686                        strcpy(cmd, current->comm);
687                }
688        }
689        k = sg_common_write(sfp, srp, cmnd, sfp->timeout, blocking);
690        return (k < 0) ? k : count;
691}
692
693static ssize_t
694sg_new_write(Sg_fd *sfp, struct file *file, const char __user *buf,
695                 size_t count, int blocking, int read_only, int sg_io_owned,
696                 Sg_request **o_srp)
697{
698        int k;
699        Sg_request *srp;
700        sg_io_hdr_t *hp;
701        unsigned char cmnd[SG_MAX_CDB_SIZE];
702        int timeout;
703        unsigned long ul_timeout;
704
705        if (count < SZ_SG_IO_HDR)
706                return -EINVAL;
707        if (!access_ok(VERIFY_READ, buf, count))
708                return -EFAULT; /* protects following copy_from_user()s + get_user()s */
709
710        sfp->cmd_q = 1; /* when sg_io_hdr seen, set command queuing on */
711        if (!(srp = sg_add_request(sfp))) {
712                SCSI_LOG_TIMEOUT(1, sg_printk(KERN_INFO, sfp->parentdp,
713                                              "sg_new_write: queue full\n"));
714                return -EDOM;
715        }
716        srp->sg_io_owned = sg_io_owned;
717        hp = &srp->header;
718        if (__copy_from_user(hp, buf, SZ_SG_IO_HDR)) {
719                sg_remove_request(sfp, srp);
720                return -EFAULT;
721        }
722        if (hp->interface_id != 'S') {
723                sg_remove_request(sfp, srp);
724                return -ENOSYS;
725        }
726        if (hp->flags & SG_FLAG_MMAP_IO) {
727                if (hp->dxfer_len > sfp->reserve.bufflen) {
728                        sg_remove_request(sfp, srp);
729                        return -ENOMEM; /* MMAP_IO size must fit in reserve buffer */
730                }
731                if (hp->flags & SG_FLAG_DIRECT_IO) {
732                        sg_remove_request(sfp, srp);
733                        return -EINVAL; /* either MMAP_IO or DIRECT_IO (not both) */
734                }
735                if (sg_res_in_use(sfp)) {
736                        sg_remove_request(sfp, srp);
737                        return -EBUSY;  /* reserve buffer already being used */
738                }
739        }
740        ul_timeout = msecs_to_jiffies(srp->header.timeout);
741        timeout = (ul_timeout < INT_MAX) ? ul_timeout : INT_MAX;
742        if ((!hp->cmdp) || (hp->cmd_len < 6) || (hp->cmd_len > sizeof (cmnd))) {
743                sg_remove_request(sfp, srp);
744                return -EMSGSIZE;
745        }
746        if (!access_ok(VERIFY_READ, hp->cmdp, hp->cmd_len)) {
747                sg_remove_request(sfp, srp);
748                return -EFAULT; /* protects following copy_from_user()s + get_user()s */
749        }
750        if (__copy_from_user(cmnd, hp->cmdp, hp->cmd_len)) {
751                sg_remove_request(sfp, srp);
752                return -EFAULT;
753        }
754        if (read_only && sg_allow_access(file, cmnd)) {
755                sg_remove_request(sfp, srp);
756                return -EPERM;
757        }
758        k = sg_common_write(sfp, srp, cmnd, timeout, blocking);
759        if (k < 0)
760                return k;
761        if (o_srp)
762                *o_srp = srp;
763        return count;
764}
765
766static int
767sg_common_write(Sg_fd * sfp, Sg_request * srp,
768                unsigned char *cmnd, int timeout, int blocking)
769{
770        int k, data_dir, at_head;
771        Sg_device *sdp = sfp->parentdp;
772        sg_io_hdr_t *hp = &srp->header;
773
774        srp->data.cmd_opcode = cmnd[0]; /* hold opcode of command */
775        hp->status = 0;
776        hp->masked_status = 0;
777        hp->msg_status = 0;
778        hp->info = 0;
779        hp->host_status = 0;
780        hp->driver_status = 0;
781        hp->resid = 0;
782        SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
783                        "sg_common_write:  scsi opcode=0x%02x, cmd_size=%d\n",
784                        (int) cmnd[0], (int) hp->cmd_len));
785
786        k = sg_start_req(srp, cmnd);
787        if (k) {
788                SCSI_LOG_TIMEOUT(1, sg_printk(KERN_INFO, sfp->parentdp,
789                        "sg_common_write: start_req err=%d\n", k));
790                sg_finish_rem_req(srp);
791                return k;       /* probably out of space --> ENOMEM */
792        }
793        if (atomic_read(&sdp->detaching)) {
794                if (srp->bio)
795                        blk_end_request_all(srp->rq, -EIO);
796                sg_finish_rem_req(srp);
797                return -ENODEV;
798        }
799
800        switch (hp->dxfer_direction) {
801        case SG_DXFER_TO_FROM_DEV:
802        case SG_DXFER_FROM_DEV:
803                data_dir = DMA_FROM_DEVICE;
804                break;
805        case SG_DXFER_TO_DEV:
806                data_dir = DMA_TO_DEVICE;
807                break;
808        case SG_DXFER_UNKNOWN:
809                data_dir = DMA_BIDIRECTIONAL;
810                break;
811        default:
812                data_dir = DMA_NONE;
813                break;
814        }
815        hp->duration = jiffies_to_msecs(jiffies);
816        if (hp->interface_id != '\0' && /* v3 (or later) interface */
817            (SG_FLAG_Q_AT_TAIL & hp->flags))
818                at_head = 0;
819        else
820                at_head = 1;
821
822        srp->rq->timeout = timeout;
823        kref_get(&sfp->f_ref); /* sg_rq_end_io() does kref_put(). */
824        blk_execute_rq_nowait(sdp->device->request_queue, sdp->disk,
825                              srp->rq, at_head, sg_rq_end_io);
826        return 0;
827}
828
829static int srp_done(Sg_fd *sfp, Sg_request *srp)
830{
831        unsigned long flags;
832        int ret;
833
834        read_lock_irqsave(&sfp->rq_list_lock, flags);
835        ret = srp->done;
836        read_unlock_irqrestore(&sfp->rq_list_lock, flags);
837        return ret;
838}
839
840static int max_sectors_bytes(struct request_queue *q)
841{
842        unsigned int max_sectors = queue_max_sectors(q);
843
844        max_sectors = min_t(unsigned int, max_sectors, INT_MAX >> 9);
845
846        return max_sectors << 9;
847}
848
849static long
850sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
851{
852        void __user *p = (void __user *)arg;
853        int __user *ip = p;
854        int result, val, read_only;
855        Sg_device *sdp;
856        Sg_fd *sfp;
857        Sg_request *srp;
858        unsigned long iflags;
859
860        if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
861                return -ENXIO;
862
863        SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
864                                   "sg_ioctl: cmd=0x%x\n", (int) cmd_in));
865        read_only = (O_RDWR != (filp->f_flags & O_ACCMODE));
866
867        switch (cmd_in) {
868        case SG_IO:
869                if (atomic_read(&sdp->detaching))
870                        return -ENODEV;
871                if (!scsi_block_when_processing_errors(sdp->device))
872                        return -ENXIO;
873                if (!access_ok(VERIFY_WRITE, p, SZ_SG_IO_HDR))
874                        return -EFAULT;
875                result = sg_new_write(sfp, filp, p, SZ_SG_IO_HDR,
876                                 1, read_only, 1, &srp);
877                if (result < 0)
878                        return result;
879                result = wait_event_interruptible(sfp->read_wait,
880                        (srp_done(sfp, srp) || atomic_read(&sdp->detaching)));
881                if (atomic_read(&sdp->detaching))
882                        return -ENODEV;
883                write_lock_irq(&sfp->rq_list_lock);
884                if (srp->done) {
885                        srp->done = 2;
886                        write_unlock_irq(&sfp->rq_list_lock);
887                        result = sg_new_read(sfp, p, SZ_SG_IO_HDR, srp);
888                        return (result < 0) ? result : 0;
889                }
890                srp->orphan = 1;
891                write_unlock_irq(&sfp->rq_list_lock);
892                return result;  /* -ERESTARTSYS because signal hit process */
893        case SG_SET_TIMEOUT:
894                result = get_user(val, ip);
895                if (result)
896                        return result;
897                if (val < 0)
898                        return -EIO;
899                if (val >= MULDIV (INT_MAX, USER_HZ, HZ))
900                    val = MULDIV (INT_MAX, USER_HZ, HZ);
901                sfp->timeout_user = val;
902                sfp->timeout = MULDIV (val, HZ, USER_HZ);
903
904                return 0;
905        case SG_GET_TIMEOUT:    /* N.B. User receives timeout as return value */
906                                /* strange ..., for backward compatibility */
907                return sfp->timeout_user;
908        case SG_SET_FORCE_LOW_DMA:
909                result = get_user(val, ip);
910                if (result)
911                        return result;
912                if (val) {
913                        sfp->low_dma = 1;
914                        if ((0 == sfp->low_dma) && (0 == sg_res_in_use(sfp))) {
915                                val = (int) sfp->reserve.bufflen;
916                                sg_remove_scat(sfp, &sfp->reserve);
917                                sg_build_reserve(sfp, val);
918                        }
919                } else {
920                        if (atomic_read(&sdp->detaching))
921                                return -ENODEV;
922                        sfp->low_dma = sdp->device->host->unchecked_isa_dma;
923                }
924                return 0;
925        case SG_GET_LOW_DMA:
926                return put_user((int) sfp->low_dma, ip);
927        case SG_GET_SCSI_ID:
928                if (!access_ok(VERIFY_WRITE, p, sizeof (sg_scsi_id_t)))
929                        return -EFAULT;
930                else {
931                        sg_scsi_id_t __user *sg_idp = p;
932
933                        if (atomic_read(&sdp->detaching))
934                                return -ENODEV;
935                        __put_user((int) sdp->device->host->host_no,
936                                   &sg_idp->host_no);
937                        __put_user((int) sdp->device->channel,
938                                   &sg_idp->channel);
939                        __put_user((int) sdp->device->id, &sg_idp->scsi_id);
940                        __put_user((int) sdp->device->lun, &sg_idp->lun);
941                        __put_user((int) sdp->device->type, &sg_idp->scsi_type);
942                        __put_user((short) sdp->device->host->cmd_per_lun,
943                                   &sg_idp->h_cmd_per_lun);
944                        __put_user((short) sdp->device->queue_depth,
945                                   &sg_idp->d_queue_depth);
946                        __put_user(0, &sg_idp->unused[0]);
947                        __put_user(0, &sg_idp->unused[1]);
948                        return 0;
949                }
950        case SG_SET_FORCE_PACK_ID:
951                result = get_user(val, ip);
952                if (result)
953                        return result;
954                sfp->force_packid = val ? 1 : 0;
955                return 0;
956        case SG_GET_PACK_ID:
957                if (!access_ok(VERIFY_WRITE, ip, sizeof (int)))
958                        return -EFAULT;
959                read_lock_irqsave(&sfp->rq_list_lock, iflags);
960                for (srp = sfp->headrp; srp; srp = srp->nextrp) {
961                        if ((1 == srp->done) && (!srp->sg_io_owned)) {
962                                read_unlock_irqrestore(&sfp->rq_list_lock,
963                                                       iflags);
964                                __put_user(srp->header.pack_id, ip);
965                                return 0;
966                        }
967                }
968                read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
969                __put_user(-1, ip);
970                return 0;
971        case SG_GET_NUM_WAITING:
972                read_lock_irqsave(&sfp->rq_list_lock, iflags);
973                for (val = 0, srp = sfp->headrp; srp; srp = srp->nextrp) {
974                        if ((1 == srp->done) && (!srp->sg_io_owned))
975                                ++val;
976                }
977                read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
978                return put_user(val, ip);
979        case SG_GET_SG_TABLESIZE:
980                return put_user(sdp->sg_tablesize, ip);
981        case SG_SET_RESERVED_SIZE:
982                result = get_user(val, ip);
983                if (result)
984                        return result;
985                if (val < 0)
986                        return -EINVAL;
987                val = min_t(int, val,
988                            max_sectors_bytes(sdp->device->request_queue));
989                if (val != sfp->reserve.bufflen) {
990                        if (sg_res_in_use(sfp) || sfp->mmap_called)
991                                return -EBUSY;
992                        sg_remove_scat(sfp, &sfp->reserve);
993                        sg_build_reserve(sfp, val);
994                }
995                return 0;
996        case SG_GET_RESERVED_SIZE:
997                val = min_t(int, sfp->reserve.bufflen,
998                            max_sectors_bytes(sdp->device->request_queue));
999                return put_user(val, ip);
1000        case SG_SET_COMMAND_Q:
1001                result = get_user(val, ip);
1002                if (result)
1003                        return result;
1004                sfp->cmd_q = val ? 1 : 0;
1005                return 0;
1006        case SG_GET_COMMAND_Q:
1007                return put_user((int) sfp->cmd_q, ip);
1008        case SG_SET_KEEP_ORPHAN:
1009                result = get_user(val, ip);
1010                if (result)
1011                        return result;
1012                sfp->keep_orphan = val;
1013                return 0;
1014        case SG_GET_KEEP_ORPHAN:
1015                return put_user((int) sfp->keep_orphan, ip);
1016        case SG_NEXT_CMD_LEN:
1017                result = get_user(val, ip);
1018                if (result)
1019                        return result;
1020                if (val > SG_MAX_CDB_SIZE)
1021                        return -ENOMEM;
1022                sfp->next_cmd_len = (val > 0) ? val : 0;
1023                return 0;
1024        case SG_GET_VERSION_NUM:
1025                return put_user(sg_version_num, ip);
1026        case SG_GET_ACCESS_COUNT:
1027                /* faked - we don't have a real access count anymore */
1028                val = (sdp->device ? 1 : 0);
1029                return put_user(val, ip);
1030        case SG_GET_REQUEST_TABLE:
1031                if (!access_ok(VERIFY_WRITE, p, SZ_SG_REQ_INFO * SG_MAX_QUEUE))
1032                        return -EFAULT;
1033                else {
1034                        sg_req_info_t *rinfo;
1035                        unsigned int ms;
1036
1037                        rinfo = kmalloc(SZ_SG_REQ_INFO * SG_MAX_QUEUE,
1038                                                                GFP_KERNEL);
1039                        if (!rinfo)
1040                                return -ENOMEM;
1041                        read_lock_irqsave(&sfp->rq_list_lock, iflags);
1042                        for (srp = sfp->headrp, val = 0; val < SG_MAX_QUEUE;
1043                             ++val, srp = srp ? srp->nextrp : srp) {
1044                                memset(&rinfo[val], 0, SZ_SG_REQ_INFO);
1045                                if (srp) {
1046                                        rinfo[val].req_state = srp->done + 1;
1047                                        rinfo[val].problem =
1048                                            srp->header.masked_status &
1049                                            srp->header.host_status &
1050                                            srp->header.driver_status;
1051                                        if (srp->done)
1052                                                rinfo[val].duration =
1053                                                        srp->header.duration;
1054                                        else {
1055                                                ms = jiffies_to_msecs(jiffies);
1056                                                rinfo[val].duration =
1057                                                    (ms > srp->header.duration) ?
1058                                                    (ms - srp->header.duration) : 0;
1059                                        }
1060                                        rinfo[val].orphan = srp->orphan;
1061                                        rinfo[val].sg_io_owned =
1062                                                        srp->sg_io_owned;
1063                                        rinfo[val].pack_id =
1064                                                        srp->header.pack_id;
1065                                        rinfo[val].usr_ptr =
1066                                                        srp->header.usr_ptr;
1067                                }
1068                        }
1069                        read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
1070                        result = __copy_to_user(p, rinfo,
1071                                                SZ_SG_REQ_INFO * SG_MAX_QUEUE);
1072                        result = result ? -EFAULT : 0;
1073                        kfree(rinfo);
1074                        return result;
1075                }
1076        case SG_EMULATED_HOST:
1077                if (atomic_read(&sdp->detaching))
1078                        return -ENODEV;
1079                return put_user(sdp->device->host->hostt->emulated, ip);
1080        case SG_SCSI_RESET:
1081                if (atomic_read(&sdp->detaching))
1082                        return -ENODEV;
1083                if (filp->f_flags & O_NONBLOCK) {
1084                        if (scsi_host_in_recovery(sdp->device->host))
1085                                return -EBUSY;
1086                } else if (!scsi_block_when_processing_errors(sdp->device))
1087                        return -EBUSY;
1088                result = get_user(val, ip);
1089                if (result)
1090                        return result;
1091                if (SG_SCSI_RESET_NOTHING == val)
1092                        return 0;
1093                switch (val) {
1094                case SG_SCSI_RESET_DEVICE:
1095                        val = SCSI_TRY_RESET_DEVICE;
1096                        break;
1097                case SG_SCSI_RESET_TARGET:
1098                        val = SCSI_TRY_RESET_TARGET;
1099                        break;
1100                case SG_SCSI_RESET_BUS:
1101                        val = SCSI_TRY_RESET_BUS;
1102                        break;
1103                case SG_SCSI_RESET_HOST:
1104                        val = SCSI_TRY_RESET_HOST;
1105                        break;
1106                default:
1107                        return -EINVAL;
1108                }
1109                if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
1110                        return -EACCES;
1111                return (scsi_reset_provider(sdp->device, val) ==
1112                        SUCCESS) ? 0 : -EIO;
1113        case SCSI_IOCTL_SEND_COMMAND:
1114                if (atomic_read(&sdp->detaching))
1115                        return -ENODEV;
1116                if (read_only) {
1117                        unsigned char opcode = WRITE_6;
1118                        Scsi_Ioctl_Command __user *siocp = p;
1119
1120                        if (copy_from_user(&opcode, siocp->data, 1))
1121                                return -EFAULT;
1122                        if (sg_allow_access(filp, &opcode))
1123                                return -EPERM;
1124                }
1125                return sg_scsi_ioctl(sdp->device->request_queue, NULL, filp->f_mode, p);
1126        case SG_SET_DEBUG:
1127                result = get_user(val, ip);
1128                if (result)
1129                        return result;
1130                sdp->sgdebug = (char) val;
1131                return 0;
1132        case SCSI_IOCTL_GET_IDLUN:
1133        case SCSI_IOCTL_GET_BUS_NUMBER:
1134        case SCSI_IOCTL_PROBE_HOST:
1135        case SG_GET_TRANSFORM:
1136                if (atomic_read(&sdp->detaching))
1137                        return -ENODEV;
1138                return scsi_ioctl(sdp->device, cmd_in, p);
1139        case BLKSECTGET:
1140                return put_user(max_sectors_bytes(sdp->device->request_queue),
1141                                ip);
1142        case BLKTRACESETUP:
1143                return blk_trace_setup(sdp->device->request_queue,
1144                                       sdp->disk->disk_name,
1145                                       MKDEV(SCSI_GENERIC_MAJOR, sdp->index),
1146                                       NULL,
1147                                       (char *)arg);
1148        case BLKTRACESTART:
1149                return blk_trace_startstop(sdp->device->request_queue, 1);
1150        case BLKTRACESTOP:
1151                return blk_trace_startstop(sdp->device->request_queue, 0);
1152        case BLKTRACETEARDOWN:
1153                return blk_trace_remove(sdp->device->request_queue);
1154        default:
1155                if (read_only)
1156                        return -EPERM;  /* don't know so take safe approach */
1157                return scsi_ioctl(sdp->device, cmd_in, p);
1158        }
1159}
1160
1161#ifdef CONFIG_COMPAT
1162static long sg_compat_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
1163{
1164        Sg_device *sdp;
1165        Sg_fd *sfp;
1166        struct scsi_device *sdev;
1167
1168        if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
1169                return -ENXIO;
1170
1171        sdev = sdp->device;
1172        if (sdev->host->hostt->compat_ioctl) {
1173                int ret;
1174
1175                ret = sdev->host->hostt->compat_ioctl(sdev, cmd_in, (void __user *)arg);
1176
1177                return ret;
1178        }
1179       
1180        return -ENOIOCTLCMD;
1181}
1182#endif
1183
1184static unsigned int
1185sg_poll(struct file *filp, poll_table * wait)
1186{
1187        unsigned int res = 0;
1188        Sg_device *sdp;
1189        Sg_fd *sfp;
1190        Sg_request *srp;
1191        int count = 0;
1192        unsigned long iflags;
1193
1194        sfp = filp->private_data;
1195        if (!sfp)
1196                return POLLERR;
1197        sdp = sfp->parentdp;
1198        if (!sdp)
1199                return POLLERR;
1200        poll_wait(filp, &sfp->read_wait, wait);
1201        read_lock_irqsave(&sfp->rq_list_lock, iflags);
1202        for (srp = sfp->headrp; srp; srp = srp->nextrp) {
1203                /* if any read waiting, flag it */
1204                if ((0 == res) && (1 == srp->done) && (!srp->sg_io_owned))
1205                        res = POLLIN | POLLRDNORM;
1206                ++count;
1207        }
1208        read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
1209
1210        if (atomic_read(&sdp->detaching))
1211                res |= POLLHUP;
1212        else if (!sfp->cmd_q) {
1213                if (0 == count)
1214                        res |= POLLOUT | POLLWRNORM;
1215        } else if (count < SG_MAX_QUEUE)
1216                res |= POLLOUT | POLLWRNORM;
1217        SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
1218                                      "sg_poll: res=0x%x\n", (int) res));
1219        return res;
1220}
1221
1222static int
1223sg_fasync(int fd, struct file *filp, int mode)
1224{
1225        Sg_device *sdp;
1226        Sg_fd *sfp;
1227
1228        if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
1229                return -ENXIO;
1230        SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
1231                                      "sg_fasync: mode=%d\n", mode));
1232
1233        return fasync_helper(fd, filp, mode, &sfp->async_qp);
1234}
1235
1236static int
1237sg_vma_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
1238{
1239        Sg_fd *sfp;
1240        unsigned long offset, len, sa;
1241        Sg_scatter_hold *rsv_schp;
1242        int k, length;
1243
1244        if ((NULL == vma) || (!(sfp = (Sg_fd *) vma->vm_private_data)))
1245                return VM_FAULT_SIGBUS;
1246        rsv_schp = &sfp->reserve;
1247        offset = vmf->pgoff << PAGE_SHIFT;
1248        if (offset >= rsv_schp->bufflen)
1249                return VM_FAULT_SIGBUS;
1250        SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sfp->parentdp,
1251                                      "sg_vma_fault: offset=%lu, scatg=%d\n",
1252                                      offset, rsv_schp->k_use_sg));
1253        sa = vma->vm_start;
1254        length = 1 << (PAGE_SHIFT + rsv_schp->page_order);
1255        for (k = 0; k < rsv_schp->k_use_sg && sa < vma->vm_end; k++) {
1256                len = vma->vm_end - sa;
1257                len = (len < length) ? len : length;
1258                if (offset < len) {
1259                        struct page *page = nth_page(rsv_schp->pages[k],
1260                                                     offset >> PAGE_SHIFT);
1261                        get_page(page); /* increment page count */
1262                        vmf->page = page;
1263                        return 0; /* success */
1264                }
1265                sa += len;
1266                offset -= len;
1267        }
1268
1269        return VM_FAULT_SIGBUS;
1270}
1271
1272static const struct vm_operations_struct sg_mmap_vm_ops = {
1273        .fault = sg_vma_fault,
1274};
1275
1276static int
1277sg_mmap(struct file *filp, struct vm_area_struct *vma)
1278{
1279        Sg_fd *sfp;
1280        unsigned long req_sz, len, sa;
1281        Sg_scatter_hold *rsv_schp;
1282        int k, length;
1283
1284        if ((!filp) || (!vma) || (!(sfp = (Sg_fd *) filp->private_data)))
1285                return -ENXIO;
1286        req_sz = vma->vm_end - vma->vm_start;
1287        SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sfp->parentdp,
1288                                      "sg_mmap starting, vm_start=%p, len=%d\n",
1289                                      (void *) vma->vm_start, (int) req_sz));
1290        if (vma->vm_pgoff)
1291                return -EINVAL; /* want no offset */
1292        rsv_schp = &sfp->reserve;
1293        if (req_sz > rsv_schp->bufflen)
1294                return -ENOMEM; /* cannot map more than reserved buffer */
1295
1296        sa = vma->vm_start;
1297        length = 1 << (PAGE_SHIFT + rsv_schp->page_order);
1298        for (k = 0; k < rsv_schp->k_use_sg && sa < vma->vm_end; k++) {
1299                len = vma->vm_end - sa;
1300                len = (len < length) ? len : length;
1301                sa += len;
1302        }
1303
1304        sfp->mmap_called = 1;
1305        vma->vm_flags |= VM_IO | VM_DONTEXPAND | VM_DONTDUMP;
1306        vma->vm_private_data = sfp;
1307        vma->vm_ops = &sg_mmap_vm_ops;
1308        return 0;
1309}
1310
1311static void
1312sg_rq_end_io_usercontext(struct work_struct *work)
1313{
1314        struct sg_request *srp = container_of(work, struct sg_request, ew.work);
1315        struct sg_fd *sfp = srp->parentfp;
1316
1317        sg_finish_rem_req(srp);
1318        kref_put(&sfp->f_ref, sg_remove_sfp);
1319}
1320
1321/*
1322 * This function is a "bottom half" handler that is called by the mid
1323 * level when a command is completed (or has failed).
1324 */
1325static void
1326sg_rq_end_io(struct request *rq, int uptodate)
1327{
1328        struct sg_request *srp = rq->end_io_data;
1329        Sg_device *sdp;
1330        Sg_fd *sfp;
1331        unsigned long iflags;
1332        unsigned int ms;
1333        char *sense;
1334        int result, resid, done = 1;
1335
1336        if (WARN_ON(srp->done != 0))
1337                return;
1338
1339        sfp = srp->parentfp;
1340        if (WARN_ON(sfp == NULL))
1341                return;
1342
1343        sdp = sfp->parentdp;
1344        if (unlikely(atomic_read(&sdp->detaching)))
1345                pr_info("%s: device detaching\n", __func__);
1346
1347        sense = rq->sense;
1348        result = rq->errors;
1349        resid = rq->resid_len;
1350
1351        SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sdp,
1352                                      "sg_cmd_done: pack_id=%d, res=0x%x\n",
1353                                      srp->header.pack_id, result));
1354        srp->header.resid = resid;
1355        ms = jiffies_to_msecs(jiffies);
1356        srp->header.duration = (ms > srp->header.duration) ?
1357                                (ms - srp->header.duration) : 0;
1358        if (0 != result) {
1359                struct scsi_sense_hdr sshdr;
1360
1361                srp->header.status = 0xff & result;
1362                srp->header.masked_status = status_byte(result);
1363                srp->header.msg_status = msg_byte(result);
1364                srp->header.host_status = host_byte(result);
1365                srp->header.driver_status = driver_byte(result);
1366                if ((sdp->sgdebug > 0) &&
1367                    ((CHECK_CONDITION == srp->header.masked_status) ||
1368                     (COMMAND_TERMINATED == srp->header.masked_status)))
1369                        __scsi_print_sense(__func__, sense,
1370                                           SCSI_SENSE_BUFFERSIZE);
1371
1372                /* Following if statement is a patch supplied by Eric Youngdale */
1373                if (driver_byte(result) != 0
1374                    && scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr)
1375                    && !scsi_sense_is_deferred(&sshdr)
1376                    && sshdr.sense_key == UNIT_ATTENTION
1377                    && sdp->device->removable) {
1378                        /* Detected possible disc change. Set the bit - this */
1379                        /* may be used if there are filesystems using this device */
1380                        sdp->device->changed = 1;
1381                }
1382        }
1383        /* Rely on write phase to clean out srp status values, so no "else" */
1384
1385        /*
1386         * Free the request as soon as it is complete so that its resources
1387         * can be reused without waiting for userspace to read() the
1388         * result.  But keep the associated bio (if any) around until
1389         * blk_rq_unmap_user() can be called from user context.
1390         */
1391        srp->rq = NULL;
1392        if (rq->cmd != rq->__cmd)
1393                kfree(rq->cmd);
1394        __blk_put_request(rq->q, rq);
1395
1396        write_lock_irqsave(&sfp->rq_list_lock, iflags);
1397        if (unlikely(srp->orphan)) {
1398                if (sfp->keep_orphan)
1399                        srp->sg_io_owned = 0;
1400                else
1401                        done = 0;
1402        }
1403        srp->done = done;
1404        write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
1405
1406        if (likely(done)) {
1407                /* Now wake up any sg_read() that is waiting for this
1408                 * packet.
1409                 */
1410                wake_up_interruptible(&sfp->read_wait);
1411                kill_fasync(&sfp->async_qp, SIGPOLL, POLL_IN);
1412                kref_put(&sfp->f_ref, sg_remove_sfp);
1413        } else {
1414                INIT_WORK(&srp->ew.work, sg_rq_end_io_usercontext);
1415                schedule_work(&srp->ew.work);
1416        }
1417}
1418
1419static const struct file_operations sg_fops = {
1420        .owner = THIS_MODULE,
1421        .read = sg_read,
1422        .write = sg_write,
1423        .poll = sg_poll,
1424        .unlocked_ioctl = sg_ioctl,
1425#ifdef CONFIG_COMPAT
1426        .compat_ioctl = sg_compat_ioctl,
1427#endif
1428        .open = sg_open,
1429        .mmap = sg_mmap,
1430        .release = sg_release,
1431        .fasync = sg_fasync,
1432        .llseek = no_llseek,
1433};
1434
1435static struct class *sg_sysfs_class;
1436
1437static int sg_sysfs_valid = 0;
1438
1439static Sg_device *
1440sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
1441{
1442        struct request_queue *q = scsidp->request_queue;
1443        Sg_device *sdp;
1444        unsigned long iflags;
1445        int error;
1446        u32 k;
1447
1448        sdp = kzalloc(sizeof(Sg_device), GFP_KERNEL);
1449        if (!sdp) {
1450                sdev_printk(KERN_WARNING, scsidp, "%s: kmalloc Sg_device "
1451                            "failure\n", __func__);
1452                return ERR_PTR(-ENOMEM);
1453        }
1454
1455        idr_preload(GFP_KERNEL);
1456        write_lock_irqsave(&sg_index_lock, iflags);
1457
1458        error = idr_alloc(&sg_index_idr, sdp, 0, SG_MAX_DEVS, GFP_NOWAIT);
1459        if (error < 0) {
1460                if (error == -ENOSPC) {
1461                        sdev_printk(KERN_WARNING, scsidp,
1462                                    "Unable to attach sg device type=%d, minor number exceeds %d\n",
1463                                    scsidp->type, SG_MAX_DEVS - 1);
1464                        error = -ENODEV;
1465                } else {
1466                        sdev_printk(KERN_WARNING, scsidp, "%s: idr "
1467                                    "allocation Sg_device failure: %d\n",
1468                                    __func__, error);
1469                }
1470                goto out_unlock;
1471        }
1472        k = error;
1473
1474        SCSI_LOG_TIMEOUT(3, sdev_printk(KERN_INFO, scsidp,
1475                                        "sg_alloc: dev=%d \n", k));
1476        sprintf(disk->disk_name, "sg%d", k);
1477        disk->first_minor = k;
1478        sdp->disk = disk;
1479        sdp->device = scsidp;
1480        mutex_init(&sdp->open_rel_lock);
1481        INIT_LIST_HEAD(&sdp->sfds);
1482        init_waitqueue_head(&sdp->open_wait);
1483        atomic_set(&sdp->detaching, 0);
1484        rwlock_init(&sdp->sfd_lock);
1485        sdp->sg_tablesize = queue_max_segments(q);
1486        sdp->index = k;
1487        kref_init(&sdp->d_ref);
1488        error = 0;
1489
1490out_unlock:
1491        write_unlock_irqrestore(&sg_index_lock, iflags);
1492        idr_preload_end();
1493
1494        if (error) {
1495                kfree(sdp);
1496                return ERR_PTR(error);
1497        }
1498        return sdp;
1499}
1500
1501static int
1502sg_add_device(struct device *cl_dev, struct class_interface *cl_intf)
1503{
1504        struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
1505        struct gendisk *disk;
1506        Sg_device *sdp = NULL;
1507        struct cdev * cdev = NULL;
1508        int error;
1509        unsigned long iflags;
1510
1511        disk = alloc_disk(1);
1512        if (!disk) {
1513                pr_warn("%s: alloc_disk failed\n", __func__);
1514                return -ENOMEM;
1515        }
1516        disk->major = SCSI_GENERIC_MAJOR;
1517
1518        error = -ENOMEM;
1519        cdev = cdev_alloc();
1520        if (!cdev) {
1521                pr_warn("%s: cdev_alloc failed\n", __func__);
1522                goto out;
1523        }
1524        cdev->owner = THIS_MODULE;
1525        cdev->ops = &sg_fops;
1526
1527        sdp = sg_alloc(disk, scsidp);
1528        if (IS_ERR(sdp)) {
1529                pr_warn("%s: sg_alloc failed\n", __func__);
1530                error = PTR_ERR(sdp);
1531                goto out;
1532        }
1533
1534        error = cdev_add(cdev, MKDEV(SCSI_GENERIC_MAJOR, sdp->index), 1);
1535        if (error)
1536                goto cdev_add_err;
1537
1538        sdp->cdev = cdev;
1539        if (sg_sysfs_valid) {
1540                struct device *sg_class_member;
1541
1542                sg_class_member = device_create(sg_sysfs_class, cl_dev->parent,
1543                                                MKDEV(SCSI_GENERIC_MAJOR,
1544                                                      sdp->index),
1545                                                sdp, "%s", disk->disk_name);
1546                if (IS_ERR(sg_class_member)) {
1547                        pr_err("%s: device_create failed\n", __func__);
1548                        error = PTR_ERR(sg_class_member);
1549                        goto cdev_add_err;
1550                }
1551                error = sysfs_create_link(&scsidp->sdev_gendev.kobj,
1552                                          &sg_class_member->kobj, "generic");
1553                if (error)
1554                        pr_err("%s: unable to make symlink 'generic' back "
1555                               "to sg%d\n", __func__, sdp->index);
1556        } else
1557                pr_warn("%s: sg_sys Invalid\n", __func__);
1558
1559        sdev_printk(KERN_NOTICE, scsidp, "Attached scsi generic sg%d "
1560                    "type %d\n", sdp->index, scsidp->type);
1561
1562        dev_set_drvdata(cl_dev, sdp);
1563
1564        return 0;
1565
1566cdev_add_err:
1567        write_lock_irqsave(&sg_index_lock, iflags);
1568        idr_remove(&sg_index_idr, sdp->index);
1569        write_unlock_irqrestore(&sg_index_lock, iflags);
1570        kfree(sdp);
1571
1572out:
1573        put_disk(disk);
1574        if (cdev)
1575                cdev_del(cdev);
1576        return error;
1577}
1578
1579static void
1580sg_device_destroy(struct kref *kref)
1581{
1582        struct sg_device *sdp = container_of(kref, struct sg_device, d_ref);
1583        unsigned long flags;
1584
1585        /* CAUTION!  Note that the device can still be found via idr_find()
1586         * even though the refcount is 0.  Therefore, do idr_remove() BEFORE
1587         * any other cleanup.
1588         */
1589
1590        write_lock_irqsave(&sg_index_lock, flags);
1591        idr_remove(&sg_index_idr, sdp->index);
1592        write_unlock_irqrestore(&sg_index_lock, flags);
1593
1594        SCSI_LOG_TIMEOUT(3,
1595                sg_printk(KERN_INFO, sdp, "sg_device_destroy\n"));
1596
1597        put_disk(sdp->disk);
1598        kfree(sdp);
1599}
1600
1601static void
1602sg_remove_device(struct device *cl_dev, struct class_interface *cl_intf)
1603{
1604        struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
1605        Sg_device *sdp = dev_get_drvdata(cl_dev);
1606        unsigned long iflags;
1607        Sg_fd *sfp;
1608        int val;
1609
1610        if (!sdp)
1611                return;
1612        /* want sdp->detaching non-zero as soon as possible */
1613        val = atomic_inc_return(&sdp->detaching);
1614        if (val > 1)
1615                return; /* only want to do following once per device */
1616
1617        SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
1618                                      "%s\n", __func__));
1619
1620        read_lock_irqsave(&sdp->sfd_lock, iflags);
1621        list_for_each_entry(sfp, &sdp->sfds, sfd_siblings) {
1622                wake_up_interruptible_all(&sfp->read_wait);
1623                kill_fasync(&sfp->async_qp, SIGPOLL, POLL_HUP);
1624        }
1625        wake_up_interruptible_all(&sdp->open_wait);
1626        read_unlock_irqrestore(&sdp->sfd_lock, iflags);
1627
1628        sysfs_remove_link(&scsidp->sdev_gendev.kobj, "generic");
1629        device_destroy(sg_sysfs_class, MKDEV(SCSI_GENERIC_MAJOR, sdp->index));
1630        cdev_del(sdp->cdev);
1631        sdp->cdev = NULL;
1632
1633        kref_put(&sdp->d_ref, sg_device_destroy);
1634}
1635
1636module_param_named(scatter_elem_sz, scatter_elem_sz, int, S_IRUGO | S_IWUSR);
1637module_param_named(def_reserved_size, def_reserved_size, int,
1638                   S_IRUGO | S_IWUSR);
1639module_param_named(allow_dio, sg_allow_dio, int, S_IRUGO | S_IWUSR);
1640
1641MODULE_AUTHOR("Douglas Gilbert");
1642MODULE_DESCRIPTION("SCSI generic (sg) driver");
1643MODULE_LICENSE("GPL");
1644MODULE_VERSION(SG_VERSION_STR);
1645MODULE_ALIAS_CHARDEV_MAJOR(SCSI_GENERIC_MAJOR);
1646
1647MODULE_PARM_DESC(scatter_elem_sz, "scatter gather element "
1648                "size (default: max(SG_SCATTER_SZ, PAGE_SIZE))");
1649MODULE_PARM_DESC(def_reserved_size, "size of buffer reserved for each fd");
1650MODULE_PARM_DESC(allow_dio, "allow direct I/O (default: 0 (disallow))");
1651
1652static int __init
1653init_sg(void)
1654{
1655        int rc;
1656
1657        if (scatter_elem_sz < PAGE_SIZE) {
1658                scatter_elem_sz = PAGE_SIZE;
1659                scatter_elem_sz_prev = scatter_elem_sz;
1660        }
1661        if (def_reserved_size >= 0)
1662                sg_big_buff = def_reserved_size;
1663        else
1664                def_reserved_size = sg_big_buff;
1665
1666        rc = register_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0),
1667                                    SG_MAX_DEVS, "sg");
1668        if (rc)
1669                return rc;
1670        sg_sysfs_class = class_create(THIS_MODULE, "scsi_generic");
1671        if ( IS_ERR(sg_sysfs_class) ) {
1672                rc = PTR_ERR(sg_sysfs_class);
1673                goto err_out;
1674        }
1675        sg_sysfs_valid = 1;
1676        rc = scsi_register_interface(&sg_interface);
1677        if (0 == rc) {
1678#ifdef CONFIG_SCSI_PROC_FS
1679                sg_proc_init();
1680#endif                          /* CONFIG_SCSI_PROC_FS */
1681                return 0;
1682        }
1683        class_destroy(sg_sysfs_class);
1684err_out:
1685        unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0), SG_MAX_DEVS);
1686        return rc;
1687}
1688
1689static void __exit
1690exit_sg(void)
1691{
1692#ifdef CONFIG_SCSI_PROC_FS
1693        sg_proc_cleanup();
1694#endif                          /* CONFIG_SCSI_PROC_FS */
1695        scsi_unregister_interface(&sg_interface);
1696        class_destroy(sg_sysfs_class);
1697        sg_sysfs_valid = 0;
1698        unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0),
1699                                 SG_MAX_DEVS);
1700        idr_destroy(&sg_index_idr);
1701}
1702
1703static int
1704sg_start_req(Sg_request *srp, unsigned char *cmd)
1705{
1706        int res;
1707        struct request *rq;
1708        Sg_fd *sfp = srp->parentfp;
1709        sg_io_hdr_t *hp = &srp->header;
1710        int dxfer_len = (int) hp->dxfer_len;
1711        int dxfer_dir = hp->dxfer_direction;
1712        unsigned int iov_count = hp->iovec_count;
1713        Sg_scatter_hold *req_schp = &srp->data;
1714        Sg_scatter_hold *rsv_schp = &sfp->reserve;
1715        struct request_queue *q = sfp->parentdp->device->request_queue;
1716        struct rq_map_data *md, map_data;
1717        int rw = hp->dxfer_direction == SG_DXFER_TO_DEV ? WRITE : READ;
1718        unsigned char *long_cmdp = NULL;
1719
1720        SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
1721                                      "sg_start_req: dxfer_len=%d\n",
1722                                      dxfer_len));
1723
1724        if (hp->cmd_len > BLK_MAX_CDB) {
1725                long_cmdp = kzalloc(hp->cmd_len, GFP_KERNEL);
1726                if (!long_cmdp)
1727                        return -ENOMEM;
1728        }
1729
1730        /*
1731         * NOTE
1732         *
1733         * With scsi-mq enabled, there are a fixed number of preallocated
1734         * requests equal in number to shost->can_queue.  If all of the
1735         * preallocated requests are already in use, then using GFP_ATOMIC with
1736         * blk_get_request() will return -EWOULDBLOCK, whereas using GFP_KERNEL
1737         * will cause blk_get_request() to sleep until an active command
1738         * completes, freeing up a request.  Neither option is ideal, but
1739         * GFP_KERNEL is the better choice to prevent userspace from getting an
1740         * unexpected EWOULDBLOCK.
1741         *
1742         * With scsi-mq disabled, blk_get_request() with GFP_KERNEL usually
1743         * does not sleep except under memory pressure.
1744         */
1745        rq = blk_get_request(q, rw, GFP_KERNEL);
1746        if (IS_ERR(rq)) {
1747                kfree(long_cmdp);
1748                return PTR_ERR(rq);
1749        }
1750
1751        blk_rq_set_block_pc(rq);
1752
1753        if (hp->cmd_len > BLK_MAX_CDB)
1754                rq->cmd = long_cmdp;
1755        memcpy(rq->cmd, cmd, hp->cmd_len);
1756        rq->cmd_len = hp->cmd_len;
1757
1758        srp->rq = rq;
1759        rq->end_io_data = srp;
1760        rq->sense = srp->sense_b;
1761        rq->retries = SG_DEFAULT_RETRIES;
1762
1763        if ((dxfer_len <= 0) || (dxfer_dir == SG_DXFER_NONE))
1764                return 0;
1765
1766        if (sg_allow_dio && hp->flags & SG_FLAG_DIRECT_IO &&
1767            dxfer_dir != SG_DXFER_UNKNOWN && !iov_count &&
1768            !sfp->parentdp->device->host->unchecked_isa_dma &&
1769            blk_rq_aligned(q, (unsigned long)hp->dxferp, dxfer_len))
1770                md = NULL;
1771        else
1772                md = &map_data;
1773
1774        if (md) {
1775                if (!sg_res_in_use(sfp) && dxfer_len <= rsv_schp->bufflen)
1776                        sg_link_reserve(sfp, srp, dxfer_len);
1777                else {
1778                        res = sg_build_indirect(req_schp, sfp, dxfer_len);
1779                        if (res)
1780                                return res;
1781                }
1782
1783                md->pages = req_schp->pages;
1784                md->page_order = req_schp->page_order;
1785                md->nr_entries = req_schp->k_use_sg;
1786                md->offset = 0;
1787                md->null_mapped = hp->dxferp ? 0 : 1;
1788                if (dxfer_dir == SG_DXFER_TO_FROM_DEV)
1789                        md->from_user = 1;
1790                else
1791                        md->from_user = 0;
1792        }
1793
1794        if (unlikely(iov_count > UIO_MAXIOV))
1795                return -EINVAL;
1796
1797        if (iov_count) {
1798                int len, size = sizeof(struct sg_iovec) * iov_count;
1799                struct iovec *iov;
1800
1801                iov = memdup_user(hp->dxferp, size);
1802                if (IS_ERR(iov))
1803                        return PTR_ERR(iov);
1804
1805                len = iov_length(iov, iov_count);
1806                if (hp->dxfer_len < len) {
1807                        iov_count = iov_shorten(iov, iov_count, hp->dxfer_len);
1808                        len = hp->dxfer_len;
1809                }
1810
1811                res = blk_rq_map_user_iov(q, rq, md, (struct sg_iovec *)iov,
1812                                          iov_count,
1813                                          len, GFP_ATOMIC);
1814                kfree(iov);
1815        } else
1816                res = blk_rq_map_user(q, rq, md, hp->dxferp,
1817                                      hp->dxfer_len, GFP_ATOMIC);
1818
1819        if (!res) {
1820                srp->bio = rq->bio;
1821
1822                if (!md) {
1823                        req_schp->dio_in_use = 1;
1824                        hp->info |= SG_INFO_DIRECT_IO;
1825                }
1826        }
1827        return res;
1828}
1829
1830static int
1831sg_finish_rem_req(Sg_request *srp)
1832{
1833        int ret = 0;
1834
1835        Sg_fd *sfp = srp->parentfp;
1836        Sg_scatter_hold *req_schp = &srp->data;
1837
1838        SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
1839                                      "sg_finish_rem_req: res_used=%d\n",
1840                                      (int) srp->res_used));
1841        if (srp->bio)
1842                ret = blk_rq_unmap_user(srp->bio);
1843
1844        if (srp->rq) {
1845                if (srp->rq->cmd != srp->rq->__cmd)
1846                        kfree(srp->rq->cmd);
1847                blk_put_request(srp->rq);
1848        }
1849
1850        if (srp->res_used)
1851                sg_unlink_reserve(sfp, srp);
1852        else
1853                sg_remove_scat(sfp, req_schp);
1854
1855        sg_remove_request(sfp, srp);
1856
1857        return ret;
1858}
1859
1860static int
1861sg_build_sgat(Sg_scatter_hold * schp, const Sg_fd * sfp, int tablesize)
1862{
1863        int sg_bufflen = tablesize * sizeof(struct page *);
1864        gfp_t gfp_flags = GFP_ATOMIC | __GFP_NOWARN;
1865
1866        schp->pages = kzalloc(sg_bufflen, gfp_flags);
1867        if (!schp->pages)
1868                return -ENOMEM;
1869        schp->sglist_len = sg_bufflen;
1870        return tablesize;       /* number of scat_gath elements allocated */
1871}
1872
1873static int
1874sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size)
1875{
1876        int ret_sz = 0, i, k, rem_sz, num, mx_sc_elems;
1877        int sg_tablesize = sfp->parentdp->sg_tablesize;
1878        int blk_size = buff_size, order;
1879        gfp_t gfp_mask = GFP_ATOMIC | __GFP_COMP | __GFP_NOWARN;
1880
1881        if (blk_size < 0)
1882                return -EFAULT;
1883        if (0 == blk_size)
1884                ++blk_size;     /* don't know why */
1885        /* round request up to next highest SG_SECTOR_SZ byte boundary */
1886        blk_size = ALIGN(blk_size, SG_SECTOR_SZ);
1887        SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
1888                "sg_build_indirect: buff_size=%d, blk_size=%d\n",
1889                buff_size, blk_size));
1890
1891        /* N.B. ret_sz carried into this block ... */
1892        mx_sc_elems = sg_build_sgat(schp, sfp, sg_tablesize);
1893        if (mx_sc_elems < 0)
1894                return mx_sc_elems;     /* most likely -ENOMEM */
1895
1896        num = scatter_elem_sz;
1897        if (unlikely(num != scatter_elem_sz_prev)) {
1898                if (num < PAGE_SIZE) {
1899                        scatter_elem_sz = PAGE_SIZE;
1900                        scatter_elem_sz_prev = PAGE_SIZE;
1901                } else
1902                        scatter_elem_sz_prev = num;
1903        }
1904
1905        if (sfp->low_dma)
1906                gfp_mask |= GFP_DMA;
1907
1908        if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
1909                gfp_mask |= __GFP_ZERO;
1910
1911        order = get_order(num);
1912retry:
1913        ret_sz = 1 << (PAGE_SHIFT + order);
1914
1915        for (k = 0, rem_sz = blk_size; rem_sz > 0 && k < mx_sc_elems;
1916             k++, rem_sz -= ret_sz) {
1917
1918                num = (rem_sz > scatter_elem_sz_prev) ?
1919                        scatter_elem_sz_prev : rem_sz;
1920
1921                schp->pages[k] = alloc_pages(gfp_mask, order);
1922                if (!schp->pages[k])
1923                        goto out;
1924
1925                if (num == scatter_elem_sz_prev) {
1926                        if (unlikely(ret_sz > scatter_elem_sz_prev)) {
1927                                scatter_elem_sz = ret_sz;
1928                                scatter_elem_sz_prev = ret_sz;
1929                        }
1930                }
1931
1932                SCSI_LOG_TIMEOUT(5, sg_printk(KERN_INFO, sfp->parentdp,
1933                                 "sg_build_indirect: k=%d, num=%d, ret_sz=%d\n",
1934                                 k, num, ret_sz));
1935        }               /* end of for loop */
1936
1937        schp->page_order = order;
1938        schp->k_use_sg = k;
1939        SCSI_LOG_TIMEOUT(5, sg_printk(KERN_INFO, sfp->parentdp,
1940                         "sg_build_indirect: k_use_sg=%d, rem_sz=%d\n",
1941                         k, rem_sz));
1942
1943        schp->bufflen = blk_size;
1944        if (rem_sz > 0) /* must have failed */
1945                return -ENOMEM;
1946        return 0;
1947out:
1948        for (i = 0; i < k; i++)
1949                __free_pages(schp->pages[i], order);
1950
1951        if (--order >= 0)
1952                goto retry;
1953
1954        return -ENOMEM;
1955}
1956
1957static void
1958sg_remove_scat(Sg_fd * sfp, Sg_scatter_hold * schp)
1959{
1960        SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
1961                         "sg_remove_scat: k_use_sg=%d\n", schp->k_use_sg));
1962        if (schp->pages && schp->sglist_len > 0) {
1963                if (!schp->dio_in_use) {
1964                        int k;
1965
1966                        for (k = 0; k < schp->k_use_sg && schp->pages[k]; k++) {
1967                                SCSI_LOG_TIMEOUT(5,
1968                                        sg_printk(KERN_INFO, sfp->parentdp,
1969                                        "sg_remove_scat: k=%d, pg=0x%p\n",
1970                                        k, schp->pages[k]));
1971                                __free_pages(schp->pages[k], schp->page_order);
1972                        }
1973
1974                        kfree(schp->pages);
1975                }
1976        }
1977        memset(schp, 0, sizeof (*schp));
1978}
1979
1980static int
1981sg_read_oxfer(Sg_request * srp, char __user *outp, int num_read_xfer)
1982{
1983        Sg_scatter_hold *schp = &srp->data;
1984        int k, num;
1985
1986        SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, srp->parentfp->parentdp,
1987                         "sg_read_oxfer: num_read_xfer=%d\n",
1988                         num_read_xfer));
1989        if ((!outp) || (num_read_xfer <= 0))
1990                return 0;
1991
1992        num = 1 << (PAGE_SHIFT + schp->page_order);
1993        for (k = 0; k < schp->k_use_sg && schp->pages[k]; k++) {
1994                if (num > num_read_xfer) {
1995                        if (__copy_to_user(outp, page_address(schp->pages[k]),
1996                                           num_read_xfer))
1997                                return -EFAULT;
1998                        break;
1999                } else {
2000                        if (__copy_to_user(outp, page_address(schp->pages[k]),
2001                                           num))
2002                                return -EFAULT;
2003                        num_read_xfer -= num;
2004                        if (num_read_xfer <= 0)
2005                                break;
2006                        outp += num;
2007                }
2008        }
2009
2010        return 0;
2011}
2012
2013static void
2014sg_build_reserve(Sg_fd * sfp, int req_size)
2015{
2016        Sg_scatter_hold *schp = &sfp->reserve;
2017
2018        SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
2019                         "sg_build_reserve: req_size=%d\n", req_size));
2020        do {
2021                if (req_size < PAGE_SIZE)
2022                        req_size = PAGE_SIZE;
2023                if (0 == sg_build_indirect(schp, sfp, req_size))
2024                        return;
2025                else
2026                        sg_remove_scat(sfp, schp);
2027                req_size >>= 1; /* divide by 2 */
2028        } while (req_size > (PAGE_SIZE / 2));
2029}
2030
2031static void
2032sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size)
2033{
2034        Sg_scatter_hold *req_schp = &srp->data;
2035        Sg_scatter_hold *rsv_schp = &sfp->reserve;
2036        int k, num, rem;
2037
2038        srp->res_used = 1;
2039        SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
2040                         "sg_link_reserve: size=%d\n", size));
2041        rem = size;
2042
2043        num = 1 << (PAGE_SHIFT + rsv_schp->page_order);
2044        for (k = 0; k < rsv_schp->k_use_sg; k++) {
2045                if (rem <= num) {
2046                        req_schp->k_use_sg = k + 1;
2047                        req_schp->sglist_len = rsv_schp->sglist_len;
2048                        req_schp->pages = rsv_schp->pages;
2049
2050                        req_schp->bufflen = size;
2051                        req_schp->page_order = rsv_schp->page_order;
2052                        break;
2053                } else
2054                        rem -= num;
2055        }
2056
2057        if (k >= rsv_schp->k_use_sg)
2058                SCSI_LOG_TIMEOUT(1, sg_printk(KERN_INFO, sfp->parentdp,
2059                                 "sg_link_reserve: BAD size\n"));
2060}
2061
2062static void
2063sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp)
2064{
2065        Sg_scatter_hold *req_schp = &srp->data;
2066
2067        SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, srp->parentfp->parentdp,
2068                                      "sg_unlink_reserve: req->k_use_sg=%d\n",
2069                                      (int) req_schp->k_use_sg));
2070        req_schp->k_use_sg = 0;
2071        req_schp->bufflen = 0;
2072        req_schp->pages = NULL;
2073        req_schp->page_order = 0;
2074        req_schp->sglist_len = 0;
2075        sfp->save_scat_len = 0;
2076        srp->res_used = 0;
2077}
2078
2079static Sg_request *
2080sg_get_rq_mark(Sg_fd * sfp, int pack_id)
2081{
2082        Sg_request *resp;
2083        unsigned long iflags;
2084
2085        write_lock_irqsave(&sfp->rq_list_lock, iflags);
2086        for (resp = sfp->headrp; resp; resp = resp->nextrp) {
2087                /* look for requests that are ready + not SG_IO owned */
2088                if ((1 == resp->done) && (!resp->sg_io_owned) &&
2089                    ((-1 == pack_id) || (resp->header.pack_id == pack_id))) {
2090                        resp->done = 2; /* guard against other readers */
2091                        break;
2092                }
2093        }
2094        write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
2095        return resp;
2096}
2097
2098/* always adds to end of list */
2099static Sg_request *
2100sg_add_request(Sg_fd * sfp)
2101{
2102        int k;
2103        unsigned long iflags;
2104        Sg_request *resp;
2105        Sg_request *rp = sfp->req_arr;
2106
2107        write_lock_irqsave(&sfp->rq_list_lock, iflags);
2108        resp = sfp->headrp;
2109        if (!resp) {
2110                memset(rp, 0, sizeof (Sg_request));
2111                rp->parentfp = sfp;
2112                resp = rp;
2113                sfp->headrp = resp;
2114        } else {
2115                if (0 == sfp->cmd_q)
2116                        resp = NULL;    /* command queuing disallowed */
2117                else {
2118                        for (k = 0; k < SG_MAX_QUEUE; ++k, ++rp) {
2119                                if (!rp->parentfp)
2120                                        break;
2121                        }
2122                        if (k < SG_MAX_QUEUE) {
2123                                memset(rp, 0, sizeof (Sg_request));
2124                                rp->parentfp = sfp;
2125                                while (resp->nextrp)
2126                                        resp = resp->nextrp;
2127                                resp->nextrp = rp;
2128                                resp = rp;
2129                        } else
2130                                resp = NULL;
2131                }
2132        }
2133        if (resp) {
2134                resp->nextrp = NULL;
2135                resp->header.duration = jiffies_to_msecs(jiffies);
2136        }
2137        write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
2138        return resp;
2139}
2140
2141/* Return of 1 for found; 0 for not found */
2142static int
2143sg_remove_request(Sg_fd * sfp, Sg_request * srp)
2144{
2145        Sg_request *prev_rp;
2146        Sg_request *rp;
2147        unsigned long iflags;
2148        int res = 0;
2149
2150        if ((!sfp) || (!srp) || (!sfp->headrp))
2151                return res;
2152        write_lock_irqsave(&sfp->rq_list_lock, iflags);
2153        prev_rp = sfp->headrp;
2154        if (srp == prev_rp) {
2155                sfp->headrp = prev_rp->nextrp;
2156                prev_rp->parentfp = NULL;
2157                res = 1;
2158        } else {
2159                while ((rp = prev_rp->nextrp)) {
2160                        if (srp == rp) {
2161                                prev_rp->nextrp = rp->nextrp;
2162                                rp->parentfp = NULL;
2163                                res = 1;
2164                                break;
2165                        }
2166                        prev_rp = rp;
2167                }
2168        }
2169        write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
2170        return res;
2171}
2172
2173static Sg_fd *
2174sg_add_sfp(Sg_device * sdp)
2175{
2176        Sg_fd *sfp;
2177        unsigned long iflags;
2178        int bufflen;
2179
2180        sfp = kzalloc(sizeof(*sfp), GFP_ATOMIC | __GFP_NOWARN);
2181        if (!sfp)
2182                return ERR_PTR(-ENOMEM);
2183
2184        init_waitqueue_head(&sfp->read_wait);
2185        rwlock_init(&sfp->rq_list_lock);
2186
2187        kref_init(&sfp->f_ref);
2188        sfp->timeout = SG_DEFAULT_TIMEOUT;
2189        sfp->timeout_user = SG_DEFAULT_TIMEOUT_USER;
2190        sfp->force_packid = SG_DEF_FORCE_PACK_ID;
2191        sfp->low_dma = (SG_DEF_FORCE_LOW_DMA == 0) ?
2192            sdp->device->host->unchecked_isa_dma : 1;
2193        sfp->cmd_q = SG_DEF_COMMAND_Q;
2194        sfp->keep_orphan = SG_DEF_KEEP_ORPHAN;
2195        sfp->parentdp = sdp;
2196        write_lock_irqsave(&sdp->sfd_lock, iflags);
2197        if (atomic_read(&sdp->detaching)) {
2198                write_unlock_irqrestore(&sdp->sfd_lock, iflags);
2199                return ERR_PTR(-ENODEV);
2200        }
2201        list_add_tail(&sfp->sfd_siblings, &sdp->sfds);
2202        write_unlock_irqrestore(&sdp->sfd_lock, iflags);
2203        SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
2204                                      "sg_add_sfp: sfp=0x%p\n", sfp));
2205        if (unlikely(sg_big_buff != def_reserved_size))
2206                sg_big_buff = def_reserved_size;
2207
2208        bufflen = min_t(int, sg_big_buff,
2209                        max_sectors_bytes(sdp->device->request_queue));
2210        sg_build_reserve(sfp, bufflen);
2211        SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
2212                                      "sg_add_sfp: bufflen=%d, k_use_sg=%d\n",
2213                                      sfp->reserve.bufflen,
2214                                      sfp->reserve.k_use_sg));
2215
2216        kref_get(&sdp->d_ref);
2217        __module_get(THIS_MODULE);
2218        return sfp;
2219}
2220
2221static void
2222sg_remove_sfp_usercontext(struct work_struct *work)
2223{
2224        struct sg_fd *sfp = container_of(work, struct sg_fd, ew.work);
2225        struct sg_device *sdp = sfp->parentdp;
2226
2227        /* Cleanup any responses which were never read(). */
2228        while (sfp->headrp)
2229                sg_finish_rem_req(sfp->headrp);
2230
2231        if (sfp->reserve.bufflen > 0) {
2232                SCSI_LOG_TIMEOUT(6, sg_printk(KERN_INFO, sdp,
2233                                "sg_remove_sfp:    bufflen=%d, k_use_sg=%d\n",
2234                                (int) sfp->reserve.bufflen,
2235                                (int) sfp->reserve.k_use_sg));
2236                sg_remove_scat(sfp, &sfp->reserve);
2237        }
2238
2239        SCSI_LOG_TIMEOUT(6, sg_printk(KERN_INFO, sdp,
2240                        "sg_remove_sfp: sfp=0x%p\n", sfp));
2241        kfree(sfp);
2242
2243        scsi_device_put(sdp->device);
2244        kref_put(&sdp->d_ref, sg_device_destroy);
2245        module_put(THIS_MODULE);
2246}
2247
2248static void
2249sg_remove_sfp(struct kref *kref)
2250{
2251        struct sg_fd *sfp = container_of(kref, struct sg_fd, f_ref);
2252        struct sg_device *sdp = sfp->parentdp;
2253        unsigned long iflags;
2254
2255        write_lock_irqsave(&sdp->sfd_lock, iflags);
2256        list_del(&sfp->sfd_siblings);
2257        write_unlock_irqrestore(&sdp->sfd_lock, iflags);
2258
2259        INIT_WORK(&sfp->ew.work, sg_remove_sfp_usercontext);
2260        schedule_work(&sfp->ew.work);
2261}
2262
2263static int
2264sg_res_in_use(Sg_fd * sfp)
2265{
2266        const Sg_request *srp;
2267        unsigned long iflags;
2268
2269        read_lock_irqsave(&sfp->rq_list_lock, iflags);
2270        for (srp = sfp->headrp; srp; srp = srp->nextrp)
2271                if (srp->res_used)
2272                        break;
2273        read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
2274        return srp ? 1 : 0;
2275}
2276
2277#ifdef CONFIG_SCSI_PROC_FS
2278static int
2279sg_idr_max_id(int id, void *p, void *data)
2280{
2281        int *k = data;
2282
2283        if (*k < id)
2284                *k = id;
2285
2286        return 0;
2287}
2288
2289static int
2290sg_last_dev(void)
2291{
2292        int k = -1;
2293        unsigned long iflags;
2294
2295        read_lock_irqsave(&sg_index_lock, iflags);
2296        idr_for_each(&sg_index_idr, sg_idr_max_id, &k);
2297        read_unlock_irqrestore(&sg_index_lock, iflags);
2298        return k + 1;           /* origin 1 */
2299}
2300#endif
2301
2302/* must be called with sg_index_lock held */
2303static Sg_device *sg_lookup_dev(int dev)
2304{
2305        return idr_find(&sg_index_idr, dev);
2306}
2307
2308static Sg_device *
2309sg_get_dev(int dev)
2310{
2311        struct sg_device *sdp;
2312        unsigned long flags;
2313
2314        read_lock_irqsave(&sg_index_lock, flags);
2315        sdp = sg_lookup_dev(dev);
2316        if (!sdp)
2317                sdp = ERR_PTR(-ENXIO);
2318        else if (atomic_read(&sdp->detaching)) {
2319                /* If sdp->detaching, then the refcount may already be 0, in
2320                 * which case it would be a bug to do kref_get().
2321                 */
2322                sdp = ERR_PTR(-ENODEV);
2323        } else
2324                kref_get(&sdp->d_ref);
2325        read_unlock_irqrestore(&sg_index_lock, flags);
2326
2327        return sdp;
2328}
2329
2330#ifdef CONFIG_SCSI_PROC_FS
2331
2332static struct proc_dir_entry *sg_proc_sgp = NULL;
2333
2334static char sg_proc_sg_dirname[] = "scsi/sg";
2335
2336static int sg_proc_seq_show_int(struct seq_file *s, void *v);
2337
2338static int sg_proc_single_open_adio(struct inode *inode, struct file *file);
2339static ssize_t sg_proc_write_adio(struct file *filp, const char __user *buffer,
2340                                  size_t count, loff_t *off);
2341static const struct file_operations adio_fops = {
2342        .owner = THIS_MODULE,
2343        .open = sg_proc_single_open_adio,
2344        .read = seq_read,
2345        .llseek = seq_lseek,
2346        .write = sg_proc_write_adio,
2347        .release = single_release,
2348};
2349
2350static int sg_proc_single_open_dressz(struct inode *inode, struct file *file);
2351static ssize_t sg_proc_write_dressz(struct file *filp,
2352                const char __user *buffer, size_t count, loff_t *off);
2353static const struct file_operations dressz_fops = {
2354        .owner = THIS_MODULE,
2355        .open = sg_proc_single_open_dressz,
2356        .read = seq_read,
2357        .llseek = seq_lseek,
2358        .write = sg_proc_write_dressz,
2359        .release = single_release,
2360};
2361
2362static int sg_proc_seq_show_version(struct seq_file *s, void *v);
2363static int sg_proc_single_open_version(struct inode *inode, struct file *file);
2364static const struct file_operations version_fops = {
2365        .owner = THIS_MODULE,
2366        .open = sg_proc_single_open_version,
2367        .read = seq_read,
2368        .llseek = seq_lseek,
2369        .release = single_release,
2370};
2371
2372static int sg_proc_seq_show_devhdr(struct seq_file *s, void *v);
2373static int sg_proc_single_open_devhdr(struct inode *inode, struct file *file);
2374static const struct file_operations devhdr_fops = {
2375        .owner = THIS_MODULE,
2376        .open = sg_proc_single_open_devhdr,
2377        .read = seq_read,
2378        .llseek = seq_lseek,
2379        .release = single_release,
2380};
2381
2382static int sg_proc_seq_show_dev(struct seq_file *s, void *v);
2383static int sg_proc_open_dev(struct inode *inode, struct file *file);
2384static void * dev_seq_start(struct seq_file *s, loff_t *pos);
2385static void * dev_seq_next(struct seq_file *s, void *v, loff_t *pos);
2386static void dev_seq_stop(struct seq_file *s, void *v);
2387static const struct file_operations dev_fops = {
2388        .owner = THIS_MODULE,
2389        .open = sg_proc_open_dev,
2390        .read = seq_read,
2391        .llseek = seq_lseek,
2392        .release = seq_release,
2393};
2394static const struct seq_operations dev_seq_ops = {
2395        .start = dev_seq_start,
2396        .next  = dev_seq_next,
2397        .stop  = dev_seq_stop,
2398        .show  = sg_proc_seq_show_dev,
2399};
2400
2401static int sg_proc_seq_show_devstrs(struct seq_file *s, void *v);
2402static int sg_proc_open_devstrs(struct inode *inode, struct file *file);
2403static const struct file_operations devstrs_fops = {
2404        .owner = THIS_MODULE,
2405        .open = sg_proc_open_devstrs,
2406        .read = seq_read,
2407        .llseek = seq_lseek,
2408        .release = seq_release,
2409};
2410static const struct seq_operations devstrs_seq_ops = {
2411        .start = dev_seq_start,
2412        .next  = dev_seq_next,
2413        .stop  = dev_seq_stop,
2414        .show  = sg_proc_seq_show_devstrs,
2415};
2416
2417static int sg_proc_seq_show_debug(struct seq_file *s, void *v);
2418static int sg_proc_open_debug(struct inode *inode, struct file *file);
2419static const struct file_operations debug_fops = {
2420        .owner = THIS_MODULE,
2421        .open = sg_proc_open_debug,
2422        .read = seq_read,
2423        .llseek = seq_lseek,
2424        .release = seq_release,
2425};
2426static const struct seq_operations debug_seq_ops = {
2427        .start = dev_seq_start,
2428        .next  = dev_seq_next,
2429        .stop  = dev_seq_stop,
2430        .show  = sg_proc_seq_show_debug,
2431};
2432
2433
2434struct sg_proc_leaf {
2435        const char * name;
2436        const struct file_operations * fops;
2437};
2438
2439static const struct sg_proc_leaf sg_proc_leaf_arr[] = {
2440        {"allow_dio", &adio_fops},
2441        {"debug", &debug_fops},
2442        {"def_reserved_size", &dressz_fops},
2443        {"device_hdr", &devhdr_fops},
2444        {"devices", &dev_fops},
2445        {"device_strs", &devstrs_fops},
2446        {"version", &version_fops}
2447};
2448
2449static int
2450sg_proc_init(void)
2451{
2452        int num_leaves = ARRAY_SIZE(sg_proc_leaf_arr);
2453        int k;
2454
2455        sg_proc_sgp = proc_mkdir(sg_proc_sg_dirname, NULL);
2456        if (!sg_proc_sgp)
2457                return 1;
2458        for (k = 0; k < num_leaves; ++k) {
2459                const struct sg_proc_leaf *leaf = &sg_proc_leaf_arr[k];
2460                umode_t mask = leaf->fops->write ? S_IRUGO | S_IWUSR : S_IRUGO;
2461                proc_create(leaf->name, mask, sg_proc_sgp, leaf->fops);
2462        }
2463        return 0;
2464}
2465
2466static void
2467sg_proc_cleanup(void)
2468{
2469        int k;
2470        int num_leaves = ARRAY_SIZE(sg_proc_leaf_arr);
2471
2472        if (!sg_proc_sgp)
2473                return;
2474        for (k = 0; k < num_leaves; ++k)
2475                remove_proc_entry(sg_proc_leaf_arr[k].name, sg_proc_sgp);
2476        remove_proc_entry(sg_proc_sg_dirname, NULL);
2477}
2478
2479
2480static int sg_proc_seq_show_int(struct seq_file *s, void *v)
2481{
2482        seq_printf(s, "%d\n", *((int *)s->private));
2483        return 0;
2484}
2485
2486static int sg_proc_single_open_adio(struct inode *inode, struct file *file)
2487{
2488        return single_open(file, sg_proc_seq_show_int, &sg_allow_dio);
2489}
2490
2491static ssize_t
2492sg_proc_write_adio(struct file *filp, const char __user *buffer,
2493                   size_t count, loff_t *off)
2494{
2495        int err;
2496        unsigned long num;
2497
2498        if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2499                return -EACCES;
2500        err = kstrtoul_from_user(buffer, count, 0, &num);
2501        if (err)
2502                return err;
2503        sg_allow_dio = num ? 1 : 0;
2504        return count;
2505}
2506
2507static int sg_proc_single_open_dressz(struct inode *inode, struct file *file)
2508{
2509        return single_open(file, sg_proc_seq_show_int, &sg_big_buff);
2510}
2511
2512static ssize_t
2513sg_proc_write_dressz(struct file *filp, const char __user *buffer,
2514                     size_t count, loff_t *off)
2515{
2516        int err;
2517        unsigned long k = ULONG_MAX;
2518
2519        if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2520                return -EACCES;
2521
2522        err = kstrtoul_from_user(buffer, count, 0, &k);
2523        if (err)
2524                return err;
2525        if (k <= 1048576) {     /* limit "big buff" to 1 MB */
2526                sg_big_buff = k;
2527                return count;
2528        }
2529        return -ERANGE;
2530}
2531
2532static int sg_proc_seq_show_version(struct seq_file *s, void *v)
2533{
2534        seq_printf(s, "%d\t%s [%s]\n", sg_version_num, SG_VERSION_STR,
2535                   sg_version_date);
2536        return 0;
2537}
2538
2539static int sg_proc_single_open_version(struct inode *inode, struct file *file)
2540{
2541        return single_open(file, sg_proc_seq_show_version, NULL);
2542}
2543
2544static int sg_proc_seq_show_devhdr(struct seq_file *s, void *v)
2545{
2546        seq_puts(s, "host\tchan\tid\tlun\ttype\topens\tqdepth\tbusy\tonline\n");
2547        return 0;
2548}
2549
2550static int sg_proc_single_open_devhdr(struct inode *inode, struct file *file)
2551{
2552        return single_open(file, sg_proc_seq_show_devhdr, NULL);
2553}
2554
2555struct sg_proc_deviter {
2556        loff_t  index;
2557        size_t  max;
2558};
2559
2560static void * dev_seq_start(struct seq_file *s, loff_t *pos)
2561{
2562        struct sg_proc_deviter * it = kmalloc(sizeof(*it), GFP_KERNEL);
2563
2564        s->private = it;
2565        if (! it)
2566                return NULL;
2567
2568        it->index = *pos;
2569        it->max = sg_last_dev();
2570        if (it->index >= it->max)
2571                return NULL;
2572        return it;
2573}
2574
2575static void * dev_seq_next(struct seq_file *s, void *v, loff_t *pos)
2576{
2577        struct sg_proc_deviter * it = s->private;
2578
2579        *pos = ++it->index;
2580        return (it->index < it->max) ? it : NULL;
2581}
2582
2583static void dev_seq_stop(struct seq_file *s, void *v)
2584{
2585        kfree(s->private);
2586}
2587
2588static int sg_proc_open_dev(struct inode *inode, struct file *file)
2589{
2590        return seq_open(file, &dev_seq_ops);
2591}
2592
2593static int sg_proc_seq_show_dev(struct seq_file *s, void *v)
2594{
2595        struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
2596        Sg_device *sdp;
2597        struct scsi_device *scsidp;
2598        unsigned long iflags;
2599
2600        read_lock_irqsave(&sg_index_lock, iflags);
2601        sdp = it ? sg_lookup_dev(it->index) : NULL;
2602        if ((NULL == sdp) || (NULL == sdp->device) ||
2603            (atomic_read(&sdp->detaching)))
2604                seq_puts(s, "-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\n");
2605        else {
2606                scsidp = sdp->device;
2607                seq_printf(s, "%d\t%d\t%d\t%llu\t%d\t%d\t%d\t%d\t%d\n",
2608                              scsidp->host->host_no, scsidp->channel,
2609                              scsidp->id, scsidp->lun, (int) scsidp->type,
2610                              1,
2611                              (int) scsidp->queue_depth,
2612                              (int) atomic_read(&scsidp->device_busy),
2613                              (int) scsi_device_online(scsidp));
2614        }
2615        read_unlock_irqrestore(&sg_index_lock, iflags);
2616        return 0;
2617}
2618
2619static int sg_proc_open_devstrs(struct inode *inode, struct file *file)
2620{
2621        return seq_open(file, &devstrs_seq_ops);
2622}
2623
2624static int sg_proc_seq_show_devstrs(struct seq_file *s, void *v)
2625{
2626        struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
2627        Sg_device *sdp;
2628        struct scsi_device *scsidp;
2629        unsigned long iflags;
2630
2631        read_lock_irqsave(&sg_index_lock, iflags);
2632        sdp = it ? sg_lookup_dev(it->index) : NULL;
2633        scsidp = sdp ? sdp->device : NULL;
2634        if (sdp && scsidp && (!atomic_read(&sdp->detaching)))
2635                seq_printf(s, "%8.8s\t%16.16s\t%4.4s\n",
2636                           scsidp->vendor, scsidp->model, scsidp->rev);
2637        else
2638                seq_puts(s, "<no active device>\n");
2639        read_unlock_irqrestore(&sg_index_lock, iflags);
2640        return 0;
2641}
2642
2643/* must be called while holding sg_index_lock */
2644static void sg_proc_debug_helper(struct seq_file *s, Sg_device * sdp)
2645{
2646        int k, m, new_interface, blen, usg;
2647        Sg_request *srp;
2648        Sg_fd *fp;
2649        const sg_io_hdr_t *hp;
2650        const char * cp;
2651        unsigned int ms;
2652
2653        k = 0;
2654        list_for_each_entry(fp, &sdp->sfds, sfd_siblings) {
2655                k++;
2656                read_lock(&fp->rq_list_lock); /* irqs already disabled */
2657                seq_printf(s, "   FD(%d): timeout=%dms bufflen=%d "
2658                           "(res)sgat=%d low_dma=%d\n", k,
2659                           jiffies_to_msecs(fp->timeout),
2660                           fp->reserve.bufflen,
2661                           (int) fp->reserve.k_use_sg,
2662                           (int) fp->low_dma);
2663                seq_printf(s, "   cmd_q=%d f_packid=%d k_orphan=%d closed=0\n",
2664                           (int) fp->cmd_q, (int) fp->force_packid,
2665                           (int) fp->keep_orphan);
2666                for (m = 0, srp = fp->headrp;
2667                                srp != NULL;
2668                                ++m, srp = srp->nextrp) {
2669                        hp = &srp->header;
2670                        new_interface = (hp->interface_id == '\0') ? 0 : 1;
2671                        if (srp->res_used) {
2672                                if (new_interface &&
2673                                    (SG_FLAG_MMAP_IO & hp->flags))
2674                                        cp = "     mmap>> ";
2675                                else
2676                                        cp = "     rb>> ";
2677                        } else {
2678                                if (SG_INFO_DIRECT_IO_MASK & hp->info)
2679                                        cp = "     dio>> ";
2680                                else
2681                                        cp = "     ";
2682                        }
2683                        seq_puts(s, cp);
2684                        blen = srp->data.bufflen;
2685                        usg = srp->data.k_use_sg;
2686                        seq_puts(s, srp->done ?
2687                                 ((1 == srp->done) ?  "rcv:" : "fin:")
2688                                  : "act:");
2689                        seq_printf(s, " id=%d blen=%d",
2690                                   srp->header.pack_id, blen);
2691                        if (srp->done)
2692                                seq_printf(s, " dur=%d", hp->duration);
2693                        else {
2694                                ms = jiffies_to_msecs(jiffies);
2695                                seq_printf(s, " t_o/elap=%d/%d",
2696                                        (new_interface ? hp->timeout :
2697                                                  jiffies_to_msecs(fp->timeout)),
2698                                        (ms > hp->duration ? ms - hp->duration : 0));
2699                        }
2700                        seq_printf(s, "ms sgat=%d op=0x%02x\n", usg,
2701                                   (int) srp->data.cmd_opcode);
2702                }
2703                if (0 == m)
2704                        seq_puts(s, "     No requests active\n");
2705                read_unlock(&fp->rq_list_lock);
2706        }
2707}
2708
2709static int sg_proc_open_debug(struct inode *inode, struct file *file)
2710{
2711        return seq_open(file, &debug_seq_ops);
2712}
2713
2714static int sg_proc_seq_show_debug(struct seq_file *s, void *v)
2715{
2716        struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
2717        Sg_device *sdp;
2718        unsigned long iflags;
2719
2720        if (it && (0 == it->index))
2721                seq_printf(s, "max_active_device=%d  def_reserved_size=%d\n",
2722                           (int)it->max, sg_big_buff);
2723
2724        read_lock_irqsave(&sg_index_lock, iflags);
2725        sdp = it ? sg_lookup_dev(it->index) : NULL;
2726        if (NULL == sdp)
2727                goto skip;
2728        read_lock(&sdp->sfd_lock);
2729        if (!list_empty(&sdp->sfds)) {
2730                seq_printf(s, " >>> device=%s ", sdp->disk->disk_name);
2731                if (atomic_read(&sdp->detaching))
2732                        seq_puts(s, "detaching pending close ");
2733                else if (sdp->device) {
2734                        struct scsi_device *scsidp = sdp->device;
2735
2736                        seq_printf(s, "%d:%d:%d:%llu   em=%d",
2737                                   scsidp->host->host_no,
2738                                   scsidp->channel, scsidp->id,
2739                                   scsidp->lun,
2740                                   scsidp->host->hostt->emulated);
2741                }
2742                seq_printf(s, " sg_tablesize=%d excl=%d open_cnt=%d\n",
2743                           sdp->sg_tablesize, sdp->exclude, sdp->open_cnt);
2744                sg_proc_debug_helper(s, sdp);
2745        }
2746        read_unlock(&sdp->sfd_lock);
2747skip:
2748        read_unlock_irqrestore(&sg_index_lock, iflags);
2749        return 0;
2750}
2751
2752#endif                          /* CONFIG_SCSI_PROC_FS */
2753
2754module_init(init_sg);
2755module_exit(exit_sg);
Note: See TracBrowser for help on using the repository browser.