11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * History: 31da177e4SLinus Torvalds * Started: Aug 9 by Lawrence Foard (entropy@world.std.com), 41da177e4SLinus Torvalds * to allow user process control of SCSI devices. 51da177e4SLinus Torvalds * Development Sponsored by Killy Corp. NY NY 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * Original driver (sg.c): 81da177e4SLinus Torvalds * Copyright (C) 1992 Lawrence Foard 91da177e4SLinus Torvalds * Version 2 and 3 extensions to driver: 101da177e4SLinus Torvalds * Copyright (C) 1998 - 2005 Douglas Gilbert 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * Modified 19-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support 131da177e4SLinus Torvalds * 141da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or modify 151da177e4SLinus Torvalds * it under the terms of the GNU General Public License as published by 161da177e4SLinus Torvalds * the Free Software Foundation; either version 2, or (at your option) 171da177e4SLinus Torvalds * any later version. 181da177e4SLinus Torvalds * 191da177e4SLinus Torvalds */ 201da177e4SLinus Torvalds 21b2155d04SDouglas Gilbert static int sg_version_num = 30534; /* 2 digits for each component */ 22b2155d04SDouglas Gilbert #define SG_VERSION_STR "3.5.34" 231da177e4SLinus Torvalds 241da177e4SLinus Torvalds /* 251da177e4SLinus Torvalds * D. P. Gilbert (dgilbert@interlog.com, dougg@triode.net.au), notes: 261da177e4SLinus Torvalds * - scsi logging is available via SCSI_LOG_TIMEOUT macros. First 271da177e4SLinus Torvalds * the kernel/module needs to be built with CONFIG_SCSI_LOGGING 281da177e4SLinus Torvalds * (otherwise the macros compile to empty statements). 291da177e4SLinus Torvalds * 301da177e4SLinus Torvalds */ 311da177e4SLinus Torvalds #include <linux/module.h> 321da177e4SLinus Torvalds 331da177e4SLinus Torvalds #include <linux/fs.h> 341da177e4SLinus Torvalds #include <linux/kernel.h> 351da177e4SLinus Torvalds #include <linux/sched.h> 361da177e4SLinus Torvalds #include <linux/string.h> 371da177e4SLinus Torvalds #include <linux/mm.h> 381da177e4SLinus Torvalds #include <linux/errno.h> 391da177e4SLinus Torvalds #include <linux/mtio.h> 401da177e4SLinus Torvalds #include <linux/ioctl.h> 415a0e3ad6STejun Heo #include <linux/slab.h> 421da177e4SLinus Torvalds #include <linux/fcntl.h> 431da177e4SLinus Torvalds #include <linux/init.h> 441da177e4SLinus Torvalds #include <linux/poll.h> 451da177e4SLinus Torvalds #include <linux/moduleparam.h> 461da177e4SLinus Torvalds #include <linux/cdev.h> 477c07d613SJames Bottomley #include <linux/idr.h> 481da177e4SLinus Torvalds #include <linux/seq_file.h> 491da177e4SLinus Torvalds #include <linux/blkdev.h> 501da177e4SLinus Torvalds #include <linux/delay.h> 516da127adSChristof Schmitt #include <linux/blktrace_api.h> 52eb09d3d4SJonathan Corbet #include <linux/smp_lock.h> 531da177e4SLinus Torvalds 541da177e4SLinus Torvalds #include "scsi.h" 55db9dff36S #include <scsi/scsi_dbg.h> 561da177e4SLinus Torvalds #include <scsi/scsi_host.h> 571da177e4SLinus Torvalds #include <scsi/scsi_driver.h> 581da177e4SLinus Torvalds #include <scsi/scsi_ioctl.h> 591da177e4SLinus Torvalds #include <scsi/sg.h> 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds #include "scsi_logging.h" 621da177e4SLinus Torvalds 631da177e4SLinus Torvalds #ifdef CONFIG_SCSI_PROC_FS 641da177e4SLinus Torvalds #include <linux/proc_fs.h> 657ca63cb4SDouglas Gilbert static char *sg_version_date = "20061027"; 661da177e4SLinus Torvalds 671da177e4SLinus Torvalds static int sg_proc_init(void); 681da177e4SLinus Torvalds static void sg_proc_cleanup(void); 691da177e4SLinus Torvalds #endif 701da177e4SLinus Torvalds 711da177e4SLinus Torvalds #define SG_ALLOW_DIO_DEF 0 721da177e4SLinus Torvalds 731da177e4SLinus Torvalds #define SG_MAX_DEVS 32768 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds /* 761da177e4SLinus Torvalds * Suppose you want to calculate the formula muldiv(x,m,d)=int(x * m / d) 771da177e4SLinus Torvalds * Then when using 32 bit integers x * m may overflow during the calculation. 781da177e4SLinus Torvalds * Replacing muldiv(x) by muldiv(x)=((x % d) * m) / d + int(x / d) * m 791da177e4SLinus Torvalds * calculates the same, but prevents the overflow when both m and d 801da177e4SLinus Torvalds * are "small" numbers (like HZ and USER_HZ). 811da177e4SLinus Torvalds * Of course an overflow is inavoidable if the result of muldiv doesn't fit 821da177e4SLinus Torvalds * in 32 bits. 831da177e4SLinus Torvalds */ 841da177e4SLinus Torvalds #define MULDIV(X,MUL,DIV) ((((X % DIV) * MUL) / DIV) + ((X / DIV) * MUL)) 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds #define SG_DEFAULT_TIMEOUT MULDIV(SG_DEFAULT_TIMEOUT_USER, HZ, USER_HZ) 871da177e4SLinus Torvalds 881da177e4SLinus Torvalds int sg_big_buff = SG_DEF_RESERVED_SIZE; 891da177e4SLinus Torvalds /* N.B. This variable is readable and writeable via 901da177e4SLinus Torvalds /proc/scsi/sg/def_reserved_size . Each time sg_open() is called a buffer 911da177e4SLinus Torvalds of this size (or less if there is not enough memory) will be reserved 921da177e4SLinus Torvalds for use by this file descriptor. [Deprecated usage: this variable is also 931da177e4SLinus Torvalds readable via /proc/sys/kernel/sg-big-buff if the sg driver is built into 941da177e4SLinus Torvalds the kernel (i.e. it is not a module).] */ 951da177e4SLinus Torvalds static int def_reserved_size = -1; /* picks up init parameter */ 961da177e4SLinus Torvalds static int sg_allow_dio = SG_ALLOW_DIO_DEF; 971da177e4SLinus Torvalds 986460e75aSDouglas Gilbert static int scatter_elem_sz = SG_SCATTER_SZ; 996460e75aSDouglas Gilbert static int scatter_elem_sz_prev = SG_SCATTER_SZ; 1006460e75aSDouglas Gilbert 1011da177e4SLinus Torvalds #define SG_SECTOR_SZ 512 1021da177e4SLinus Torvalds 103ee959b00STony Jones static int sg_add(struct device *, struct class_interface *); 104ee959b00STony Jones static void sg_remove(struct device *, struct class_interface *); 1051da177e4SLinus Torvalds 1067c07d613SJames Bottomley static DEFINE_IDR(sg_index_idr); 1077c07d613SJames Bottomley static DEFINE_RWLOCK(sg_index_lock); /* Also used to lock 1081da177e4SLinus Torvalds file descriptor list for device */ 1091da177e4SLinus Torvalds 1101da177e4SLinus Torvalds static struct class_interface sg_interface = { 111ee959b00STony Jones .add_dev = sg_add, 112ee959b00STony Jones .remove_dev = sg_remove, 1131da177e4SLinus Torvalds }; 1141da177e4SLinus Torvalds 1151da177e4SLinus Torvalds typedef struct sg_scatter_hold { /* holding area for scsi scatter gather info */ 1161da177e4SLinus Torvalds unsigned short k_use_sg; /* Count of kernel scatter-gather pieces */ 117ea312552SFUJITA Tomonori unsigned sglist_len; /* size of malloc'd scatter-gather list ++ */ 1181da177e4SLinus Torvalds unsigned bufflen; /* Size of (aggregate) data buffer */ 11910db10d1SFUJITA Tomonori struct page **pages; 12010db10d1SFUJITA Tomonori int page_order; 1211da177e4SLinus Torvalds char dio_in_use; /* 0->indirect IO (or mmap), 1->dio */ 1221da177e4SLinus Torvalds unsigned char cmd_opcode; /* first byte of command */ 1231da177e4SLinus Torvalds } Sg_scatter_hold; 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds struct sg_device; /* forward declarations */ 1261da177e4SLinus Torvalds struct sg_fd; 1271da177e4SLinus Torvalds 1281da177e4SLinus Torvalds typedef struct sg_request { /* SG_MAX_QUEUE requests outstanding per file */ 1291da177e4SLinus Torvalds struct sg_request *nextrp; /* NULL -> tail request (slist) */ 1301da177e4SLinus Torvalds struct sg_fd *parentfp; /* NULL -> not in use */ 1311da177e4SLinus Torvalds Sg_scatter_hold data; /* hold buffer, perhaps scatter list */ 1321da177e4SLinus Torvalds sg_io_hdr_t header; /* scsi command+info, see <scsi/sg.h> */ 133d6b10348SMike Christie unsigned char sense_b[SCSI_SENSE_BUFFERSIZE]; 1341da177e4SLinus Torvalds char res_used; /* 1 -> using reserve buffer, 0 -> not ... */ 1351da177e4SLinus Torvalds char orphan; /* 1 -> drop on sight, 0 -> normal */ 1361da177e4SLinus Torvalds char sg_io_owned; /* 1 -> packet belongs to SG_IO */ 1371da177e4SLinus Torvalds volatile char done; /* 0->before bh, 1->before read, 2->read */ 13810865dfaSFUJITA Tomonori struct request *rq; 1396e5a30cbSFUJITA Tomonori struct bio *bio; 140c96952edSFUJITA Tomonori struct execute_work ew; 1411da177e4SLinus Torvalds } Sg_request; 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds typedef struct sg_fd { /* holds the state of a file descriptor */ 1443442f802SFUJITA Tomonori struct list_head sfd_siblings; 1451da177e4SLinus Torvalds struct sg_device *parentdp; /* owning device */ 1461da177e4SLinus Torvalds wait_queue_head_t read_wait; /* queue read until command done */ 1471da177e4SLinus Torvalds rwlock_t rq_list_lock; /* protect access to list in req_arr */ 1481da177e4SLinus Torvalds int timeout; /* defaults to SG_DEFAULT_TIMEOUT */ 1491da177e4SLinus Torvalds int timeout_user; /* defaults to SG_DEFAULT_TIMEOUT_USER */ 1501da177e4SLinus Torvalds Sg_scatter_hold reserve; /* buffer held for this file descriptor */ 1511da177e4SLinus Torvalds unsigned save_scat_len; /* original length of trunc. scat. element */ 1521da177e4SLinus Torvalds Sg_request *headrp; /* head of request slist, NULL->empty */ 1531da177e4SLinus Torvalds struct fasync_struct *async_qp; /* used by asynchronous notification */ 1541da177e4SLinus Torvalds Sg_request req_arr[SG_MAX_QUEUE]; /* used as singly-linked list */ 1551da177e4SLinus Torvalds char low_dma; /* as in parent but possibly overridden to 1 */ 1561da177e4SLinus Torvalds char force_packid; /* 1 -> pack_id input to read(), 0 -> ignored */ 1571da177e4SLinus Torvalds volatile char closed; /* 1 -> fd closed but request(s) outstanding */ 1581da177e4SLinus Torvalds char cmd_q; /* 1 -> allow command queuing, 0 -> don't */ 1591da177e4SLinus Torvalds char next_cmd_len; /* 0 -> automatic (def), >0 -> use on next write() */ 1601da177e4SLinus Torvalds char keep_orphan; /* 0 -> drop orphan (def), 1 -> keep for read() */ 1611da177e4SLinus Torvalds char mmap_called; /* 0 -> mmap() never called on this fd */ 162c6517b79STony Battersby struct kref f_ref; 163c6517b79STony Battersby struct execute_work ew; 1641da177e4SLinus Torvalds } Sg_fd; 1651da177e4SLinus Torvalds 1661da177e4SLinus Torvalds typedef struct sg_device { /* holds the state of each scsi generic device */ 1671da177e4SLinus Torvalds struct scsi_device *device; 1681da177e4SLinus Torvalds wait_queue_head_t o_excl_wait; /* queue open() when O_EXCL in use */ 1691da177e4SLinus Torvalds int sg_tablesize; /* adapter's max scatter-gather table size */ 1707c07d613SJames Bottomley u32 index; /* device index number */ 1713442f802SFUJITA Tomonori struct list_head sfds; 1721da177e4SLinus Torvalds volatile char detached; /* 0->attached, 1->detached pending removal */ 1731da177e4SLinus Torvalds volatile char exclude; /* opened for exclusive access */ 1741da177e4SLinus Torvalds char sgdebug; /* 0->off, 1->sense, 9->dump dev, 10-> all devs */ 1751da177e4SLinus Torvalds struct gendisk *disk; 1761da177e4SLinus Torvalds struct cdev * cdev; /* char_dev [sysfs: /sys/cdev/major/sg<n>] */ 177c6517b79STony Battersby struct kref d_ref; 1781da177e4SLinus Torvalds } Sg_device; 1791da177e4SLinus Torvalds 180d6b10348SMike Christie /* tasklet or soft irq callback */ 181a91a3a20SFUJITA Tomonori static void sg_rq_end_io(struct request *rq, int uptodate); 18210865dfaSFUJITA Tomonori static int sg_start_req(Sg_request *srp, unsigned char *cmd); 183e7ee4cc0SFUJITA Tomonori static int sg_finish_rem_req(Sg_request * srp); 1841da177e4SLinus Torvalds static int sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size); 1851da177e4SLinus Torvalds static ssize_t sg_new_read(Sg_fd * sfp, char __user *buf, size_t count, 1861da177e4SLinus Torvalds Sg_request * srp); 1870b07de85SAdel Gadllah static ssize_t sg_new_write(Sg_fd *sfp, struct file *file, 1880b07de85SAdel Gadllah const char __user *buf, size_t count, int blocking, 189a2dd3b4cSTony Battersby int read_only, int sg_io_owned, Sg_request **o_srp); 1901da177e4SLinus Torvalds static int sg_common_write(Sg_fd * sfp, Sg_request * srp, 1911da177e4SLinus Torvalds unsigned char *cmnd, int timeout, int blocking); 1921da177e4SLinus Torvalds static int sg_read_oxfer(Sg_request * srp, char __user *outp, int num_read_xfer); 1931da177e4SLinus Torvalds static void sg_remove_scat(Sg_scatter_hold * schp); 1941da177e4SLinus Torvalds static void sg_build_reserve(Sg_fd * sfp, int req_size); 1951da177e4SLinus Torvalds static void sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size); 1961da177e4SLinus Torvalds static void sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp); 1971da177e4SLinus Torvalds static Sg_fd *sg_add_sfp(Sg_device * sdp, int dev); 198c6517b79STony Battersby static void sg_remove_sfp(struct kref *); 1991da177e4SLinus Torvalds static Sg_request *sg_get_rq_mark(Sg_fd * sfp, int pack_id); 2001da177e4SLinus Torvalds static Sg_request *sg_add_request(Sg_fd * sfp); 2011da177e4SLinus Torvalds static int sg_remove_request(Sg_fd * sfp, Sg_request * srp); 2021da177e4SLinus Torvalds static int sg_res_in_use(Sg_fd * sfp); 2031da177e4SLinus Torvalds static Sg_device *sg_get_dev(int dev); 204c6517b79STony Battersby static void sg_put_dev(Sg_device *sdp); 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds #define SZ_SG_HEADER sizeof(struct sg_header) 2071da177e4SLinus Torvalds #define SZ_SG_IO_HDR sizeof(sg_io_hdr_t) 2081da177e4SLinus Torvalds #define SZ_SG_IOVEC sizeof(sg_iovec_t) 2091da177e4SLinus Torvalds #define SZ_SG_REQ_INFO sizeof(sg_req_info_t) 2101da177e4SLinus Torvalds 21114e507b8SFUJITA Tomonori static int sg_allow_access(struct file *filp, unsigned char *cmd) 21214e507b8SFUJITA Tomonori { 21314e507b8SFUJITA Tomonori struct sg_fd *sfp = (struct sg_fd *)filp->private_data; 21414e507b8SFUJITA Tomonori 21514e507b8SFUJITA Tomonori if (sfp->parentdp->device->type == TYPE_SCANNER) 21614e507b8SFUJITA Tomonori return 0; 21714e507b8SFUJITA Tomonori 218018e0446SJens Axboe return blk_verify_command(cmd, filp->f_mode & FMODE_WRITE); 21914e507b8SFUJITA Tomonori } 22014e507b8SFUJITA Tomonori 2211da177e4SLinus Torvalds static int 2221da177e4SLinus Torvalds sg_open(struct inode *inode, struct file *filp) 2231da177e4SLinus Torvalds { 2241da177e4SLinus Torvalds int dev = iminor(inode); 2251da177e4SLinus Torvalds int flags = filp->f_flags; 226d6b10348SMike Christie struct request_queue *q; 2271da177e4SLinus Torvalds Sg_device *sdp; 2281da177e4SLinus Torvalds Sg_fd *sfp; 2291da177e4SLinus Torvalds int res; 2301da177e4SLinus Torvalds int retval; 2311da177e4SLinus Torvalds 232eb09d3d4SJonathan Corbet lock_kernel(); 2331da177e4SLinus Torvalds nonseekable_open(inode, filp); 2341da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(3, printk("sg_open: dev=%d, flags=0x%x\n", dev, flags)); 2351da177e4SLinus Torvalds sdp = sg_get_dev(dev); 236c6517b79STony Battersby if (IS_ERR(sdp)) { 237c6517b79STony Battersby retval = PTR_ERR(sdp); 238c6517b79STony Battersby sdp = NULL; 239c6517b79STony Battersby goto sg_put; 240eb09d3d4SJonathan Corbet } 2411da177e4SLinus Torvalds 2421da177e4SLinus Torvalds /* This driver's module count bumped by fops_get in <linux/fs.h> */ 2431da177e4SLinus Torvalds /* Prevent the device driver from vanishing while we sleep */ 2441da177e4SLinus Torvalds retval = scsi_device_get(sdp->device); 245c6517b79STony Battersby if (retval) 246c6517b79STony Battersby goto sg_put; 2471da177e4SLinus Torvalds 248*bc4f2401SAlan Stern retval = scsi_autopm_get_device(sdp->device); 249*bc4f2401SAlan Stern if (retval) 250*bc4f2401SAlan Stern goto sdp_put; 251*bc4f2401SAlan Stern 2521da177e4SLinus Torvalds if (!((flags & O_NONBLOCK) || 2531da177e4SLinus Torvalds scsi_block_when_processing_errors(sdp->device))) { 2541da177e4SLinus Torvalds retval = -ENXIO; 2551da177e4SLinus Torvalds /* we are in error recovery for this device */ 2561da177e4SLinus Torvalds goto error_out; 2571da177e4SLinus Torvalds } 2581da177e4SLinus Torvalds 2591da177e4SLinus Torvalds if (flags & O_EXCL) { 2601da177e4SLinus Torvalds if (O_RDONLY == (flags & O_ACCMODE)) { 2611da177e4SLinus Torvalds retval = -EPERM; /* Can't lock it with read only access */ 2621da177e4SLinus Torvalds goto error_out; 2631da177e4SLinus Torvalds } 2643442f802SFUJITA Tomonori if (!list_empty(&sdp->sfds) && (flags & O_NONBLOCK)) { 2651da177e4SLinus Torvalds retval = -EBUSY; 2661da177e4SLinus Torvalds goto error_out; 2671da177e4SLinus Torvalds } 2681da177e4SLinus Torvalds res = 0; 2691da177e4SLinus Torvalds __wait_event_interruptible(sdp->o_excl_wait, 2703442f802SFUJITA Tomonori ((!list_empty(&sdp->sfds) || sdp->exclude) ? 0 : (sdp->exclude = 1)), res); 2711da177e4SLinus Torvalds if (res) { 2721da177e4SLinus Torvalds retval = res; /* -ERESTARTSYS because signal hit process */ 2731da177e4SLinus Torvalds goto error_out; 2741da177e4SLinus Torvalds } 2751da177e4SLinus Torvalds } else if (sdp->exclude) { /* some other fd has an exclusive lock on dev */ 2761da177e4SLinus Torvalds if (flags & O_NONBLOCK) { 2771da177e4SLinus Torvalds retval = -EBUSY; 2781da177e4SLinus Torvalds goto error_out; 2791da177e4SLinus Torvalds } 2801da177e4SLinus Torvalds res = 0; 2811da177e4SLinus Torvalds __wait_event_interruptible(sdp->o_excl_wait, (!sdp->exclude), 2821da177e4SLinus Torvalds res); 2831da177e4SLinus Torvalds if (res) { 2841da177e4SLinus Torvalds retval = res; /* -ERESTARTSYS because signal hit process */ 2851da177e4SLinus Torvalds goto error_out; 2861da177e4SLinus Torvalds } 2871da177e4SLinus Torvalds } 2881da177e4SLinus Torvalds if (sdp->detached) { 2891da177e4SLinus Torvalds retval = -ENODEV; 2901da177e4SLinus Torvalds goto error_out; 2911da177e4SLinus Torvalds } 2923442f802SFUJITA Tomonori if (list_empty(&sdp->sfds)) { /* no existing opens on this device */ 2931da177e4SLinus Torvalds sdp->sgdebug = 0; 294d6b10348SMike Christie q = sdp->device->request_queue; 2958a78362cSMartin K. Petersen sdp->sg_tablesize = queue_max_segments(q); 2961da177e4SLinus Torvalds } 2971da177e4SLinus Torvalds if ((sfp = sg_add_sfp(sdp, dev))) 2981da177e4SLinus Torvalds filp->private_data = sfp; 2991da177e4SLinus Torvalds else { 300c6517b79STony Battersby if (flags & O_EXCL) { 3011da177e4SLinus Torvalds sdp->exclude = 0; /* undo if error */ 302c6517b79STony Battersby wake_up_interruptible(&sdp->o_excl_wait); 303c6517b79STony Battersby } 3041da177e4SLinus Torvalds retval = -ENOMEM; 3051da177e4SLinus Torvalds goto error_out; 3061da177e4SLinus Torvalds } 307c6517b79STony Battersby retval = 0; 3081da177e4SLinus Torvalds error_out: 309*bc4f2401SAlan Stern if (retval) { 310*bc4f2401SAlan Stern scsi_autopm_put_device(sdp->device); 311*bc4f2401SAlan Stern sdp_put: 3121da177e4SLinus Torvalds scsi_device_put(sdp->device); 313*bc4f2401SAlan Stern } 314c6517b79STony Battersby sg_put: 315c6517b79STony Battersby if (sdp) 316c6517b79STony Battersby sg_put_dev(sdp); 317eb09d3d4SJonathan Corbet unlock_kernel(); 3181da177e4SLinus Torvalds return retval; 3191da177e4SLinus Torvalds } 3201da177e4SLinus Torvalds 3211da177e4SLinus Torvalds /* Following function was formerly called 'sg_close' */ 3221da177e4SLinus Torvalds static int 3231da177e4SLinus Torvalds sg_release(struct inode *inode, struct file *filp) 3241da177e4SLinus Torvalds { 3251da177e4SLinus Torvalds Sg_device *sdp; 3261da177e4SLinus Torvalds Sg_fd *sfp; 3271da177e4SLinus Torvalds 3281da177e4SLinus Torvalds if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp))) 3291da177e4SLinus Torvalds return -ENXIO; 3301da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(3, printk("sg_release: %s\n", sdp->disk->disk_name)); 331c6517b79STony Battersby 332c6517b79STony Battersby sfp->closed = 1; 333c6517b79STony Battersby 3341da177e4SLinus Torvalds sdp->exclude = 0; 3351da177e4SLinus Torvalds wake_up_interruptible(&sdp->o_excl_wait); 336c6517b79STony Battersby 337*bc4f2401SAlan Stern scsi_autopm_put_device(sdp->device); 338c6517b79STony Battersby kref_put(&sfp->f_ref, sg_remove_sfp); 3391da177e4SLinus Torvalds return 0; 3401da177e4SLinus Torvalds } 3411da177e4SLinus Torvalds 3421da177e4SLinus Torvalds static ssize_t 3431da177e4SLinus Torvalds sg_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos) 3441da177e4SLinus Torvalds { 3451da177e4SLinus Torvalds Sg_device *sdp; 3461da177e4SLinus Torvalds Sg_fd *sfp; 3471da177e4SLinus Torvalds Sg_request *srp; 3481da177e4SLinus Torvalds int req_pack_id = -1; 3491da177e4SLinus Torvalds sg_io_hdr_t *hp; 350cb59e840S struct sg_header *old_hdr = NULL; 351cb59e840S int retval = 0; 3521da177e4SLinus Torvalds 3531da177e4SLinus Torvalds if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp))) 3541da177e4SLinus Torvalds return -ENXIO; 3551da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(3, printk("sg_read: %s, count=%d\n", 3561da177e4SLinus Torvalds sdp->disk->disk_name, (int) count)); 357d6b10348SMike Christie 3581da177e4SLinus Torvalds if (!access_ok(VERIFY_WRITE, buf, count)) 3591da177e4SLinus Torvalds return -EFAULT; 3601da177e4SLinus Torvalds if (sfp->force_packid && (count >= SZ_SG_HEADER)) { 361cb59e840S old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL); 362cb59e840S if (!old_hdr) 363cb59e840S return -ENOMEM; 364cb59e840S if (__copy_from_user(old_hdr, buf, SZ_SG_HEADER)) { 365cb59e840S retval = -EFAULT; 366cb59e840S goto free_old_hdr; 367cb59e840S } 368cb59e840S if (old_hdr->reply_len < 0) { 3691da177e4SLinus Torvalds if (count >= SZ_SG_IO_HDR) { 370cb59e840S sg_io_hdr_t *new_hdr; 371cb59e840S new_hdr = kmalloc(SZ_SG_IO_HDR, GFP_KERNEL); 372cb59e840S if (!new_hdr) { 373cb59e840S retval = -ENOMEM; 374cb59e840S goto free_old_hdr; 375cb59e840S } 376cb59e840S retval =__copy_from_user 377cb59e840S (new_hdr, buf, SZ_SG_IO_HDR); 378cb59e840S req_pack_id = new_hdr->pack_id; 379cb59e840S kfree(new_hdr); 380cb59e840S if (retval) { 381cb59e840S retval = -EFAULT; 382cb59e840S goto free_old_hdr; 383cb59e840S } 3841da177e4SLinus Torvalds } 3851da177e4SLinus Torvalds } else 386cb59e840S req_pack_id = old_hdr->pack_id; 3871da177e4SLinus Torvalds } 3881da177e4SLinus Torvalds srp = sg_get_rq_mark(sfp, req_pack_id); 3891da177e4SLinus Torvalds if (!srp) { /* now wait on packet to arrive */ 390cb59e840S if (sdp->detached) { 391cb59e840S retval = -ENODEV; 392cb59e840S goto free_old_hdr; 393cb59e840S } 394cb59e840S if (filp->f_flags & O_NONBLOCK) { 395cb59e840S retval = -EAGAIN; 396cb59e840S goto free_old_hdr; 397cb59e840S } 3981da177e4SLinus Torvalds while (1) { 399cb59e840S retval = 0; /* following macro beats race condition */ 4001da177e4SLinus Torvalds __wait_event_interruptible(sfp->read_wait, 401cb59e840S (sdp->detached || 402cb59e840S (srp = sg_get_rq_mark(sfp, req_pack_id))), 403cb59e840S retval); 404cb59e840S if (sdp->detached) { 405cb59e840S retval = -ENODEV; 406cb59e840S goto free_old_hdr; 407cb59e840S } 408cb59e840S if (0 == retval) 4091da177e4SLinus Torvalds break; 410cb59e840S 411cb59e840S /* -ERESTARTSYS as signal hit process */ 412cb59e840S goto free_old_hdr; 4131da177e4SLinus Torvalds } 4141da177e4SLinus Torvalds } 415cb59e840S if (srp->header.interface_id != '\0') { 416cb59e840S retval = sg_new_read(sfp, buf, count, srp); 417cb59e840S goto free_old_hdr; 418cb59e840S } 4191da177e4SLinus Torvalds 4201da177e4SLinus Torvalds hp = &srp->header; 421cb59e840S if (old_hdr == NULL) { 422cb59e840S old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL); 423cb59e840S if (! old_hdr) { 424cb59e840S retval = -ENOMEM; 425cb59e840S goto free_old_hdr; 426cb59e840S } 427cb59e840S } 428cb59e840S memset(old_hdr, 0, SZ_SG_HEADER); 429cb59e840S old_hdr->reply_len = (int) hp->timeout; 430cb59e840S old_hdr->pack_len = old_hdr->reply_len; /* old, strange behaviour */ 431cb59e840S old_hdr->pack_id = hp->pack_id; 432cb59e840S old_hdr->twelve_byte = 4331da177e4SLinus Torvalds ((srp->data.cmd_opcode >= 0xc0) && (12 == hp->cmd_len)) ? 1 : 0; 434cb59e840S old_hdr->target_status = hp->masked_status; 435cb59e840S old_hdr->host_status = hp->host_status; 436cb59e840S old_hdr->driver_status = hp->driver_status; 4371da177e4SLinus Torvalds if ((CHECK_CONDITION & hp->masked_status) || 4381da177e4SLinus Torvalds (DRIVER_SENSE & hp->driver_status)) 439cb59e840S memcpy(old_hdr->sense_buffer, srp->sense_b, 440cb59e840S sizeof (old_hdr->sense_buffer)); 4411da177e4SLinus Torvalds switch (hp->host_status) { 4421da177e4SLinus Torvalds /* This setup of 'result' is for backward compatibility and is best 4431da177e4SLinus Torvalds ignored by the user who should use target, host + driver status */ 4441da177e4SLinus Torvalds case DID_OK: 4451da177e4SLinus Torvalds case DID_PASSTHROUGH: 4461da177e4SLinus Torvalds case DID_SOFT_ERROR: 447cb59e840S old_hdr->result = 0; 4481da177e4SLinus Torvalds break; 4491da177e4SLinus Torvalds case DID_NO_CONNECT: 4501da177e4SLinus Torvalds case DID_BUS_BUSY: 4511da177e4SLinus Torvalds case DID_TIME_OUT: 452cb59e840S old_hdr->result = EBUSY; 4531da177e4SLinus Torvalds break; 4541da177e4SLinus Torvalds case DID_BAD_TARGET: 4551da177e4SLinus Torvalds case DID_ABORT: 4561da177e4SLinus Torvalds case DID_PARITY: 4571da177e4SLinus Torvalds case DID_RESET: 4581da177e4SLinus Torvalds case DID_BAD_INTR: 459cb59e840S old_hdr->result = EIO; 4601da177e4SLinus Torvalds break; 4611da177e4SLinus Torvalds case DID_ERROR: 462cb59e840S old_hdr->result = (srp->sense_b[0] == 0 && 4631da177e4SLinus Torvalds hp->masked_status == GOOD) ? 0 : EIO; 4641da177e4SLinus Torvalds break; 4651da177e4SLinus Torvalds default: 466cb59e840S old_hdr->result = EIO; 4671da177e4SLinus Torvalds break; 4681da177e4SLinus Torvalds } 4691da177e4SLinus Torvalds 4701da177e4SLinus Torvalds /* Now copy the result back to the user buffer. */ 4711da177e4SLinus Torvalds if (count >= SZ_SG_HEADER) { 472cb59e840S if (__copy_to_user(buf, old_hdr, SZ_SG_HEADER)) { 473cb59e840S retval = -EFAULT; 474cb59e840S goto free_old_hdr; 475cb59e840S } 4761da177e4SLinus Torvalds buf += SZ_SG_HEADER; 477cb59e840S if (count > old_hdr->reply_len) 478cb59e840S count = old_hdr->reply_len; 4791da177e4SLinus Torvalds if (count > SZ_SG_HEADER) { 480cb59e840S if (sg_read_oxfer(srp, buf, count - SZ_SG_HEADER)) { 481cb59e840S retval = -EFAULT; 482cb59e840S goto free_old_hdr; 483cb59e840S } 4841da177e4SLinus Torvalds } 4851da177e4SLinus Torvalds } else 486cb59e840S count = (old_hdr->result == 0) ? 0 : -EIO; 4871da177e4SLinus Torvalds sg_finish_rem_req(srp); 488cb59e840S retval = count; 489cb59e840S free_old_hdr: 490cb59e840S kfree(old_hdr); 491cb59e840S return retval; 4921da177e4SLinus Torvalds } 4931da177e4SLinus Torvalds 4941da177e4SLinus Torvalds static ssize_t 4951da177e4SLinus Torvalds sg_new_read(Sg_fd * sfp, char __user *buf, size_t count, Sg_request * srp) 4961da177e4SLinus Torvalds { 4971da177e4SLinus Torvalds sg_io_hdr_t *hp = &srp->header; 4981da177e4SLinus Torvalds int err = 0; 4991da177e4SLinus Torvalds int len; 5001da177e4SLinus Torvalds 5011da177e4SLinus Torvalds if (count < SZ_SG_IO_HDR) { 5021da177e4SLinus Torvalds err = -EINVAL; 5031da177e4SLinus Torvalds goto err_out; 5041da177e4SLinus Torvalds } 5051da177e4SLinus Torvalds hp->sb_len_wr = 0; 5061da177e4SLinus Torvalds if ((hp->mx_sb_len > 0) && hp->sbp) { 5071da177e4SLinus Torvalds if ((CHECK_CONDITION & hp->masked_status) || 5081da177e4SLinus Torvalds (DRIVER_SENSE & hp->driver_status)) { 509d6b10348SMike Christie int sb_len = SCSI_SENSE_BUFFERSIZE; 5101da177e4SLinus Torvalds sb_len = (hp->mx_sb_len > sb_len) ? sb_len : hp->mx_sb_len; 5111da177e4SLinus Torvalds len = 8 + (int) srp->sense_b[7]; /* Additional sense length field */ 5121da177e4SLinus Torvalds len = (len > sb_len) ? sb_len : len; 5131da177e4SLinus Torvalds if (copy_to_user(hp->sbp, srp->sense_b, len)) { 5141da177e4SLinus Torvalds err = -EFAULT; 5151da177e4SLinus Torvalds goto err_out; 5161da177e4SLinus Torvalds } 5171da177e4SLinus Torvalds hp->sb_len_wr = len; 5181da177e4SLinus Torvalds } 5191da177e4SLinus Torvalds } 5201da177e4SLinus Torvalds if (hp->masked_status || hp->host_status || hp->driver_status) 5211da177e4SLinus Torvalds hp->info |= SG_INFO_CHECK; 5221da177e4SLinus Torvalds if (copy_to_user(buf, hp, SZ_SG_IO_HDR)) { 5231da177e4SLinus Torvalds err = -EFAULT; 5241da177e4SLinus Torvalds goto err_out; 5251da177e4SLinus Torvalds } 5261da177e4SLinus Torvalds err_out: 527e7ee4cc0SFUJITA Tomonori err = sg_finish_rem_req(srp); 5281da177e4SLinus Torvalds return (0 == err) ? count : err; 5291da177e4SLinus Torvalds } 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds static ssize_t 5321da177e4SLinus Torvalds sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos) 5331da177e4SLinus Torvalds { 5341da177e4SLinus Torvalds int mxsize, cmd_size, k; 5351da177e4SLinus Torvalds int input_size, blocking; 5361da177e4SLinus Torvalds unsigned char opcode; 5371da177e4SLinus Torvalds Sg_device *sdp; 5381da177e4SLinus Torvalds Sg_fd *sfp; 5391da177e4SLinus Torvalds Sg_request *srp; 5401da177e4SLinus Torvalds struct sg_header old_hdr; 5411da177e4SLinus Torvalds sg_io_hdr_t *hp; 542d6b10348SMike Christie unsigned char cmnd[MAX_COMMAND_SIZE]; 5431da177e4SLinus Torvalds 5441da177e4SLinus Torvalds if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp))) 5451da177e4SLinus Torvalds return -ENXIO; 5461da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(3, printk("sg_write: %s, count=%d\n", 5471da177e4SLinus Torvalds sdp->disk->disk_name, (int) count)); 5481da177e4SLinus Torvalds if (sdp->detached) 5491da177e4SLinus Torvalds return -ENODEV; 5501da177e4SLinus Torvalds if (!((filp->f_flags & O_NONBLOCK) || 5511da177e4SLinus Torvalds scsi_block_when_processing_errors(sdp->device))) 5521da177e4SLinus Torvalds return -ENXIO; 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds if (!access_ok(VERIFY_READ, buf, count)) 5551da177e4SLinus Torvalds return -EFAULT; /* protects following copy_from_user()s + get_user()s */ 5561da177e4SLinus Torvalds if (count < SZ_SG_HEADER) 5571da177e4SLinus Torvalds return -EIO; 5581da177e4SLinus Torvalds if (__copy_from_user(&old_hdr, buf, SZ_SG_HEADER)) 5591da177e4SLinus Torvalds return -EFAULT; 5601da177e4SLinus Torvalds blocking = !(filp->f_flags & O_NONBLOCK); 5611da177e4SLinus Torvalds if (old_hdr.reply_len < 0) 562a2dd3b4cSTony Battersby return sg_new_write(sfp, filp, buf, count, 563a2dd3b4cSTony Battersby blocking, 0, 0, NULL); 5641da177e4SLinus Torvalds if (count < (SZ_SG_HEADER + 6)) 5651da177e4SLinus Torvalds return -EIO; /* The minimum scsi command length is 6 bytes. */ 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds if (!(srp = sg_add_request(sfp))) { 5681da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(1, printk("sg_write: queue full\n")); 5691da177e4SLinus Torvalds return -EDOM; 5701da177e4SLinus Torvalds } 5711da177e4SLinus Torvalds buf += SZ_SG_HEADER; 5721da177e4SLinus Torvalds __get_user(opcode, buf); 5731da177e4SLinus Torvalds if (sfp->next_cmd_len > 0) { 5741da177e4SLinus Torvalds if (sfp->next_cmd_len > MAX_COMMAND_SIZE) { 5751da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(1, printk("sg_write: command length too long\n")); 5761da177e4SLinus Torvalds sfp->next_cmd_len = 0; 5771da177e4SLinus Torvalds sg_remove_request(sfp, srp); 5781da177e4SLinus Torvalds return -EIO; 5791da177e4SLinus Torvalds } 5801da177e4SLinus Torvalds cmd_size = sfp->next_cmd_len; 5811da177e4SLinus Torvalds sfp->next_cmd_len = 0; /* reset so only this write() effected */ 5821da177e4SLinus Torvalds } else { 5831da177e4SLinus Torvalds cmd_size = COMMAND_SIZE(opcode); /* based on SCSI command group */ 5841da177e4SLinus Torvalds if ((opcode >= 0xc0) && old_hdr.twelve_byte) 5851da177e4SLinus Torvalds cmd_size = 12; 5861da177e4SLinus Torvalds } 5871da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(4, printk( 5881da177e4SLinus Torvalds "sg_write: scsi opcode=0x%02x, cmd_size=%d\n", (int) opcode, cmd_size)); 5891da177e4SLinus Torvalds /* Determine buffer size. */ 5901da177e4SLinus Torvalds input_size = count - cmd_size; 5911da177e4SLinus Torvalds mxsize = (input_size > old_hdr.reply_len) ? input_size : old_hdr.reply_len; 5921da177e4SLinus Torvalds mxsize -= SZ_SG_HEADER; 5931da177e4SLinus Torvalds input_size -= SZ_SG_HEADER; 5941da177e4SLinus Torvalds if (input_size < 0) { 5951da177e4SLinus Torvalds sg_remove_request(sfp, srp); 5961da177e4SLinus Torvalds return -EIO; /* User did not pass enough bytes for this command. */ 5971da177e4SLinus Torvalds } 5981da177e4SLinus Torvalds hp = &srp->header; 5991da177e4SLinus Torvalds hp->interface_id = '\0'; /* indicator of old interface tunnelled */ 6001da177e4SLinus Torvalds hp->cmd_len = (unsigned char) cmd_size; 6011da177e4SLinus Torvalds hp->iovec_count = 0; 6021da177e4SLinus Torvalds hp->mx_sb_len = 0; 6031da177e4SLinus Torvalds if (input_size > 0) 6041da177e4SLinus Torvalds hp->dxfer_direction = (old_hdr.reply_len > SZ_SG_HEADER) ? 6051da177e4SLinus Torvalds SG_DXFER_TO_FROM_DEV : SG_DXFER_TO_DEV; 6061da177e4SLinus Torvalds else 6071da177e4SLinus Torvalds hp->dxfer_direction = (mxsize > 0) ? SG_DXFER_FROM_DEV : SG_DXFER_NONE; 6081da177e4SLinus Torvalds hp->dxfer_len = mxsize; 609fad7f01eSFUJITA Tomonori if (hp->dxfer_direction == SG_DXFER_TO_DEV) 6101da177e4SLinus Torvalds hp->dxferp = (char __user *)buf + cmd_size; 611fad7f01eSFUJITA Tomonori else 612fad7f01eSFUJITA Tomonori hp->dxferp = NULL; 6131da177e4SLinus Torvalds hp->sbp = NULL; 6141da177e4SLinus Torvalds hp->timeout = old_hdr.reply_len; /* structure abuse ... */ 6151da177e4SLinus Torvalds hp->flags = input_size; /* structure abuse ... */ 6161da177e4SLinus Torvalds hp->pack_id = old_hdr.pack_id; 6171da177e4SLinus Torvalds hp->usr_ptr = NULL; 6181da177e4SLinus Torvalds if (__copy_from_user(cmnd, buf, cmd_size)) 6191da177e4SLinus Torvalds return -EFAULT; 6201da177e4SLinus Torvalds /* 6211da177e4SLinus Torvalds * SG_DXFER_TO_FROM_DEV is functionally equivalent to SG_DXFER_FROM_DEV, 6221da177e4SLinus Torvalds * but is is possible that the app intended SG_DXFER_TO_DEV, because there 6231da177e4SLinus Torvalds * is a non-zero input_size, so emit a warning. 6241da177e4SLinus Torvalds */ 625eaa3e22eSAndi Kleen if (hp->dxfer_direction == SG_DXFER_TO_FROM_DEV) { 626eaa3e22eSAndi Kleen static char cmd[TASK_COMM_LEN]; 627eaa3e22eSAndi Kleen if (strcmp(current->comm, cmd) && printk_ratelimit()) { 6281da177e4SLinus Torvalds printk(KERN_WARNING 6291da177e4SLinus Torvalds "sg_write: data in/out %d/%d bytes for SCSI command 0x%x--" 630ad361c98SJoe Perches "guessing data in;\n " 6311da177e4SLinus Torvalds "program %s not setting count and/or reply_len properly\n", 6321da177e4SLinus Torvalds old_hdr.reply_len - (int)SZ_SG_HEADER, 6331da177e4SLinus Torvalds input_size, (unsigned int) cmnd[0], 6341da177e4SLinus Torvalds current->comm); 635eaa3e22eSAndi Kleen strcpy(cmd, current->comm); 636eaa3e22eSAndi Kleen } 637eaa3e22eSAndi Kleen } 6381da177e4SLinus Torvalds k = sg_common_write(sfp, srp, cmnd, sfp->timeout, blocking); 6391da177e4SLinus Torvalds return (k < 0) ? k : count; 6401da177e4SLinus Torvalds } 6411da177e4SLinus Torvalds 6421da177e4SLinus Torvalds static ssize_t 6430b07de85SAdel Gadllah sg_new_write(Sg_fd *sfp, struct file *file, const char __user *buf, 644a2dd3b4cSTony Battersby size_t count, int blocking, int read_only, int sg_io_owned, 6450b07de85SAdel Gadllah Sg_request **o_srp) 6461da177e4SLinus Torvalds { 6471da177e4SLinus Torvalds int k; 6481da177e4SLinus Torvalds Sg_request *srp; 6491da177e4SLinus Torvalds sg_io_hdr_t *hp; 650d6b10348SMike Christie unsigned char cmnd[MAX_COMMAND_SIZE]; 6511da177e4SLinus Torvalds int timeout; 6521da177e4SLinus Torvalds unsigned long ul_timeout; 6531da177e4SLinus Torvalds 6541da177e4SLinus Torvalds if (count < SZ_SG_IO_HDR) 6551da177e4SLinus Torvalds return -EINVAL; 6561da177e4SLinus Torvalds if (!access_ok(VERIFY_READ, buf, count)) 6571da177e4SLinus Torvalds return -EFAULT; /* protects following copy_from_user()s + get_user()s */ 6581da177e4SLinus Torvalds 6591da177e4SLinus Torvalds sfp->cmd_q = 1; /* when sg_io_hdr seen, set command queuing on */ 6601da177e4SLinus Torvalds if (!(srp = sg_add_request(sfp))) { 6611da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(1, printk("sg_new_write: queue full\n")); 6621da177e4SLinus Torvalds return -EDOM; 6631da177e4SLinus Torvalds } 664a2dd3b4cSTony Battersby srp->sg_io_owned = sg_io_owned; 6651da177e4SLinus Torvalds hp = &srp->header; 6661da177e4SLinus Torvalds if (__copy_from_user(hp, buf, SZ_SG_IO_HDR)) { 6671da177e4SLinus Torvalds sg_remove_request(sfp, srp); 6681da177e4SLinus Torvalds return -EFAULT; 6691da177e4SLinus Torvalds } 6701da177e4SLinus Torvalds if (hp->interface_id != 'S') { 6711da177e4SLinus Torvalds sg_remove_request(sfp, srp); 6721da177e4SLinus Torvalds return -ENOSYS; 6731da177e4SLinus Torvalds } 6741da177e4SLinus Torvalds if (hp->flags & SG_FLAG_MMAP_IO) { 6751da177e4SLinus Torvalds if (hp->dxfer_len > sfp->reserve.bufflen) { 6761da177e4SLinus Torvalds sg_remove_request(sfp, srp); 6771da177e4SLinus Torvalds return -ENOMEM; /* MMAP_IO size must fit in reserve buffer */ 6781da177e4SLinus Torvalds } 6791da177e4SLinus Torvalds if (hp->flags & SG_FLAG_DIRECT_IO) { 6801da177e4SLinus Torvalds sg_remove_request(sfp, srp); 6811da177e4SLinus Torvalds return -EINVAL; /* either MMAP_IO or DIRECT_IO (not both) */ 6821da177e4SLinus Torvalds } 6831da177e4SLinus Torvalds if (sg_res_in_use(sfp)) { 6841da177e4SLinus Torvalds sg_remove_request(sfp, srp); 6851da177e4SLinus Torvalds return -EBUSY; /* reserve buffer already being used */ 6861da177e4SLinus Torvalds } 6871da177e4SLinus Torvalds } 6881da177e4SLinus Torvalds ul_timeout = msecs_to_jiffies(srp->header.timeout); 6891da177e4SLinus Torvalds timeout = (ul_timeout < INT_MAX) ? ul_timeout : INT_MAX; 6901da177e4SLinus Torvalds if ((!hp->cmdp) || (hp->cmd_len < 6) || (hp->cmd_len > sizeof (cmnd))) { 6911da177e4SLinus Torvalds sg_remove_request(sfp, srp); 6921da177e4SLinus Torvalds return -EMSGSIZE; 6931da177e4SLinus Torvalds } 6941da177e4SLinus Torvalds if (!access_ok(VERIFY_READ, hp->cmdp, hp->cmd_len)) { 6951da177e4SLinus Torvalds sg_remove_request(sfp, srp); 6961da177e4SLinus Torvalds return -EFAULT; /* protects following copy_from_user()s + get_user()s */ 6971da177e4SLinus Torvalds } 6981da177e4SLinus Torvalds if (__copy_from_user(cmnd, hp->cmdp, hp->cmd_len)) { 6991da177e4SLinus Torvalds sg_remove_request(sfp, srp); 7001da177e4SLinus Torvalds return -EFAULT; 7011da177e4SLinus Torvalds } 70214e507b8SFUJITA Tomonori if (read_only && sg_allow_access(file, cmnd)) { 7031da177e4SLinus Torvalds sg_remove_request(sfp, srp); 7041da177e4SLinus Torvalds return -EPERM; 7051da177e4SLinus Torvalds } 7061da177e4SLinus Torvalds k = sg_common_write(sfp, srp, cmnd, timeout, blocking); 7071da177e4SLinus Torvalds if (k < 0) 7081da177e4SLinus Torvalds return k; 7091da177e4SLinus Torvalds if (o_srp) 7101da177e4SLinus Torvalds *o_srp = srp; 7111da177e4SLinus Torvalds return count; 7121da177e4SLinus Torvalds } 7131da177e4SLinus Torvalds 7141da177e4SLinus Torvalds static int 7151da177e4SLinus Torvalds sg_common_write(Sg_fd * sfp, Sg_request * srp, 7161da177e4SLinus Torvalds unsigned char *cmnd, int timeout, int blocking) 7171da177e4SLinus Torvalds { 718d6b10348SMike Christie int k, data_dir; 7191da177e4SLinus Torvalds Sg_device *sdp = sfp->parentdp; 7201da177e4SLinus Torvalds sg_io_hdr_t *hp = &srp->header; 7211da177e4SLinus Torvalds 7221da177e4SLinus Torvalds srp->data.cmd_opcode = cmnd[0]; /* hold opcode of command */ 7231da177e4SLinus Torvalds hp->status = 0; 7241da177e4SLinus Torvalds hp->masked_status = 0; 7251da177e4SLinus Torvalds hp->msg_status = 0; 7261da177e4SLinus Torvalds hp->info = 0; 7271da177e4SLinus Torvalds hp->host_status = 0; 7281da177e4SLinus Torvalds hp->driver_status = 0; 7291da177e4SLinus Torvalds hp->resid = 0; 7301da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(4, printk("sg_common_write: scsi opcode=0x%02x, cmd_size=%d\n", 7311da177e4SLinus Torvalds (int) cmnd[0], (int) hp->cmd_len)); 7321da177e4SLinus Torvalds 73310865dfaSFUJITA Tomonori k = sg_start_req(srp, cmnd); 73410865dfaSFUJITA Tomonori if (k) { 7357ca63cb4SDouglas Gilbert SCSI_LOG_TIMEOUT(1, printk("sg_common_write: start_req err=%d\n", k)); 7361da177e4SLinus Torvalds sg_finish_rem_req(srp); 7371da177e4SLinus Torvalds return k; /* probably out of space --> ENOMEM */ 7381da177e4SLinus Torvalds } 7391da177e4SLinus Torvalds if (sdp->detached) { 740caf19d38SFUJITA Tomonori if (srp->bio) 741caf19d38SFUJITA Tomonori blk_end_request_all(srp->rq, -EIO); 7421da177e4SLinus Torvalds sg_finish_rem_req(srp); 7431da177e4SLinus Torvalds return -ENODEV; 7441da177e4SLinus Torvalds } 7451da177e4SLinus Torvalds 7461da177e4SLinus Torvalds switch (hp->dxfer_direction) { 7471da177e4SLinus Torvalds case SG_DXFER_TO_FROM_DEV: 7481da177e4SLinus Torvalds case SG_DXFER_FROM_DEV: 749d6b10348SMike Christie data_dir = DMA_FROM_DEVICE; 7501da177e4SLinus Torvalds break; 7511da177e4SLinus Torvalds case SG_DXFER_TO_DEV: 752d6b10348SMike Christie data_dir = DMA_TO_DEVICE; 7531da177e4SLinus Torvalds break; 7541da177e4SLinus Torvalds case SG_DXFER_UNKNOWN: 755d6b10348SMike Christie data_dir = DMA_BIDIRECTIONAL; 7561da177e4SLinus Torvalds break; 7571da177e4SLinus Torvalds default: 758d6b10348SMike Christie data_dir = DMA_NONE; 7591da177e4SLinus Torvalds break; 7601da177e4SLinus Torvalds } 761cb59e840S hp->duration = jiffies_to_msecs(jiffies); 76210db10d1SFUJITA Tomonori 76310865dfaSFUJITA Tomonori srp->rq->timeout = timeout; 764c6517b79STony Battersby kref_get(&sfp->f_ref); /* sg_rq_end_io() does kref_put(). */ 76510865dfaSFUJITA Tomonori blk_execute_rq_nowait(sdp->device->request_queue, sdp->disk, 76610865dfaSFUJITA Tomonori srp->rq, 1, sg_rq_end_io); 76710865dfaSFUJITA Tomonori return 0; 76810865dfaSFUJITA Tomonori } 7691da177e4SLinus Torvalds 7701da177e4SLinus Torvalds static int 771f4927c45SArnd Bergmann sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg) 7721da177e4SLinus Torvalds { 7731da177e4SLinus Torvalds void __user *p = (void __user *)arg; 7741da177e4SLinus Torvalds int __user *ip = p; 7751da177e4SLinus Torvalds int result, val, read_only; 7761da177e4SLinus Torvalds Sg_device *sdp; 7771da177e4SLinus Torvalds Sg_fd *sfp; 7781da177e4SLinus Torvalds Sg_request *srp; 7791da177e4SLinus Torvalds unsigned long iflags; 7801da177e4SLinus Torvalds 7811da177e4SLinus Torvalds if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp))) 7821da177e4SLinus Torvalds return -ENXIO; 783abf54393SFUJITA Tomonori 7841da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(3, printk("sg_ioctl: %s, cmd=0x%x\n", 7851da177e4SLinus Torvalds sdp->disk->disk_name, (int) cmd_in)); 7861da177e4SLinus Torvalds read_only = (O_RDWR != (filp->f_flags & O_ACCMODE)); 7871da177e4SLinus Torvalds 7881da177e4SLinus Torvalds switch (cmd_in) { 7891da177e4SLinus Torvalds case SG_IO: 7901da177e4SLinus Torvalds { 7911da177e4SLinus Torvalds int blocking = 1; /* ignore O_NONBLOCK flag */ 7921da177e4SLinus Torvalds 7931da177e4SLinus Torvalds if (sdp->detached) 7941da177e4SLinus Torvalds return -ENODEV; 7951da177e4SLinus Torvalds if (!scsi_block_when_processing_errors(sdp->device)) 7961da177e4SLinus Torvalds return -ENXIO; 7971da177e4SLinus Torvalds if (!access_ok(VERIFY_WRITE, p, SZ_SG_IO_HDR)) 7981da177e4SLinus Torvalds return -EFAULT; 7991da177e4SLinus Torvalds result = 8000b07de85SAdel Gadllah sg_new_write(sfp, filp, p, SZ_SG_IO_HDR, 801a2dd3b4cSTony Battersby blocking, read_only, 1, &srp); 8021da177e4SLinus Torvalds if (result < 0) 8031da177e4SLinus Torvalds return result; 8041da177e4SLinus Torvalds while (1) { 8051da177e4SLinus Torvalds result = 0; /* following macro to beat race condition */ 8061da177e4SLinus Torvalds __wait_event_interruptible(sfp->read_wait, 807a2dd3b4cSTony Battersby (srp->done || sdp->detached), 8081da177e4SLinus Torvalds result); 8091da177e4SLinus Torvalds if (sdp->detached) 8101da177e4SLinus Torvalds return -ENODEV; 811a2dd3b4cSTony Battersby write_lock_irq(&sfp->rq_list_lock); 812a2dd3b4cSTony Battersby if (srp->done) { 813a2dd3b4cSTony Battersby srp->done = 2; 814a2dd3b4cSTony Battersby write_unlock_irq(&sfp->rq_list_lock); 8151da177e4SLinus Torvalds break; 816a2dd3b4cSTony Battersby } 8171da177e4SLinus Torvalds srp->orphan = 1; 818a2dd3b4cSTony Battersby write_unlock_irq(&sfp->rq_list_lock); 8191da177e4SLinus Torvalds return result; /* -ERESTARTSYS because signal hit process */ 8201da177e4SLinus Torvalds } 8211da177e4SLinus Torvalds result = sg_new_read(sfp, p, SZ_SG_IO_HDR, srp); 8221da177e4SLinus Torvalds return (result < 0) ? result : 0; 8231da177e4SLinus Torvalds } 8241da177e4SLinus Torvalds case SG_SET_TIMEOUT: 8251da177e4SLinus Torvalds result = get_user(val, ip); 8261da177e4SLinus Torvalds if (result) 8271da177e4SLinus Torvalds return result; 8281da177e4SLinus Torvalds if (val < 0) 8291da177e4SLinus Torvalds return -EIO; 8301da177e4SLinus Torvalds if (val >= MULDIV (INT_MAX, USER_HZ, HZ)) 8311da177e4SLinus Torvalds val = MULDIV (INT_MAX, USER_HZ, HZ); 8321da177e4SLinus Torvalds sfp->timeout_user = val; 8331da177e4SLinus Torvalds sfp->timeout = MULDIV (val, HZ, USER_HZ); 8341da177e4SLinus Torvalds 8351da177e4SLinus Torvalds return 0; 8361da177e4SLinus Torvalds case SG_GET_TIMEOUT: /* N.B. User receives timeout as return value */ 8371da177e4SLinus Torvalds /* strange ..., for backward compatibility */ 8381da177e4SLinus Torvalds return sfp->timeout_user; 8391da177e4SLinus Torvalds case SG_SET_FORCE_LOW_DMA: 8401da177e4SLinus Torvalds result = get_user(val, ip); 8411da177e4SLinus Torvalds if (result) 8421da177e4SLinus Torvalds return result; 8431da177e4SLinus Torvalds if (val) { 8441da177e4SLinus Torvalds sfp->low_dma = 1; 8451da177e4SLinus Torvalds if ((0 == sfp->low_dma) && (0 == sg_res_in_use(sfp))) { 8461da177e4SLinus Torvalds val = (int) sfp->reserve.bufflen; 8471da177e4SLinus Torvalds sg_remove_scat(&sfp->reserve); 8481da177e4SLinus Torvalds sg_build_reserve(sfp, val); 8491da177e4SLinus Torvalds } 8501da177e4SLinus Torvalds } else { 8511da177e4SLinus Torvalds if (sdp->detached) 8521da177e4SLinus Torvalds return -ENODEV; 8531da177e4SLinus Torvalds sfp->low_dma = sdp->device->host->unchecked_isa_dma; 8541da177e4SLinus Torvalds } 8551da177e4SLinus Torvalds return 0; 8561da177e4SLinus Torvalds case SG_GET_LOW_DMA: 8571da177e4SLinus Torvalds return put_user((int) sfp->low_dma, ip); 8581da177e4SLinus Torvalds case SG_GET_SCSI_ID: 8591da177e4SLinus Torvalds if (!access_ok(VERIFY_WRITE, p, sizeof (sg_scsi_id_t))) 8601da177e4SLinus Torvalds return -EFAULT; 8611da177e4SLinus Torvalds else { 8621da177e4SLinus Torvalds sg_scsi_id_t __user *sg_idp = p; 8631da177e4SLinus Torvalds 8641da177e4SLinus Torvalds if (sdp->detached) 8651da177e4SLinus Torvalds return -ENODEV; 8661da177e4SLinus Torvalds __put_user((int) sdp->device->host->host_no, 8671da177e4SLinus Torvalds &sg_idp->host_no); 8681da177e4SLinus Torvalds __put_user((int) sdp->device->channel, 8691da177e4SLinus Torvalds &sg_idp->channel); 8701da177e4SLinus Torvalds __put_user((int) sdp->device->id, &sg_idp->scsi_id); 8711da177e4SLinus Torvalds __put_user((int) sdp->device->lun, &sg_idp->lun); 8721da177e4SLinus Torvalds __put_user((int) sdp->device->type, &sg_idp->scsi_type); 8731da177e4SLinus Torvalds __put_user((short) sdp->device->host->cmd_per_lun, 8741da177e4SLinus Torvalds &sg_idp->h_cmd_per_lun); 8751da177e4SLinus Torvalds __put_user((short) sdp->device->queue_depth, 8761da177e4SLinus Torvalds &sg_idp->d_queue_depth); 8771da177e4SLinus Torvalds __put_user(0, &sg_idp->unused[0]); 8781da177e4SLinus Torvalds __put_user(0, &sg_idp->unused[1]); 8791da177e4SLinus Torvalds return 0; 8801da177e4SLinus Torvalds } 8811da177e4SLinus Torvalds case SG_SET_FORCE_PACK_ID: 8821da177e4SLinus Torvalds result = get_user(val, ip); 8831da177e4SLinus Torvalds if (result) 8841da177e4SLinus Torvalds return result; 8851da177e4SLinus Torvalds sfp->force_packid = val ? 1 : 0; 8861da177e4SLinus Torvalds return 0; 8871da177e4SLinus Torvalds case SG_GET_PACK_ID: 8881da177e4SLinus Torvalds if (!access_ok(VERIFY_WRITE, ip, sizeof (int))) 8891da177e4SLinus Torvalds return -EFAULT; 8901da177e4SLinus Torvalds read_lock_irqsave(&sfp->rq_list_lock, iflags); 8911da177e4SLinus Torvalds for (srp = sfp->headrp; srp; srp = srp->nextrp) { 8921da177e4SLinus Torvalds if ((1 == srp->done) && (!srp->sg_io_owned)) { 8931da177e4SLinus Torvalds read_unlock_irqrestore(&sfp->rq_list_lock, 8941da177e4SLinus Torvalds iflags); 8951da177e4SLinus Torvalds __put_user(srp->header.pack_id, ip); 8961da177e4SLinus Torvalds return 0; 8971da177e4SLinus Torvalds } 8981da177e4SLinus Torvalds } 8991da177e4SLinus Torvalds read_unlock_irqrestore(&sfp->rq_list_lock, iflags); 9001da177e4SLinus Torvalds __put_user(-1, ip); 9011da177e4SLinus Torvalds return 0; 9021da177e4SLinus Torvalds case SG_GET_NUM_WAITING: 9031da177e4SLinus Torvalds read_lock_irqsave(&sfp->rq_list_lock, iflags); 9041da177e4SLinus Torvalds for (val = 0, srp = sfp->headrp; srp; srp = srp->nextrp) { 9051da177e4SLinus Torvalds if ((1 == srp->done) && (!srp->sg_io_owned)) 9061da177e4SLinus Torvalds ++val; 9071da177e4SLinus Torvalds } 9081da177e4SLinus Torvalds read_unlock_irqrestore(&sfp->rq_list_lock, iflags); 9091da177e4SLinus Torvalds return put_user(val, ip); 9101da177e4SLinus Torvalds case SG_GET_SG_TABLESIZE: 9111da177e4SLinus Torvalds return put_user(sdp->sg_tablesize, ip); 9121da177e4SLinus Torvalds case SG_SET_RESERVED_SIZE: 9131da177e4SLinus Torvalds result = get_user(val, ip); 9141da177e4SLinus Torvalds if (result) 9151da177e4SLinus Torvalds return result; 9161da177e4SLinus Torvalds if (val < 0) 9171da177e4SLinus Torvalds return -EINVAL; 91844ec9542SAlan Stern val = min_t(int, val, 919ae03bf63SMartin K. Petersen queue_max_sectors(sdp->device->request_queue) * 512); 9201da177e4SLinus Torvalds if (val != sfp->reserve.bufflen) { 9211da177e4SLinus Torvalds if (sg_res_in_use(sfp) || sfp->mmap_called) 9221da177e4SLinus Torvalds return -EBUSY; 9231da177e4SLinus Torvalds sg_remove_scat(&sfp->reserve); 9241da177e4SLinus Torvalds sg_build_reserve(sfp, val); 9251da177e4SLinus Torvalds } 9261da177e4SLinus Torvalds return 0; 9271da177e4SLinus Torvalds case SG_GET_RESERVED_SIZE: 92844ec9542SAlan Stern val = min_t(int, sfp->reserve.bufflen, 929ae03bf63SMartin K. Petersen queue_max_sectors(sdp->device->request_queue) * 512); 9301da177e4SLinus Torvalds return put_user(val, ip); 9311da177e4SLinus Torvalds case SG_SET_COMMAND_Q: 9321da177e4SLinus Torvalds result = get_user(val, ip); 9331da177e4SLinus Torvalds if (result) 9341da177e4SLinus Torvalds return result; 9351da177e4SLinus Torvalds sfp->cmd_q = val ? 1 : 0; 9361da177e4SLinus Torvalds return 0; 9371da177e4SLinus Torvalds case SG_GET_COMMAND_Q: 9381da177e4SLinus Torvalds return put_user((int) sfp->cmd_q, ip); 9391da177e4SLinus Torvalds case SG_SET_KEEP_ORPHAN: 9401da177e4SLinus Torvalds result = get_user(val, ip); 9411da177e4SLinus Torvalds if (result) 9421da177e4SLinus Torvalds return result; 9431da177e4SLinus Torvalds sfp->keep_orphan = val; 9441da177e4SLinus Torvalds return 0; 9451da177e4SLinus Torvalds case SG_GET_KEEP_ORPHAN: 9461da177e4SLinus Torvalds return put_user((int) sfp->keep_orphan, ip); 9471da177e4SLinus Torvalds case SG_NEXT_CMD_LEN: 9481da177e4SLinus Torvalds result = get_user(val, ip); 9491da177e4SLinus Torvalds if (result) 9501da177e4SLinus Torvalds return result; 9511da177e4SLinus Torvalds sfp->next_cmd_len = (val > 0) ? val : 0; 9521da177e4SLinus Torvalds return 0; 9531da177e4SLinus Torvalds case SG_GET_VERSION_NUM: 9541da177e4SLinus Torvalds return put_user(sg_version_num, ip); 9551da177e4SLinus Torvalds case SG_GET_ACCESS_COUNT: 9561da177e4SLinus Torvalds /* faked - we don't have a real access count anymore */ 9571da177e4SLinus Torvalds val = (sdp->device ? 1 : 0); 9581da177e4SLinus Torvalds return put_user(val, ip); 9591da177e4SLinus Torvalds case SG_GET_REQUEST_TABLE: 9601da177e4SLinus Torvalds if (!access_ok(VERIFY_WRITE, p, SZ_SG_REQ_INFO * SG_MAX_QUEUE)) 9611da177e4SLinus Torvalds return -EFAULT; 9621da177e4SLinus Torvalds else { 963cb59e840S sg_req_info_t *rinfo; 964cb59e840S unsigned int ms; 965cb59e840S 966cb59e840S rinfo = kmalloc(SZ_SG_REQ_INFO * SG_MAX_QUEUE, 967cb59e840S GFP_KERNEL); 968cb59e840S if (!rinfo) 969cb59e840S return -ENOMEM; 9701da177e4SLinus Torvalds read_lock_irqsave(&sfp->rq_list_lock, iflags); 9711da177e4SLinus Torvalds for (srp = sfp->headrp, val = 0; val < SG_MAX_QUEUE; 9721da177e4SLinus Torvalds ++val, srp = srp ? srp->nextrp : srp) { 9731da177e4SLinus Torvalds memset(&rinfo[val], 0, SZ_SG_REQ_INFO); 9741da177e4SLinus Torvalds if (srp) { 9751da177e4SLinus Torvalds rinfo[val].req_state = srp->done + 1; 9761da177e4SLinus Torvalds rinfo[val].problem = 9771da177e4SLinus Torvalds srp->header.masked_status & 9781da177e4SLinus Torvalds srp->header.host_status & 9791da177e4SLinus Torvalds srp->header.driver_status; 980cb59e840S if (srp->done) 9811da177e4SLinus Torvalds rinfo[val].duration = 982cb59e840S srp->header.duration; 983cb59e840S else { 984cb59e840S ms = jiffies_to_msecs(jiffies); 985cb59e840S rinfo[val].duration = 986cb59e840S (ms > srp->header.duration) ? 987cb59e840S (ms - srp->header.duration) : 0; 988cb59e840S } 9891da177e4SLinus Torvalds rinfo[val].orphan = srp->orphan; 990cb59e840S rinfo[val].sg_io_owned = 991cb59e840S srp->sg_io_owned; 992cb59e840S rinfo[val].pack_id = 993cb59e840S srp->header.pack_id; 994cb59e840S rinfo[val].usr_ptr = 995cb59e840S srp->header.usr_ptr; 9961da177e4SLinus Torvalds } 9971da177e4SLinus Torvalds } 9981da177e4SLinus Torvalds read_unlock_irqrestore(&sfp->rq_list_lock, iflags); 999cb59e840S result = __copy_to_user(p, rinfo, 1000cb59e840S SZ_SG_REQ_INFO * SG_MAX_QUEUE); 1001cb59e840S result = result ? -EFAULT : 0; 1002cb59e840S kfree(rinfo); 1003cb59e840S return result; 10041da177e4SLinus Torvalds } 10051da177e4SLinus Torvalds case SG_EMULATED_HOST: 10061da177e4SLinus Torvalds if (sdp->detached) 10071da177e4SLinus Torvalds return -ENODEV; 10081da177e4SLinus Torvalds return put_user(sdp->device->host->hostt->emulated, ip); 10091da177e4SLinus Torvalds case SG_SCSI_RESET: 10101da177e4SLinus Torvalds if (sdp->detached) 10111da177e4SLinus Torvalds return -ENODEV; 10121da177e4SLinus Torvalds if (filp->f_flags & O_NONBLOCK) { 1013939647eeSJames Bottomley if (scsi_host_in_recovery(sdp->device->host)) 10141da177e4SLinus Torvalds return -EBUSY; 10151da177e4SLinus Torvalds } else if (!scsi_block_when_processing_errors(sdp->device)) 10161da177e4SLinus Torvalds return -EBUSY; 10171da177e4SLinus Torvalds result = get_user(val, ip); 10181da177e4SLinus Torvalds if (result) 10191da177e4SLinus Torvalds return result; 10201da177e4SLinus Torvalds if (SG_SCSI_RESET_NOTHING == val) 10211da177e4SLinus Torvalds return 0; 10221da177e4SLinus Torvalds switch (val) { 10231da177e4SLinus Torvalds case SG_SCSI_RESET_DEVICE: 10241da177e4SLinus Torvalds val = SCSI_TRY_RESET_DEVICE; 10251da177e4SLinus Torvalds break; 102639120e11SBrian King case SG_SCSI_RESET_TARGET: 102739120e11SBrian King val = SCSI_TRY_RESET_TARGET; 102839120e11SBrian King break; 10291da177e4SLinus Torvalds case SG_SCSI_RESET_BUS: 10301da177e4SLinus Torvalds val = SCSI_TRY_RESET_BUS; 10311da177e4SLinus Torvalds break; 10321da177e4SLinus Torvalds case SG_SCSI_RESET_HOST: 10331da177e4SLinus Torvalds val = SCSI_TRY_RESET_HOST; 10341da177e4SLinus Torvalds break; 10351da177e4SLinus Torvalds default: 10361da177e4SLinus Torvalds return -EINVAL; 10371da177e4SLinus Torvalds } 10381da177e4SLinus Torvalds if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO)) 10391da177e4SLinus Torvalds return -EACCES; 10401da177e4SLinus Torvalds return (scsi_reset_provider(sdp->device, val) == 10411da177e4SLinus Torvalds SUCCESS) ? 0 : -EIO; 10421da177e4SLinus Torvalds case SCSI_IOCTL_SEND_COMMAND: 10431da177e4SLinus Torvalds if (sdp->detached) 10441da177e4SLinus Torvalds return -ENODEV; 10451da177e4SLinus Torvalds if (read_only) { 10461da177e4SLinus Torvalds unsigned char opcode = WRITE_6; 10471da177e4SLinus Torvalds Scsi_Ioctl_Command __user *siocp = p; 10481da177e4SLinus Torvalds 10491da177e4SLinus Torvalds if (copy_from_user(&opcode, siocp->data, 1)) 10501da177e4SLinus Torvalds return -EFAULT; 105114e507b8SFUJITA Tomonori if (sg_allow_access(filp, &opcode)) 10521da177e4SLinus Torvalds return -EPERM; 10531da177e4SLinus Torvalds } 1054e915e872SAl Viro return sg_scsi_ioctl(sdp->device->request_queue, NULL, filp->f_mode, p); 10551da177e4SLinus Torvalds case SG_SET_DEBUG: 10561da177e4SLinus Torvalds result = get_user(val, ip); 10571da177e4SLinus Torvalds if (result) 10581da177e4SLinus Torvalds return result; 10591da177e4SLinus Torvalds sdp->sgdebug = (char) val; 10601da177e4SLinus Torvalds return 0; 10611da177e4SLinus Torvalds case SCSI_IOCTL_GET_IDLUN: 10621da177e4SLinus Torvalds case SCSI_IOCTL_GET_BUS_NUMBER: 10631da177e4SLinus Torvalds case SCSI_IOCTL_PROBE_HOST: 10641da177e4SLinus Torvalds case SG_GET_TRANSFORM: 10651da177e4SLinus Torvalds if (sdp->detached) 10661da177e4SLinus Torvalds return -ENODEV; 10671da177e4SLinus Torvalds return scsi_ioctl(sdp->device, cmd_in, p); 106844ec9542SAlan Stern case BLKSECTGET: 1069ae03bf63SMartin K. Petersen return put_user(queue_max_sectors(sdp->device->request_queue) * 512, 107044ec9542SAlan Stern ip); 10716da127adSChristof Schmitt case BLKTRACESETUP: 10726da127adSChristof Schmitt return blk_trace_setup(sdp->device->request_queue, 10736da127adSChristof Schmitt sdp->disk->disk_name, 107476e3a19dSMartin Peschke MKDEV(SCSI_GENERIC_MAJOR, sdp->index), 1075d0deef5bSShawn Du NULL, 10766da127adSChristof Schmitt (char *)arg); 10776da127adSChristof Schmitt case BLKTRACESTART: 10786da127adSChristof Schmitt return blk_trace_startstop(sdp->device->request_queue, 1); 10796da127adSChristof Schmitt case BLKTRACESTOP: 10806da127adSChristof Schmitt return blk_trace_startstop(sdp->device->request_queue, 0); 10816da127adSChristof Schmitt case BLKTRACETEARDOWN: 10826da127adSChristof Schmitt return blk_trace_remove(sdp->device->request_queue); 10831da177e4SLinus Torvalds default: 10841da177e4SLinus Torvalds if (read_only) 10851da177e4SLinus Torvalds return -EPERM; /* don't know so take safe approach */ 10861da177e4SLinus Torvalds return scsi_ioctl(sdp->device, cmd_in, p); 10871da177e4SLinus Torvalds } 10881da177e4SLinus Torvalds } 10891da177e4SLinus Torvalds 1090f4927c45SArnd Bergmann static long 1091f4927c45SArnd Bergmann sg_unlocked_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg) 1092f4927c45SArnd Bergmann { 1093f4927c45SArnd Bergmann int ret; 1094f4927c45SArnd Bergmann 1095f4927c45SArnd Bergmann lock_kernel(); 1096f4927c45SArnd Bergmann ret = sg_ioctl(filp, cmd_in, arg); 1097f4927c45SArnd Bergmann unlock_kernel(); 1098f4927c45SArnd Bergmann 1099f4927c45SArnd Bergmann return ret; 1100f4927c45SArnd Bergmann } 1101f4927c45SArnd Bergmann 11021da177e4SLinus Torvalds #ifdef CONFIG_COMPAT 11031da177e4SLinus Torvalds static long sg_compat_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg) 11041da177e4SLinus Torvalds { 11051da177e4SLinus Torvalds Sg_device *sdp; 11061da177e4SLinus Torvalds Sg_fd *sfp; 11071da177e4SLinus Torvalds struct scsi_device *sdev; 11081da177e4SLinus Torvalds 11091da177e4SLinus Torvalds if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp))) 11101da177e4SLinus Torvalds return -ENXIO; 11111da177e4SLinus Torvalds 11121da177e4SLinus Torvalds sdev = sdp->device; 11131da177e4SLinus Torvalds if (sdev->host->hostt->compat_ioctl) { 11141da177e4SLinus Torvalds int ret; 11151da177e4SLinus Torvalds 11161da177e4SLinus Torvalds ret = sdev->host->hostt->compat_ioctl(sdev, cmd_in, (void __user *)arg); 11171da177e4SLinus Torvalds 11181da177e4SLinus Torvalds return ret; 11191da177e4SLinus Torvalds } 11201da177e4SLinus Torvalds 11211da177e4SLinus Torvalds return -ENOIOCTLCMD; 11221da177e4SLinus Torvalds } 11231da177e4SLinus Torvalds #endif 11241da177e4SLinus Torvalds 11251da177e4SLinus Torvalds static unsigned int 11261da177e4SLinus Torvalds sg_poll(struct file *filp, poll_table * wait) 11271da177e4SLinus Torvalds { 11281da177e4SLinus Torvalds unsigned int res = 0; 11291da177e4SLinus Torvalds Sg_device *sdp; 11301da177e4SLinus Torvalds Sg_fd *sfp; 11311da177e4SLinus Torvalds Sg_request *srp; 11321da177e4SLinus Torvalds int count = 0; 11331da177e4SLinus Torvalds unsigned long iflags; 11341da177e4SLinus Torvalds 11351da177e4SLinus Torvalds if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)) 11361da177e4SLinus Torvalds || sfp->closed) 11371da177e4SLinus Torvalds return POLLERR; 11381da177e4SLinus Torvalds poll_wait(filp, &sfp->read_wait, wait); 11391da177e4SLinus Torvalds read_lock_irqsave(&sfp->rq_list_lock, iflags); 11401da177e4SLinus Torvalds for (srp = sfp->headrp; srp; srp = srp->nextrp) { 11411da177e4SLinus Torvalds /* if any read waiting, flag it */ 11421da177e4SLinus Torvalds if ((0 == res) && (1 == srp->done) && (!srp->sg_io_owned)) 11431da177e4SLinus Torvalds res = POLLIN | POLLRDNORM; 11441da177e4SLinus Torvalds ++count; 11451da177e4SLinus Torvalds } 11461da177e4SLinus Torvalds read_unlock_irqrestore(&sfp->rq_list_lock, iflags); 11471da177e4SLinus Torvalds 11481da177e4SLinus Torvalds if (sdp->detached) 11491da177e4SLinus Torvalds res |= POLLHUP; 11501da177e4SLinus Torvalds else if (!sfp->cmd_q) { 11511da177e4SLinus Torvalds if (0 == count) 11521da177e4SLinus Torvalds res |= POLLOUT | POLLWRNORM; 11531da177e4SLinus Torvalds } else if (count < SG_MAX_QUEUE) 11541da177e4SLinus Torvalds res |= POLLOUT | POLLWRNORM; 11551da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(3, printk("sg_poll: %s, res=0x%x\n", 11561da177e4SLinus Torvalds sdp->disk->disk_name, (int) res)); 11571da177e4SLinus Torvalds return res; 11581da177e4SLinus Torvalds } 11591da177e4SLinus Torvalds 11601da177e4SLinus Torvalds static int 11611da177e4SLinus Torvalds sg_fasync(int fd, struct file *filp, int mode) 11621da177e4SLinus Torvalds { 11631da177e4SLinus Torvalds Sg_device *sdp; 11641da177e4SLinus Torvalds Sg_fd *sfp; 11651da177e4SLinus Torvalds 11661da177e4SLinus Torvalds if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp))) 11671da177e4SLinus Torvalds return -ENXIO; 11681da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(3, printk("sg_fasync: %s, mode=%d\n", 11691da177e4SLinus Torvalds sdp->disk->disk_name, mode)); 11701da177e4SLinus Torvalds 117160aa4924SJonathan Corbet return fasync_helper(fd, filp, mode, &sfp->async_qp); 11721da177e4SLinus Torvalds } 11731da177e4SLinus Torvalds 1174a13ff0bbSNick Piggin static int 1175a13ff0bbSNick Piggin sg_vma_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 11761da177e4SLinus Torvalds { 11771da177e4SLinus Torvalds Sg_fd *sfp; 1178d6b10348SMike Christie unsigned long offset, len, sa; 11791da177e4SLinus Torvalds Sg_scatter_hold *rsv_schp; 118010db10d1SFUJITA Tomonori int k, length; 11811da177e4SLinus Torvalds 11821da177e4SLinus Torvalds if ((NULL == vma) || (!(sfp = (Sg_fd *) vma->vm_private_data))) 1183a13ff0bbSNick Piggin return VM_FAULT_SIGBUS; 11841da177e4SLinus Torvalds rsv_schp = &sfp->reserve; 1185a13ff0bbSNick Piggin offset = vmf->pgoff << PAGE_SHIFT; 11861da177e4SLinus Torvalds if (offset >= rsv_schp->bufflen) 1187a13ff0bbSNick Piggin return VM_FAULT_SIGBUS; 1188a13ff0bbSNick Piggin SCSI_LOG_TIMEOUT(3, printk("sg_vma_fault: offset=%lu, scatg=%d\n", 11891da177e4SLinus Torvalds offset, rsv_schp->k_use_sg)); 1190d6b10348SMike Christie sa = vma->vm_start; 119110db10d1SFUJITA Tomonori length = 1 << (PAGE_SHIFT + rsv_schp->page_order); 119210db10d1SFUJITA Tomonori for (k = 0; k < rsv_schp->k_use_sg && sa < vma->vm_end; k++) { 11931da177e4SLinus Torvalds len = vma->vm_end - sa; 119410db10d1SFUJITA Tomonori len = (len < length) ? len : length; 11951da177e4SLinus Torvalds if (offset < len) { 119610db10d1SFUJITA Tomonori struct page *page = nth_page(rsv_schp->pages[k], 119710db10d1SFUJITA Tomonori offset >> PAGE_SHIFT); 11981da177e4SLinus Torvalds get_page(page); /* increment page count */ 1199a13ff0bbSNick Piggin vmf->page = page; 1200a13ff0bbSNick Piggin return 0; /* success */ 12011da177e4SLinus Torvalds } 12021da177e4SLinus Torvalds sa += len; 12031da177e4SLinus Torvalds offset -= len; 12041da177e4SLinus Torvalds } 1205d6b10348SMike Christie 1206a13ff0bbSNick Piggin return VM_FAULT_SIGBUS; 12071da177e4SLinus Torvalds } 12081da177e4SLinus Torvalds 1209f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct sg_mmap_vm_ops = { 1210a13ff0bbSNick Piggin .fault = sg_vma_fault, 12111da177e4SLinus Torvalds }; 12121da177e4SLinus Torvalds 12131da177e4SLinus Torvalds static int 12141da177e4SLinus Torvalds sg_mmap(struct file *filp, struct vm_area_struct *vma) 12151da177e4SLinus Torvalds { 12161da177e4SLinus Torvalds Sg_fd *sfp; 1217d6b10348SMike Christie unsigned long req_sz, len, sa; 12181da177e4SLinus Torvalds Sg_scatter_hold *rsv_schp; 121910db10d1SFUJITA Tomonori int k, length; 12201da177e4SLinus Torvalds 12211da177e4SLinus Torvalds if ((!filp) || (!vma) || (!(sfp = (Sg_fd *) filp->private_data))) 12221da177e4SLinus Torvalds return -ENXIO; 1223cb59e840S req_sz = vma->vm_end - vma->vm_start; 12241da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(3, printk("sg_mmap starting, vm_start=%p, len=%d\n", 12251da177e4SLinus Torvalds (void *) vma->vm_start, (int) req_sz)); 12261da177e4SLinus Torvalds if (vma->vm_pgoff) 12271da177e4SLinus Torvalds return -EINVAL; /* want no offset */ 12281da177e4SLinus Torvalds rsv_schp = &sfp->reserve; 12291da177e4SLinus Torvalds if (req_sz > rsv_schp->bufflen) 12301da177e4SLinus Torvalds return -ENOMEM; /* cannot map more than reserved buffer */ 12311da177e4SLinus Torvalds 1232d6b10348SMike Christie sa = vma->vm_start; 123310db10d1SFUJITA Tomonori length = 1 << (PAGE_SHIFT + rsv_schp->page_order); 123410db10d1SFUJITA Tomonori for (k = 0; k < rsv_schp->k_use_sg && sa < vma->vm_end; k++) { 12351da177e4SLinus Torvalds len = vma->vm_end - sa; 123610db10d1SFUJITA Tomonori len = (len < length) ? len : length; 12371da177e4SLinus Torvalds sa += len; 12381da177e4SLinus Torvalds } 1239d6b10348SMike Christie 12401da177e4SLinus Torvalds sfp->mmap_called = 1; 12411c8e71d7SDouglas Gilbert vma->vm_flags |= VM_RESERVED; 12421da177e4SLinus Torvalds vma->vm_private_data = sfp; 12431da177e4SLinus Torvalds vma->vm_ops = &sg_mmap_vm_ops; 12441da177e4SLinus Torvalds return 0; 12451da177e4SLinus Torvalds } 12461da177e4SLinus Torvalds 1247c96952edSFUJITA Tomonori static void sg_rq_end_io_usercontext(struct work_struct *work) 1248c96952edSFUJITA Tomonori { 1249c96952edSFUJITA Tomonori struct sg_request *srp = container_of(work, struct sg_request, ew.work); 1250c96952edSFUJITA Tomonori struct sg_fd *sfp = srp->parentfp; 1251c96952edSFUJITA Tomonori 1252c96952edSFUJITA Tomonori sg_finish_rem_req(srp); 1253c96952edSFUJITA Tomonori kref_put(&sfp->f_ref, sg_remove_sfp); 1254c96952edSFUJITA Tomonori } 1255c96952edSFUJITA Tomonori 1256a91a3a20SFUJITA Tomonori /* 1257a91a3a20SFUJITA Tomonori * This function is a "bottom half" handler that is called by the mid 1258a91a3a20SFUJITA Tomonori * level when a command is completed (or has failed). 1259a91a3a20SFUJITA Tomonori */ 1260a91a3a20SFUJITA Tomonori static void sg_rq_end_io(struct request *rq, int uptodate) 12611da177e4SLinus Torvalds { 1262a91a3a20SFUJITA Tomonori struct sg_request *srp = rq->end_io_data; 1263c6517b79STony Battersby Sg_device *sdp; 12641da177e4SLinus Torvalds Sg_fd *sfp; 12651da177e4SLinus Torvalds unsigned long iflags; 1266cb59e840S unsigned int ms; 1267a91a3a20SFUJITA Tomonori char *sense; 1268c6517b79STony Battersby int result, resid, done = 1; 12691da177e4SLinus Torvalds 1270c6517b79STony Battersby if (WARN_ON(srp->done != 0)) 12711da177e4SLinus Torvalds return; 1272c6517b79STony Battersby 12731da177e4SLinus Torvalds sfp = srp->parentfp; 1274c6517b79STony Battersby if (WARN_ON(sfp == NULL)) 12751da177e4SLinus Torvalds return; 1276c6517b79STony Battersby 1277c6517b79STony Battersby sdp = sfp->parentdp; 1278c6517b79STony Battersby if (unlikely(sdp->detached)) 1279c6517b79STony Battersby printk(KERN_INFO "sg_rq_end_io: device detached\n"); 12801da177e4SLinus Torvalds 1281a91a3a20SFUJITA Tomonori sense = rq->sense; 1282a91a3a20SFUJITA Tomonori result = rq->errors; 1283c3a4d78cSTejun Heo resid = rq->resid_len; 12841da177e4SLinus Torvalds 12851da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(4, printk("sg_cmd_done: %s, pack_id=%d, res=0x%x\n", 1286d6b10348SMike Christie sdp->disk->disk_name, srp->header.pack_id, result)); 1287d6b10348SMike Christie srp->header.resid = resid; 1288cb59e840S ms = jiffies_to_msecs(jiffies); 1289cb59e840S srp->header.duration = (ms > srp->header.duration) ? 1290cb59e840S (ms - srp->header.duration) : 0; 1291d6b10348SMike Christie if (0 != result) { 12921da177e4SLinus Torvalds struct scsi_sense_hdr sshdr; 12931da177e4SLinus Torvalds 1294d6b10348SMike Christie srp->header.status = 0xff & result; 1295d6b10348SMike Christie srp->header.masked_status = status_byte(result); 1296d6b10348SMike Christie srp->header.msg_status = msg_byte(result); 1297d6b10348SMike Christie srp->header.host_status = host_byte(result); 1298d6b10348SMike Christie srp->header.driver_status = driver_byte(result); 12991da177e4SLinus Torvalds if ((sdp->sgdebug > 0) && 13001da177e4SLinus Torvalds ((CHECK_CONDITION == srp->header.masked_status) || 13011da177e4SLinus Torvalds (COMMAND_TERMINATED == srp->header.masked_status))) 1302d6b10348SMike Christie __scsi_print_sense("sg_cmd_done", sense, 1303d6b10348SMike Christie SCSI_SENSE_BUFFERSIZE); 13041da177e4SLinus Torvalds 13051da177e4SLinus Torvalds /* Following if statement is a patch supplied by Eric Youngdale */ 1306d6b10348SMike Christie if (driver_byte(result) != 0 1307d6b10348SMike Christie && scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr) 13081da177e4SLinus Torvalds && !scsi_sense_is_deferred(&sshdr) 13091da177e4SLinus Torvalds && sshdr.sense_key == UNIT_ATTENTION 13101da177e4SLinus Torvalds && sdp->device->removable) { 13111da177e4SLinus Torvalds /* Detected possible disc change. Set the bit - this */ 13121da177e4SLinus Torvalds /* may be used if there are filesystems using this device */ 13131da177e4SLinus Torvalds sdp->device->changed = 1; 13141da177e4SLinus Torvalds } 13151da177e4SLinus Torvalds } 13161da177e4SLinus Torvalds /* Rely on write phase to clean out srp status values, so no "else" */ 13171da177e4SLinus Torvalds 1318c6517b79STony Battersby write_lock_irqsave(&sfp->rq_list_lock, iflags); 1319c6517b79STony Battersby if (unlikely(srp->orphan)) { 13201da177e4SLinus Torvalds if (sfp->keep_orphan) 13211da177e4SLinus Torvalds srp->sg_io_owned = 0; 1322c6517b79STony Battersby else 1323c6517b79STony Battersby done = 0; 13241da177e4SLinus Torvalds } 1325c6517b79STony Battersby srp->done = done; 13261da177e4SLinus Torvalds write_unlock_irqrestore(&sfp->rq_list_lock, iflags); 1327c6517b79STony Battersby 1328c6517b79STony Battersby if (likely(done)) { 1329c6517b79STony Battersby /* Now wake up any sg_read() that is waiting for this 1330c6517b79STony Battersby * packet. 1331c6517b79STony Battersby */ 1332c6517b79STony Battersby wake_up_interruptible(&sfp->read_wait); 1333c6517b79STony Battersby kill_fasync(&sfp->async_qp, SIGPOLL, POLL_IN); 1334c6517b79STony Battersby kref_put(&sfp->f_ref, sg_remove_sfp); 1335015640edSFUJITA Tomonori } else { 1336015640edSFUJITA Tomonori INIT_WORK(&srp->ew.work, sg_rq_end_io_usercontext); 1337015640edSFUJITA Tomonori schedule_work(&srp->ew.work); 1338015640edSFUJITA Tomonori } 13391da177e4SLinus Torvalds } 13401da177e4SLinus Torvalds 1341828c0950SAlexey Dobriyan static const struct file_operations sg_fops = { 13421da177e4SLinus Torvalds .owner = THIS_MODULE, 13431da177e4SLinus Torvalds .read = sg_read, 13441da177e4SLinus Torvalds .write = sg_write, 13451da177e4SLinus Torvalds .poll = sg_poll, 1346f4927c45SArnd Bergmann .unlocked_ioctl = sg_unlocked_ioctl, 13471da177e4SLinus Torvalds #ifdef CONFIG_COMPAT 13481da177e4SLinus Torvalds .compat_ioctl = sg_compat_ioctl, 13491da177e4SLinus Torvalds #endif 13501da177e4SLinus Torvalds .open = sg_open, 13511da177e4SLinus Torvalds .mmap = sg_mmap, 13521da177e4SLinus Torvalds .release = sg_release, 13531da177e4SLinus Torvalds .fasync = sg_fasync, 13541da177e4SLinus Torvalds }; 13551da177e4SLinus Torvalds 1356d253878bSgregkh@suse.de static struct class *sg_sysfs_class; 13571da177e4SLinus Torvalds 13581da177e4SLinus Torvalds static int sg_sysfs_valid = 0; 13591da177e4SLinus Torvalds 13607c07d613SJames Bottomley static Sg_device *sg_alloc(struct gendisk *disk, struct scsi_device *scsidp) 13611da177e4SLinus Torvalds { 1362d6b10348SMike Christie struct request_queue *q = scsidp->request_queue; 13631da177e4SLinus Torvalds Sg_device *sdp; 13641da177e4SLinus Torvalds unsigned long iflags; 13657c07d613SJames Bottomley int error; 13667c07d613SJames Bottomley u32 k; 13671da177e4SLinus Torvalds 136824669f75SJes Sorensen sdp = kzalloc(sizeof(Sg_device), GFP_KERNEL); 13691da177e4SLinus Torvalds if (!sdp) { 13701da177e4SLinus Torvalds printk(KERN_WARNING "kmalloc Sg_device failure\n"); 13717c07d613SJames Bottomley return ERR_PTR(-ENOMEM); 13727c07d613SJames Bottomley } 1373c6517b79STony Battersby 13747c07d613SJames Bottomley if (!idr_pre_get(&sg_index_idr, GFP_KERNEL)) { 13757c07d613SJames Bottomley printk(KERN_WARNING "idr expansion Sg_device failure\n"); 1376c6517b79STony Battersby error = -ENOMEM; 13777c07d613SJames Bottomley goto out; 13781da177e4SLinus Torvalds } 13791da177e4SLinus Torvalds 13807c07d613SJames Bottomley write_lock_irqsave(&sg_index_lock, iflags); 13811da177e4SLinus Torvalds 1382c6517b79STony Battersby error = idr_get_new(&sg_index_idr, sdp, &k); 13837c07d613SJames Bottomley if (error) { 1384c6517b79STony Battersby write_unlock_irqrestore(&sg_index_lock, iflags); 13857c07d613SJames Bottomley printk(KERN_WARNING "idr allocation Sg_device failure: %d\n", 13867c07d613SJames Bottomley error); 13877c07d613SJames Bottomley goto out; 13881da177e4SLinus Torvalds } 13891da177e4SLinus Torvalds 13901da177e4SLinus Torvalds if (unlikely(k >= SG_MAX_DEVS)) 13911da177e4SLinus Torvalds goto overflow; 13921da177e4SLinus Torvalds 13931da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(3, printk("sg_alloc: dev=%d \n", k)); 13941da177e4SLinus Torvalds sprintf(disk->disk_name, "sg%d", k); 13951da177e4SLinus Torvalds disk->first_minor = k; 13961da177e4SLinus Torvalds sdp->disk = disk; 13971da177e4SLinus Torvalds sdp->device = scsidp; 13983442f802SFUJITA Tomonori INIT_LIST_HEAD(&sdp->sfds); 13991da177e4SLinus Torvalds init_waitqueue_head(&sdp->o_excl_wait); 14008a78362cSMartin K. Petersen sdp->sg_tablesize = queue_max_segments(q); 14017c07d613SJames Bottomley sdp->index = k; 1402c6517b79STony Battersby kref_init(&sdp->d_ref); 1403c6517b79STony Battersby 1404c6517b79STony Battersby write_unlock_irqrestore(&sg_index_lock, iflags); 14051da177e4SLinus Torvalds 14067c07d613SJames Bottomley error = 0; 14071da177e4SLinus Torvalds out: 14087c07d613SJames Bottomley if (error) { 14091da177e4SLinus Torvalds kfree(sdp); 14107c07d613SJames Bottomley return ERR_PTR(error); 14117c07d613SJames Bottomley } 14127c07d613SJames Bottomley return sdp; 14131da177e4SLinus Torvalds 14141da177e4SLinus Torvalds overflow: 1415c6517b79STony Battersby idr_remove(&sg_index_idr, k); 1416c6517b79STony Battersby write_unlock_irqrestore(&sg_index_lock, iflags); 14179ccfc756SJames Bottomley sdev_printk(KERN_WARNING, scsidp, 14189ccfc756SJames Bottomley "Unable to attach sg device type=%d, minor " 14199ccfc756SJames Bottomley "number exceeds %d\n", scsidp->type, SG_MAX_DEVS - 1); 14201da177e4SLinus Torvalds error = -ENODEV; 14211da177e4SLinus Torvalds goto out; 14221da177e4SLinus Torvalds } 14231da177e4SLinus Torvalds 14241da177e4SLinus Torvalds static int 1425ee959b00STony Jones sg_add(struct device *cl_dev, struct class_interface *cl_intf) 14261da177e4SLinus Torvalds { 1427ee959b00STony Jones struct scsi_device *scsidp = to_scsi_device(cl_dev->parent); 14281da177e4SLinus Torvalds struct gendisk *disk; 14291da177e4SLinus Torvalds Sg_device *sdp = NULL; 14301da177e4SLinus Torvalds struct cdev * cdev = NULL; 14317c07d613SJames Bottomley int error; 1432454e8957SIshai Rabinovitz unsigned long iflags; 14331da177e4SLinus Torvalds 14341da177e4SLinus Torvalds disk = alloc_disk(1); 14351da177e4SLinus Torvalds if (!disk) { 14361da177e4SLinus Torvalds printk(KERN_WARNING "alloc_disk failed\n"); 14371da177e4SLinus Torvalds return -ENOMEM; 14381da177e4SLinus Torvalds } 14391da177e4SLinus Torvalds disk->major = SCSI_GENERIC_MAJOR; 14401da177e4SLinus Torvalds 14411da177e4SLinus Torvalds error = -ENOMEM; 14421da177e4SLinus Torvalds cdev = cdev_alloc(); 14431da177e4SLinus Torvalds if (!cdev) { 14441da177e4SLinus Torvalds printk(KERN_WARNING "cdev_alloc failed\n"); 14451da177e4SLinus Torvalds goto out; 14461da177e4SLinus Torvalds } 14471da177e4SLinus Torvalds cdev->owner = THIS_MODULE; 14481da177e4SLinus Torvalds cdev->ops = &sg_fops; 14491da177e4SLinus Torvalds 14507c07d613SJames Bottomley sdp = sg_alloc(disk, scsidp); 14517c07d613SJames Bottomley if (IS_ERR(sdp)) { 14521da177e4SLinus Torvalds printk(KERN_WARNING "sg_alloc failed\n"); 14537c07d613SJames Bottomley error = PTR_ERR(sdp); 14541da177e4SLinus Torvalds goto out; 14551da177e4SLinus Torvalds } 14561da177e4SLinus Torvalds 14577c07d613SJames Bottomley error = cdev_add(cdev, MKDEV(SCSI_GENERIC_MAJOR, sdp->index), 1); 14585e3c34c1SGreg KH if (error) 1459454e8957SIshai Rabinovitz goto cdev_add_err; 14605e3c34c1SGreg KH 14611da177e4SLinus Torvalds sdp->cdev = cdev; 14621da177e4SLinus Torvalds if (sg_sysfs_valid) { 1463ee959b00STony Jones struct device *sg_class_member; 14641da177e4SLinus Torvalds 1465d73a1a67SGreg Kroah-Hartman sg_class_member = device_create(sg_sysfs_class, cl_dev->parent, 1466ee959b00STony Jones MKDEV(SCSI_GENERIC_MAJOR, 1467ee959b00STony Jones sdp->index), 1468d73a1a67SGreg Kroah-Hartman sdp, "%s", disk->disk_name); 1469d07e0361SFUJITA Tomonori if (IS_ERR(sg_class_member)) { 1470d07e0361SFUJITA Tomonori printk(KERN_ERR "sg_add: " 1471ee959b00STony Jones "device_create failed\n"); 1472d07e0361SFUJITA Tomonori error = PTR_ERR(sg_class_member); 1473d07e0361SFUJITA Tomonori goto cdev_add_err; 1474d07e0361SFUJITA Tomonori } 14751da177e4SLinus Torvalds error = sysfs_create_link(&scsidp->sdev_gendev.kobj, 14761da177e4SLinus Torvalds &sg_class_member->kobj, "generic"); 14771da177e4SLinus Torvalds if (error) 14781da177e4SLinus Torvalds printk(KERN_ERR "sg_add: unable to make symlink " 14797c07d613SJames Bottomley "'generic' back to sg%d\n", sdp->index); 14801da177e4SLinus Torvalds } else 14817c07d613SJames Bottomley printk(KERN_WARNING "sg_add: sg_sys Invalid\n"); 14821da177e4SLinus Torvalds 14839ccfc756SJames Bottomley sdev_printk(KERN_NOTICE, scsidp, 14847c07d613SJames Bottomley "Attached scsi generic sg%d type %d\n", sdp->index, 14857c07d613SJames Bottomley scsidp->type); 14861da177e4SLinus Torvalds 1487ee959b00STony Jones dev_set_drvdata(cl_dev, sdp); 1488a24484f2SFUJITA Tomonori 14891da177e4SLinus Torvalds return 0; 14901da177e4SLinus Torvalds 1491454e8957SIshai Rabinovitz cdev_add_err: 14927c07d613SJames Bottomley write_lock_irqsave(&sg_index_lock, iflags); 14937c07d613SJames Bottomley idr_remove(&sg_index_idr, sdp->index); 14947c07d613SJames Bottomley write_unlock_irqrestore(&sg_index_lock, iflags); 14957c07d613SJames Bottomley kfree(sdp); 1496454e8957SIshai Rabinovitz 14971da177e4SLinus Torvalds out: 14981da177e4SLinus Torvalds put_disk(disk); 14991da177e4SLinus Torvalds if (cdev) 15001da177e4SLinus Torvalds cdev_del(cdev); 15011da177e4SLinus Torvalds return error; 15021da177e4SLinus Torvalds } 15031da177e4SLinus Torvalds 1504c6517b79STony Battersby static void sg_device_destroy(struct kref *kref) 1505c6517b79STony Battersby { 1506c6517b79STony Battersby struct sg_device *sdp = container_of(kref, struct sg_device, d_ref); 1507c6517b79STony Battersby unsigned long flags; 1508c6517b79STony Battersby 1509c6517b79STony Battersby /* CAUTION! Note that the device can still be found via idr_find() 1510c6517b79STony Battersby * even though the refcount is 0. Therefore, do idr_remove() BEFORE 1511c6517b79STony Battersby * any other cleanup. 1512c6517b79STony Battersby */ 1513c6517b79STony Battersby 1514c6517b79STony Battersby write_lock_irqsave(&sg_index_lock, flags); 1515c6517b79STony Battersby idr_remove(&sg_index_idr, sdp->index); 1516c6517b79STony Battersby write_unlock_irqrestore(&sg_index_lock, flags); 1517c6517b79STony Battersby 1518c6517b79STony Battersby SCSI_LOG_TIMEOUT(3, 1519c6517b79STony Battersby printk("sg_device_destroy: %s\n", 1520c6517b79STony Battersby sdp->disk->disk_name)); 1521c6517b79STony Battersby 1522c6517b79STony Battersby put_disk(sdp->disk); 1523c6517b79STony Battersby kfree(sdp); 1524c6517b79STony Battersby } 1525c6517b79STony Battersby 1526c6517b79STony Battersby static void sg_remove(struct device *cl_dev, struct class_interface *cl_intf) 15271da177e4SLinus Torvalds { 1528ee959b00STony Jones struct scsi_device *scsidp = to_scsi_device(cl_dev->parent); 1529ee959b00STony Jones Sg_device *sdp = dev_get_drvdata(cl_dev); 15301da177e4SLinus Torvalds unsigned long iflags; 15311da177e4SLinus Torvalds Sg_fd *sfp; 15321da177e4SLinus Torvalds 1533c6517b79STony Battersby if (!sdp || sdp->detached) 15341da177e4SLinus Torvalds return; 15357c07d613SJames Bottomley 1536c6517b79STony Battersby SCSI_LOG_TIMEOUT(3, printk("sg_remove: %s\n", sdp->disk->disk_name)); 1537c6517b79STony Battersby 1538c6517b79STony Battersby /* Need a write lock to set sdp->detached. */ 15397c07d613SJames Bottomley write_lock_irqsave(&sg_index_lock, iflags); 15401da177e4SLinus Torvalds sdp->detached = 1; 15413442f802SFUJITA Tomonori list_for_each_entry(sfp, &sdp->sfds, sfd_siblings) { 15421da177e4SLinus Torvalds wake_up_interruptible(&sfp->read_wait); 1543c6517b79STony Battersby kill_fasync(&sfp->async_qp, SIGPOLL, POLL_HUP); 15441da177e4SLinus Torvalds } 15457c07d613SJames Bottomley write_unlock_irqrestore(&sg_index_lock, iflags); 15461da177e4SLinus Torvalds 15471da177e4SLinus Torvalds sysfs_remove_link(&scsidp->sdev_gendev.kobj, "generic"); 1548ee959b00STony Jones device_destroy(sg_sysfs_class, MKDEV(SCSI_GENERIC_MAJOR, sdp->index)); 15491da177e4SLinus Torvalds cdev_del(sdp->cdev); 15501da177e4SLinus Torvalds sdp->cdev = NULL; 15511da177e4SLinus Torvalds 1552c6517b79STony Battersby sg_put_dev(sdp); 15531da177e4SLinus Torvalds } 15541da177e4SLinus Torvalds 15556460e75aSDouglas Gilbert module_param_named(scatter_elem_sz, scatter_elem_sz, int, S_IRUGO | S_IWUSR); 15566460e75aSDouglas Gilbert module_param_named(def_reserved_size, def_reserved_size, int, 15576460e75aSDouglas Gilbert S_IRUGO | S_IWUSR); 15581da177e4SLinus Torvalds module_param_named(allow_dio, sg_allow_dio, int, S_IRUGO | S_IWUSR); 15591da177e4SLinus Torvalds 15601da177e4SLinus Torvalds MODULE_AUTHOR("Douglas Gilbert"); 15611da177e4SLinus Torvalds MODULE_DESCRIPTION("SCSI generic (sg) driver"); 15621da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 15631da177e4SLinus Torvalds MODULE_VERSION(SG_VERSION_STR); 1564f018fa55SRene Herman MODULE_ALIAS_CHARDEV_MAJOR(SCSI_GENERIC_MAJOR); 15651da177e4SLinus Torvalds 15666460e75aSDouglas Gilbert MODULE_PARM_DESC(scatter_elem_sz, "scatter gather element " 15676460e75aSDouglas Gilbert "size (default: max(SG_SCATTER_SZ, PAGE_SIZE))"); 15681da177e4SLinus Torvalds MODULE_PARM_DESC(def_reserved_size, "size of buffer reserved for each fd"); 15691da177e4SLinus Torvalds MODULE_PARM_DESC(allow_dio, "allow direct I/O (default: 0 (disallow))"); 15701da177e4SLinus Torvalds 15711da177e4SLinus Torvalds static int __init 15721da177e4SLinus Torvalds init_sg(void) 15731da177e4SLinus Torvalds { 15741da177e4SLinus Torvalds int rc; 15751da177e4SLinus Torvalds 15766460e75aSDouglas Gilbert if (scatter_elem_sz < PAGE_SIZE) { 15776460e75aSDouglas Gilbert scatter_elem_sz = PAGE_SIZE; 15786460e75aSDouglas Gilbert scatter_elem_sz_prev = scatter_elem_sz; 15796460e75aSDouglas Gilbert } 15801da177e4SLinus Torvalds if (def_reserved_size >= 0) 15811da177e4SLinus Torvalds sg_big_buff = def_reserved_size; 15826460e75aSDouglas Gilbert else 15836460e75aSDouglas Gilbert def_reserved_size = sg_big_buff; 15841da177e4SLinus Torvalds 15851da177e4SLinus Torvalds rc = register_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0), 15861da177e4SLinus Torvalds SG_MAX_DEVS, "sg"); 15871da177e4SLinus Torvalds if (rc) 15881da177e4SLinus Torvalds return rc; 1589d253878bSgregkh@suse.de sg_sysfs_class = class_create(THIS_MODULE, "scsi_generic"); 15901da177e4SLinus Torvalds if ( IS_ERR(sg_sysfs_class) ) { 15911da177e4SLinus Torvalds rc = PTR_ERR(sg_sysfs_class); 15921da177e4SLinus Torvalds goto err_out; 15931da177e4SLinus Torvalds } 15941da177e4SLinus Torvalds sg_sysfs_valid = 1; 15951da177e4SLinus Torvalds rc = scsi_register_interface(&sg_interface); 15961da177e4SLinus Torvalds if (0 == rc) { 15971da177e4SLinus Torvalds #ifdef CONFIG_SCSI_PROC_FS 15981da177e4SLinus Torvalds sg_proc_init(); 15991da177e4SLinus Torvalds #endif /* CONFIG_SCSI_PROC_FS */ 16001da177e4SLinus Torvalds return 0; 16011da177e4SLinus Torvalds } 1602d253878bSgregkh@suse.de class_destroy(sg_sysfs_class); 16031da177e4SLinus Torvalds err_out: 16041da177e4SLinus Torvalds unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0), SG_MAX_DEVS); 16051da177e4SLinus Torvalds return rc; 16061da177e4SLinus Torvalds } 16071da177e4SLinus Torvalds 16081da177e4SLinus Torvalds static void __exit 16091da177e4SLinus Torvalds exit_sg(void) 16101da177e4SLinus Torvalds { 16111da177e4SLinus Torvalds #ifdef CONFIG_SCSI_PROC_FS 16121da177e4SLinus Torvalds sg_proc_cleanup(); 16131da177e4SLinus Torvalds #endif /* CONFIG_SCSI_PROC_FS */ 16141da177e4SLinus Torvalds scsi_unregister_interface(&sg_interface); 1615d253878bSgregkh@suse.de class_destroy(sg_sysfs_class); 16161da177e4SLinus Torvalds sg_sysfs_valid = 0; 16171da177e4SLinus Torvalds unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0), 16181da177e4SLinus Torvalds SG_MAX_DEVS); 16197c07d613SJames Bottomley idr_destroy(&sg_index_idr); 16201da177e4SLinus Torvalds } 16211da177e4SLinus Torvalds 162244c7b0eaSFUJITA Tomonori static int sg_start_req(Sg_request *srp, unsigned char *cmd) 162310865dfaSFUJITA Tomonori { 1624626710c9SFUJITA Tomonori int res; 162510865dfaSFUJITA Tomonori struct request *rq; 162644c7b0eaSFUJITA Tomonori Sg_fd *sfp = srp->parentfp; 162744c7b0eaSFUJITA Tomonori sg_io_hdr_t *hp = &srp->header; 162844c7b0eaSFUJITA Tomonori int dxfer_len = (int) hp->dxfer_len; 162944c7b0eaSFUJITA Tomonori int dxfer_dir = hp->dxfer_direction; 1630626710c9SFUJITA Tomonori unsigned int iov_count = hp->iovec_count; 163144c7b0eaSFUJITA Tomonori Sg_scatter_hold *req_schp = &srp->data; 163244c7b0eaSFUJITA Tomonori Sg_scatter_hold *rsv_schp = &sfp->reserve; 163344c7b0eaSFUJITA Tomonori struct request_queue *q = sfp->parentdp->device->request_queue; 1634626710c9SFUJITA Tomonori struct rq_map_data *md, map_data; 163510865dfaSFUJITA Tomonori int rw = hp->dxfer_direction == SG_DXFER_TO_DEV ? WRITE : READ; 163610865dfaSFUJITA Tomonori 163744c7b0eaSFUJITA Tomonori SCSI_LOG_TIMEOUT(4, printk(KERN_INFO "sg_start_req: dxfer_len=%d\n", 163844c7b0eaSFUJITA Tomonori dxfer_len)); 163944c7b0eaSFUJITA Tomonori 164010865dfaSFUJITA Tomonori rq = blk_get_request(q, rw, GFP_ATOMIC); 164110865dfaSFUJITA Tomonori if (!rq) 164210865dfaSFUJITA Tomonori return -ENOMEM; 164310865dfaSFUJITA Tomonori 164410865dfaSFUJITA Tomonori memcpy(rq->cmd, cmd, hp->cmd_len); 164510865dfaSFUJITA Tomonori 164610865dfaSFUJITA Tomonori rq->cmd_len = hp->cmd_len; 164710865dfaSFUJITA Tomonori rq->cmd_type = REQ_TYPE_BLOCK_PC; 164810865dfaSFUJITA Tomonori 164910865dfaSFUJITA Tomonori srp->rq = rq; 165010865dfaSFUJITA Tomonori rq->end_io_data = srp; 165110865dfaSFUJITA Tomonori rq->sense = srp->sense_b; 165210865dfaSFUJITA Tomonori rq->retries = SG_DEFAULT_RETRIES; 165310865dfaSFUJITA Tomonori 16541da177e4SLinus Torvalds if ((dxfer_len <= 0) || (dxfer_dir == SG_DXFER_NONE)) 165510db10d1SFUJITA Tomonori return 0; 165610865dfaSFUJITA Tomonori 1657626710c9SFUJITA Tomonori if (sg_allow_dio && hp->flags & SG_FLAG_DIRECT_IO && 1658626710c9SFUJITA Tomonori dxfer_dir != SG_DXFER_UNKNOWN && !iov_count && 1659626710c9SFUJITA Tomonori !sfp->parentdp->device->host->unchecked_isa_dma && 166001cfcdddSFUJITA Tomonori blk_rq_aligned(q, hp->dxferp, dxfer_len)) 1661626710c9SFUJITA Tomonori md = NULL; 1662626710c9SFUJITA Tomonori else 1663626710c9SFUJITA Tomonori md = &map_data; 16647e56cb0fSFUJITA Tomonori 1665626710c9SFUJITA Tomonori if (md) { 1666626710c9SFUJITA Tomonori if (!sg_res_in_use(sfp) && dxfer_len <= rsv_schp->bufflen) 16671da177e4SLinus Torvalds sg_link_reserve(sfp, srp, dxfer_len); 1668626710c9SFUJITA Tomonori else { 16691da177e4SLinus Torvalds res = sg_build_indirect(req_schp, sfp, dxfer_len); 1670626710c9SFUJITA Tomonori if (res) 1671626710c9SFUJITA Tomonori return res; 167210db10d1SFUJITA Tomonori } 167310db10d1SFUJITA Tomonori 1674626710c9SFUJITA Tomonori md->pages = req_schp->pages; 1675626710c9SFUJITA Tomonori md->page_order = req_schp->page_order; 1676626710c9SFUJITA Tomonori md->nr_entries = req_schp->k_use_sg; 167756c451f4SFUJITA Tomonori md->offset = 0; 167897ae77a1SFUJITA Tomonori md->null_mapped = hp->dxferp ? 0 : 1; 1679ecb554a8SFUJITA Tomonori if (dxfer_dir == SG_DXFER_TO_FROM_DEV) 1680ecb554a8SFUJITA Tomonori md->from_user = 1; 1681ecb554a8SFUJITA Tomonori else 1682ecb554a8SFUJITA Tomonori md->from_user = 0; 1683626710c9SFUJITA Tomonori } 1684626710c9SFUJITA Tomonori 16850fdf96b6SFUJITA Tomonori if (iov_count) { 16860fdf96b6SFUJITA Tomonori int len, size = sizeof(struct sg_iovec) * iov_count; 16870fdf96b6SFUJITA Tomonori struct iovec *iov; 16880fdf96b6SFUJITA Tomonori 16890fdf96b6SFUJITA Tomonori iov = kmalloc(size, GFP_ATOMIC); 16900fdf96b6SFUJITA Tomonori if (!iov) 16910fdf96b6SFUJITA Tomonori return -ENOMEM; 16920fdf96b6SFUJITA Tomonori 16930fdf96b6SFUJITA Tomonori if (copy_from_user(iov, hp->dxferp, size)) { 16940fdf96b6SFUJITA Tomonori kfree(iov); 16950fdf96b6SFUJITA Tomonori return -EFAULT; 16960fdf96b6SFUJITA Tomonori } 16970fdf96b6SFUJITA Tomonori 16980fdf96b6SFUJITA Tomonori len = iov_length(iov, iov_count); 16990fdf96b6SFUJITA Tomonori if (hp->dxfer_len < len) { 17000fdf96b6SFUJITA Tomonori iov_count = iov_shorten(iov, iov_count, hp->dxfer_len); 17010fdf96b6SFUJITA Tomonori len = hp->dxfer_len; 17020fdf96b6SFUJITA Tomonori } 17030fdf96b6SFUJITA Tomonori 17040fdf96b6SFUJITA Tomonori res = blk_rq_map_user_iov(q, rq, md, (struct sg_iovec *)iov, 17050fdf96b6SFUJITA Tomonori iov_count, 17060fdf96b6SFUJITA Tomonori len, GFP_ATOMIC); 17070fdf96b6SFUJITA Tomonori kfree(iov); 17080fdf96b6SFUJITA Tomonori } else 1709626710c9SFUJITA Tomonori res = blk_rq_map_user(q, rq, md, hp->dxferp, 1710626710c9SFUJITA Tomonori hp->dxfer_len, GFP_ATOMIC); 1711626710c9SFUJITA Tomonori 1712626710c9SFUJITA Tomonori if (!res) { 1713626710c9SFUJITA Tomonori srp->bio = rq->bio; 1714626710c9SFUJITA Tomonori 1715626710c9SFUJITA Tomonori if (!md) { 1716626710c9SFUJITA Tomonori req_schp->dio_in_use = 1; 1717626710c9SFUJITA Tomonori hp->info |= SG_INFO_DIRECT_IO; 1718626710c9SFUJITA Tomonori } 1719626710c9SFUJITA Tomonori } 17201da177e4SLinus Torvalds return res; 17211da177e4SLinus Torvalds } 17221da177e4SLinus Torvalds 1723e7ee4cc0SFUJITA Tomonori static int sg_finish_rem_req(Sg_request * srp) 17241da177e4SLinus Torvalds { 1725e7ee4cc0SFUJITA Tomonori int ret = 0; 1726e7ee4cc0SFUJITA Tomonori 17271da177e4SLinus Torvalds Sg_fd *sfp = srp->parentfp; 17281da177e4SLinus Torvalds Sg_scatter_hold *req_schp = &srp->data; 17291da177e4SLinus Torvalds 17301da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(4, printk("sg_finish_rem_req: res_used=%d\n", (int) srp->res_used)); 17316e5a30cbSFUJITA Tomonori if (srp->rq) { 17326e5a30cbSFUJITA Tomonori if (srp->bio) 1733e7ee4cc0SFUJITA Tomonori ret = blk_rq_unmap_user(srp->bio); 173410db10d1SFUJITA Tomonori 173510865dfaSFUJITA Tomonori blk_put_request(srp->rq); 17366e5a30cbSFUJITA Tomonori } 173710865dfaSFUJITA Tomonori 1738e27168f8SChristof Schmitt if (srp->res_used) 1739e27168f8SChristof Schmitt sg_unlink_reserve(sfp, srp); 1740e27168f8SChristof Schmitt else 1741e27168f8SChristof Schmitt sg_remove_scat(req_schp); 1742e27168f8SChristof Schmitt 17431da177e4SLinus Torvalds sg_remove_request(sfp, srp); 1744e7ee4cc0SFUJITA Tomonori 1745e7ee4cc0SFUJITA Tomonori return ret; 17461da177e4SLinus Torvalds } 17471da177e4SLinus Torvalds 17481da177e4SLinus Torvalds static int 17491da177e4SLinus Torvalds sg_build_sgat(Sg_scatter_hold * schp, const Sg_fd * sfp, int tablesize) 17501da177e4SLinus Torvalds { 175110db10d1SFUJITA Tomonori int sg_bufflen = tablesize * sizeof(struct page *); 17522d20eaf9SAl Viro gfp_t gfp_flags = GFP_ATOMIC | __GFP_NOWARN; 17531da177e4SLinus Torvalds 175410db10d1SFUJITA Tomonori schp->pages = kzalloc(sg_bufflen, gfp_flags); 175510db10d1SFUJITA Tomonori if (!schp->pages) 17561da177e4SLinus Torvalds return -ENOMEM; 17571da177e4SLinus Torvalds schp->sglist_len = sg_bufflen; 1758d6b10348SMike Christie return tablesize; /* number of scat_gath elements allocated */ 17591da177e4SLinus Torvalds } 17601da177e4SLinus Torvalds 17611da177e4SLinus Torvalds static int 17621da177e4SLinus Torvalds sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size) 17631da177e4SLinus Torvalds { 176410db10d1SFUJITA Tomonori int ret_sz = 0, i, k, rem_sz, num, mx_sc_elems; 1765d6b10348SMike Christie int sg_tablesize = sfp->parentdp->sg_tablesize; 176610db10d1SFUJITA Tomonori int blk_size = buff_size, order; 176710db10d1SFUJITA Tomonori gfp_t gfp_mask = GFP_ATOMIC | __GFP_COMP | __GFP_NOWARN; 17681da177e4SLinus Torvalds 1769fb119935SEric Sesterhenn if (blk_size < 0) 17701da177e4SLinus Torvalds return -EFAULT; 17711da177e4SLinus Torvalds if (0 == blk_size) 17721da177e4SLinus Torvalds ++blk_size; /* don't know why */ 17731da177e4SLinus Torvalds /* round request up to next highest SG_SECTOR_SZ byte boundary */ 1774b2ed6c69SFUJITA Tomonori blk_size = ALIGN(blk_size, SG_SECTOR_SZ); 17751da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(4, printk("sg_build_indirect: buff_size=%d, blk_size=%d\n", 17761da177e4SLinus Torvalds buff_size, blk_size)); 17771da177e4SLinus Torvalds 17781da177e4SLinus Torvalds /* N.B. ret_sz carried into this block ... */ 17791da177e4SLinus Torvalds mx_sc_elems = sg_build_sgat(schp, sfp, sg_tablesize); 17801da177e4SLinus Torvalds if (mx_sc_elems < 0) 17811da177e4SLinus Torvalds return mx_sc_elems; /* most likely -ENOMEM */ 17821da177e4SLinus Torvalds 17836460e75aSDouglas Gilbert num = scatter_elem_sz; 17846460e75aSDouglas Gilbert if (unlikely(num != scatter_elem_sz_prev)) { 17856460e75aSDouglas Gilbert if (num < PAGE_SIZE) { 17866460e75aSDouglas Gilbert scatter_elem_sz = PAGE_SIZE; 17876460e75aSDouglas Gilbert scatter_elem_sz_prev = PAGE_SIZE; 17886460e75aSDouglas Gilbert } else 17896460e75aSDouglas Gilbert scatter_elem_sz_prev = num; 17906460e75aSDouglas Gilbert } 179110db10d1SFUJITA Tomonori 179210db10d1SFUJITA Tomonori if (sfp->low_dma) 179310db10d1SFUJITA Tomonori gfp_mask |= GFP_DMA; 179410db10d1SFUJITA Tomonori 179510db10d1SFUJITA Tomonori if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO)) 179610db10d1SFUJITA Tomonori gfp_mask |= __GFP_ZERO; 179710db10d1SFUJITA Tomonori 179810db10d1SFUJITA Tomonori order = get_order(num); 179910db10d1SFUJITA Tomonori retry: 180010db10d1SFUJITA Tomonori ret_sz = 1 << (PAGE_SHIFT + order); 180110db10d1SFUJITA Tomonori 180210db10d1SFUJITA Tomonori for (k = 0, rem_sz = blk_size; rem_sz > 0 && k < mx_sc_elems; 180310db10d1SFUJITA Tomonori k++, rem_sz -= ret_sz) { 1804d6b10348SMike Christie 18056460e75aSDouglas Gilbert num = (rem_sz > scatter_elem_sz_prev) ? 18066460e75aSDouglas Gilbert scatter_elem_sz_prev : rem_sz; 180710db10d1SFUJITA Tomonori 180810db10d1SFUJITA Tomonori schp->pages[k] = alloc_pages(gfp_mask, order); 180910db10d1SFUJITA Tomonori if (!schp->pages[k]) 181010db10d1SFUJITA Tomonori goto out; 1811d6b10348SMike Christie 18126460e75aSDouglas Gilbert if (num == scatter_elem_sz_prev) { 18136460e75aSDouglas Gilbert if (unlikely(ret_sz > scatter_elem_sz_prev)) { 18146460e75aSDouglas Gilbert scatter_elem_sz = ret_sz; 18156460e75aSDouglas Gilbert scatter_elem_sz_prev = ret_sz; 18166460e75aSDouglas Gilbert } 18176460e75aSDouglas Gilbert } 18181da177e4SLinus Torvalds 18197ca63cb4SDouglas Gilbert SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k=%d, num=%d, " 18207ca63cb4SDouglas Gilbert "ret_sz=%d\n", k, num, ret_sz)); 18211da177e4SLinus Torvalds } /* end of for loop */ 1822d6b10348SMike Christie 182310db10d1SFUJITA Tomonori schp->page_order = order; 18241da177e4SLinus Torvalds schp->k_use_sg = k; 18257ca63cb4SDouglas Gilbert SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k_use_sg=%d, " 18267ca63cb4SDouglas Gilbert "rem_sz=%d\n", k, rem_sz)); 1827d6b10348SMike Christie 18281da177e4SLinus Torvalds schp->bufflen = blk_size; 18291da177e4SLinus Torvalds if (rem_sz > 0) /* must have failed */ 18301da177e4SLinus Torvalds return -ENOMEM; 18311da177e4SLinus Torvalds return 0; 183210db10d1SFUJITA Tomonori out: 183310db10d1SFUJITA Tomonori for (i = 0; i < k; i++) 1834e71044eeSMichal Schmidt __free_pages(schp->pages[i], order); 183510db10d1SFUJITA Tomonori 183610db10d1SFUJITA Tomonori if (--order >= 0) 183710db10d1SFUJITA Tomonori goto retry; 183810db10d1SFUJITA Tomonori 183910db10d1SFUJITA Tomonori return -ENOMEM; 18401da177e4SLinus Torvalds } 18411da177e4SLinus Torvalds 18421da177e4SLinus Torvalds static void 18431da177e4SLinus Torvalds sg_remove_scat(Sg_scatter_hold * schp) 18441da177e4SLinus Torvalds { 18451da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(4, printk("sg_remove_scat: k_use_sg=%d\n", schp->k_use_sg)); 184610db10d1SFUJITA Tomonori if (schp->pages && schp->sglist_len > 0) { 18476e5a30cbSFUJITA Tomonori if (!schp->dio_in_use) { 18481da177e4SLinus Torvalds int k; 18491da177e4SLinus Torvalds 185010db10d1SFUJITA Tomonori for (k = 0; k < schp->k_use_sg && schp->pages[k]; k++) { 18511da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(5, printk( 185210db10d1SFUJITA Tomonori "sg_remove_scat: k=%d, pg=0x%p\n", 185310db10d1SFUJITA Tomonori k, schp->pages[k])); 185410db10d1SFUJITA Tomonori __free_pages(schp->pages[k], schp->page_order); 18551da177e4SLinus Torvalds } 18566e5a30cbSFUJITA Tomonori 185710db10d1SFUJITA Tomonori kfree(schp->pages); 1858d6b10348SMike Christie } 18596e5a30cbSFUJITA Tomonori } 18601da177e4SLinus Torvalds memset(schp, 0, sizeof (*schp)); 18611da177e4SLinus Torvalds } 18621da177e4SLinus Torvalds 18631da177e4SLinus Torvalds static int 18641da177e4SLinus Torvalds sg_read_oxfer(Sg_request * srp, char __user *outp, int num_read_xfer) 18651da177e4SLinus Torvalds { 18661da177e4SLinus Torvalds Sg_scatter_hold *schp = &srp->data; 1867d6b10348SMike Christie int k, num; 18681da177e4SLinus Torvalds 18691da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(4, printk("sg_read_oxfer: num_read_xfer=%d\n", 18701da177e4SLinus Torvalds num_read_xfer)); 18711da177e4SLinus Torvalds if ((!outp) || (num_read_xfer <= 0)) 18721da177e4SLinus Torvalds return 0; 18731da177e4SLinus Torvalds 187410db10d1SFUJITA Tomonori num = 1 << (PAGE_SHIFT + schp->page_order); 187510db10d1SFUJITA Tomonori for (k = 0; k < schp->k_use_sg && schp->pages[k]; k++) { 18761da177e4SLinus Torvalds if (num > num_read_xfer) { 187710db10d1SFUJITA Tomonori if (__copy_to_user(outp, page_address(schp->pages[k]), 1878d6b10348SMike Christie num_read_xfer)) 18791da177e4SLinus Torvalds return -EFAULT; 18801da177e4SLinus Torvalds break; 18811da177e4SLinus Torvalds } else { 188210db10d1SFUJITA Tomonori if (__copy_to_user(outp, page_address(schp->pages[k]), 1883d6b10348SMike Christie num)) 18841da177e4SLinus Torvalds return -EFAULT; 18851da177e4SLinus Torvalds num_read_xfer -= num; 18861da177e4SLinus Torvalds if (num_read_xfer <= 0) 18871da177e4SLinus Torvalds break; 18881da177e4SLinus Torvalds outp += num; 18891da177e4SLinus Torvalds } 18901da177e4SLinus Torvalds } 1891d6b10348SMike Christie 18921da177e4SLinus Torvalds return 0; 18931da177e4SLinus Torvalds } 18941da177e4SLinus Torvalds 18951da177e4SLinus Torvalds static void 18961da177e4SLinus Torvalds sg_build_reserve(Sg_fd * sfp, int req_size) 18971da177e4SLinus Torvalds { 18981da177e4SLinus Torvalds Sg_scatter_hold *schp = &sfp->reserve; 18991da177e4SLinus Torvalds 19001da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(4, printk("sg_build_reserve: req_size=%d\n", req_size)); 19011da177e4SLinus Torvalds do { 19021da177e4SLinus Torvalds if (req_size < PAGE_SIZE) 19031da177e4SLinus Torvalds req_size = PAGE_SIZE; 19041da177e4SLinus Torvalds if (0 == sg_build_indirect(schp, sfp, req_size)) 19051da177e4SLinus Torvalds return; 19061da177e4SLinus Torvalds else 19071da177e4SLinus Torvalds sg_remove_scat(schp); 19081da177e4SLinus Torvalds req_size >>= 1; /* divide by 2 */ 19091da177e4SLinus Torvalds } while (req_size > (PAGE_SIZE / 2)); 19101da177e4SLinus Torvalds } 19111da177e4SLinus Torvalds 19121da177e4SLinus Torvalds static void 19131da177e4SLinus Torvalds sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size) 19141da177e4SLinus Torvalds { 19151da177e4SLinus Torvalds Sg_scatter_hold *req_schp = &srp->data; 19161da177e4SLinus Torvalds Sg_scatter_hold *rsv_schp = &sfp->reserve; 1917d6b10348SMike Christie int k, num, rem; 19181da177e4SLinus Torvalds 19191da177e4SLinus Torvalds srp->res_used = 1; 19201da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(4, printk("sg_link_reserve: size=%d\n", size)); 1921eca7be5eSBrian King rem = size; 19221da177e4SLinus Torvalds 192310db10d1SFUJITA Tomonori num = 1 << (PAGE_SHIFT + rsv_schp->page_order); 192410db10d1SFUJITA Tomonori for (k = 0; k < rsv_schp->k_use_sg; k++) { 19251da177e4SLinus Torvalds if (rem <= num) { 19261da177e4SLinus Torvalds req_schp->k_use_sg = k + 1; 1927d6b10348SMike Christie req_schp->sglist_len = rsv_schp->sglist_len; 192810db10d1SFUJITA Tomonori req_schp->pages = rsv_schp->pages; 1929d6b10348SMike Christie 19301da177e4SLinus Torvalds req_schp->bufflen = size; 193110db10d1SFUJITA Tomonori req_schp->page_order = rsv_schp->page_order; 19321da177e4SLinus Torvalds break; 19331da177e4SLinus Torvalds } else 19341da177e4SLinus Torvalds rem -= num; 19351da177e4SLinus Torvalds } 1936d6b10348SMike Christie 19371da177e4SLinus Torvalds if (k >= rsv_schp->k_use_sg) 19381da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(1, printk("sg_link_reserve: BAD size\n")); 19391da177e4SLinus Torvalds } 19401da177e4SLinus Torvalds 19411da177e4SLinus Torvalds static void 19421da177e4SLinus Torvalds sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp) 19431da177e4SLinus Torvalds { 19441da177e4SLinus Torvalds Sg_scatter_hold *req_schp = &srp->data; 19451da177e4SLinus Torvalds 19461da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(4, printk("sg_unlink_reserve: req->k_use_sg=%d\n", 19471da177e4SLinus Torvalds (int) req_schp->k_use_sg)); 19481da177e4SLinus Torvalds req_schp->k_use_sg = 0; 19491da177e4SLinus Torvalds req_schp->bufflen = 0; 195010db10d1SFUJITA Tomonori req_schp->pages = NULL; 195110db10d1SFUJITA Tomonori req_schp->page_order = 0; 19521da177e4SLinus Torvalds req_schp->sglist_len = 0; 19531da177e4SLinus Torvalds sfp->save_scat_len = 0; 19541da177e4SLinus Torvalds srp->res_used = 0; 19551da177e4SLinus Torvalds } 19561da177e4SLinus Torvalds 19571da177e4SLinus Torvalds static Sg_request * 19581da177e4SLinus Torvalds sg_get_rq_mark(Sg_fd * sfp, int pack_id) 19591da177e4SLinus Torvalds { 19601da177e4SLinus Torvalds Sg_request *resp; 19611da177e4SLinus Torvalds unsigned long iflags; 19621da177e4SLinus Torvalds 19631da177e4SLinus Torvalds write_lock_irqsave(&sfp->rq_list_lock, iflags); 19641da177e4SLinus Torvalds for (resp = sfp->headrp; resp; resp = resp->nextrp) { 19651da177e4SLinus Torvalds /* look for requests that are ready + not SG_IO owned */ 19661da177e4SLinus Torvalds if ((1 == resp->done) && (!resp->sg_io_owned) && 19671da177e4SLinus Torvalds ((-1 == pack_id) || (resp->header.pack_id == pack_id))) { 19681da177e4SLinus Torvalds resp->done = 2; /* guard against other readers */ 19691da177e4SLinus Torvalds break; 19701da177e4SLinus Torvalds } 19711da177e4SLinus Torvalds } 19721da177e4SLinus Torvalds write_unlock_irqrestore(&sfp->rq_list_lock, iflags); 19731da177e4SLinus Torvalds return resp; 19741da177e4SLinus Torvalds } 19751da177e4SLinus Torvalds 19761da177e4SLinus Torvalds /* always adds to end of list */ 19771da177e4SLinus Torvalds static Sg_request * 19781da177e4SLinus Torvalds sg_add_request(Sg_fd * sfp) 19791da177e4SLinus Torvalds { 19801da177e4SLinus Torvalds int k; 19811da177e4SLinus Torvalds unsigned long iflags; 19821da177e4SLinus Torvalds Sg_request *resp; 19831da177e4SLinus Torvalds Sg_request *rp = sfp->req_arr; 19841da177e4SLinus Torvalds 19851da177e4SLinus Torvalds write_lock_irqsave(&sfp->rq_list_lock, iflags); 19861da177e4SLinus Torvalds resp = sfp->headrp; 19871da177e4SLinus Torvalds if (!resp) { 19881da177e4SLinus Torvalds memset(rp, 0, sizeof (Sg_request)); 19891da177e4SLinus Torvalds rp->parentfp = sfp; 19901da177e4SLinus Torvalds resp = rp; 19911da177e4SLinus Torvalds sfp->headrp = resp; 19921da177e4SLinus Torvalds } else { 19931da177e4SLinus Torvalds if (0 == sfp->cmd_q) 19941da177e4SLinus Torvalds resp = NULL; /* command queuing disallowed */ 19951da177e4SLinus Torvalds else { 19961da177e4SLinus Torvalds for (k = 0; k < SG_MAX_QUEUE; ++k, ++rp) { 19971da177e4SLinus Torvalds if (!rp->parentfp) 19981da177e4SLinus Torvalds break; 19991da177e4SLinus Torvalds } 20001da177e4SLinus Torvalds if (k < SG_MAX_QUEUE) { 20011da177e4SLinus Torvalds memset(rp, 0, sizeof (Sg_request)); 20021da177e4SLinus Torvalds rp->parentfp = sfp; 20031da177e4SLinus Torvalds while (resp->nextrp) 20041da177e4SLinus Torvalds resp = resp->nextrp; 20051da177e4SLinus Torvalds resp->nextrp = rp; 20061da177e4SLinus Torvalds resp = rp; 20071da177e4SLinus Torvalds } else 20081da177e4SLinus Torvalds resp = NULL; 20091da177e4SLinus Torvalds } 20101da177e4SLinus Torvalds } 20111da177e4SLinus Torvalds if (resp) { 20121da177e4SLinus Torvalds resp->nextrp = NULL; 2013cb59e840S resp->header.duration = jiffies_to_msecs(jiffies); 20141da177e4SLinus Torvalds } 20151da177e4SLinus Torvalds write_unlock_irqrestore(&sfp->rq_list_lock, iflags); 20161da177e4SLinus Torvalds return resp; 20171da177e4SLinus Torvalds } 20181da177e4SLinus Torvalds 20191da177e4SLinus Torvalds /* Return of 1 for found; 0 for not found */ 20201da177e4SLinus Torvalds static int 20211da177e4SLinus Torvalds sg_remove_request(Sg_fd * sfp, Sg_request * srp) 20221da177e4SLinus Torvalds { 20231da177e4SLinus Torvalds Sg_request *prev_rp; 20241da177e4SLinus Torvalds Sg_request *rp; 20251da177e4SLinus Torvalds unsigned long iflags; 20261da177e4SLinus Torvalds int res = 0; 20271da177e4SLinus Torvalds 20281da177e4SLinus Torvalds if ((!sfp) || (!srp) || (!sfp->headrp)) 20291da177e4SLinus Torvalds return res; 20301da177e4SLinus Torvalds write_lock_irqsave(&sfp->rq_list_lock, iflags); 20311da177e4SLinus Torvalds prev_rp = sfp->headrp; 20321da177e4SLinus Torvalds if (srp == prev_rp) { 20331da177e4SLinus Torvalds sfp->headrp = prev_rp->nextrp; 20341da177e4SLinus Torvalds prev_rp->parentfp = NULL; 20351da177e4SLinus Torvalds res = 1; 20361da177e4SLinus Torvalds } else { 20371da177e4SLinus Torvalds while ((rp = prev_rp->nextrp)) { 20381da177e4SLinus Torvalds if (srp == rp) { 20391da177e4SLinus Torvalds prev_rp->nextrp = rp->nextrp; 20401da177e4SLinus Torvalds rp->parentfp = NULL; 20411da177e4SLinus Torvalds res = 1; 20421da177e4SLinus Torvalds break; 20431da177e4SLinus Torvalds } 20441da177e4SLinus Torvalds prev_rp = rp; 20451da177e4SLinus Torvalds } 20461da177e4SLinus Torvalds } 20471da177e4SLinus Torvalds write_unlock_irqrestore(&sfp->rq_list_lock, iflags); 20481da177e4SLinus Torvalds return res; 20491da177e4SLinus Torvalds } 20501da177e4SLinus Torvalds 20511da177e4SLinus Torvalds static Sg_fd * 20521da177e4SLinus Torvalds sg_add_sfp(Sg_device * sdp, int dev) 20531da177e4SLinus Torvalds { 20541da177e4SLinus Torvalds Sg_fd *sfp; 20551da177e4SLinus Torvalds unsigned long iflags; 205644ec9542SAlan Stern int bufflen; 20571da177e4SLinus Torvalds 2058d6b10348SMike Christie sfp = kzalloc(sizeof(*sfp), GFP_ATOMIC | __GFP_NOWARN); 20591da177e4SLinus Torvalds if (!sfp) 20601da177e4SLinus Torvalds return NULL; 2061d6b10348SMike Christie 20621da177e4SLinus Torvalds init_waitqueue_head(&sfp->read_wait); 20631da177e4SLinus Torvalds rwlock_init(&sfp->rq_list_lock); 20641da177e4SLinus Torvalds 2065c6517b79STony Battersby kref_init(&sfp->f_ref); 20661da177e4SLinus Torvalds sfp->timeout = SG_DEFAULT_TIMEOUT; 20671da177e4SLinus Torvalds sfp->timeout_user = SG_DEFAULT_TIMEOUT_USER; 20681da177e4SLinus Torvalds sfp->force_packid = SG_DEF_FORCE_PACK_ID; 20691da177e4SLinus Torvalds sfp->low_dma = (SG_DEF_FORCE_LOW_DMA == 0) ? 20701da177e4SLinus Torvalds sdp->device->host->unchecked_isa_dma : 1; 20711da177e4SLinus Torvalds sfp->cmd_q = SG_DEF_COMMAND_Q; 20721da177e4SLinus Torvalds sfp->keep_orphan = SG_DEF_KEEP_ORPHAN; 20731da177e4SLinus Torvalds sfp->parentdp = sdp; 20747c07d613SJames Bottomley write_lock_irqsave(&sg_index_lock, iflags); 20753442f802SFUJITA Tomonori list_add_tail(&sfp->sfd_siblings, &sdp->sfds); 20767c07d613SJames Bottomley write_unlock_irqrestore(&sg_index_lock, iflags); 20771da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp: sfp=0x%p\n", sfp)); 20786460e75aSDouglas Gilbert if (unlikely(sg_big_buff != def_reserved_size)) 20796460e75aSDouglas Gilbert sg_big_buff = def_reserved_size; 20806460e75aSDouglas Gilbert 208144ec9542SAlan Stern bufflen = min_t(int, sg_big_buff, 2082ae03bf63SMartin K. Petersen queue_max_sectors(sdp->device->request_queue) * 512); 208344ec9542SAlan Stern sg_build_reserve(sfp, bufflen); 20841da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp: bufflen=%d, k_use_sg=%d\n", 20851da177e4SLinus Torvalds sfp->reserve.bufflen, sfp->reserve.k_use_sg)); 2086c6517b79STony Battersby 2087c6517b79STony Battersby kref_get(&sdp->d_ref); 2088c6517b79STony Battersby __module_get(THIS_MODULE); 20891da177e4SLinus Torvalds return sfp; 20901da177e4SLinus Torvalds } 20911da177e4SLinus Torvalds 2092c6517b79STony Battersby static void sg_remove_sfp_usercontext(struct work_struct *work) 20931da177e4SLinus Torvalds { 2094c6517b79STony Battersby struct sg_fd *sfp = container_of(work, struct sg_fd, ew.work); 2095c6517b79STony Battersby struct sg_device *sdp = sfp->parentdp; 20961da177e4SLinus Torvalds 2097c6517b79STony Battersby /* Cleanup any responses which were never read(). */ 2098c6517b79STony Battersby while (sfp->headrp) 2099c6517b79STony Battersby sg_finish_rem_req(sfp->headrp); 2100c6517b79STony Battersby 21011da177e4SLinus Torvalds if (sfp->reserve.bufflen > 0) { 21021da177e4SLinus Torvalds SCSI_LOG_TIMEOUT(6, 2103c6517b79STony Battersby printk("sg_remove_sfp: bufflen=%d, k_use_sg=%d\n", 2104c6517b79STony Battersby (int) sfp->reserve.bufflen, 2105c6517b79STony Battersby (int) sfp->reserve.k_use_sg)); 21061da177e4SLinus Torvalds sg_remove_scat(&sfp->reserve); 21071da177e4SLinus Torvalds } 2108c6517b79STony Battersby 2109c6517b79STony Battersby SCSI_LOG_TIMEOUT(6, 2110c6517b79STony Battersby printk("sg_remove_sfp: %s, sfp=0x%p\n", 2111c6517b79STony Battersby sdp->disk->disk_name, 2112c6517b79STony Battersby sfp)); 2113d6b10348SMike Christie kfree(sfp); 2114c6517b79STony Battersby 2115c6517b79STony Battersby scsi_device_put(sdp->device); 2116c6517b79STony Battersby sg_put_dev(sdp); 2117c6517b79STony Battersby module_put(THIS_MODULE); 21181da177e4SLinus Torvalds } 21191da177e4SLinus Torvalds 2120c6517b79STony Battersby static void sg_remove_sfp(struct kref *kref) 21211da177e4SLinus Torvalds { 2122c6517b79STony Battersby struct sg_fd *sfp = container_of(kref, struct sg_fd, f_ref); 2123c6517b79STony Battersby struct sg_device *sdp = sfp->parentdp; 21241da177e4SLinus Torvalds unsigned long iflags; 21251da177e4SLinus Torvalds 21267c07d613SJames Bottomley write_lock_irqsave(&sg_index_lock, iflags); 21273442f802SFUJITA Tomonori list_del(&sfp->sfd_siblings); 21287c07d613SJames Bottomley write_unlock_irqrestore(&sg_index_lock, iflags); 2129c6517b79STony Battersby wake_up_interruptible(&sdp->o_excl_wait); 2130c6517b79STony Battersby 2131015640edSFUJITA Tomonori INIT_WORK(&sfp->ew.work, sg_remove_sfp_usercontext); 2132015640edSFUJITA Tomonori schedule_work(&sfp->ew.work); 21331da177e4SLinus Torvalds } 21341da177e4SLinus Torvalds 21351da177e4SLinus Torvalds static int 21361da177e4SLinus Torvalds sg_res_in_use(Sg_fd * sfp) 21371da177e4SLinus Torvalds { 21381da177e4SLinus Torvalds const Sg_request *srp; 21391da177e4SLinus Torvalds unsigned long iflags; 21401da177e4SLinus Torvalds 21411da177e4SLinus Torvalds read_lock_irqsave(&sfp->rq_list_lock, iflags); 21421da177e4SLinus Torvalds for (srp = sfp->headrp; srp; srp = srp->nextrp) 21431da177e4SLinus Torvalds if (srp->res_used) 21441da177e4SLinus Torvalds break; 21451da177e4SLinus Torvalds read_unlock_irqrestore(&sfp->rq_list_lock, iflags); 21461da177e4SLinus Torvalds return srp ? 1 : 0; 21471da177e4SLinus Torvalds } 21481da177e4SLinus Torvalds 21491da177e4SLinus Torvalds #ifdef CONFIG_SCSI_PROC_FS 21501da177e4SLinus Torvalds static int 21517c07d613SJames Bottomley sg_idr_max_id(int id, void *p, void *data) 21527c07d613SJames Bottomley { 21537c07d613SJames Bottomley int *k = data; 21547c07d613SJames Bottomley 21557c07d613SJames Bottomley if (*k < id) 21567c07d613SJames Bottomley *k = id; 21577c07d613SJames Bottomley 21587c07d613SJames Bottomley return 0; 21597c07d613SJames Bottomley } 21607c07d613SJames Bottomley 21617c07d613SJames Bottomley static int 21621da177e4SLinus Torvalds sg_last_dev(void) 21631da177e4SLinus Torvalds { 216453474c04STony Battersby int k = -1; 21651da177e4SLinus Torvalds unsigned long iflags; 21661da177e4SLinus Torvalds 21677c07d613SJames Bottomley read_lock_irqsave(&sg_index_lock, iflags); 21687c07d613SJames Bottomley idr_for_each(&sg_index_idr, sg_idr_max_id, &k); 21697c07d613SJames Bottomley read_unlock_irqrestore(&sg_index_lock, iflags); 21701da177e4SLinus Torvalds return k + 1; /* origin 1 */ 21711da177e4SLinus Torvalds } 21721da177e4SLinus Torvalds #endif 21731da177e4SLinus Torvalds 2174c6517b79STony Battersby /* must be called with sg_index_lock held */ 2175c6517b79STony Battersby static Sg_device *sg_lookup_dev(int dev) 21761da177e4SLinus Torvalds { 2177c6517b79STony Battersby return idr_find(&sg_index_idr, dev); 2178c6517b79STony Battersby } 21791da177e4SLinus Torvalds 2180c6517b79STony Battersby static Sg_device *sg_get_dev(int dev) 2181c6517b79STony Battersby { 2182c6517b79STony Battersby struct sg_device *sdp; 2183c6517b79STony Battersby unsigned long flags; 2184c6517b79STony Battersby 2185c6517b79STony Battersby read_lock_irqsave(&sg_index_lock, flags); 2186c6517b79STony Battersby sdp = sg_lookup_dev(dev); 2187c6517b79STony Battersby if (!sdp) 2188c6517b79STony Battersby sdp = ERR_PTR(-ENXIO); 2189c6517b79STony Battersby else if (sdp->detached) { 2190c6517b79STony Battersby /* If sdp->detached, then the refcount may already be 0, in 2191c6517b79STony Battersby * which case it would be a bug to do kref_get(). 2192c6517b79STony Battersby */ 2193c6517b79STony Battersby sdp = ERR_PTR(-ENODEV); 2194c6517b79STony Battersby } else 2195c6517b79STony Battersby kref_get(&sdp->d_ref); 2196c6517b79STony Battersby read_unlock_irqrestore(&sg_index_lock, flags); 21977c07d613SJames Bottomley 21981da177e4SLinus Torvalds return sdp; 21991da177e4SLinus Torvalds } 22001da177e4SLinus Torvalds 2201c6517b79STony Battersby static void sg_put_dev(struct sg_device *sdp) 2202c6517b79STony Battersby { 2203c6517b79STony Battersby kref_put(&sdp->d_ref, sg_device_destroy); 2204c6517b79STony Battersby } 2205c6517b79STony Battersby 22061da177e4SLinus Torvalds #ifdef CONFIG_SCSI_PROC_FS 22071da177e4SLinus Torvalds 22081da177e4SLinus Torvalds static struct proc_dir_entry *sg_proc_sgp = NULL; 22091da177e4SLinus Torvalds 22101da177e4SLinus Torvalds static char sg_proc_sg_dirname[] = "scsi/sg"; 22111da177e4SLinus Torvalds 22121da177e4SLinus Torvalds static int sg_proc_seq_show_int(struct seq_file *s, void *v); 22131da177e4SLinus Torvalds 22141da177e4SLinus Torvalds static int sg_proc_single_open_adio(struct inode *inode, struct file *file); 22151da177e4SLinus Torvalds static ssize_t sg_proc_write_adio(struct file *filp, const char __user *buffer, 22161da177e4SLinus Torvalds size_t count, loff_t *off); 2217828c0950SAlexey Dobriyan static const struct file_operations adio_fops = { 2218828c0950SAlexey Dobriyan .owner = THIS_MODULE, 22191da177e4SLinus Torvalds .open = sg_proc_single_open_adio, 2220828c0950SAlexey Dobriyan .read = seq_read, 2221828c0950SAlexey Dobriyan .llseek = seq_lseek, 22221da177e4SLinus Torvalds .write = sg_proc_write_adio, 22231da177e4SLinus Torvalds .release = single_release, 22241da177e4SLinus Torvalds }; 22251da177e4SLinus Torvalds 22261da177e4SLinus Torvalds static int sg_proc_single_open_dressz(struct inode *inode, struct file *file); 22271da177e4SLinus Torvalds static ssize_t sg_proc_write_dressz(struct file *filp, 22281da177e4SLinus Torvalds const char __user *buffer, size_t count, loff_t *off); 2229828c0950SAlexey Dobriyan static const struct file_operations dressz_fops = { 2230828c0950SAlexey Dobriyan .owner = THIS_MODULE, 22311da177e4SLinus Torvalds .open = sg_proc_single_open_dressz, 2232828c0950SAlexey Dobriyan .read = seq_read, 2233828c0950SAlexey Dobriyan .llseek = seq_lseek, 22341da177e4SLinus Torvalds .write = sg_proc_write_dressz, 22351da177e4SLinus Torvalds .release = single_release, 22361da177e4SLinus Torvalds }; 22371da177e4SLinus Torvalds 22381da177e4SLinus Torvalds static int sg_proc_seq_show_version(struct seq_file *s, void *v); 22391da177e4SLinus Torvalds static int sg_proc_single_open_version(struct inode *inode, struct file *file); 2240828c0950SAlexey Dobriyan static const struct file_operations version_fops = { 2241828c0950SAlexey Dobriyan .owner = THIS_MODULE, 22421da177e4SLinus Torvalds .open = sg_proc_single_open_version, 2243828c0950SAlexey Dobriyan .read = seq_read, 2244828c0950SAlexey Dobriyan .llseek = seq_lseek, 22451da177e4SLinus Torvalds .release = single_release, 22461da177e4SLinus Torvalds }; 22471da177e4SLinus Torvalds 22481da177e4SLinus Torvalds static int sg_proc_seq_show_devhdr(struct seq_file *s, void *v); 22491da177e4SLinus Torvalds static int sg_proc_single_open_devhdr(struct inode *inode, struct file *file); 2250828c0950SAlexey Dobriyan static const struct file_operations devhdr_fops = { 2251828c0950SAlexey Dobriyan .owner = THIS_MODULE, 22521da177e4SLinus Torvalds .open = sg_proc_single_open_devhdr, 2253828c0950SAlexey Dobriyan .read = seq_read, 2254828c0950SAlexey Dobriyan .llseek = seq_lseek, 22551da177e4SLinus Torvalds .release = single_release, 22561da177e4SLinus Torvalds }; 22571da177e4SLinus Torvalds 22581da177e4SLinus Torvalds static int sg_proc_seq_show_dev(struct seq_file *s, void *v); 22591da177e4SLinus Torvalds static int sg_proc_open_dev(struct inode *inode, struct file *file); 22601da177e4SLinus Torvalds static void * dev_seq_start(struct seq_file *s, loff_t *pos); 22611da177e4SLinus Torvalds static void * dev_seq_next(struct seq_file *s, void *v, loff_t *pos); 22621da177e4SLinus Torvalds static void dev_seq_stop(struct seq_file *s, void *v); 2263828c0950SAlexey Dobriyan static const struct file_operations dev_fops = { 2264828c0950SAlexey Dobriyan .owner = THIS_MODULE, 22651da177e4SLinus Torvalds .open = sg_proc_open_dev, 2266828c0950SAlexey Dobriyan .read = seq_read, 2267828c0950SAlexey Dobriyan .llseek = seq_lseek, 22681da177e4SLinus Torvalds .release = seq_release, 22691da177e4SLinus Torvalds }; 227088e9d34cSJames Morris static const struct seq_operations dev_seq_ops = { 22711da177e4SLinus Torvalds .start = dev_seq_start, 22721da177e4SLinus Torvalds .next = dev_seq_next, 22731da177e4SLinus Torvalds .stop = dev_seq_stop, 22741da177e4SLinus Torvalds .show = sg_proc_seq_show_dev, 22751da177e4SLinus Torvalds }; 22761da177e4SLinus Torvalds 22771da177e4SLinus Torvalds static int sg_proc_seq_show_devstrs(struct seq_file *s, void *v); 22781da177e4SLinus Torvalds static int sg_proc_open_devstrs(struct inode *inode, struct file *file); 2279828c0950SAlexey Dobriyan static const struct file_operations devstrs_fops = { 2280828c0950SAlexey Dobriyan .owner = THIS_MODULE, 22811da177e4SLinus Torvalds .open = sg_proc_open_devstrs, 2282828c0950SAlexey Dobriyan .read = seq_read, 2283828c0950SAlexey Dobriyan .llseek = seq_lseek, 22841da177e4SLinus Torvalds .release = seq_release, 22851da177e4SLinus Torvalds }; 228688e9d34cSJames Morris static const struct seq_operations devstrs_seq_ops = { 22871da177e4SLinus Torvalds .start = dev_seq_start, 22881da177e4SLinus Torvalds .next = dev_seq_next, 22891da177e4SLinus Torvalds .stop = dev_seq_stop, 22901da177e4SLinus Torvalds .show = sg_proc_seq_show_devstrs, 22911da177e4SLinus Torvalds }; 22921da177e4SLinus Torvalds 22931da177e4SLinus Torvalds static int sg_proc_seq_show_debug(struct seq_file *s, void *v); 22941da177e4SLinus Torvalds static int sg_proc_open_debug(struct inode *inode, struct file *file); 2295828c0950SAlexey Dobriyan static const struct file_operations debug_fops = { 2296828c0950SAlexey Dobriyan .owner = THIS_MODULE, 22971da177e4SLinus Torvalds .open = sg_proc_open_debug, 2298828c0950SAlexey Dobriyan .read = seq_read, 2299828c0950SAlexey Dobriyan .llseek = seq_lseek, 23001da177e4SLinus Torvalds .release = seq_release, 23011da177e4SLinus Torvalds }; 230288e9d34cSJames Morris static const struct seq_operations debug_seq_ops = { 23031da177e4SLinus Torvalds .start = dev_seq_start, 23041da177e4SLinus Torvalds .next = dev_seq_next, 23051da177e4SLinus Torvalds .stop = dev_seq_stop, 23061da177e4SLinus Torvalds .show = sg_proc_seq_show_debug, 23071da177e4SLinus Torvalds }; 23081da177e4SLinus Torvalds 23091da177e4SLinus Torvalds 23101da177e4SLinus Torvalds struct sg_proc_leaf { 23111da177e4SLinus Torvalds const char * name; 2312828c0950SAlexey Dobriyan const struct file_operations * fops; 23131da177e4SLinus Torvalds }; 23141da177e4SLinus Torvalds 23151da177e4SLinus Torvalds static struct sg_proc_leaf sg_proc_leaf_arr[] = { 23161da177e4SLinus Torvalds {"allow_dio", &adio_fops}, 23171da177e4SLinus Torvalds {"debug", &debug_fops}, 23181da177e4SLinus Torvalds {"def_reserved_size", &dressz_fops}, 23191da177e4SLinus Torvalds {"device_hdr", &devhdr_fops}, 23201da177e4SLinus Torvalds {"devices", &dev_fops}, 23211da177e4SLinus Torvalds {"device_strs", &devstrs_fops}, 23221da177e4SLinus Torvalds {"version", &version_fops} 23231da177e4SLinus Torvalds }; 23241da177e4SLinus Torvalds 23251da177e4SLinus Torvalds static int 23261da177e4SLinus Torvalds sg_proc_init(void) 23271da177e4SLinus Torvalds { 23281da177e4SLinus Torvalds int k, mask; 23296391a113STobias Klauser int num_leaves = ARRAY_SIZE(sg_proc_leaf_arr); 23301da177e4SLinus Torvalds struct sg_proc_leaf * leaf; 23311da177e4SLinus Torvalds 233266600221SAl Viro sg_proc_sgp = proc_mkdir(sg_proc_sg_dirname, NULL); 23331da177e4SLinus Torvalds if (!sg_proc_sgp) 23341da177e4SLinus Torvalds return 1; 23351da177e4SLinus Torvalds for (k = 0; k < num_leaves; ++k) { 23361da177e4SLinus Torvalds leaf = &sg_proc_leaf_arr[k]; 23371da177e4SLinus Torvalds mask = leaf->fops->write ? S_IRUGO | S_IWUSR : S_IRUGO; 2338a973909fSDenis V. Lunev proc_create(leaf->name, mask, sg_proc_sgp, leaf->fops); 23391da177e4SLinus Torvalds } 23401da177e4SLinus Torvalds return 0; 23411da177e4SLinus Torvalds } 23421da177e4SLinus Torvalds 23431da177e4SLinus Torvalds static void 23441da177e4SLinus Torvalds sg_proc_cleanup(void) 23451da177e4SLinus Torvalds { 23461da177e4SLinus Torvalds int k; 23476391a113STobias Klauser int num_leaves = ARRAY_SIZE(sg_proc_leaf_arr); 23481da177e4SLinus Torvalds 23491da177e4SLinus Torvalds if (!sg_proc_sgp) 23501da177e4SLinus Torvalds return; 23511da177e4SLinus Torvalds for (k = 0; k < num_leaves; ++k) 23521da177e4SLinus Torvalds remove_proc_entry(sg_proc_leaf_arr[k].name, sg_proc_sgp); 23531da177e4SLinus Torvalds remove_proc_entry(sg_proc_sg_dirname, NULL); 23541da177e4SLinus Torvalds } 23551da177e4SLinus Torvalds 23561da177e4SLinus Torvalds 23571da177e4SLinus Torvalds static int sg_proc_seq_show_int(struct seq_file *s, void *v) 23581da177e4SLinus Torvalds { 23591da177e4SLinus Torvalds seq_printf(s, "%d\n", *((int *)s->private)); 23601da177e4SLinus Torvalds return 0; 23611da177e4SLinus Torvalds } 23621da177e4SLinus Torvalds 23631da177e4SLinus Torvalds static int sg_proc_single_open_adio(struct inode *inode, struct file *file) 23641da177e4SLinus Torvalds { 23651da177e4SLinus Torvalds return single_open(file, sg_proc_seq_show_int, &sg_allow_dio); 23661da177e4SLinus Torvalds } 23671da177e4SLinus Torvalds 23681da177e4SLinus Torvalds static ssize_t 23691da177e4SLinus Torvalds sg_proc_write_adio(struct file *filp, const char __user *buffer, 23701da177e4SLinus Torvalds size_t count, loff_t *off) 23711da177e4SLinus Torvalds { 23721da177e4SLinus Torvalds int num; 23731da177e4SLinus Torvalds char buff[11]; 23741da177e4SLinus Torvalds 23751da177e4SLinus Torvalds if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO)) 23761da177e4SLinus Torvalds return -EACCES; 23771da177e4SLinus Torvalds num = (count < 10) ? count : 10; 23781da177e4SLinus Torvalds if (copy_from_user(buff, buffer, num)) 23791da177e4SLinus Torvalds return -EFAULT; 23801da177e4SLinus Torvalds buff[num] = '\0'; 23811da177e4SLinus Torvalds sg_allow_dio = simple_strtoul(buff, NULL, 10) ? 1 : 0; 23821da177e4SLinus Torvalds return count; 23831da177e4SLinus Torvalds } 23841da177e4SLinus Torvalds 23851da177e4SLinus Torvalds static int sg_proc_single_open_dressz(struct inode *inode, struct file *file) 23861da177e4SLinus Torvalds { 23871da177e4SLinus Torvalds return single_open(file, sg_proc_seq_show_int, &sg_big_buff); 23881da177e4SLinus Torvalds } 23891da177e4SLinus Torvalds 23901da177e4SLinus Torvalds static ssize_t 23911da177e4SLinus Torvalds sg_proc_write_dressz(struct file *filp, const char __user *buffer, 23921da177e4SLinus Torvalds size_t count, loff_t *off) 23931da177e4SLinus Torvalds { 23941da177e4SLinus Torvalds int num; 23951da177e4SLinus Torvalds unsigned long k = ULONG_MAX; 23961da177e4SLinus Torvalds char buff[11]; 23971da177e4SLinus Torvalds 23981da177e4SLinus Torvalds if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO)) 23991da177e4SLinus Torvalds return -EACCES; 24001da177e4SLinus Torvalds num = (count < 10) ? count : 10; 24011da177e4SLinus Torvalds if (copy_from_user(buff, buffer, num)) 24021da177e4SLinus Torvalds return -EFAULT; 24031da177e4SLinus Torvalds buff[num] = '\0'; 24041da177e4SLinus Torvalds k = simple_strtoul(buff, NULL, 10); 24051da177e4SLinus Torvalds if (k <= 1048576) { /* limit "big buff" to 1 MB */ 24061da177e4SLinus Torvalds sg_big_buff = k; 24071da177e4SLinus Torvalds return count; 24081da177e4SLinus Torvalds } 24091da177e4SLinus Torvalds return -ERANGE; 24101da177e4SLinus Torvalds } 24111da177e4SLinus Torvalds 24121da177e4SLinus Torvalds static int sg_proc_seq_show_version(struct seq_file *s, void *v) 24131da177e4SLinus Torvalds { 24141da177e4SLinus Torvalds seq_printf(s, "%d\t%s [%s]\n", sg_version_num, SG_VERSION_STR, 24151da177e4SLinus Torvalds sg_version_date); 24161da177e4SLinus Torvalds return 0; 24171da177e4SLinus Torvalds } 24181da177e4SLinus Torvalds 24191da177e4SLinus Torvalds static int sg_proc_single_open_version(struct inode *inode, struct file *file) 24201da177e4SLinus Torvalds { 24211da177e4SLinus Torvalds return single_open(file, sg_proc_seq_show_version, NULL); 24221da177e4SLinus Torvalds } 24231da177e4SLinus Torvalds 24241da177e4SLinus Torvalds static int sg_proc_seq_show_devhdr(struct seq_file *s, void *v) 24251da177e4SLinus Torvalds { 24261da177e4SLinus Torvalds seq_printf(s, "host\tchan\tid\tlun\ttype\topens\tqdepth\tbusy\t" 24271da177e4SLinus Torvalds "online\n"); 24281da177e4SLinus Torvalds return 0; 24291da177e4SLinus Torvalds } 24301da177e4SLinus Torvalds 24311da177e4SLinus Torvalds static int sg_proc_single_open_devhdr(struct inode *inode, struct file *file) 24321da177e4SLinus Torvalds { 24331da177e4SLinus Torvalds return single_open(file, sg_proc_seq_show_devhdr, NULL); 24341da177e4SLinus Torvalds } 24351da177e4SLinus Torvalds 24361da177e4SLinus Torvalds struct sg_proc_deviter { 24371da177e4SLinus Torvalds loff_t index; 24381da177e4SLinus Torvalds size_t max; 24391da177e4SLinus Torvalds }; 24401da177e4SLinus Torvalds 24411da177e4SLinus Torvalds static void * dev_seq_start(struct seq_file *s, loff_t *pos) 24421da177e4SLinus Torvalds { 24431da177e4SLinus Torvalds struct sg_proc_deviter * it = kmalloc(sizeof(*it), GFP_KERNEL); 24441da177e4SLinus Torvalds 2445729d70f5SJan Blunck s->private = it; 24461da177e4SLinus Torvalds if (! it) 24471da177e4SLinus Torvalds return NULL; 2448729d70f5SJan Blunck 24491da177e4SLinus Torvalds it->index = *pos; 24501da177e4SLinus Torvalds it->max = sg_last_dev(); 24511da177e4SLinus Torvalds if (it->index >= it->max) 24521da177e4SLinus Torvalds return NULL; 2453729d70f5SJan Blunck return it; 24541da177e4SLinus Torvalds } 24551da177e4SLinus Torvalds 24561da177e4SLinus Torvalds static void * dev_seq_next(struct seq_file *s, void *v, loff_t *pos) 24571da177e4SLinus Torvalds { 2458729d70f5SJan Blunck struct sg_proc_deviter * it = s->private; 24591da177e4SLinus Torvalds 24601da177e4SLinus Torvalds *pos = ++it->index; 24611da177e4SLinus Torvalds return (it->index < it->max) ? it : NULL; 24621da177e4SLinus Torvalds } 24631da177e4SLinus Torvalds 24641da177e4SLinus Torvalds static void dev_seq_stop(struct seq_file *s, void *v) 24651da177e4SLinus Torvalds { 2466729d70f5SJan Blunck kfree(s->private); 24671da177e4SLinus Torvalds } 24681da177e4SLinus Torvalds 24691da177e4SLinus Torvalds static int sg_proc_open_dev(struct inode *inode, struct file *file) 24701da177e4SLinus Torvalds { 24711da177e4SLinus Torvalds return seq_open(file, &dev_seq_ops); 24721da177e4SLinus Torvalds } 24731da177e4SLinus Torvalds 24741da177e4SLinus Torvalds static int sg_proc_seq_show_dev(struct seq_file *s, void *v) 24751da177e4SLinus Torvalds { 24761da177e4SLinus Torvalds struct sg_proc_deviter * it = (struct sg_proc_deviter *) v; 24771da177e4SLinus Torvalds Sg_device *sdp; 24781da177e4SLinus Torvalds struct scsi_device *scsidp; 2479c6517b79STony Battersby unsigned long iflags; 24801da177e4SLinus Torvalds 2481c6517b79STony Battersby read_lock_irqsave(&sg_index_lock, iflags); 2482c6517b79STony Battersby sdp = it ? sg_lookup_dev(it->index) : NULL; 24831da177e4SLinus Torvalds if (sdp && (scsidp = sdp->device) && (!sdp->detached)) 24841da177e4SLinus Torvalds seq_printf(s, "%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n", 24851da177e4SLinus Torvalds scsidp->host->host_no, scsidp->channel, 24861da177e4SLinus Torvalds scsidp->id, scsidp->lun, (int) scsidp->type, 24871da177e4SLinus Torvalds 1, 24881da177e4SLinus Torvalds (int) scsidp->queue_depth, 24891da177e4SLinus Torvalds (int) scsidp->device_busy, 24901da177e4SLinus Torvalds (int) scsi_device_online(scsidp)); 24911da177e4SLinus Torvalds else 24921da177e4SLinus Torvalds seq_printf(s, "-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\n"); 2493c6517b79STony Battersby read_unlock_irqrestore(&sg_index_lock, iflags); 24941da177e4SLinus Torvalds return 0; 24951da177e4SLinus Torvalds } 24961da177e4SLinus Torvalds 24971da177e4SLinus Torvalds static int sg_proc_open_devstrs(struct inode *inode, struct file *file) 24981da177e4SLinus Torvalds { 24991da177e4SLinus Torvalds return seq_open(file, &devstrs_seq_ops); 25001da177e4SLinus Torvalds } 25011da177e4SLinus Torvalds 25021da177e4SLinus Torvalds static int sg_proc_seq_show_devstrs(struct seq_file *s, void *v) 25031da177e4SLinus Torvalds { 25041da177e4SLinus Torvalds struct sg_proc_deviter * it = (struct sg_proc_deviter *) v; 25051da177e4SLinus Torvalds Sg_device *sdp; 25061da177e4SLinus Torvalds struct scsi_device *scsidp; 2507c6517b79STony Battersby unsigned long iflags; 25081da177e4SLinus Torvalds 2509c6517b79STony Battersby read_lock_irqsave(&sg_index_lock, iflags); 2510c6517b79STony Battersby sdp = it ? sg_lookup_dev(it->index) : NULL; 25111da177e4SLinus Torvalds if (sdp && (scsidp = sdp->device) && (!sdp->detached)) 25121da177e4SLinus Torvalds seq_printf(s, "%8.8s\t%16.16s\t%4.4s\n", 25131da177e4SLinus Torvalds scsidp->vendor, scsidp->model, scsidp->rev); 25141da177e4SLinus Torvalds else 25151da177e4SLinus Torvalds seq_printf(s, "<no active device>\n"); 2516c6517b79STony Battersby read_unlock_irqrestore(&sg_index_lock, iflags); 25171da177e4SLinus Torvalds return 0; 25181da177e4SLinus Torvalds } 25191da177e4SLinus Torvalds 2520c6517b79STony Battersby /* must be called while holding sg_index_lock */ 25211da177e4SLinus Torvalds static void sg_proc_debug_helper(struct seq_file *s, Sg_device * sdp) 25221da177e4SLinus Torvalds { 25231da177e4SLinus Torvalds int k, m, new_interface, blen, usg; 25241da177e4SLinus Torvalds Sg_request *srp; 25251da177e4SLinus Torvalds Sg_fd *fp; 25261da177e4SLinus Torvalds const sg_io_hdr_t *hp; 25271da177e4SLinus Torvalds const char * cp; 2528cb59e840S unsigned int ms; 25291da177e4SLinus Torvalds 25303442f802SFUJITA Tomonori k = 0; 25313442f802SFUJITA Tomonori list_for_each_entry(fp, &sdp->sfds, sfd_siblings) { 25323442f802SFUJITA Tomonori k++; 2533c6517b79STony Battersby read_lock(&fp->rq_list_lock); /* irqs already disabled */ 25341da177e4SLinus Torvalds seq_printf(s, " FD(%d): timeout=%dms bufflen=%d " 25353442f802SFUJITA Tomonori "(res)sgat=%d low_dma=%d\n", k, 25361da177e4SLinus Torvalds jiffies_to_msecs(fp->timeout), 25371da177e4SLinus Torvalds fp->reserve.bufflen, 25381da177e4SLinus Torvalds (int) fp->reserve.k_use_sg, 25391da177e4SLinus Torvalds (int) fp->low_dma); 25401da177e4SLinus Torvalds seq_printf(s, " cmd_q=%d f_packid=%d k_orphan=%d closed=%d\n", 25411da177e4SLinus Torvalds (int) fp->cmd_q, (int) fp->force_packid, 25421da177e4SLinus Torvalds (int) fp->keep_orphan, (int) fp->closed); 2543c6517b79STony Battersby for (m = 0, srp = fp->headrp; 2544c6517b79STony Battersby srp != NULL; 2545c6517b79STony Battersby ++m, srp = srp->nextrp) { 25461da177e4SLinus Torvalds hp = &srp->header; 25471da177e4SLinus Torvalds new_interface = (hp->interface_id == '\0') ? 0 : 1; 25481da177e4SLinus Torvalds if (srp->res_used) { 25491da177e4SLinus Torvalds if (new_interface && 25501da177e4SLinus Torvalds (SG_FLAG_MMAP_IO & hp->flags)) 25511da177e4SLinus Torvalds cp = " mmap>> "; 25521da177e4SLinus Torvalds else 25531da177e4SLinus Torvalds cp = " rb>> "; 25541da177e4SLinus Torvalds } else { 25551da177e4SLinus Torvalds if (SG_INFO_DIRECT_IO_MASK & hp->info) 25561da177e4SLinus Torvalds cp = " dio>> "; 25571da177e4SLinus Torvalds else 25581da177e4SLinus Torvalds cp = " "; 25591da177e4SLinus Torvalds } 25601da177e4SLinus Torvalds seq_printf(s, cp); 2561d6b10348SMike Christie blen = srp->data.bufflen; 2562d6b10348SMike Christie usg = srp->data.k_use_sg; 25631da177e4SLinus Torvalds seq_printf(s, srp->done ? 25641da177e4SLinus Torvalds ((1 == srp->done) ? "rcv:" : "fin:") 2565d6b10348SMike Christie : "act:"); 25661da177e4SLinus Torvalds seq_printf(s, " id=%d blen=%d", 25671da177e4SLinus Torvalds srp->header.pack_id, blen); 25681da177e4SLinus Torvalds if (srp->done) 25691da177e4SLinus Torvalds seq_printf(s, " dur=%d", hp->duration); 2570cb59e840S else { 2571cb59e840S ms = jiffies_to_msecs(jiffies); 25721da177e4SLinus Torvalds seq_printf(s, " t_o/elap=%d/%d", 2573cb59e840S (new_interface ? hp->timeout : 2574cb59e840S jiffies_to_msecs(fp->timeout)), 2575cb59e840S (ms > hp->duration ? ms - hp->duration : 0)); 2576cb59e840S } 25771da177e4SLinus Torvalds seq_printf(s, "ms sgat=%d op=0x%02x\n", usg, 25781da177e4SLinus Torvalds (int) srp->data.cmd_opcode); 25791da177e4SLinus Torvalds } 25801da177e4SLinus Torvalds if (0 == m) 25811da177e4SLinus Torvalds seq_printf(s, " No requests active\n"); 2582c6517b79STony Battersby read_unlock(&fp->rq_list_lock); 25831da177e4SLinus Torvalds } 25841da177e4SLinus Torvalds } 25851da177e4SLinus Torvalds 25861da177e4SLinus Torvalds static int sg_proc_open_debug(struct inode *inode, struct file *file) 25871da177e4SLinus Torvalds { 25881da177e4SLinus Torvalds return seq_open(file, &debug_seq_ops); 25891da177e4SLinus Torvalds } 25901da177e4SLinus Torvalds 25911da177e4SLinus Torvalds static int sg_proc_seq_show_debug(struct seq_file *s, void *v) 25921da177e4SLinus Torvalds { 25931da177e4SLinus Torvalds struct sg_proc_deviter * it = (struct sg_proc_deviter *) v; 25941da177e4SLinus Torvalds Sg_device *sdp; 2595c6517b79STony Battersby unsigned long iflags; 25961da177e4SLinus Torvalds 25971da177e4SLinus Torvalds if (it && (0 == it->index)) { 25987c07d613SJames Bottomley seq_printf(s, "max_active_device=%d(origin 1)\n", 25997c07d613SJames Bottomley (int)it->max); 26001da177e4SLinus Torvalds seq_printf(s, " def_reserved_size=%d\n", sg_big_buff); 26011da177e4SLinus Torvalds } 2602c6517b79STony Battersby 2603c6517b79STony Battersby read_lock_irqsave(&sg_index_lock, iflags); 2604c6517b79STony Battersby sdp = it ? sg_lookup_dev(it->index) : NULL; 26053442f802SFUJITA Tomonori if (sdp && !list_empty(&sdp->sfds)) { 26061da177e4SLinus Torvalds struct scsi_device *scsidp = sdp->device; 26071da177e4SLinus Torvalds 2608c6517b79STony Battersby seq_printf(s, " >>> device=%s ", sdp->disk->disk_name); 26091da177e4SLinus Torvalds if (sdp->detached) 26101da177e4SLinus Torvalds seq_printf(s, "detached pending close "); 26111da177e4SLinus Torvalds else 26121da177e4SLinus Torvalds seq_printf 26131da177e4SLinus Torvalds (s, "scsi%d chan=%d id=%d lun=%d em=%d", 26141da177e4SLinus Torvalds scsidp->host->host_no, 26151da177e4SLinus Torvalds scsidp->channel, scsidp->id, 26161da177e4SLinus Torvalds scsidp->lun, 26171da177e4SLinus Torvalds scsidp->host->hostt->emulated); 26181da177e4SLinus Torvalds seq_printf(s, " sg_tablesize=%d excl=%d\n", 26191da177e4SLinus Torvalds sdp->sg_tablesize, sdp->exclude); 26201da177e4SLinus Torvalds sg_proc_debug_helper(s, sdp); 26211da177e4SLinus Torvalds } 2622c6517b79STony Battersby read_unlock_irqrestore(&sg_index_lock, iflags); 26231da177e4SLinus Torvalds return 0; 26241da177e4SLinus Torvalds } 26251da177e4SLinus Torvalds 26261da177e4SLinus Torvalds #endif /* CONFIG_SCSI_PROC_FS */ 26271da177e4SLinus Torvalds 26281da177e4SLinus Torvalds module_init(init_sg); 26291da177e4SLinus Torvalds module_exit(exit_sg); 2630