drivers/scsi/sg.c

   1 /*
   2  *  History:
   3  *  Started: Aug 9 by Lawrence Foard (entropy@world.std.com),
   4  *           to allow user process control of SCSI devices.
   5  *  Development Sponsored by Killy Corp. NY NY
   6  *
   7  * Original driver (sg.c):
   8  *        Copyright (C) 1992 Lawrence Foard
   9  * Version 2 and 3 extensions to driver:
  10  *        Copyright (C) 1998 - 2003 Douglas Gilbert
  11  *
  12  *  Modified  19-JAN-1998  Richard Gooch <rgooch@atnf.csiro.au>  Devfs support
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2, or (at your option)
  17  * any later version.
  18  *
  19  */
  20 #include <linux/config.h>
  21 #ifdef CONFIG_PROC_FS
  22  static char * sg_version_str = "Version: 3.1.25 (20030529)";
  23 #endif
  24  static int sg_version_num = 30125; /* 2 digits for each component */
  25 /*
  26  *  D. P. Gilbert (dgilbert@interlog.com, dougg@triode.net.au), notes:
  27  *      - scsi logging is available via SCSI_LOG_TIMEOUT macros. First
  28  *        the kernel/module needs to be built with CONFIG_SCSI_LOGGING
  29  *        (otherwise the macros compile to empty statements).
  30  *        Then before running the program to be debugged enter:
  31  *          # echo "scsi log timeout 7" > /proc/scsi/scsi
  32  *        This will send copious output to the console and the log which
  33  *        is usually /var/log/messages. To turn off debugging enter:
  34  *          # echo "scsi log timeout 0" > /proc/scsi/scsi
  35  *        The 'timeout' token was chosen because it is relatively unused.
  36  *        The token 'hlcomplete' should be used but that triggers too
  37  *        much output from the sd device driver. To dump the current
  38  *        state of the SCSI mid level data structures enter:
  39  *          # echo "scsi dump 1" > /proc/scsi/scsi
  40  *        To dump the state of sg's data structures use:
  41  *          # cat /proc/scsi/sg/debug
  42  *
  43  */
  44 #include <linux/module.h>
  45
  46 #include <linux/fs.h>
  47 #include <linux/kernel.h>
  48 #include <linux/sched.h>
  49 #include <linux/string.h>
  50 #include <linux/mm.h>
  51 #include <linux/errno.h>
  52 #include <linux/mtio.h>
  53 #include <linux/ioctl.h>
  54 #include <linux/fcntl.h>
  55 #include <linux/init.h>
  56 #include <linux/poll.h>
  57 #include <linux/smp_lock.h>
  58
  59 #include <asm/io.h>
  60 #include <asm/uaccess.h>
  61 #include <asm/system.h>
  62
  63 #include <linux/blk.h>
  64 #include "scsi.h"
  65 #include "hosts.h"
  66 #include <scsi/scsi_ioctl.h>
  67 #include <scsi/sg.h>
  68
  69 #ifdef CONFIG_PROC_FS
  70 #include <linux/proc_fs.h>
  71 static int sg_proc_init(void);
  72 static void sg_proc_cleanup(void);
  73 #endif
  74
  75 #ifndef LINUX_VERSION_CODE
  76 #include <linux/version.h>
  77 #endif /* LINUX_VERSION_CODE */
  78
  79 #define SG_ALLOW_DIO_DEF 0
  80 #define SG_ALLOW_DIO_CODE       /* compile out be commenting this define */
  81 #ifdef SG_ALLOW_DIO_CODE
  82 #include <linux/iobuf.h>
  83 #endif
  84
  85 #define SG_NEW_KIOVEC 0 /* use alloc_kiovec(), not alloc_kiovec_sz() */
  86
  87 int sg_big_buff = SG_DEF_RESERVED_SIZE;
  88 /* N.B. This variable is readable and writeable via
  89    /proc/scsi/sg/def_reserved_size . Each time sg_open() is called a buffer
  90    of this size (or less if there is not enough memory) will be reserved
  91    for use by this file descriptor. [Deprecated usage: this variable is also
  92    readable via /proc/sys/kernel/sg-big-buff if the sg driver is built into
  93    the kernel (i.e. it is not a module).] */
  94 static int def_reserved_size = -1;      /* picks up init parameter */
  95 static int sg_allow_dio = SG_ALLOW_DIO_DEF;
  96
  97 #define SG_SECTOR_SZ 512
  98 #define SG_SECTOR_MSK (SG_SECTOR_SZ - 1)
  99
 100 #define SG_LOW_POOL_THRESHHOLD 30
 101 #define SG_MAX_POOL_SECTORS 320  /* Max. number of pool sectors to take */
 102
 103 static int sg_pool_secs_avail = SG_MAX_POOL_SECTORS;
 104
 105 #define SG_HEAP_PAGE 1  /* heap from kernel via get_free_pages() */
 106 #define SG_HEAP_KMAL 2  /* heap from kernel via kmalloc() */
 107 #define SG_HEAP_POOL 3  /* heap from scsi dma pool (mid-level) */
 108 #define SG_USER_MEM 4   /* memory belongs to user space */
 109
 110 #define SG_DEV_ARR_LUMP 6 /* amount to over allocate sg_dev_arr by */
 111
 112
 113 static int sg_init(void);
 114 static int sg_attach(Scsi_Device *);
 115 static void sg_finish(void);
 116 static int sg_detect(Scsi_Device *);
 117 static void sg_detach(Scsi_Device *);
 118
 119 static Scsi_Request * dummy_cmdp;       /* only used for sizeof */
 120
 121 static rwlock_t sg_dev_arr_lock = RW_LOCK_UNLOCKED;  /* Also used to lock
 122                         file descriptor list for device */
 123
 124 static struct Scsi_Device_Template sg_template =
 125 {
 126       tag:"sg",
 127       scsi_type:0xff,
 128       major:SCSI_GENERIC_MAJOR,
 129       detect:sg_detect,
 130       init:sg_init,
 131       finish:sg_finish,
 132       attach:sg_attach,
 133       detach:sg_detach
 134 };
 135
 136
 137 typedef struct sg_scatter_hold  /* holding area for scsi scatter gather info */
 138 {
 139     unsigned short k_use_sg;    /* Count of kernel scatter-gather pieces */
 140     unsigned short sglist_len;  /* size of malloc'd scatter-gather list ++ */
 141     unsigned bufflen;           /* Size of (aggregate) data buffer */
 142     unsigned b_malloc_len;      /* actual len malloc'ed in buffer */
 143     void * buffer;              /* Data buffer or scatter list + mem_src_arr */
 144     struct kiobuf * kiobp;      /* for direct IO information */
 145     char mapped;                /* indicates kiobp has locked pages */
 146     char buffer_mem_src;        /* heap whereabouts of 'buffer' */
 147     unsigned char cmd_opcode;   /* first byte of command */
 148 } Sg_scatter_hold;    /* 24 bytes long on i386 */
 149
 150 struct sg_device;               /* forward declarations */
 151 struct sg_fd;
 152
 153 typedef struct sg_request  /* SG_MAX_QUEUE requests outstanding per file */
 154 {
 155     Scsi_Request * my_cmdp;     /* != 0  when request with lower levels */
 156     struct sg_request * nextrp; /* NULL -> tail request (slist) */
 157     struct sg_fd * parentfp;    /* NULL -> not in use */
 158     Sg_scatter_hold data;       /* hold buffer, perhaps scatter list */
 159     sg_io_hdr_t header;         /* scsi command+info, see <scsi/sg.h> */
 160     unsigned char sense_b[sizeof(dummy_cmdp->sr_sense_buffer)];
 161     char res_used;              /* 1 -> using reserve buffer, 0 -> not ... */
 162     char orphan;                /* 1 -> drop on sight, 0 -> normal */
 163     char sg_io_owned;           /* 1 -> packet belongs to SG_IO */
 164     volatile char done;         /* 0->before bh, 1->before read, 2->read */
 165 } Sg_request; /* 168 bytes long on i386 */
 166
 167 typedef struct sg_fd /* holds the state of a file descriptor */
 168 {
 169     struct sg_fd * nextfp; /* NULL when last opened fd on this device */
 170     struct sg_device * parentdp;     /* owning device */
 171     wait_queue_head_t read_wait;     /* queue read until command done */
 172     rwlock_t rq_list_lock;           /* protect access to list in req_arr */
 173     int timeout;                     /* defaults to SG_DEFAULT_TIMEOUT */
 174     Sg_scatter_hold reserve;  /* buffer held for this file descriptor */
 175     unsigned save_scat_len;   /* original length of trunc. scat. element */
 176     Sg_request * headrp;      /* head of request slist, NULL->empty */
 177     struct fasync_struct * async_qp; /* used by asynchronous notification */
 178     Sg_request req_arr[SG_MAX_QUEUE]; /* used as singly-linked list */
 179     char low_dma;       /* as in parent but possibly overridden to 1 */
 180     char force_packid;  /* 1 -> pack_id input to read(), 0 -> ignored */
 181     volatile char closed; /* 1 -> fd closed but request(s) outstanding */
 182     char fd_mem_src;    /* heap whereabouts of this Sg_fd object */
 183     char cmd_q;         /* 1 -> allow command queuing, 0 -> don't */
 184     char next_cmd_len;  /* 0 -> automatic (def), >0 -> use on next write() */
 185     char keep_orphan;   /* 0 -> drop orphan (def), 1 -> keep for read() */
 186     char mmap_called;   /* 0 -> mmap() never called on this fd */
 187 } Sg_fd; /* 2760 bytes long on i386 */
 188
 189 typedef struct sg_device /* holds the state of each scsi generic device */
 190 {
 191     Scsi_Device * device;
 192     wait_queue_head_t o_excl_wait;   /* queue open() when O_EXCL in use */
 193     int sg_tablesize;   /* adapter's max scatter-gather table size */
 194     Sg_fd * headfp;     /* first open fd belonging to this device */
 195     devfs_handle_t de;
 196     kdev_t i_rdev;      /* holds device major+minor number */
 197     volatile char detached;  /* 0->attached, 1->detached pending removal */
 198     volatile char exclude;   /* opened for exclusive access */
 199     char sgdebug;       /* 0->off, 1->sense, 9->dump dev, 10-> all devs */
 200 } Sg_device; /* 36 bytes long on i386 */
 201
 202
 203 static int sg_fasync(int fd, struct file * filp, int mode);
 204 static void sg_cmd_done_bh(Scsi_Cmnd * SCpnt);
 205 static int sg_start_req(Sg_request * srp);
 206 static void sg_finish_rem_req(Sg_request * srp);
 207 static int sg_build_indi(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size);
 208 static int sg_build_sgat(Sg_scatter_hold * schp, const Sg_fd * sfp,
 209                          int tablesize);
 210 static ssize_t sg_new_read(Sg_fd * sfp, char * buf, size_t count,
 211                            Sg_request * srp);
 212 static ssize_t sg_new_write(Sg_fd * sfp, const char * buf, size_t count,
 213                         int blocking, int read_only, Sg_request ** o_srp);
 214 static int sg_common_write(Sg_fd * sfp, Sg_request * srp,
 215                            unsigned char * cmnd, int timeout, int blocking);
 216 static int sg_u_iovec(sg_io_hdr_t * hp, int sg_num, int ind,
 217                       int wr_xf, int * countp, unsigned char ** up);
 218 static int sg_write_xfer(Sg_request * srp);
 219 static int sg_read_xfer(Sg_request * srp);
 220 static void sg_read_oxfer(Sg_request * srp, char * outp, int num_read_xfer);
 221 static void sg_remove_scat(Sg_scatter_hold * schp);
 222 static char * sg_get_sgat_msa(Sg_scatter_hold * schp);
 223 static void sg_build_reserve(Sg_fd * sfp, int req_size);
 224 static void sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size);
 225 static void sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp);
 226 static char * sg_malloc(const Sg_fd * sfp, int size, int * retSzp,
 227                         int * mem_srcp);
 228 static void sg_free(char * buff, int size, int mem_src);
 229 static char * sg_low_malloc(int rqSz, int lowDma, int mem_src,
 230                             int * retSzp);
 231 static void sg_low_free(char * buff, int size, int mem_src);
 232 static Sg_fd * sg_add_sfp(Sg_device * sdp, int dev);
 233 static int sg_remove_sfp(Sg_device * sdp, Sg_fd * sfp);
 234 static void __sg_remove_sfp(Sg_device * sdp, Sg_fd * sfp);
 235 static Sg_request * sg_get_rq_mark(Sg_fd * sfp, int pack_id);
 236 static Sg_request * sg_add_request(Sg_fd * sfp);
 237 static int sg_remove_request(Sg_fd * sfp, Sg_request * srp);
 238 static int sg_res_in_use(Sg_fd * sfp);
 239 static int sg_ms_to_jif(unsigned int msecs);
 240 static inline unsigned sg_jif_to_ms(int jifs);
 241 static int sg_allow_access(unsigned char opcode, char dev_type);
 242 static int sg_build_dir(Sg_request * srp, Sg_fd * sfp, int dxfer_len);
 243 static void sg_unmap_and(Sg_scatter_hold * schp, int free_also);
 244 static Sg_device * sg_get_dev(int dev);
 245 static inline int sg_alloc_kiovec(int nr, struct kiobuf **bufp, int *szp);
 246 static inline void sg_free_kiovec(int nr, struct kiobuf **bufp, int *szp);
 247 #ifdef CONFIG_PROC_FS
 248 static int sg_last_dev(void);
 249 #endif
 250
 251 static Sg_device ** sg_dev_arr = NULL;
 252
 253 #define SZ_SG_HEADER sizeof(struct sg_header)
 254 #define SZ_SG_IO_HDR sizeof(sg_io_hdr_t)
 255 #define SZ_SG_IOVEC sizeof(sg_iovec_t)
 256 #define SZ_SG_REQ_INFO sizeof(sg_req_info_t)
 257
 258
 259 static int sg_open(struct inode * inode, struct file * filp)
 260 {
 261     int dev = MINOR(inode->i_rdev);
 262     int flags = filp->f_flags;
 263     Sg_device * sdp;
 264     Sg_fd * sfp;
 265     int res;
 266     int retval = -EBUSY;
 267
 268     SCSI_LOG_TIMEOUT(3, printk("sg_open: dev=%d, flags=0x%x\n", dev, flags));
 269     sdp = sg_get_dev(dev);
 270     if ((! sdp) || (! sdp->device))
 271         return -ENXIO;
 272     if (sdp->detached)
 273         return -ENODEV;
 274
 275      /* This driver's module count bumped by fops_get in <linux/fs.h> */
 276      /* Prevent the device driver from vanishing while we sleep */
 277      if (sdp->device->host->hostt->module)
 278         __MOD_INC_USE_COUNT(sdp->device->host->hostt->module);
 279     sdp->device->access_count++;
 280
 281     if (! ((flags & O_NONBLOCK) ||
 282            scsi_block_when_processing_errors(sdp->device))) {
 283         retval = -ENXIO;
 284         /* we are in error recovery for this device */
 285         goto error_out;
 286     }
 287
 288     if (flags & O_EXCL) {
 289         if (O_RDONLY == (flags & O_ACCMODE))  {
 290             retval = -EPERM;   /* Can't lock it with read only access */
 291             goto error_out;
 292         }
 293         if (sdp->headfp && (flags & O_NONBLOCK))
 294             goto error_out;
 295         res = 0;
 296         __wait_event_interruptible(sdp->o_excl_wait,
 297                ((sdp->headfp || sdp->exclude) ? 0 : (sdp->exclude = 1)),
 298                                    res);
 299         if (res) {
 300             retval = res; /* -ERESTARTSYS because signal hit process */
 301             goto error_out;
 302         }
 303     }
 304     else if (sdp->exclude) { /* some other fd has an exclusive lock on dev */
 305         if (flags & O_NONBLOCK)
 306             goto error_out;
 307         res = 0;
 308         __wait_event_interruptible(sdp->o_excl_wait, (! sdp->exclude), res);
 309         if (res) {
 310             retval = res; /* -ERESTARTSYS because signal hit process */
 311             goto error_out;
 312         }
 313     }
 314     if (sdp->detached) {
 315         retval = -ENODEV;
 316         goto error_out;
 317     }
 318     if (! sdp->headfp) { /* no existing opens on this device */
 319         sdp->sgdebug = 0;
 320         sdp->sg_tablesize = sdp->device->host->sg_tablesize;
 321     }
 322     if ((sfp = sg_add_sfp(sdp, dev)))
 323         filp->private_data = sfp;
 324     else {
 325         if (flags & O_EXCL) sdp->exclude = 0; /* undo if error */
 326         retval = -ENOMEM;
 327         goto error_out;
 328     }
 329     return 0;
 330
 331 error_out:
 332     sdp->device->access_count--;
 333     if ((! sdp->detached) && sdp->device->host->hostt->module)
 334         __MOD_DEC_USE_COUNT(sdp->device->host->hostt->module);
 335     return retval;
 336 }
 337
 338 /* Following function was formerly called 'sg_close' */
 339 static int sg_release(struct inode * inode, struct file * filp)
 340 {
 341     Sg_device * sdp;
 342     Sg_fd * sfp;
 343
 344     lock_kernel();
 345     if ((! (sfp = (Sg_fd *)filp->private_data)) || (! (sdp = sfp->parentdp))) {
 346         unlock_kernel();
 347         return -ENXIO;
 348     }
 349     SCSI_LOG_TIMEOUT(3, printk("sg_release: dev=%d\n", MINOR(sdp->i_rdev)));
 350     sg_fasync(-1, filp, 0);   /* remove filp from async notification list */
 351     if (0 == sg_remove_sfp(sdp, sfp)) { /* Returns 1 when sdp gone */
 352         if (! sdp->detached) {
 353             sdp->device->access_count--;
 354             if (sdp->device->host->hostt->module)
 355                 __MOD_DEC_USE_COUNT(sdp->device->host->hostt->module);
 356         }
 357         sdp->exclude = 0;
 358         wake_up_interruptible(&sdp->o_excl_wait);
 359     }
 360     unlock_kernel();
 361     return 0;
 362 }
 363
 364 static ssize_t sg_read(struct file * filp, char * buf,
 365                        size_t count, loff_t *ppos)
 366 {
 367     int k, res;
 368     Sg_device * sdp;
 369     Sg_fd * sfp;
 370     Sg_request * srp;
 371     int req_pack_id = -1;
 372     struct sg_header old_hdr;
 373     sg_io_hdr_t new_hdr;
 374     sg_io_hdr_t * hp;
 375
 376     if ((! (sfp = (Sg_fd *)filp->private_data)) || (! (sdp = sfp->parentdp)))
 377         return -ENXIO;
 378     SCSI_LOG_TIMEOUT(3, printk("sg_read: dev=%d, count=%d\n",
 379                                MINOR(sdp->i_rdev), (int)count));
 380     if (ppos != &filp->f_pos)
 381         ; /* FIXME: Hmm.  Seek to the right place, or fail?  */
 382     if ((k = verify_area(VERIFY_WRITE, buf, count)))
 383         return k;
 384     if (sfp->force_packid && (count >= SZ_SG_HEADER)) {
 385         __copy_from_user(&old_hdr, buf, SZ_SG_HEADER);
 386         if (old_hdr.reply_len < 0) {
 387             if (count >= SZ_SG_IO_HDR) {
 388                 __copy_from_user(&new_hdr, buf, SZ_SG_IO_HDR);
 389                 req_pack_id = new_hdr.pack_id;
 390             }
 391         }
 392         else
 393             req_pack_id = old_hdr.pack_id;
 394     }
 395     srp = sg_get_rq_mark(sfp, req_pack_id);
 396     if (! srp) { /* now wait on packet to arrive */
 397         if (sdp->detached)
 398             return -ENODEV;
 399         if (filp->f_flags & O_NONBLOCK)
 400             return -EAGAIN;
 401         while (1) {
 402             res = 0;  /* following is a macro that beats race condition */
 403             __wait_event_interruptible(sfp->read_wait, (sdp->detached ||
 404                     (srp = sg_get_rq_mark(sfp, req_pack_id))), res);
 405             if (sdp->detached)
 406                 return -ENODEV;
 407             if (0 == res)
 408                 break;
 409             return res; /* -ERESTARTSYS because signal hit process */
 410         }
 411     }
 412     if (srp->header.interface_id != '\0')
 413         return sg_new_read(sfp, buf, count, srp);
 414
 415     hp = &srp->header;
 416     memset(&old_hdr, 0, SZ_SG_HEADER);
 417     old_hdr.reply_len = (int)hp->timeout;
 418     old_hdr.pack_len = old_hdr.reply_len;   /* very old, strange behaviour */
 419     old_hdr.pack_id = hp->pack_id;
 420     old_hdr.twelve_byte =
 421             ((srp->data.cmd_opcode >= 0xc0) && (12 == hp->cmd_len)) ? 1 : 0;
 422     old_hdr.target_status = hp->masked_status;
 423     old_hdr.host_status = hp->host_status;
 424     old_hdr.driver_status = hp->driver_status;
 425     if ((CHECK_CONDITION & hp->masked_status) ||
 426         (DRIVER_SENSE & hp->driver_status))
 427         memcpy(old_hdr.sense_buffer, srp->sense_b,
 428                sizeof(old_hdr.sense_buffer));
 429     switch (hp->host_status)
 430     { /* This setup of 'result' is for backward compatibility and is best
 431          ignored by the user who should use target, host + driver status */
 432         case DID_OK:
 433         case DID_PASSTHROUGH:
 434         case DID_SOFT_ERROR:
 435             old_hdr.result = 0;
 436             break;
 437         case DID_NO_CONNECT:
 438         case DID_BUS_BUSY:
 439         case DID_TIME_OUT:
 440             old_hdr.result = EBUSY;
 441             break;
 442         case DID_BAD_TARGET:
 443         case DID_ABORT:
 444         case DID_PARITY:
 445         case DID_RESET:
 446         case DID_BAD_INTR:
 447             old_hdr.result = EIO;
 448             break;
 449         case DID_ERROR:
 450             old_hdr.result =
 451               (srp->sense_b[0] == 0 && hp->masked_status == GOOD) ? 0 : EIO;
 452             break;
 453         default:
 454             old_hdr.result = EIO;
 455             break;
 456     }
 457
 458     /* Now copy the result back to the user buffer.  */
 459     if (count >= SZ_SG_HEADER) {
 460         __copy_to_user(buf, &old_hdr, SZ_SG_HEADER);
 461         buf += SZ_SG_HEADER;
 462         if (count > old_hdr.reply_len)
 463             count = old_hdr.reply_len;
 464         if (count > SZ_SG_HEADER)
 465             sg_read_oxfer(srp, buf, count - SZ_SG_HEADER);
 466     }
 467     else
 468         count = (old_hdr.result == 0) ? 0 : -EIO;
 469     sg_finish_rem_req(srp);
 470     return count;
 471 }
 472
 473 static ssize_t sg_new_read(Sg_fd * sfp, char * buf, size_t count,
 474                            Sg_request * srp)
 475 {
 476     sg_io_hdr_t * hp = &srp->header;
 477     int err = 0;
 478     int len;
 479
 480     if (count < SZ_SG_IO_HDR) {
 481         err = -EINVAL;
 482         goto err_out;
 483     }
 484     hp->sb_len_wr = 0;
 485     if ((hp->mx_sb_len > 0) && hp->sbp) {
 486         if ((CHECK_CONDITION & hp->masked_status) ||
 487             (DRIVER_SENSE & hp->driver_status)) {
 488             int sb_len = sizeof(dummy_cmdp->sr_sense_buffer);
 489             sb_len = (hp->mx_sb_len > sb_len) ? sb_len : hp->mx_sb_len;
 490             len = 8 + (int)srp->sense_b[7]; /* Additional sense length field */
 491             len = (len > sb_len) ? sb_len : len;
 492             if ((err = verify_area(VERIFY_WRITE, hp->sbp, len)))
 493                 goto err_out;
 494             __copy_to_user(hp->sbp, srp->sense_b, len);
 495             hp->sb_len_wr = len;
 496         }
 497     }
 498     if (hp->masked_status || hp->host_status || hp->driver_status)
 499         hp->info |= SG_INFO_CHECK;
 500     copy_to_user(buf, hp, SZ_SG_IO_HDR);
 501     err = sg_read_xfer(srp);
 502 err_out:
 503     sg_finish_rem_req(srp);
 504     return (0 == err) ? count : err;
 505 }
 506
 507
 508 static ssize_t sg_write(struct file * filp, const char * buf,
 509                         size_t count, loff_t *ppos)
 510 {
 511     int                   mxsize, cmd_size, k;
 512     int                   input_size, blocking;
 513     unsigned char         opcode;
 514     Sg_device           * sdp;
 515     Sg_fd               * sfp;
 516     Sg_request          * srp;
 517     struct sg_header      old_hdr;
 518     sg_io_hdr_t         * hp;
 519     unsigned char         cmnd[sizeof(dummy_cmdp->sr_cmnd)];
 520
 521     if ((! (sfp = (Sg_fd *)filp->private_data)) || (! (sdp = sfp->parentdp)))
 522         return -ENXIO;
 523     SCSI_LOG_TIMEOUT(3, printk("sg_write: dev=%d, count=%d\n",
 524                                MINOR(sdp->i_rdev), (int)count));
 525     if (sdp->detached)
 526         return -ENODEV;
 527     if (! ((filp->f_flags & O_NONBLOCK) ||
 528            scsi_block_when_processing_errors(sdp->device)))
 529         return -ENXIO;
 530     if (ppos != &filp->f_pos)
 531         ; /* FIXME: Hmm.  Seek to the right place, or fail?  */
 532
 533     if ((k = verify_area(VERIFY_READ, buf, count)))
 534         return k;  /* protects following copy_from_user()s + get_user()s */
 535     if (count < SZ_SG_HEADER)
 536         return -EIO;
 537     __copy_from_user(&old_hdr, buf, SZ_SG_HEADER);
 538     blocking = !(filp->f_flags & O_NONBLOCK);
 539     if (old_hdr.reply_len < 0)
 540         return sg_new_write(sfp, buf, count, blocking, 0, NULL);
 541     if (count < (SZ_SG_HEADER + 6))
 542         return -EIO;   /* The minimum scsi command length is 6 bytes. */
 543
 544     if (! (srp = sg_add_request(sfp))) {
 545         SCSI_LOG_TIMEOUT(1, printk("sg_write: queue full\n"));
 546         return -EDOM;
 547     }
 548     buf += SZ_SG_HEADER;
 549     __get_user(opcode, buf);
 550     if (sfp->next_cmd_len > 0) {
 551         if (sfp->next_cmd_len > MAX_COMMAND_SIZE) {
 552             SCSI_LOG_TIMEOUT(1, printk("sg_write: command length too long\n"));
 553             sfp->next_cmd_len = 0;
 554             sg_remove_request(sfp, srp);
 555             return -EIO;
 556         }
 557         cmd_size = sfp->next_cmd_len;
 558         sfp->next_cmd_len = 0; /* reset so only this write() effected */
 559     }
 560     else {
 561         cmd_size = COMMAND_SIZE(opcode); /* based on SCSI command group */
 562         if ((opcode >= 0xc0) && old_hdr.twelve_byte)
 563             cmd_size = 12;
 564     }
 565     SCSI_LOG_TIMEOUT(4, printk("sg_write:   scsi opcode=0x%02x, cmd_size=%d\n",
 566                                (int)opcode, cmd_size));
 567 /* Determine buffer size.  */
 568     input_size = count - cmd_size;
 569     mxsize = (input_size > old_hdr.reply_len) ? input_size :
 570                                                 old_hdr.reply_len;
 571     mxsize -= SZ_SG_HEADER;
 572     input_size -= SZ_SG_HEADER;
 573     if (input_size < 0) {
 574         sg_remove_request(sfp, srp);
 575         return -EIO; /* User did not pass enough bytes for this command. */
 576     }
 577     hp = &srp->header;
 578     hp->interface_id = '\0'; /* indicator of old interface tunnelled */
 579     hp->cmd_len = (unsigned char)cmd_size;
 580     hp->iovec_count = 0;
 581     hp->mx_sb_len = 0;
 582     if (input_size > 0)
 583         hp->dxfer_direction = (old_hdr.reply_len > SZ_SG_HEADER) ?
 584                               SG_DXFER_TO_FROM_DEV : SG_DXFER_TO_DEV;
 585     else
 586         hp->dxfer_direction = (mxsize > 0) ? SG_DXFER_FROM_DEV :
 587                                              SG_DXFER_NONE;
 588     hp->dxfer_len = mxsize;
 589     hp->dxferp = (unsigned char *)buf + cmd_size;
 590     hp->sbp = NULL;
 591     hp->timeout = old_hdr.reply_len;    /* structure abuse ... */
 592     hp->flags = input_size;             /* structure abuse ... */
 593     hp->pack_id = old_hdr.pack_id;
 594     hp->usr_ptr = NULL;
 595     __copy_from_user(cmnd, buf, cmd_size);
 596     k = sg_common_write(sfp, srp, cmnd, sfp->timeout, blocking);
 597     return (k < 0) ? k : count;
 598 }
 599
 600 static ssize_t sg_new_write(Sg_fd * sfp, const char * buf, size_t count,
 601                             int blocking, int read_only, Sg_request ** o_srp)
 602 {
 603     int                   k;
 604     Sg_request          * srp;
 605     sg_io_hdr_t         * hp;
 606     unsigned char         cmnd[sizeof(dummy_cmdp->sr_cmnd)];
 607     int                   timeout;
 608
 609     if (count < SZ_SG_IO_HDR)
 610         return -EINVAL;
 611     if ((k = verify_area(VERIFY_READ, buf, count)))
 612         return k;  /* protects following copy_from_user()s + get_user()s */
 613
 614     sfp->cmd_q = 1;  /* when sg_io_hdr seen, set command queuing on */
 615     if (! (srp = sg_add_request(sfp))) {
 616         SCSI_LOG_TIMEOUT(1, printk("sg_new_write: queue full\n"));
 617         return -EDOM;
 618     }
 619     hp = &srp->header;
 620     __copy_from_user(hp, buf, SZ_SG_IO_HDR);
 621     if (hp->interface_id != 'S') {
 622         sg_remove_request(sfp, srp);
 623         return -ENOSYS;
 624     }
 625     if (hp->flags & SG_FLAG_MMAP_IO) {
 626         if (hp->dxfer_len > sfp->reserve.bufflen) {
 627             sg_remove_request(sfp, srp);
 628             return -ENOMEM;     /* MMAP_IO size must fit in reserve buffer */
 629         }
 630         if (hp->flags & SG_FLAG_DIRECT_IO) {
 631             sg_remove_request(sfp, srp);
 632             return -EINVAL;     /* either MMAP_IO or DIRECT_IO (not both) */
 633         }
 634         if (sg_res_in_use(sfp)) {
 635             sg_remove_request(sfp, srp);
 636             return -EBUSY;      /* reserve buffer already being used */
 637         }
 638     }
 639     timeout = sg_ms_to_jif(srp->header.timeout);
 640     if ((! hp->cmdp) || (hp->cmd_len < 6) || (hp->cmd_len > sizeof(cmnd))) {
 641         sg_remove_request(sfp, srp);
 642         return -EMSGSIZE;
 643     }
 644     if ((k = verify_area(VERIFY_READ, hp->cmdp, hp->cmd_len))) {
 645         sg_remove_request(sfp, srp);
 646         return k;  /* protects following copy_from_user()s + get_user()s */
 647     }
 648     __copy_from_user(cmnd, hp->cmdp, hp->cmd_len);
 649     if (read_only &&
 650         (! sg_allow_access(cmnd[0], sfp->parentdp->device->type))) {
 651         sg_remove_request(sfp, srp);
 652         return -EPERM;
 653     }
 654     k = sg_common_write(sfp, srp, cmnd, timeout, blocking);
 655     if (k < 0) return k;
 656     if (o_srp) *o_srp = srp;
 657     return count;
 658 }
 659
 660 static int sg_common_write(Sg_fd * sfp, Sg_request * srp,
 661                            unsigned char * cmnd, int timeout, int blocking)
 662 {
 663     int                   k;
 664     Scsi_Request        * SRpnt;
 665     Sg_device           * sdp = sfp->parentdp;
 666     sg_io_hdr_t         * hp = &srp->header;
 667     request_queue_t     * q;
 668
 669     srp->data.cmd_opcode = cmnd[0];  /* hold opcode of command */
 670     hp->status = 0;
 671     hp->masked_status = 0;
 672     hp->msg_status = 0;
 673     hp->info = 0;
 674     hp->host_status = 0;
 675     hp->driver_status = 0;
 676     hp->resid = 0;
 677     SCSI_LOG_TIMEOUT(4,
 678         printk("sg_common_write:  scsi opcode=0x%02x, cmd_size=%d\n",
 679                (int)cmnd[0], (int)hp->cmd_len));
 680
 681     if ((k = sg_start_req(srp))) {
 682         SCSI_LOG_TIMEOUT(1, printk("sg_write: start_req err=%d\n", k));
 683         sg_finish_rem_req(srp);
 684         return k;    /* probably out of space --> ENOMEM */
 685     }
 686     if ((k = sg_write_xfer(srp))) {
 687         SCSI_LOG_TIMEOUT(1, printk("sg_write: write_xfer, bad address\n"));
 688         sg_finish_rem_req(srp);
 689         return k;
 690     }
 691     if (sdp->detached) {
 692         sg_finish_rem_req(srp);
 693         return -ENODEV;
 694     }
 695     SRpnt = scsi_allocate_request(sdp->device);
 696     if(SRpnt == NULL) {
 697         SCSI_LOG_TIMEOUT(1, printk("sg_write: no mem\n"));
 698         sg_finish_rem_req(srp);
 699         return -ENOMEM;
 700     }
 701
 702     srp->my_cmdp = SRpnt;
 703     q = &SRpnt->sr_device->request_queue;
 704     SRpnt->sr_request.rq_dev = sdp->i_rdev;
 705     SRpnt->sr_request.rq_status = RQ_ACTIVE;
 706     SRpnt->sr_sense_buffer[0] = 0;
 707     SRpnt->sr_cmd_len = hp->cmd_len;
 708     if (! (hp->flags & SG_FLAG_LUN_INHIBIT)) {
 709         if (sdp->device->scsi_level <= SCSI_2)
 710             cmnd[1] = (cmnd[1] & 0x1f) | (sdp->device->lun << 5);
 711     }
 712     SRpnt->sr_use_sg = srp->data.k_use_sg;
 713     SRpnt->sr_sglist_len = srp->data.sglist_len;
 714     SRpnt->sr_bufflen = srp->data.bufflen;
 715     SRpnt->sr_underflow = 0;
 716     SRpnt->sr_buffer = srp->data.buffer;
 717     switch (hp->dxfer_direction) {
 718     case SG_DXFER_TO_FROM_DEV:
 719     case SG_DXFER_FROM_DEV:
 720         SRpnt->sr_data_direction = SCSI_DATA_READ; break;
 721     case SG_DXFER_TO_DEV:
 722         SRpnt->sr_data_direction = SCSI_DATA_WRITE; break;
 723     case SG_DXFER_UNKNOWN:
 724         SRpnt->sr_data_direction = SCSI_DATA_UNKNOWN; break;
 725     default:
 726         SRpnt->sr_data_direction = SCSI_DATA_NONE; break;
 727     }
 728     srp->data.k_use_sg = 0;
 729     srp->data.sglist_len = 0;
 730     srp->data.bufflen = 0;
 731     srp->data.buffer = NULL;
 732     hp->duration = jiffies;     /* unit jiffies now, millisecs after done */
 733 /* Now send everything of to mid-level. The next time we hear about this
 734    packet is when sg_cmd_done_bh() is called (i.e. a callback). */
 735     scsi_do_req(SRpnt, (void *)cmnd,
 736                 (void *)SRpnt->sr_buffer, hp->dxfer_len,
 737                 sg_cmd_done_bh, timeout, SG_DEFAULT_RETRIES);
 738     /* dxfer_len overwrites SRpnt->sr_bufflen, hence need for b_malloc_len */
 739 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,1)
 740     generic_unplug_device(q);
 741 #endif
 742     return 0;
 743 }
 744
 745 static inline unsigned sg_jif_to_ms(int jifs)
 746 {
 747     if (jifs <= 0)
 748         return 0U;
 749     else {
 750         unsigned int j = (unsigned int)jifs;
 751         return (j < (UINT_MAX / 1000)) ? ((j * 1000) / HZ) : ((j / HZ) * 1000);
 752     }
 753 }
 754
 755 static int sg_ioctl(struct inode * inode, struct file * filp,
 756                     unsigned int cmd_in, unsigned long arg)
 757 {
 758     int result, val, read_only;
 759     Sg_device * sdp;
 760     Sg_fd * sfp;
 761     Sg_request * srp;
 762     unsigned long iflags;
 763
 764     if ((! (sfp = (Sg_fd *)filp->private_data)) || (! (sdp = sfp->parentdp)))
 765         return -ENXIO;
 766     SCSI_LOG_TIMEOUT(3, printk("sg_ioctl: dev=%d, cmd=0x%x\n",
 767                                MINOR(sdp->i_rdev), (int)cmd_in));
 768     read_only = (O_RDWR != (filp->f_flags & O_ACCMODE));
 769
 770     switch(cmd_in)
 771     {
 772     case SG_IO:
 773         {
 774             int blocking = 1;   /* ignore O_NONBLOCK flag */
 775
 776             if (sdp->detached)
 777                 return -ENODEV;
 778             if(! scsi_block_when_processing_errors(sdp->device) )
 779                 return -ENXIO;
 780             result = verify_area(VERIFY_WRITE, (void *)arg, SZ_SG_IO_HDR);
 781             if (result) return result;
 782             result = sg_new_write(sfp, (const char *)arg, SZ_SG_IO_HDR,
 783                                   blocking, read_only, &srp);
 784             if (result < 0) return result;
 785             srp->sg_io_owned = 1;
 786             while (1) {
 787                 result = 0;  /* following macro to beat race condition */
 788                 __wait_event_interruptible(sfp->read_wait,
 789                        (sdp->detached || sfp->closed || srp->done), result);
 790                 if (sdp->detached)
 791                     return -ENODEV;
 792                 if (sfp->closed)
 793                     return 0;       /* request packet dropped already */
 794                 if (0 == result)
 795                     break;
 796                 srp->orphan = 1;
 797                 return result; /* -ERESTARTSYS because signal hit process */
 798             }
 799             srp->done = 2;
 800             result = sg_new_read(sfp, (char *)arg, SZ_SG_IO_HDR, srp);
 801             return (result < 0) ? result : 0;
 802         }
 803     case SG_SET_TIMEOUT:
 804         result =  get_user(val, (int *)arg);
 805         if (result) return result;
 806         if (val < 0)
 807             return -EIO;
 808         sfp->timeout = val;
 809         return 0;
 810     case SG_GET_TIMEOUT:  /* N.B. User receives timeout as return value */
 811         return sfp->timeout; /* strange ..., for backward compatibility */
 812     case SG_SET_FORCE_LOW_DMA:
 813         result = get_user(val, (int *)arg);
 814         if (result) return result;
 815         if (val) {
 816             sfp->low_dma = 1;
 817             if ((0 == sfp->low_dma) && (0 == sg_res_in_use(sfp))) {
 818                 val = (int)sfp->reserve.bufflen;
 819                 sg_remove_scat(&sfp->reserve);
 820                 sg_build_reserve(sfp, val);
 821             }
 822         }
 823         else {
 824             if (sdp->detached)
 825                 return -ENODEV;
 826             sfp->low_dma = sdp->device->host->unchecked_isa_dma;
 827         }
 828         return 0;
 829     case SG_GET_LOW_DMA:
 830         return put_user((int)sfp->low_dma, (int *)arg);
 831     case SG_GET_SCSI_ID:
 832         result = verify_area(VERIFY_WRITE, (void *)arg, sizeof(sg_scsi_id_t));
 833         if (result) return result;
 834         else {
 835             sg_scsi_id_t * sg_idp = (sg_scsi_id_t *)arg;
 836
 837             if (sdp->detached)
 838                 return -ENODEV;
 839             __put_user((int)sdp->device->host->host_no, &sg_idp->host_no);
 840             __put_user((int)sdp->device->channel, &sg_idp->channel);
 841             __put_user((int)sdp->device->id, &sg_idp->scsi_id);
 842             __put_user((int)sdp->device->lun, &sg_idp->lun);
 843             __put_user((int)sdp->device->type, &sg_idp->scsi_type);
 844             __put_user((short)sdp->device->host->cmd_per_lun,
 845                        &sg_idp->h_cmd_per_lun);
 846             __put_user((short)sdp->device->queue_depth,
 847                        &sg_idp->d_queue_depth);
 848             __put_user(0, &sg_idp->unused[0]);
 849             __put_user(0, &sg_idp->unused[1]);
 850             return 0;
 851         }
 852     case SG_SET_FORCE_PACK_ID:
 853         result = get_user(val, (int *)arg);
 854         if (result) return result;
 855         sfp->force_packid = val ? 1 : 0;
 856         return 0;
 857     case SG_GET_PACK_ID:
 858         result = verify_area(VERIFY_WRITE, (void *) arg, sizeof(int));
 859         if (result) return result;
 860         read_lock_irqsave(&sfp->rq_list_lock, iflags);
 861         for (srp = sfp->headrp; srp; srp = srp->nextrp) {
 862             if ((1 == srp->done) && (! srp->sg_io_owned)) {
 863                 read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 864                 __put_user(srp->header.pack_id, (int *)arg);
 865                 return 0;
 866             }
 867         }
 868         read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 869         __put_user(-1, (int *)arg);
 870         return 0;
 871     case SG_GET_NUM_WAITING:
 872         read_lock_irqsave(&sfp->rq_list_lock, iflags);
 873         for (val = 0, srp = sfp->headrp; srp; srp = srp->nextrp) {
 874             if ((1 == srp->done) && (! srp->sg_io_owned))
 875                 ++val;
 876         }
 877         read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 878         return put_user(val, (int *)arg);
 879     case SG_GET_SG_TABLESIZE:
 880         return put_user(sdp->sg_tablesize, (int *)arg);
 881     case SG_SET_RESERVED_SIZE:
 882         result = get_user(val, (int *)arg);
 883         if (result) return result;
 884         if (val < 0)
 885             return -EINVAL;
 886         if (val != sfp->reserve.bufflen) {
 887             if (sg_res_in_use(sfp) || sfp->mmap_called)
 888                 return -EBUSY;
 889             sg_remove_scat(&sfp->reserve);
 890             sg_build_reserve(sfp, val);
 891         }
 892         return 0;
 893     case SG_GET_RESERVED_SIZE:
 894         val = (int)sfp->reserve.bufflen;
 895         return put_user(val, (int *)arg);
 896     case SG_SET_COMMAND_Q:
 897         result = get_user(val, (int *)arg);
 898         if (result) return result;
 899         sfp->cmd_q = val ? 1 : 0;
 900         return 0;
 901     case SG_GET_COMMAND_Q:
 902         return put_user((int)sfp->cmd_q, (int *)arg);
 903     case SG_SET_KEEP_ORPHAN:
 904         result = get_user(val, (int *)arg);
 905         if (result) return result;
 906         sfp->keep_orphan = val;
 907         return 0;
 908     case SG_GET_KEEP_ORPHAN:
 909         return put_user((int)sfp->keep_orphan, (int *)arg);
 910     case SG_NEXT_CMD_LEN:
 911         result = get_user(val, (int *)arg);
 912         if (result) return result;
 913         sfp->next_cmd_len = (val > 0) ? val : 0;
 914         return 0;
 915     case SG_GET_VERSION_NUM:
 916         return put_user(sg_version_num, (int *)arg);
 917     case SG_GET_ACCESS_COUNT:
 918         val = (sdp->device ? sdp->device->access_count : 0);
 919         return put_user(val, (int *)arg);
 920     case SG_GET_REQUEST_TABLE:
 921         result = verify_area(VERIFY_WRITE, (void *) arg,
 922                              SZ_SG_REQ_INFO * SG_MAX_QUEUE);
 923         if (result) return result;
 924         else {
 925             sg_req_info_t rinfo[SG_MAX_QUEUE];
 926             Sg_request * srp;
 927             read_lock_irqsave(&sfp->rq_list_lock, iflags);
 928             for (srp = sfp->headrp, val = 0; val < SG_MAX_QUEUE;
 929                  ++val, srp = srp ? srp->nextrp : srp) {
 930                 memset(&rinfo[val], 0, SZ_SG_REQ_INFO);
 931                 if (srp) {
 932                     rinfo[val].req_state = srp->done + 1;
 933                     rinfo[val].problem = srp->header.masked_status &
 934                         srp->header.host_status & srp->header.driver_status;
 935                     rinfo[val].duration = srp->done ?
 936                             srp->header.duration :
 937                             sg_jif_to_ms(jiffies - srp->header.duration);
 938                     rinfo[val].orphan = srp->orphan;
 939                     rinfo[val].sg_io_owned = srp->sg_io_owned;
 940                     rinfo[val].pack_id = srp->header.pack_id;
 941                     rinfo[val].usr_ptr = srp->header.usr_ptr;
 942                 }
 943             }
 944             read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 945             __copy_to_user((void *)arg, rinfo, SZ_SG_REQ_INFO * SG_MAX_QUEUE);
 946             return 0;
 947         }
 948     case SG_EMULATED_HOST:
 949         if (sdp->detached)
 950             return -ENODEV;
 951         return put_user(sdp->device->host->hostt->emulated, (int *)arg);
 952     case SG_SCSI_RESET:
 953         if (sdp->detached)
 954             return -ENODEV;
 955         if (filp->f_flags & O_NONBLOCK) {
 956             if (sdp->device->host->in_recovery)
 957                 return -EBUSY;
 958         }
 959         else if (! scsi_block_when_processing_errors(sdp->device))
 960             return -EBUSY;
 961         result = get_user(val, (int *)arg);
 962         if (result) return result;
 963         if (SG_SCSI_RESET_NOTHING == val)
 964             return 0;
 965 #ifdef SCSI_TRY_RESET_DEVICE
 966         switch (val)
 967         {
 968         case SG_SCSI_RESET_DEVICE:
 969             val = SCSI_TRY_RESET_DEVICE;
 970             break;
 971         case SG_SCSI_RESET_BUS:
 972             val = SCSI_TRY_RESET_BUS;
 973             break;
 974         case SG_SCSI_RESET_HOST:
 975             val = SCSI_TRY_RESET_HOST;
 976             break;
 977         default:
 978             return -EINVAL;
 979         }
 980         if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
 981             return -EACCES;
 982         return (scsi_reset_provider(sdp->device, val) == SUCCESS) ? 0 : -EIO;
 983 #else
 984         SCSI_LOG_TIMEOUT(1, printk("sg_ioctl: SG_RESET_SCSI not supported\n"));
 985         result = -EINVAL;
 986 #endif
 987     case SCSI_IOCTL_SEND_COMMAND:
 988         if (sdp->detached)
 989             return -ENODEV;
 990         if (read_only) {
 991             unsigned char opcode = WRITE_6;
 992             Scsi_Ioctl_Command * siocp = (void *)arg;
 993
 994             copy_from_user(&opcode, siocp->data, 1);
 995             if (! sg_allow_access(opcode, sdp->device->type))
 996                 return -EPERM;
 997         }
 998         return scsi_ioctl_send_command(sdp->device, (void *)arg);
 999     case SG_SET_DEBUG:
1000         result = get_user(val, (int *)arg);
1001         if (result) return result;
1002         sdp->sgdebug = (char)val;
1003         return 0;
1004     case SCSI_IOCTL_GET_IDLUN:
1005     case SCSI_IOCTL_GET_BUS_NUMBER:
1006     case SCSI_IOCTL_PROBE_HOST:
1007     case SG_GET_TRANSFORM:
1008         if (sdp->detached)
1009             return -ENODEV;
1010         return scsi_ioctl(sdp->device, cmd_in, (void *)arg);
1011     default:
1012         if (read_only)
1013             return -EPERM; /* don't know so take safe approach */
1014         return scsi_ioctl(sdp->device, cmd_in, (void *)arg);
1015     }
1016 }
1017
1018 static unsigned int sg_poll(struct file * filp, poll_table * wait)
1019 {
1020     unsigned int res = 0;
1021     Sg_device * sdp;
1022     Sg_fd * sfp;
1023     Sg_request * srp;
1024     int count = 0;
1025     unsigned long iflags;
1026
1027     if ((! (sfp = (Sg_fd *)filp->private_data)) || (! (sdp = sfp->parentdp))
1028         || sfp->closed)
1029         return POLLERR;
1030     poll_wait(filp, &sfp->read_wait, wait);
1031     read_lock_irqsave(&sfp->rq_list_lock, iflags);
1032     for (srp = sfp->headrp; srp; srp = srp->nextrp) {
1033         /* if any read waiting, flag it */
1034         if ((0 == res) && (1 == srp->done) && (! srp->sg_io_owned))
1035             res = POLLIN | POLLRDNORM;
1036         ++count;
1037     }
1038     read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
1039
1040     if (sdp->detached)
1041         res |= POLLHUP;
1042     else if (! sfp->cmd_q) {
1043         if (0 == count)
1044             res |= POLLOUT | POLLWRNORM;
1045     }
1046     else if (count < SG_MAX_QUEUE)
1047         res |= POLLOUT | POLLWRNORM;
1048     SCSI_LOG_TIMEOUT(3, printk("sg_poll: dev=%d, res=0x%x\n",
1049                         MINOR(sdp->i_rdev), (int)res));
1050     return res;
1051 }
1052
1053 static int sg_fasync(int fd, struct file * filp, int mode)
1054 {
1055     int retval;
1056     Sg_device * sdp;
1057     Sg_fd * sfp;
1058
1059     if ((! (sfp = (Sg_fd *)filp->private_data)) || (! (sdp = sfp->parentdp)))
1060         return -ENXIO;
1061     SCSI_LOG_TIMEOUT(3, printk("sg_fasync: dev=%d, mode=%d\n",
1062                                MINOR(sdp->i_rdev), mode));
1063
1064     retval = fasync_helper(fd, filp, mode, &sfp->async_qp);
1065     return (retval < 0) ? retval : 0;
1066 }
1067
1068 static void sg_rb_correct4mmap(Sg_scatter_hold * rsv_schp, int startFinish)
1069 {
1070     void * page_ptr;
1071     struct page * page;
1072     int k, m;
1073
1074     SCSI_LOG_TIMEOUT(3, printk("sg_rb_correct4mmap: startFinish=%d, "
1075                            "scatg=%d\n", startFinish, rsv_schp->k_use_sg));
1076     /* N.B. correction _not_ applied to base page of aech allocation */
1077     if (rsv_schp->k_use_sg) { /* reserve buffer is a scatter gather list */
1078         struct scatterlist * sclp = rsv_schp->buffer;
1079
1080         for (k = 0; k < rsv_schp->k_use_sg; ++k, ++sclp) {
1081             for (m = PAGE_SIZE; m < sclp->length; m += PAGE_SIZE) {
1082                 page_ptr = (unsigned char *)sclp->address + m;
1083                 page = virt_to_page(page_ptr);
1084                 if (startFinish)
1085                     get_page(page);     /* increment page count */
1086                 else {
1087                     if (page_count(page) > 0)
1088                         put_page_testzero(page); /* decrement page count */
1089                 }
1090             }
1091         }
1092     }
1093     else { /* reserve buffer is just a single allocation */
1094         for (m = PAGE_SIZE; m < rsv_schp->bufflen; m += PAGE_SIZE) {
1095             page_ptr = (unsigned char *)rsv_schp->buffer + m;
1096             page = virt_to_page(page_ptr);
1097             if (startFinish)
1098                 get_page(page); /* increment page count */
1099             else {
1100                 if (page_count(page) > 0)
1101                     put_page_testzero(page); /* decrement page count */
1102             }
1103         }
1104     }
1105 }
1106
1107 static struct page * sg_vma_nopage(struct vm_area_struct *vma,
1108                                    unsigned long addr, int unused)
1109 {
1110     Sg_fd * sfp;
1111     struct page * page = NOPAGE_SIGBUS;
1112     void * page_ptr = NULL;
1113     unsigned long offset;
1114     Sg_scatter_hold * rsv_schp;
1115
1116     if ((NULL == vma) || (! (sfp = (Sg_fd *)vma->vm_private_data)))
1117         return page;
1118     rsv_schp = &sfp->reserve;
1119     offset = addr - vma->vm_start;
1120     if (offset >= rsv_schp->bufflen)
1121         return page;
1122     SCSI_LOG_TIMEOUT(3, printk("sg_vma_nopage: offset=%lu, scatg=%d\n",
1123                                offset, rsv_schp->k_use_sg));
1124     if (rsv_schp->k_use_sg) { /* reserve buffer is a scatter gather list */
1125         int k;
1126         unsigned long sa = vma->vm_start;
1127         unsigned long len;
1128         struct scatterlist * sclp = rsv_schp->buffer;
1129
1130         for (k = 0; (k < rsv_schp->k_use_sg) && (sa < vma->vm_end);
1131              ++k, ++sclp) {
1132             len = vma->vm_end - sa;
1133             len = (len < sclp->length) ? len : sclp->length;
1134             if (offset < len) {
1135                 page_ptr = (unsigned char *)sclp->address + offset;
1136                 page = virt_to_page(page_ptr);
1137                 get_page(page); /* increment page count */
1138                 break;
1139             }
1140             sa += len;
1141             offset -= len;
1142         }
1143     }
1144     else { /* reserve buffer is just a single allocation */
1145         page_ptr = (unsigned char *)rsv_schp->buffer + offset;
1146         page = virt_to_page(page_ptr);
1147         get_page(page); /* increment page count */
1148     }
1149     return page;
1150 }
1151
1152 static struct vm_operations_struct sg_mmap_vm_ops = {
1153     nopage : sg_vma_nopage,
1154 };
1155
1156 static int sg_mmap(struct file * filp, struct vm_area_struct *vma)
1157 {
1158     Sg_fd * sfp;
1159     unsigned long req_sz = vma->vm_end - vma->vm_start;
1160     Sg_scatter_hold * rsv_schp;
1161
1162     if ((! filp) || (! vma) || (! (sfp = (Sg_fd *)filp->private_data)))
1163         return -ENXIO;
1164     SCSI_LOG_TIMEOUT(3, printk("sg_mmap starting, vm_start=%p, len=%d\n",
1165                                (void *)vma->vm_start, (int)req_sz));
1166     if (vma->vm_pgoff)
1167         return -EINVAL;         /* want no offset */
1168     rsv_schp = &sfp->reserve;
1169     if (req_sz > rsv_schp->bufflen)
1170         return -ENOMEM;         /* cannot map more than reserved buffer */
1171
1172     if (rsv_schp->k_use_sg) { /* reserve buffer is a scatter gather list */
1173         int k;
1174         unsigned long sa = vma->vm_start;
1175         unsigned long len;
1176         struct scatterlist * sclp = rsv_schp->buffer;
1177
1178         for (k = 0; (k < rsv_schp->k_use_sg) && (sa < vma->vm_end);
1179              ++k, ++sclp) {
1180             if ((unsigned long)sclp->address & (PAGE_SIZE - 1))
1181                 return -EFAULT;     /* non page aligned memory ?? */
1182             len = vma->vm_end - sa;
1183             len = (len < sclp->length) ? len : sclp->length;
1184             sa += len;
1185         }
1186     }
1187     else { /* reserve buffer is just a single allocation */
1188         if ((unsigned long)rsv_schp->buffer & (PAGE_SIZE - 1))
1189             return -EFAULT;     /* non page aligned memory ?? */
1190     }
1191     if (0 == sfp->mmap_called) {
1192         sg_rb_correct4mmap(rsv_schp, 1);  /* do only once per fd lifetime */
1193         sfp->mmap_called = 1;
1194     }
1195     vma->vm_flags |= VM_RESERVED;
1196     vma->vm_private_data = sfp;
1197     vma->vm_ops = &sg_mmap_vm_ops;
1198     return 0;
1199 }
1200
1201 /* This function is a "bottom half" handler that is called by the
1202  * mid level when a command is completed (or has failed). */
1203 static void sg_cmd_done_bh(Scsi_Cmnd * SCpnt)
1204 {
1205     Scsi_Request * SRpnt = SCpnt->sc_request;
1206     int dev = MINOR(SRpnt->sr_request.rq_dev);
1207     Sg_device * sdp = NULL;
1208     Sg_fd * sfp;
1209     Sg_request * srp = NULL;
1210
1211     read_lock(&sg_dev_arr_lock);
1212     if (sg_dev_arr && (dev >= 0)) {
1213         if (dev < sg_template.dev_max)
1214             sdp = sg_dev_arr[dev];
1215     }
1216     if ((NULL == sdp) || sdp->detached) {
1217         read_unlock(&sg_dev_arr_lock);
1218         SCSI_LOG_TIMEOUT(1, printk("sg...bh: dev=%d gone\n", dev));
1219         scsi_release_request(SRpnt);
1220         SRpnt = NULL;
1221         return;
1222     }
1223     sfp = sdp->headfp;
1224     while (sfp) {
1225         read_lock(&sfp->rq_list_lock);
1226         for (srp = sfp->headrp; srp; srp = srp->nextrp) {
1227             if (SRpnt == srp->my_cmdp)
1228                 break;
1229         }
1230         read_unlock(&sfp->rq_list_lock);
1231         if (srp)
1232             break;
1233         sfp = sfp->nextfp;
1234     }
1235     if (! srp) {
1236         read_unlock(&sg_dev_arr_lock);
1237         SCSI_LOG_TIMEOUT(1, printk("sg...bh: req missing, dev=%d\n", dev));
1238         scsi_release_request(SRpnt);
1239         SRpnt = NULL;
1240         return;
1241     }
1242     /* First transfer ownership of data buffers to sg_device object. */
1243     srp->data.k_use_sg = SRpnt->sr_use_sg;
1244     srp->data.sglist_len = SRpnt->sr_sglist_len;
1245     srp->data.bufflen = SRpnt->sr_bufflen;
1246     srp->data.buffer = SRpnt->sr_buffer;
1247     /* now clear out request structure */
1248     SRpnt->sr_use_sg = 0;
1249     SRpnt->sr_sglist_len = 0;
1250     SRpnt->sr_bufflen = 0;
1251     SRpnt->sr_buffer = NULL;
1252     SRpnt->sr_underflow = 0;
1253     SRpnt->sr_request.rq_dev = MKDEV(0, 0);  /* "sg" _disowns_ request blk */
1254
1255     srp->my_cmdp = NULL;
1256     read_unlock(&sg_dev_arr_lock);
1257
1258     SCSI_LOG_TIMEOUT(4, printk("sg...bh: dev=%d, pack_id=%d, res=0x%x\n",
1259                      dev, srp->header.pack_id, (int)SRpnt->sr_result));
1260     srp->header.resid = SCpnt->resid;
1261     /* sg_unmap_and(&srp->data, 0); */     /* unmap locked pages a.s.a.p. */
1262     /* N.B. unit of duration changes here from jiffies to millisecs */
1263     srp->header.duration = sg_jif_to_ms(jiffies - (int)srp->header.duration);
1264     if (0 != SRpnt->sr_result) {
1265         memcpy(srp->sense_b, SRpnt->sr_sense_buffer, sizeof(srp->sense_b));
1266         srp->header.status = 0xff & SRpnt->sr_result;
1267         srp->header.masked_status  = status_byte(SRpnt->sr_result);
1268         srp->header.msg_status  = msg_byte(SRpnt->sr_result);
1269         srp->header.host_status = host_byte(SRpnt->sr_result);
1270         srp->header.driver_status = driver_byte(SRpnt->sr_result);
1271         if ((sdp->sgdebug > 0) &&
1272             ((CHECK_CONDITION == srp->header.masked_status) ||
1273              (COMMAND_TERMINATED == srp->header.masked_status)))
1274             print_req_sense("sg_cmd_done_bh", SRpnt);
1275
1276         /* Following if statement is a patch supplied by Eric Youngdale */
1277         if (driver_byte(SRpnt->sr_result) != 0
1278             && (SRpnt->sr_sense_buffer[0] & 0x7f) == 0x70
1279             && (SRpnt->sr_sense_buffer[2] & 0xf) == UNIT_ATTENTION
1280             && sdp->device->removable) {
1281             /* Detected disc change. Set the bit - this may be used if */
1282             /* there are filesystems using this device. */
1283             sdp->device->changed = 1;
1284         }
1285     }
1286     /* Rely on write phase to clean out srp status values, so no "else" */
1287
1288     scsi_release_request(SRpnt);
1289     SRpnt = NULL;
1290     if (sfp->closed) { /* whoops this fd already released, cleanup */
1291         SCSI_LOG_TIMEOUT(1,
1292                printk("sg...bh: already closed, freeing ...\n"));
1293         sg_finish_rem_req(srp);
1294         srp = NULL;
1295         if (NULL == sfp->headrp) {
1296             SCSI_LOG_TIMEOUT(1,
1297                 printk("sg...bh: already closed, final cleanup\n"));
1298             if (0 == sg_remove_sfp(sdp, sfp)) { /* device still present */
1299                 sdp->device->access_count--;
1300                 if (sdp->device->host->hostt->module)
1301                     __MOD_DEC_USE_COUNT(sdp->device->host->hostt->module);
1302             }
1303             if (sg_template.module)
1304                     __MOD_DEC_USE_COUNT(sg_template.module);
1305             sfp = NULL;
1306         }
1307     }
1308     else if (srp && srp->orphan) {
1309         if (sfp->keep_orphan)
1310             srp->sg_io_owned = 0;
1311         else {
1312             sg_finish_rem_req(srp);
1313             srp = NULL;
1314         }
1315     }
1316     if (sfp && srp) {
1317         /* Now wake up any sg_read() that is waiting for this packet. */
1318         kill_fasync(&sfp->async_qp, SIGPOLL, POLL_IN);
1319         srp->done = 1;
1320         wake_up_interruptible(&sfp->read_wait);
1321     }
1322 }
1323
1324 static struct file_operations sg_fops = {
1325         owner:          THIS_MODULE,
1326         read:           sg_read,
1327         write:          sg_write,
1328         poll:           sg_poll,
1329         ioctl:          sg_ioctl,
1330         open:           sg_open,
1331         mmap:           sg_mmap,
1332         release:        sg_release,
1333         fasync:         sg_fasync,
1334 };
1335
1336
1337 static int sg_detect(Scsi_Device * scsidp)
1338 {
1339     sg_template.dev_noticed++;
1340     return 1;
1341 }
1342
1343 /* Driver initialization */
1344 static int sg_init()
1345 {
1346     static int sg_registered = 0;
1347     unsigned long iflags;
1348
1349     if ((sg_template.dev_noticed == 0) || sg_dev_arr)
1350         return 0;
1351
1352     write_lock_irqsave(&sg_dev_arr_lock, iflags);
1353     if(!sg_registered) {
1354         if (devfs_register_chrdev(SCSI_GENERIC_MAJOR,"sg",&sg_fops))
1355         {
1356             printk(KERN_ERR "Unable to get major %d for generic SCSI device\n",
1357                    SCSI_GENERIC_MAJOR);
1358             write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1359             sg_template.dev_noticed = 0;
1360             return 1;
1361         }
1362         sg_registered++;
1363     }
1364
1365     SCSI_LOG_TIMEOUT(3, printk("sg_init\n"));
1366     sg_template.dev_max = sg_template.dev_noticed + SG_DEV_ARR_LUMP;
1367     sg_dev_arr = (Sg_device **)kmalloc(sg_template.dev_max *
1368                                         sizeof(Sg_device *), GFP_ATOMIC);
1369     if (NULL == sg_dev_arr) {
1370         printk(KERN_ERR "sg_init: no space for sg_dev_arr\n");
1371         write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1372         sg_template.dev_noticed = 0;
1373         return 1;
1374     }
1375     memset(sg_dev_arr, 0, sg_template.dev_max * sizeof(Sg_device *));
1376     write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1377 #ifdef CONFIG_PROC_FS
1378     sg_proc_init();
1379 #endif  /* CONFIG_PROC_FS */
1380     return 0;
1381 }
1382
1383 #ifndef MODULE
1384 static int __init sg_def_reserved_size_setup(char *str)
1385 {
1386     int tmp;
1387
1388     if (get_option(&str, &tmp) == 1) {
1389         def_reserved_size = tmp;
1390         if (tmp >= 0)
1391             sg_big_buff = tmp;
1392         return 1;
1393     } else {
1394         printk(KERN_WARNING "sg_def_reserved_size : usage "
1395             "sg_def_reserved_size=n (n could be 65536, 131072 or 262144)\n");
1396         return 0;
1397     }
1398 }
1399
1400 __setup("sg_def_reserved_size=", sg_def_reserved_size_setup);
1401 #endif
1402
1403
1404 static int sg_attach(Scsi_Device * scsidp)
1405 {
1406     Sg_device * sdp;
1407     unsigned long iflags;
1408     int k;
1409
1410     write_lock_irqsave(&sg_dev_arr_lock, iflags);
1411     if (sg_template.nr_dev >= sg_template.dev_max) { /* try to resize */
1412         Sg_device ** tmp_da;
1413         int tmp_dev_max = sg_template.nr_dev + SG_DEV_ARR_LUMP;
1414
1415         tmp_da = (Sg_device **)kmalloc(tmp_dev_max *
1416                                         sizeof(Sg_device *), GFP_ATOMIC);
1417         if (NULL == tmp_da) {
1418             scsidp->attached--;
1419             write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1420             printk(KERN_ERR "sg_attach: device array cannot be resized\n");
1421             return 1;
1422         }
1423         memset(tmp_da, 0, tmp_dev_max * sizeof(Sg_device *));
1424         memcpy(tmp_da, sg_dev_arr, sg_template.dev_max * sizeof(Sg_device *));
1425         kfree((char *)sg_dev_arr);
1426         sg_dev_arr = tmp_da;
1427         sg_template.dev_max = tmp_dev_max;
1428     }
1429
1430     for(k = 0; k < sg_template.dev_max; k++)
1431         if(! sg_dev_arr[k]) break;
1432     if (k > MINORMASK) {
1433         scsidp->attached--;
1434         write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1435         printk(KERN_WARNING "Unable to attach sg device <%d, %d, %d, %d>"
1436                " type=%d, minor number exceed %d\n", scsidp->host->host_no,
1437                scsidp->channel, scsidp->id, scsidp->lun, scsidp->type,
1438                MINORMASK);
1439         return 1;
1440     }
1441     if(k < sg_template.dev_max)
1442         sdp = (Sg_device *)kmalloc(sizeof(Sg_device), GFP_ATOMIC);
1443     else
1444         sdp = NULL;
1445     if (NULL == sdp) {
1446         scsidp->attached--;
1447         write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1448         printk(KERN_ERR "sg_attach: Sg_device cannot be allocated\n");
1449         return 1;
1450     }
1451
1452     SCSI_LOG_TIMEOUT(3, printk("sg_attach: dev=%d \n", k));
1453     sdp->device = scsidp;
1454     init_waitqueue_head(&sdp->o_excl_wait);
1455     sdp->headfp= NULL;
1456     sdp->exclude = 0;
1457     sdp->sgdebug = 0;
1458     sdp->detached = 0;
1459     sdp->sg_tablesize = scsidp->host ? scsidp->host->sg_tablesize : 0;
1460     sdp->i_rdev = MKDEV(SCSI_GENERIC_MAJOR, k);
1461     sdp->de = devfs_register (scsidp->de, "generic", DEVFS_FL_DEFAULT,
1462                              SCSI_GENERIC_MAJOR, k,
1463                              S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP,
1464                              &sg_fops, sdp);
1465     sg_template.nr_dev++;
1466     sg_dev_arr[k] = sdp;
1467     write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1468     switch (scsidp->type) {
1469         case TYPE_DISK:
1470         case TYPE_MOD:
1471         case TYPE_ROM:
1472         case TYPE_WORM:
1473         case TYPE_TAPE: break;
1474         default:
1475             printk(KERN_NOTICE "Attached scsi generic sg%d at scsi%d, channel"
1476                    " %d, id %d, lun %d,  type %d\n", k, scsidp->host->host_no,
1477                    scsidp->channel, scsidp->id, scsidp->lun, scsidp->type);
1478     }
1479     return 0;
1480 }
1481
1482 /* Called at 'finish' of init process, after all attaches */
1483 static void sg_finish(void)
1484 { }
1485
1486 static void sg_detach(Scsi_Device * scsidp)
1487 {
1488     Sg_device * sdp;
1489     unsigned long iflags;
1490     Sg_fd * sfp;
1491     Sg_fd * tsfp;
1492     Sg_request * srp;
1493     Sg_request * tsrp;
1494     int k, delay;
1495
1496     if (NULL == sg_dev_arr)
1497         return;
1498     delay = 0;
1499     write_lock_irqsave(&sg_dev_arr_lock, iflags);
1500     for (k = 0; k < sg_template.dev_max; k++) {
1501         sdp = sg_dev_arr[k];
1502         if ((NULL == sdp) || (sdp->device != scsidp))
1503             continue;   /* dirty but lowers nesting */
1504         if (sdp->headfp) {
1505             sdp->detached = 1;
1506             for (sfp = sdp->headfp; sfp; sfp = tsfp) {
1507                 tsfp = sfp->nextfp;
1508                 for (srp = sfp->headrp; srp; srp = tsrp) {
1509                     tsrp = srp->nextrp;
1510                     if (sfp->closed || (0 == srp->done))
1511                         sg_finish_rem_req(srp);
1512                 }
1513                 if (sfp->closed) {
1514                     sdp->device->access_count--;
1515                     if (sg_template.module)
1516                         __MOD_DEC_USE_COUNT(sg_template.module);
1517                     if (sdp->device->host->hostt->module)
1518                         __MOD_DEC_USE_COUNT(sdp->device->host->hostt->module);
1519                     __sg_remove_sfp(sdp, sfp);
1520                 }
1521                 else {
1522                     delay = 1;
1523                     wake_up_interruptible(&sfp->read_wait);
1524                     kill_fasync(&sfp->async_qp, SIGPOLL, POLL_HUP);
1525                 }
1526             }
1527             SCSI_LOG_TIMEOUT(3, printk("sg_detach: dev=%d, dirty\n", k));
1528             devfs_unregister (sdp->de);
1529             sdp->de = NULL;
1530             if (NULL == sdp->headfp) {
1531                 kfree((char *)sdp);
1532                 sg_dev_arr[k] = NULL;
1533             }
1534         }
1535         else { /* nothing active, simple case */
1536             SCSI_LOG_TIMEOUT(3, printk("sg_detach: dev=%d\n", k));
1537             devfs_unregister (sdp->de);
1538             kfree((char *)sdp);
1539             sg_dev_arr[k] = NULL;
1540         }
1541         scsidp->attached--;
1542         sg_template.nr_dev--;
1543         sg_template.dev_noticed--;      /* from <dan@lectra.fr> */
1544         break;
1545     }
1546     write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
1547     if (delay)
1548         scsi_sleep(2);  /* dirty detach so delay device destruction */
1549 }
1550
1551 MODULE_AUTHOR("Douglas Gilbert");
1552 MODULE_DESCRIPTION("SCSI generic (sg) driver");
1553
1554 #ifdef MODULE_LICENSE
1555 MODULE_LICENSE("GPL");
1556 #endif
1557
1558 MODULE_PARM(def_reserved_size, "i");
1559 MODULE_PARM_DESC(def_reserved_size, "size of buffer reserved for each fd");
1560
1561 static int __init init_sg(void) {
1562     if (def_reserved_size >= 0)
1563         sg_big_buff = def_reserved_size;
1564     sg_template.module = THIS_MODULE;
1565     return scsi_register_module(MODULE_SCSI_DEV, &sg_template);
1566 }
1567
1568 static void __exit exit_sg( void)
1569 {
1570 #ifdef CONFIG_PROC_FS
1571     sg_proc_cleanup();
1572 #endif  /* CONFIG_PROC_FS */
1573     scsi_unregister_module(MODULE_SCSI_DEV, &sg_template);
1574     devfs_unregister_chrdev(SCSI_GENERIC_MAJOR, "sg");
1575     if(sg_dev_arr != NULL) {
1576         kfree((char *)sg_dev_arr);
1577         sg_dev_arr = NULL;
1578     }
1579     sg_template.dev_max = 0;
1580 }
1581
1582
1583 static int sg_start_req(Sg_request * srp)
1584 {
1585     int res;
1586     Sg_fd * sfp = srp->parentfp;
1587     sg_io_hdr_t * hp = &srp->header;
1588     int dxfer_len = (int)hp->dxfer_len;
1589     int dxfer_dir = hp->dxfer_direction;
1590     Sg_scatter_hold * req_schp = &srp->data;
1591     Sg_scatter_hold * rsv_schp = &sfp->reserve;
1592
1593     SCSI_LOG_TIMEOUT(4, printk("sg_start_req: dxfer_len=%d\n", dxfer_len));
1594     if ((dxfer_len <= 0) || (dxfer_dir == SG_DXFER_NONE))
1595         return 0;
1596     if (sg_allow_dio && (hp->flags & SG_FLAG_DIRECT_IO) &&
1597         (dxfer_dir != SG_DXFER_UNKNOWN) && (0 == hp->iovec_count) &&
1598         (! sfp->parentdp->device->host->unchecked_isa_dma)) {
1599         res = sg_build_dir(srp, sfp, dxfer_len);
1600         if (res <= 0)   /* -ve -> error, 0 -> done, 1 -> try indirect */
1601             return res;
1602     }
1603     if ((! sg_res_in_use(sfp)) && (dxfer_len <= rsv_schp->bufflen))
1604         sg_link_reserve(sfp, srp, dxfer_len);
1605     else {
1606         res = sg_build_indi(req_schp, sfp, dxfer_len);
1607         if (res) {
1608             sg_remove_scat(req_schp);
1609             return res;
1610         }
1611     }
1612     return 0;
1613 }
1614
1615 static void sg_finish_rem_req(Sg_request * srp)
1616 {
1617     Sg_fd * sfp = srp->parentfp;
1618     Sg_scatter_hold * req_schp = &srp->data;
1619
1620     SCSI_LOG_TIMEOUT(4, printk("sg_finish_rem_req: res_used=%d\n",
1621                                (int)srp->res_used));
1622     sg_unmap_and(&srp->data, 1);
1623     if (srp->res_used)
1624         sg_unlink_reserve(sfp, srp);
1625     else
1626         sg_remove_scat(req_schp);
1627     sg_remove_request(sfp, srp);
1628 }
1629
1630 static int sg_build_sgat(Sg_scatter_hold * schp, const Sg_fd * sfp,
1631                          int tablesize)
1632 {
1633     int mem_src, ret_sz;
1634     int elem_sz = sizeof(struct scatterlist) + sizeof(char);
1635     /* scatter gather array, followed by mem_src_arr (array of chars) */
1636     int sg_bufflen = tablesize * elem_sz;
1637     int mx_sc_elems = tablesize;
1638
1639     mem_src = SG_HEAP_KMAL;
1640     schp->buffer = sg_malloc(sfp, sg_bufflen, &ret_sz, &mem_src);
1641     if (! schp->buffer)
1642         return -ENOMEM;
1643     else if (ret_sz != sg_bufflen) {
1644         sg_bufflen = ret_sz;
1645         mx_sc_elems = sg_bufflen / elem_sz;
1646     }
1647     schp->buffer_mem_src = (char)mem_src;
1648     schp->sglist_len = sg_bufflen;
1649     memset(schp->buffer, 0, sg_bufflen);
1650     return mx_sc_elems; /* number of scat_gath elements allocated */
1651 }
1652
1653 static inline int sg_alloc_kiovec(int nr, struct kiobuf **bufp, int *szp)
1654 {
1655 #if SG_NEW_KIOVEC
1656     return alloc_kiovec_sz(nr, bufp, szp);
1657 #else
1658     return alloc_kiovec(nr, bufp);
1659 #endif
1660 }
1661
1662 static inline void sg_free_kiovec(int nr, struct kiobuf **bufp, int *szp)
1663 {
1664 #if SG_NEW_KIOVEC
1665     free_kiovec_sz(nr, bufp, szp);
1666 #else
1667     free_kiovec(nr, bufp);
1668 #endif
1669 }
1670
1671 static void sg_unmap_and(Sg_scatter_hold * schp, int free_also)
1672 {
1673 #ifdef SG_ALLOW_DIO_CODE
1674     int nbhs = 0;
1675
1676     if (schp && schp->kiobp) {
1677         if (schp->mapped) {
1678             unmap_kiobuf(schp->kiobp);
1679             schp->mapped = 0;
1680         }
1681         if (free_also) {
1682             sg_free_kiovec(1, &schp->kiobp, &nbhs);
1683             schp->kiobp = NULL;
1684         }
1685     }
1686 #endif
1687 }
1688
1689 static int sg_build_dir(Sg_request * srp, Sg_fd * sfp, int dxfer_len)
1690 {
1691 #ifdef SG_ALLOW_DIO_CODE
1692     int res, k, split, offset, num, mx_sc_elems, rem_sz;
1693     struct kiobuf * kp;
1694     char * mem_src_arr;
1695     struct scatterlist * sclp;
1696     unsigned long addr, prev_addr;
1697     sg_io_hdr_t * hp = &srp->header;
1698     Sg_scatter_hold * schp = &srp->data;
1699     int sg_tablesize = sfp->parentdp->sg_tablesize;
1700     int nbhs = 0;
1701
1702     res = sg_alloc_kiovec(1, &schp->kiobp, &nbhs);
1703     if (0 != res) {
1704         SCSI_LOG_TIMEOUT(5, printk("sg_build_dir: sg_alloc_kiovec res=%d\n",
1705                          res));
1706         return 1;
1707     }
1708     res = map_user_kiobuf((SG_DXFER_TO_DEV == hp->dxfer_direction) ? 1 : 0,
1709                           schp->kiobp, (unsigned long)hp->dxferp, dxfer_len);
1710     if (0 != res) {
1711         SCSI_LOG_TIMEOUT(5,
1712                 printk("sg_build_dir: map_user_kiobuf res=%d\n", res));
1713         sg_unmap_and(schp, 1);
1714         return 1;
1715     }
1716     schp->mapped = 1;
1717     kp = schp->kiobp;
1718     prev_addr = (unsigned long) page_address(kp->maplist[0]);
1719     for (k = 1, split = 0; k < kp->nr_pages; ++k, prev_addr = addr) {
1720         addr = (unsigned long) page_address(kp->maplist[k]);
1721         if ((prev_addr + PAGE_SIZE) != addr) {
1722             split = k;
1723             break;
1724         }
1725     }
1726     if (! split) {
1727         schp->k_use_sg = 0;
1728         schp->buffer = page_address(kp->maplist[0]) + kp->offset;
1729         schp->bufflen = dxfer_len;
1730         schp->buffer_mem_src = SG_USER_MEM;
1731         schp->b_malloc_len = dxfer_len;
1732         hp->info |= SG_INFO_DIRECT_IO;
1733         return 0;
1734     }
1735     mx_sc_elems = sg_build_sgat(schp, sfp, sg_tablesize);
1736     if (mx_sc_elems <= 1) {
1737         sg_unmap_and(schp, 1);
1738         sg_remove_scat(schp);
1739         return 1;
1740     }
1741     mem_src_arr = schp->buffer + (mx_sc_elems * sizeof(struct scatterlist));
1742     for (k = 0, sclp = schp->buffer, rem_sz = dxfer_len;
1743          (rem_sz > 0) && (k < mx_sc_elems);
1744          ++k, ++sclp) {
1745         offset = (0 == k) ? kp->offset : 0;
1746         num = (rem_sz > (PAGE_SIZE - offset)) ? (PAGE_SIZE - offset) :
1747                                                 rem_sz;
1748         sclp->address = page_address(kp->maplist[k]) + offset;
1749 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,13)
1750         sclp->page = NULL;
1751 #endif
1752         sclp->length = num;
1753         mem_src_arr[k] = SG_USER_MEM;
1754         rem_sz -= num;
1755         SCSI_LOG_TIMEOUT(5,
1756             printk("sg_build_dir: k=%d, a=0x%p, len=%d, ms=%d\n",
1757             k, sclp->address, num, mem_src_arr[k]));
1758     }
1759     schp->k_use_sg = k;
1760     SCSI_LOG_TIMEOUT(5,
1761         printk("sg_build_dir: k_use_sg=%d, rem_sz=%d\n", k, rem_sz));
1762     schp->bufflen = dxfer_len;
1763     if (rem_sz > 0) {   /* must have failed */
1764         sg_unmap_and(schp, 1);
1765         sg_remove_scat(schp);
1766         return 1;   /* out of scatter gather elements, try indirect */
1767     }
1768     hp->info |= SG_INFO_DIRECT_IO;
1769     return 0;
1770 #else
1771     return 1;
1772 #endif /* SG_ALLOW_DIO_CODE */
1773 }
1774
1775 static int sg_build_indi(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size)
1776 {
1777     int ret_sz, mem_src;
1778     int blk_size = buff_size;
1779     char * p = NULL;
1780
1781     if ((blk_size < 0) || (! sfp))
1782         return -EFAULT;
1783     if (0 == blk_size)
1784         ++blk_size;             /* don't know why */
1785 /* round request up to next highest SG_SECTOR_SZ byte boundary */
1786     blk_size = (blk_size + SG_SECTOR_MSK) & (~SG_SECTOR_MSK);
1787     SCSI_LOG_TIMEOUT(4, printk("sg_build_indi: buff_size=%d, blk_size=%d\n",
1788                                buff_size, blk_size));
1789     if (blk_size <= SG_SCATTER_SZ) {
1790         mem_src = SG_HEAP_PAGE;
1791         p = sg_malloc(sfp, blk_size, &ret_sz, &mem_src);
1792         if (! p)
1793             return -ENOMEM;
1794         if (blk_size == ret_sz) { /* got it on the first attempt */
1795             schp->k_use_sg = 0;
1796             schp->buffer = p;
1797             schp->bufflen = blk_size;
1798             schp->buffer_mem_src = (char)mem_src;
1799             schp->b_malloc_len = blk_size;
1800             return 0;
1801         }
1802     }
1803     else {
1804         mem_src = SG_HEAP_PAGE;
1805         p = sg_malloc(sfp, SG_SCATTER_SZ, &ret_sz, &mem_src);
1806         if (! p)
1807             return -ENOMEM;
1808     }
1809 /* Want some local declarations, so start new block ... */
1810     {   /* lets try and build a scatter gather list */
1811         struct scatterlist * sclp;
1812         int k, rem_sz, num;
1813         int mx_sc_elems;
1814         int sg_tablesize = sfp->parentdp->sg_tablesize;
1815         int first = 1;
1816         char * mem_src_arr;
1817
1818         /* N.B. ret_sz and mem_src carried into this block ... */
1819         mx_sc_elems = sg_build_sgat(schp, sfp, sg_tablesize);
1820         if (mx_sc_elems < 0)
1821             return mx_sc_elems; /* most likely -ENOMEM */
1822         mem_src_arr = schp->buffer +
1823                       (mx_sc_elems * sizeof(struct scatterlist));
1824
1825         for (k = 0, sclp = schp->buffer, rem_sz = blk_size;
1826              (rem_sz > 0) && (k < mx_sc_elems);
1827              ++k, rem_sz -= ret_sz, ++sclp) {
1828             if (first)
1829                 first = 0;
1830             else {
1831                 num = (rem_sz > SG_SCATTER_SZ) ? SG_SCATTER_SZ : rem_sz;
1832                 mem_src = SG_HEAP_PAGE;
1833                 p = sg_malloc(sfp, num, &ret_sz, &mem_src);
1834                 if (! p)
1835                     break;
1836             }
1837             sclp->address = p;
1838 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,13)
1839             sclp->page = NULL;
1840 #endif
1841             sclp->length = ret_sz;
1842             mem_src_arr[k] = mem_src;
1843
1844             SCSI_LOG_TIMEOUT(5,
1845                 printk("sg_build_build: k=%d, a=0x%p, len=%d, ms=%d\n",
1846                 k, sclp->address, ret_sz, mem_src));
1847         } /* end of for loop */
1848         schp->k_use_sg = k;
1849         SCSI_LOG_TIMEOUT(5,
1850             printk("sg_build_indi: k_use_sg=%d, rem_sz=%d\n", k, rem_sz));
1851         schp->bufflen = blk_size;
1852         if (rem_sz > 0)   /* must have failed */
1853             return -ENOMEM;
1854     }
1855     return 0;
1856 }
1857
1858 static int sg_write_xfer(Sg_request * srp)
1859 {
1860     sg_io_hdr_t * hp = &srp->header;
1861     Sg_scatter_hold * schp = &srp->data;
1862     int num_xfer = 0;
1863     int j, k, onum, usglen, ksglen, res, ok;
1864     int iovec_count = (int)hp->iovec_count;
1865     int dxfer_dir = hp->dxfer_direction;
1866     unsigned char * p;
1867     unsigned char * up;
1868     int new_interface = ('\0' == hp->interface_id) ? 0 : 1;
1869
1870     if ((SG_DXFER_UNKNOWN == dxfer_dir) || (SG_DXFER_TO_DEV == dxfer_dir) ||
1871         (SG_DXFER_TO_FROM_DEV == dxfer_dir)) {
1872         num_xfer = (int)(new_interface ?  hp->dxfer_len : hp->flags);
1873         if (schp->bufflen < num_xfer)
1874             num_xfer = schp->bufflen;
1875     }
1876     if ((num_xfer <= 0) ||
1877         (new_interface && ((SG_FLAG_NO_DXFER | SG_FLAG_MMAP_IO) & hp->flags)))
1878         return 0;
1879
1880     SCSI_LOG_TIMEOUT(4,
1881          printk("sg_write_xfer: num_xfer=%d, iovec_count=%d, k_use_sg=%d\n",
1882                 num_xfer, iovec_count, schp->k_use_sg));
1883     if (iovec_count) {
1884         onum = iovec_count;
1885         if ((k = verify_area(VERIFY_READ, hp->dxferp,
1886                              SZ_SG_IOVEC * onum)))
1887             return k;
1888     }
1889     else
1890         onum = 1;
1891
1892     if (0 == schp->k_use_sg) {  /* kernel has single buffer */
1893         if (SG_USER_MEM != schp->buffer_mem_src) { /* else nothing to do */
1894
1895             for (j = 0, p = schp->buffer; j < onum; ++j) {
1896                 res = sg_u_iovec(hp, iovec_count, j, 1, &usglen, &up);
1897                 if (res) return res;
1898                 usglen = (num_xfer > usglen) ? usglen : num_xfer;
1899                 __copy_from_user(p, up, usglen);
1900                 p += usglen;
1901                 num_xfer -= usglen;
1902                 if (num_xfer <= 0)
1903                     return 0;
1904             }
1905         }
1906     }
1907     else {      /* kernel using scatter gather list */
1908         struct scatterlist * sclp = (struct scatterlist *)schp->buffer;
1909         char * mem_src_arr = sg_get_sgat_msa(schp);
1910         ksglen = (int)sclp->length;
1911         p = sclp->address;
1912
1913         for (j = 0, k = 0; j < onum; ++j) {
1914             res = sg_u_iovec(hp, iovec_count, j, 1, &usglen, &up);
1915             if (res) return res;
1916
1917             for ( ; p; ++sclp, ksglen = (int)sclp->length, p = sclp->address) {
1918                 ok = (SG_USER_MEM != mem_src_arr[k]);
1919                 if (usglen <= 0)
1920                     break;
1921                 if (ksglen > usglen) {
1922                     if (usglen >= num_xfer) {
1923                         if (ok) __copy_from_user(p, up, num_xfer);
1924                         return 0;
1925                     }
1926                     if (ok) __copy_from_user(p, up, usglen);
1927                     p += usglen;
1928                     ksglen -= usglen;
1929                     break;
1930                 }
1931                 else {
1932                     if (ksglen >= num_xfer) {
1933                         if (ok) __copy_from_user(p, up, num_xfer);
1934                         return 0;
1935                     }
1936                     if (ok) __copy_from_user(p, up, ksglen);
1937                     up += ksglen;
1938                     usglen -= ksglen;
1939                 }
1940                 ++k;
1941                 if (k >= schp->k_use_sg)
1942                     return 0;
1943             }
1944         }
1945     }
1946     return 0;
1947 }
1948
1949 static int sg_u_iovec(sg_io_hdr_t * hp, int sg_num, int ind,
1950                       int wr_xf, int * countp, unsigned char ** up)
1951 {
1952     int num_xfer = (int)hp->dxfer_len;
1953     unsigned char * p;
1954     int count, k;
1955     sg_iovec_t u_iovec;
1956
1957     if (0 == sg_num) {
1958         p = (unsigned char *)hp->dxferp;
1959         if (wr_xf && ('\0' == hp->interface_id))
1960             count = (int)hp->flags; /* holds "old" input_size */
1961         else
1962             count = num_xfer;
1963     }
1964     else {
1965         __copy_from_user(&u_iovec,
1966                          (unsigned char *)hp->dxferp + (ind * SZ_SG_IOVEC),
1967                          SZ_SG_IOVEC);
1968         p = (unsigned char *)u_iovec.iov_base;
1969         count = (int)u_iovec.iov_len;
1970     }
1971     if ((k = verify_area(wr_xf ? VERIFY_READ : VERIFY_WRITE, p, count)))
1972         return k;
1973     if (up) *up = p;
1974     if (countp) *countp = count;
1975     return 0;
1976 }
1977
1978 static char * sg_get_sgat_msa(Sg_scatter_hold * schp)
1979 {
1980     int elem_sz = sizeof(struct scatterlist) + sizeof(char);
1981     int mx_sc_elems = schp->sglist_len / elem_sz;
1982     return schp->buffer + (sizeof(struct scatterlist) * mx_sc_elems);
1983 }
1984
1985 static void sg_remove_scat(Sg_scatter_hold * schp)
1986 {
1987     SCSI_LOG_TIMEOUT(4, printk("sg_remove_scat: k_use_sg=%d\n",
1988                                schp->k_use_sg));
1989     if (schp->buffer && schp->sglist_len) {
1990         int k, mem_src;
1991         struct scatterlist * sclp = (struct scatterlist *)schp->buffer;
1992         char * mem_src_arr = sg_get_sgat_msa(schp);
1993
1994         for (k = 0; (k < schp->k_use_sg) && sclp->address; ++k, ++sclp) {
1995             mem_src = mem_src_arr[k];
1996             SCSI_LOG_TIMEOUT(5,
1997                 printk("sg_remove_scat: k=%d, a=0x%p, len=%d, ms=%d\n",
1998                        k, sclp->address, sclp->length, mem_src));
1999             sg_free(sclp->address, sclp->length, mem_src);
2000             sclp->address = NULL;
2001 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,13)
2002             sclp->page = NULL;
2003 #endif
2004             sclp->length = 0;
2005         }
2006         sg_free(schp->buffer, schp->sglist_len, schp->buffer_mem_src);
2007     }
2008     else if (schp->buffer)
2009         sg_free(schp->buffer, schp->b_malloc_len, schp->buffer_mem_src);
2010     memset(schp, 0, sizeof(*schp));
2011 }
2012
2013 static int sg_read_xfer(Sg_request * srp)
2014 {
2015     sg_io_hdr_t * hp = &srp->header;
2016     Sg_scatter_hold * schp = &srp->data;
2017     int num_xfer = 0;
2018     int j, k, onum, usglen, ksglen, res, ok;
2019     int iovec_count = (int)hp->iovec_count;
2020     int dxfer_dir = hp->dxfer_direction;
2021     unsigned char * p;
2022     unsigned char * up;
2023     int new_interface = ('\0' == hp->interface_id) ? 0 : 1;
2024
2025     if ((SG_DXFER_UNKNOWN == dxfer_dir) || (SG_DXFER_FROM_DEV == dxfer_dir) ||
2026         (SG_DXFER_TO_FROM_DEV == dxfer_dir)) {
2027         num_xfer =  hp->dxfer_len;
2028         if (schp->bufflen < num_xfer)
2029             num_xfer = schp->bufflen;
2030     }
2031     if ((num_xfer <= 0) ||
2032         (new_interface && ((SG_FLAG_NO_DXFER | SG_FLAG_MMAP_IO) & hp->flags)))
2033         return 0;
2034
2035     SCSI_LOG_TIMEOUT(4,
2036          printk("sg_read_xfer: num_xfer=%d, iovec_count=%d, k_use_sg=%d\n",
2037                 num_xfer, iovec_count, schp->k_use_sg));
2038     if (iovec_count) {
2039         onum = iovec_count;
2040         if ((k = verify_area(VERIFY_READ, hp->dxferp,
2041                              SZ_SG_IOVEC * onum)))
2042             return k;
2043     }
2044     else
2045         onum = 1;
2046
2047     if (0 == schp->k_use_sg) {  /* kernel has single buffer */
2048         if (SG_USER_MEM != schp->buffer_mem_src) { /* else nothing to do */
2049
2050             for (j = 0, p = schp->buffer; j < onum; ++j) {
2051                 res = sg_u_iovec(hp, iovec_count, j, 0, &usglen, &up);
2052                 if (res) return res;
2053                 usglen = (num_xfer > usglen) ? usglen : num_xfer;
2054                 __copy_to_user(up, p, usglen);
2055                 p += usglen;
2056                 num_xfer -= usglen;
2057                 if (num_xfer <= 0)
2058                     return 0;
2059             }
2060         }
2061     }
2062     else {      /* kernel using scatter gather list */
2063         struct scatterlist * sclp = (struct scatterlist *)schp->buffer;
2064         char * mem_src_arr = sg_get_sgat_msa(schp);
2065         ksglen = (int)sclp->length;
2066         p = sclp->address;
2067
2068         for (j = 0, k = 0; j < onum; ++j) {
2069             res = sg_u_iovec(hp, iovec_count, j, 0, &usglen, &up);
2070             if (res) return res;
2071
2072             for ( ; p; ++sclp, ksglen = (int)sclp->length, p = sclp->address) {
2073                 ok = (SG_USER_MEM != mem_src_arr[k]);
2074                 if (usglen <= 0)
2075                     break;
2076                 if (ksglen > usglen) {
2077                     if (usglen >= num_xfer) {
2078                         if (ok) __copy_to_user(up, p, num_xfer);
2079                         return 0;
2080                     }
2081                     if (ok) __copy_to_user(up, p, usglen);
2082                     p += usglen;
2083                     ksglen -= usglen;
2084                     break;
2085                 }
2086                 else {
2087                     if (ksglen >= num_xfer) {
2088                         if (ok) __copy_to_user(up, p, num_xfer);
2089                         return 0;
2090                     }
2091                     if (ok) __copy_to_user(up, p, ksglen);
2092                     up += ksglen;
2093                     usglen -= ksglen;
2094                 }
2095                 ++k;
2096                 if (k >= schp->k_use_sg)
2097                     return 0;
2098             }
2099         }
2100     }
2101     return 0;
2102 }
2103
2104 static void sg_read_oxfer(Sg_request * srp, char * outp, int num_read_xfer)
2105 {
2106     Sg_scatter_hold * schp = &srp->data;
2107
2108     SCSI_LOG_TIMEOUT(4, printk("sg_read_oxfer: num_read_xfer=%d\n",
2109                                num_read_xfer));
2110     if ((! outp) || (num_read_xfer <= 0))
2111         return;
2112     if(schp->k_use_sg > 0) {
2113         int k, num;
2114         struct scatterlist * sclp = (struct scatterlist *)schp->buffer;
2115
2116         for (k = 0; (k < schp->k_use_sg) && sclp->address; ++k, ++sclp) {
2117             num = (int)sclp->length;
2118             if (num > num_read_xfer) {
2119                 __copy_to_user(outp, sclp->address, num_read_xfer);
2120                 break;
2121             }
2122             else {
2123                 __copy_to_user(outp, sclp->address, num);
2124                 num_read_xfer -= num;
2125                 if (num_read_xfer <= 0)
2126                     break;
2127                 outp += num;
2128             }
2129         }
2130     }
2131     else
2132         __copy_to_user(outp, schp->buffer, num_read_xfer);
2133 }
2134
2135 static void sg_build_reserve(Sg_fd * sfp, int req_size)
2136 {
2137     Sg_scatter_hold * schp = &sfp->reserve;
2138
2139     SCSI_LOG_TIMEOUT(4, printk("sg_build_reserve: req_size=%d\n", req_size));
2140     do {
2141         if (req_size < PAGE_SIZE)
2142             req_size = PAGE_SIZE;
2143         if (0 == sg_build_indi(schp, sfp, req_size))
2144             return;
2145         else
2146             sg_remove_scat(schp);
2147         req_size >>= 1; /* divide by 2 */
2148     } while (req_size >  (PAGE_SIZE / 2));
2149 }
2150
2151 static void sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size)
2152 {
2153     Sg_scatter_hold * req_schp = &srp->data;
2154     Sg_scatter_hold * rsv_schp = &sfp->reserve;
2155
2156     srp->res_used = 1;
2157     SCSI_LOG_TIMEOUT(4, printk("sg_link_reserve: size=%d\n", size));
2158     size = (size + 1) & (~1);    /* round to even for aha1542 */
2159     if (rsv_schp->k_use_sg > 0) {
2160         int k, num;
2161         int rem = size;
2162         struct scatterlist * sclp = (struct scatterlist *)rsv_schp->buffer;
2163
2164         for (k = 0; k < rsv_schp->k_use_sg; ++k, ++sclp) {
2165             num = (int)sclp->length;
2166             if (rem <= num) {
2167                 if (0 == k) {
2168                     req_schp->k_use_sg = 0;
2169                     req_schp->buffer = sclp->address;
2170                 }
2171                 else {
2172                     sfp->save_scat_len = num;
2173                     sclp->length = (unsigned)rem;
2174                     req_schp->k_use_sg = k + 1;
2175                     req_schp->sglist_len = rsv_schp->sglist_len;
2176                     req_schp->buffer = rsv_schp->buffer;
2177                 }
2178                 req_schp->bufflen = size;
2179                 req_schp->buffer_mem_src = rsv_schp->buffer_mem_src;
2180                 req_schp->b_malloc_len = rsv_schp->b_malloc_len;
2181                 break;
2182             }
2183             else
2184                 rem -= num;
2185         }
2186         if (k >= rsv_schp->k_use_sg)
2187             SCSI_LOG_TIMEOUT(1, printk("sg_link_reserve: BAD size\n"));
2188     }
2189     else {
2190         req_schp->k_use_sg = 0;
2191         req_schp->bufflen = size;
2192         req_schp->buffer = rsv_schp->buffer;
2193         req_schp->buffer_mem_src = rsv_schp->buffer_mem_src;
2194         req_schp->b_malloc_len = rsv_schp->b_malloc_len;
2195     }
2196 }
2197
2198 static void sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp)
2199 {
2200     Sg_scatter_hold * req_schp = &srp->data;
2201     Sg_scatter_hold * rsv_schp = &sfp->reserve;
2202
2203     SCSI_LOG_TIMEOUT(4, printk("sg_unlink_reserve: req->k_use_sg=%d\n",
2204                                (int)req_schp->k_use_sg));
2205     if ((rsv_schp->k_use_sg > 0) && (req_schp->k_use_sg > 0)) {
2206         struct scatterlist * sclp = (struct scatterlist *)rsv_schp->buffer;
2207
2208         if (sfp->save_scat_len > 0)
2209             (sclp + (req_schp->k_use_sg - 1))->length =
2210                                         (unsigned)sfp->save_scat_len;
2211         else
2212             SCSI_LOG_TIMEOUT(1, printk(
2213                         "sg_unlink_reserve: BAD save_scat_len\n"));
2214     }
2215     req_schp->k_use_sg = 0;
2216     req_schp->bufflen = 0;
2217     req_schp->buffer = NULL;
2218     req_schp->sglist_len = 0;
2219     sfp->save_scat_len = 0;
2220     srp->res_used = 0;
2221 }
2222
2223 static Sg_request * sg_get_rq_mark(Sg_fd * sfp, int pack_id)
2224 {
2225     Sg_request * resp;
2226     unsigned long iflags;
2227
2228     write_lock_irqsave(&sfp->rq_list_lock, iflags);
2229     for (resp = sfp->headrp; resp; resp = resp->nextrp) {
2230         /* look for requests that are ready + not SG_IO owned */
2231         if ((1 == resp->done) && (! resp->sg_io_owned) &&
2232             ((-1 == pack_id) || (resp->header.pack_id == pack_id))) {
2233             resp->done = 2;   /* guard against other readers */
2234             break;
2235         }
2236     }
2237     write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
2238     return resp;
2239 }
2240
2241 #ifdef CONFIG_PROC_FS
2242 static Sg_request * sg_get_nth_request(Sg_fd * sfp, int nth)
2243 {
2244     Sg_request * resp;
2245     unsigned long iflags;
2246     int k;
2247
2248     read_lock_irqsave(&sfp->rq_list_lock, iflags);
2249     for (k = 0, resp = sfp->headrp; resp && (k < nth);
2250          ++k, resp = resp->nextrp)
2251         ;
2252     read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
2253     return resp;
2254 }
2255 #endif
2256
2257 /* always adds to end of list */
2258 static Sg_request * sg_add_request(Sg_fd * sfp)
2259 {
2260     int k;
2261     unsigned long iflags;
2262     Sg_request * resp;
2263     Sg_request * rp =  sfp->req_arr;
2264
2265     write_lock_irqsave(&sfp->rq_list_lock, iflags);
2266     resp = sfp->headrp;
2267     if (! resp) {
2268         memset(rp, 0, sizeof(Sg_request));
2269         rp->parentfp = sfp;
2270         resp = rp;
2271         sfp->headrp = resp;
2272     }
2273     else {
2274         if (0 == sfp->cmd_q)
2275             resp = NULL;   /* command queuing disallowed */
2276         else {
2277             for (k = 0; k < SG_MAX_QUEUE; ++k, ++rp) {
2278                 if (! rp->parentfp)
2279                     break;
2280             }
2281             if (k < SG_MAX_QUEUE) {
2282                 memset(rp, 0, sizeof(Sg_request));
2283                 rp->parentfp = sfp;
2284                 while (resp->nextrp)
2285                     resp = resp->nextrp;
2286                 resp->nextrp = rp;
2287                 resp = rp;
2288             }
2289             else
2290                 resp = NULL;
2291         }
2292     }
2293     if (resp) {
2294         resp->nextrp = NULL;
2295         resp->header.duration = jiffies;
2296         resp->my_cmdp = NULL;
2297         resp->data.kiobp = NULL;
2298     }
2299     write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
2300     return resp;
2301 }
2302
2303 /* Return of 1 for found; 0 for not found */
2304 static int sg_remove_request(Sg_fd * sfp, Sg_request * srp)
2305 {
2306     Sg_request * prev_rp;
2307     Sg_request * rp;
2308     unsigned long iflags;
2309     int res = 0;
2310
2311     if ((! sfp) || (! srp) || (! sfp->headrp))
2312         return res;
2313     write_lock_irqsave(&sfp->rq_list_lock, iflags);
2314     prev_rp = sfp->headrp;
2315     if (srp == prev_rp) {
2316         sfp->headrp = prev_rp->nextrp;
2317         prev_rp->parentfp = NULL;
2318         res = 1;
2319     }
2320     else {
2321         while ((rp = prev_rp->nextrp)) {
2322             if (srp == rp) {
2323                 prev_rp->nextrp = rp->nextrp;
2324                 rp->parentfp = NULL;
2325                 res = 1;
2326                 break;
2327             }
2328             prev_rp = rp;
2329         }
2330     }
2331     write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
2332     return res;
2333 }
2334
2335 #ifdef CONFIG_PROC_FS
2336 static Sg_fd * sg_get_nth_sfp(Sg_device * sdp, int nth)
2337 {
2338     Sg_fd * resp;
2339     unsigned long iflags;
2340     int k;
2341
2342     read_lock_irqsave(&sg_dev_arr_lock, iflags);
2343     for (k = 0, resp = sdp->headfp; resp && (k < nth);
2344          ++k, resp = resp->nextfp)
2345         ;
2346     read_unlock_irqrestore(&sg_dev_arr_lock, iflags);
2347     return resp;
2348 }
2349 #endif
2350
2351 static Sg_fd * sg_add_sfp(Sg_device * sdp, int dev)
2352 {
2353     Sg_fd * sfp;
2354     unsigned long iflags;
2355
2356     sfp = (Sg_fd *)sg_low_malloc(sizeof(Sg_fd), 0, SG_HEAP_KMAL, 0);
2357     if (! sfp)
2358         return NULL;
2359     memset(sfp, 0, sizeof(Sg_fd));
2360     sfp->fd_mem_src = SG_HEAP_KMAL;
2361     init_waitqueue_head(&sfp->read_wait);
2362     sfp->rq_list_lock = RW_LOCK_UNLOCKED;
2363
2364     sfp->timeout = SG_DEFAULT_TIMEOUT;
2365     sfp->force_packid = SG_DEF_FORCE_PACK_ID;
2366     sfp->low_dma = (SG_DEF_FORCE_LOW_DMA == 0) ?
2367                    sdp->device->host->unchecked_isa_dma : 1;
2368     sfp->cmd_q = SG_DEF_COMMAND_Q;
2369     sfp->keep_orphan = SG_DEF_KEEP_ORPHAN;
2370     sfp->parentdp = sdp;
2371     write_lock_irqsave(&sg_dev_arr_lock, iflags);
2372     if (! sdp->headfp)
2373         sdp->headfp = sfp;
2374     else {    /* add to tail of existing list */
2375         Sg_fd * pfp = sdp->headfp;
2376         while (pfp->nextfp)
2377             pfp = pfp->nextfp;
2378         pfp->nextfp = sfp;
2379     }
2380     write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
2381     SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp: sfp=0x%p, m_s=%d\n",
2382                                sfp, (int)sfp->fd_mem_src));
2383     sg_build_reserve(sfp, sg_big_buff);
2384     SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp:   bufflen=%d, k_use_sg=%d\n",
2385                            sfp->reserve.bufflen, sfp->reserve.k_use_sg));
2386     return sfp;
2387 }
2388
2389 static void __sg_remove_sfp(Sg_device * sdp, Sg_fd * sfp)
2390 {
2391     Sg_fd * fp;
2392     Sg_fd * prev_fp;
2393
2394     prev_fp =  sdp->headfp;
2395     if (sfp == prev_fp)
2396         sdp->headfp = prev_fp->nextfp;
2397     else {
2398         while ((fp = prev_fp->nextfp)) {
2399             if (sfp == fp) {
2400                 prev_fp->nextfp = fp->nextfp;
2401                 break;
2402             }
2403             prev_fp = fp;
2404         }
2405     }
2406     if (sfp->reserve.bufflen > 0) {
2407     SCSI_LOG_TIMEOUT(6, printk("__sg_remove_sfp:    bufflen=%d, k_use_sg=%d\n",
2408              (int)sfp->reserve.bufflen, (int)sfp->reserve.k_use_sg));
2409         if (sfp->mmap_called)
2410             sg_rb_correct4mmap(&sfp->reserve, 0); /* undo correction */
2411         sg_remove_scat(&sfp->reserve);
2412     }
2413     sfp->parentdp = NULL;
2414     SCSI_LOG_TIMEOUT(6, printk("__sg_remove_sfp:    sfp=0x%p\n", sfp));
2415     sg_low_free((char *)sfp, sizeof(Sg_fd), sfp->fd_mem_src);
2416 }
2417
2418 /* Returns 0 in normal case, 1 when detached and sdp object removed */
2419 static int sg_remove_sfp(Sg_device * sdp, Sg_fd * sfp)
2420 {
2421     Sg_request * srp;
2422     Sg_request * tsrp;
2423     int dirty = 0;
2424     int res = 0;
2425
2426     for (srp = sfp->headrp; srp; srp = tsrp) {
2427         tsrp = srp->nextrp;
2428         if (srp->done)
2429             sg_finish_rem_req(srp);
2430         else
2431             ++dirty;
2432     }
2433     if (0 == dirty) {
2434         unsigned long iflags;
2435
2436         write_lock_irqsave(&sg_dev_arr_lock, iflags);
2437         __sg_remove_sfp(sdp, sfp);
2438         if (sdp->detached && (NULL == sdp->headfp)) {
2439             int k, maxd;
2440
2441             maxd = sg_template.dev_max;
2442             for (k = 0; k < maxd; ++k) {
2443                 if (sdp == sg_dev_arr[k])
2444                     break;
2445             }
2446             if (k < maxd)
2447                 sg_dev_arr[k] = NULL;
2448             kfree((char *)sdp);
2449             res = 1;
2450         }
2451         write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
2452     }
2453     else {
2454         sfp->closed = 1; /* flag dirty state on this fd */
2455         sdp->device->access_count++;
2456         /* MOD_INC's to inhibit unloading sg and associated adapter driver */
2457         if (sg_template.module)
2458             __MOD_INC_USE_COUNT(sg_template.module);
2459         if (sdp->device->host->hostt->module)
2460             __MOD_INC_USE_COUNT(sdp->device->host->hostt->module);
2461         SCSI_LOG_TIMEOUT(1, printk(
2462           "sg_remove_sfp: worrisome, %d writes pending\n", dirty));
2463     }
2464     return res;
2465 }
2466
2467 static int sg_res_in_use(Sg_fd * sfp)
2468 {
2469     const Sg_request * srp;
2470     unsigned long iflags;
2471
2472     read_lock_irqsave(&sfp->rq_list_lock, iflags);
2473     for (srp = sfp->headrp; srp; srp = srp->nextrp)
2474         if (srp->res_used) break;
2475     read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
2476     return srp ? 1 : 0;
2477 }
2478
2479 /* If retSzp==NULL want exact size or fail */
2480 static char * sg_low_malloc(int rqSz, int lowDma, int mem_src, int * retSzp)
2481 {
2482     char * resp = NULL;
2483     int page_mask = lowDma ? (GFP_ATOMIC | GFP_DMA) : GFP_ATOMIC;
2484
2485     if (rqSz <= 0)
2486         return resp;
2487     if (SG_HEAP_KMAL == mem_src) {
2488         resp = kmalloc(rqSz, page_mask);
2489         if (resp) {
2490             if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2491                 memset(resp, 0, rqSz);
2492             if (retSzp) *retSzp = rqSz;
2493         }
2494         return resp;
2495     }
2496     if (SG_HEAP_POOL == mem_src) {
2497         int num_sect = rqSz / SG_SECTOR_SZ;
2498
2499         if (0 != (rqSz & SG_SECTOR_MSK)) {
2500             if (! retSzp)
2501                 return resp;
2502             ++num_sect;
2503             rqSz = num_sect * SG_SECTOR_SZ;
2504         }
2505         while (num_sect > 0) {
2506             if ((num_sect <= sg_pool_secs_avail) &&
2507                 (scsi_dma_free_sectors > (SG_LOW_POOL_THRESHHOLD + num_sect))) {
2508                 resp = scsi_malloc(rqSz);
2509                 if (resp) {
2510                     if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2511                         memset(resp, 0, rqSz);
2512                     if (retSzp) *retSzp = rqSz;
2513                     sg_pool_secs_avail -= num_sect;
2514                     return resp;
2515                 }
2516             }
2517             if (! retSzp)
2518                 return resp;
2519             num_sect /= 2;      /* try half as many */
2520             rqSz = num_sect * SG_SECTOR_SZ;
2521         }
2522     }
2523     else if (SG_HEAP_PAGE == mem_src) {
2524         int order, a_size;
2525         int resSz = rqSz;
2526
2527         for (order = 0, a_size = PAGE_SIZE;
2528              a_size < rqSz; order++, a_size <<= 1)
2529             ;
2530         resp = (char *)__get_free_pages(page_mask, order);
2531         while ((! resp) && order && retSzp) {
2532             --order;
2533             a_size >>= 1;   /* divide by 2, until PAGE_SIZE */
2534             resp = (char *)__get_free_pages(page_mask, order); /* try half */
2535             resSz = a_size;
2536         }
2537         if (resp) {
2538             if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2539                 memset(resp, 0, resSz);
2540             if (retSzp) *retSzp = resSz;
2541         }
2542     }
2543     else
2544         printk(KERN_ERR "sg_low_malloc: bad mem_src=%d, rqSz=%df\n",
2545                mem_src, rqSz);
2546     return resp;
2547 }
2548
2549 static char * sg_malloc(const Sg_fd * sfp, int size, int * retSzp,
2550                         int * mem_srcp)
2551 {
2552     char * resp = NULL;
2553
2554     if (retSzp) *retSzp = size;
2555     if (size <= 0)
2556         ;
2557     else {
2558         int low_dma = sfp->low_dma;
2559         int l_ms = -1;  /* invalid value */
2560
2561         switch (*mem_srcp)
2562         {
2563         case SG_HEAP_PAGE:
2564             l_ms = (size < PAGE_SIZE) ? SG_HEAP_POOL : SG_HEAP_PAGE;
2565             resp = sg_low_malloc(size, low_dma, l_ms, 0);
2566             if (resp)
2567                 break;
2568             resp = sg_low_malloc(size, low_dma, l_ms, &size);
2569             if (! resp) {
2570                 l_ms = (SG_HEAP_POOL == l_ms) ? SG_HEAP_PAGE : SG_HEAP_POOL;
2571                 resp = sg_low_malloc(size, low_dma, l_ms, &size);
2572                 if (! resp) {
2573                     l_ms = SG_HEAP_KMAL;
2574                     resp = sg_low_malloc(size, low_dma, l_ms, &size);
2575                 }
2576             }
2577             if (resp && retSzp) *retSzp = size;
2578             break;
2579         case SG_HEAP_KMAL:
2580             l_ms = SG_HEAP_KMAL; /* was SG_HEAP_PAGE */
2581             resp = sg_low_malloc(size, low_dma, l_ms, 0);
2582             if (resp)
2583                 break;
2584             l_ms = SG_HEAP_POOL;
2585             resp = sg_low_malloc(size, low_dma, l_ms, &size);
2586             if (resp && retSzp) *retSzp = size;
2587             break;
2588         default:
2589             SCSI_LOG_TIMEOUT(1, printk("sg_malloc: bad ms=%d\n", *mem_srcp));
2590             break;
2591         }
2592         if (resp) *mem_srcp = l_ms;
2593     }
2594     SCSI_LOG_TIMEOUT(6, printk("sg_malloc: size=%d, ms=%d, ret=0x%p\n",
2595                                size, *mem_srcp, resp));
2596     return resp;
2597 }
2598
2599 static void sg_low_free(char * buff, int size, int mem_src)
2600 {
2601     if (! buff) return;
2602     switch (mem_src) {
2603     case SG_HEAP_POOL:
2604         {
2605             int num_sect = size / SG_SECTOR_SZ;
2606
2607             scsi_free(buff, size);
2608             sg_pool_secs_avail += num_sect;
2609         }
2610         break;
2611     case SG_HEAP_KMAL:
2612         kfree(buff);    /* size not used */
2613         break;
2614     case SG_HEAP_PAGE:
2615         {
2616             int order, a_size;
2617             for (order = 0, a_size = PAGE_SIZE;
2618                  a_size < size; order++, a_size <<= 1)
2619                 ;
2620             free_pages((unsigned long)buff, order);
2621         }
2622         break;
2623     case SG_USER_MEM:
2624         break; /* nothing to do */
2625     default:
2626         printk(KERN_ERR "sg_low_free: bad mem_src=%d, buff=0x%p, rqSz=%d\n",
2627                mem_src, buff, size);
2628         break;
2629     }
2630 }
2631
2632 static void sg_free(char * buff, int size, int mem_src)
2633 {
2634     SCSI_LOG_TIMEOUT(6,
2635         printk("sg_free: buff=0x%p, size=%d\n", buff, size));
2636     if ((! buff) || (size <= 0))
2637         ;
2638     else
2639         sg_low_free(buff, size, mem_src);
2640 }
2641
2642 static int sg_ms_to_jif(unsigned int msecs)
2643 {
2644     if ((UINT_MAX / 2U) < msecs)
2645         return INT_MAX;      /* special case, set largest possible */
2646     else
2647         return ((int)msecs < (INT_MAX / 1000)) ? (((int)msecs * HZ) / 1000)
2648                                                : (((int)msecs / 1000) * HZ);
2649 }
2650
2651 static unsigned char allow_ops[] = {TEST_UNIT_READY, REQUEST_SENSE,
2652 INQUIRY, READ_CAPACITY, READ_BUFFER, READ_6, READ_10, READ_12,
2653 MODE_SENSE, MODE_SENSE_10, LOG_SENSE};
2654
2655 static int sg_allow_access(unsigned char opcode, char dev_type)
2656 {
2657     int k;
2658
2659     if (TYPE_SCANNER == dev_type) /* TYPE_ROM maybe burner */
2660         return 1;
2661     for (k = 0; k < sizeof(allow_ops); ++k) {
2662         if (opcode == allow_ops[k])
2663             return 1;
2664     }
2665     return 0;
2666 }
2667
2668
2669 #ifdef CONFIG_PROC_FS
2670 static int sg_last_dev()
2671 {
2672     int k;
2673     unsigned long iflags;
2674
2675     read_lock_irqsave(&sg_dev_arr_lock, iflags);
2676     for (k = sg_template.dev_max - 1; k >= 0; --k)
2677         if (sg_dev_arr[k] && sg_dev_arr[k]->device) break;
2678     read_unlock_irqrestore(&sg_dev_arr_lock, iflags);
2679     return k + 1;   /* origin 1 */
2680 }
2681 #endif
2682
2683 static Sg_device * sg_get_dev(int dev)
2684 {
2685     Sg_device * sdp = NULL;
2686     unsigned long iflags;
2687
2688     if (sg_dev_arr && (dev >= 0))
2689     {
2690         read_lock_irqsave(&sg_dev_arr_lock, iflags);
2691         if (dev < sg_template.dev_max)
2692             sdp = sg_dev_arr[dev];
2693         read_unlock_irqrestore(&sg_dev_arr_lock, iflags);
2694     }
2695     return sdp;
2696 }
2697
2698 #ifdef CONFIG_PROC_FS
2699
2700 static struct proc_dir_entry * sg_proc_sgp = NULL;
2701
2702 static char sg_proc_sg_dirname[] = "sg";
2703 static const char * sg_proc_leaf_names[] = {"allow_dio", "def_reserved_size",
2704                 "debug", "devices", "device_hdr", "device_strs",
2705                 "hosts", "host_hdr", "host_strs", "version"};
2706
2707 static int sg_proc_adio_read(char * buffer, char ** start, off_t offset,
2708                              int size, int * eof, void * data);
2709 static int sg_proc_adio_info(char * buffer, int * len, off_t * begin,
2710                              off_t offset, int size);
2711 static int sg_proc_adio_write(struct file * filp, const char * buffer,
2712                               unsigned long count, void * data);
2713 static int sg_proc_dressz_read(char * buffer, char ** start, off_t offset,
2714                                int size, int * eof, void * data);
2715 static int sg_proc_dressz_info(char * buffer, int * len, off_t * begin,
2716                                off_t offset, int size);
2717 static int sg_proc_dressz_write(struct file * filp, const char * buffer,
2718                                 unsigned long count, void * data);
2719 static int sg_proc_debug_read(char * buffer, char ** start, off_t offset,
2720                               int size, int * eof, void * data);
2721 static int sg_proc_debug_info(char * buffer, int * len, off_t * begin,
2722                               off_t offset, int size);
2723 static int sg_proc_dev_read(char * buffer, char ** start, off_t offset,
2724                             int size, int * eof, void * data);
2725 static int sg_proc_dev_info(char * buffer, int * len, off_t * begin,
2726                             off_t offset, int size);
2727 static int sg_proc_devhdr_read(char * buffer, char ** start, off_t offset,
2728                                int size, int * eof, void * data);
2729 static int sg_proc_devhdr_info(char * buffer, int * len, off_t * begin,
2730                                off_t offset, int size);
2731 static int sg_proc_devstrs_read(char * buffer, char ** start, off_t offset,
2732                                 int size, int * eof, void * data);
2733 static int sg_proc_devstrs_info(char * buffer, int * len, off_t * begin,
2734                                 off_t offset, int size);
2735 static int sg_proc_host_read(char * buffer, char ** start, off_t offset,
2736                              int size, int * eof, void * data);
2737 static int sg_proc_host_info(char * buffer, int * len, off_t * begin,
2738                              off_t offset, int size);
2739 static int sg_proc_hosthdr_read(char * buffer, char ** start, off_t offset,
2740                                 int size, int * eof, void * data);
2741 static int sg_proc_hosthdr_info(char * buffer, int * len, off_t * begin,
2742                                 off_t offset, int size);
2743 static int sg_proc_hoststrs_read(char * buffer, char ** start, off_t offset,
2744                                  int size, int * eof, void * data);
2745 static int sg_proc_hoststrs_info(char * buffer, int * len, off_t * begin,
2746                                  off_t offset, int size);
2747 static int sg_proc_version_read(char * buffer, char ** start, off_t offset,
2748                                 int size, int * eof, void * data);
2749 static int sg_proc_version_info(char * buffer, int * len, off_t * begin,
2750                                 off_t offset, int size);
2751 static read_proc_t * sg_proc_leaf_reads[] = {
2752              sg_proc_adio_read, sg_proc_dressz_read, sg_proc_debug_read,
2753              sg_proc_dev_read, sg_proc_devhdr_read, sg_proc_devstrs_read,
2754              sg_proc_host_read, sg_proc_hosthdr_read, sg_proc_hoststrs_read,
2755              sg_proc_version_read};
2756 static write_proc_t * sg_proc_leaf_writes[] = {
2757              sg_proc_adio_write, sg_proc_dressz_write, 0, 0, 0, 0, 0, 0, 0, 0};
2758
2759 #define PRINT_PROC(fmt,args...)                                 \
2760     do {                                                        \
2761         *len += sprintf(buffer + *len, fmt, ##args);            \
2762         if (*begin + *len > offset + size)                      \
2763             return 0;                                           \
2764         if (*begin + *len < offset) {                           \
2765             *begin += *len;                                     \
2766             *len = 0;                                           \
2767         }                                                       \
2768     } while(0)
2769
2770 #define SG_PROC_READ_FN(infofp)                                 \
2771     do {                                                        \
2772         int len = 0;                                            \
2773         off_t begin = 0;                                        \
2774         *eof = infofp(buffer, &len, &begin, offset, size);      \
2775         if (offset >= (begin + len))                            \
2776             return 0;                                           \
2777         *start = buffer + offset - begin;                       \
2778         return (size < (begin + len - offset)) ?                \
2779                                 size : begin + len - offset;    \
2780     } while(0)
2781
2782
2783 static int sg_proc_init()
2784 {
2785     int k, mask;
2786     int leaves = sizeof(sg_proc_leaf_names) / sizeof(sg_proc_leaf_names[0]);
2787     struct proc_dir_entry * pdep;
2788
2789     if (! proc_scsi)
2790         return 1;
2791     sg_proc_sgp = create_proc_entry(sg_proc_sg_dirname,
2792                                     S_IFDIR | S_IRUGO | S_IXUGO, proc_scsi);
2793     if (! sg_proc_sgp)
2794         return 1;
2795     for (k = 0; k < leaves; ++k) {
2796         mask = sg_proc_leaf_writes[k] ? S_IRUGO | S_IWUSR : S_IRUGO;
2797         pdep = create_proc_entry(sg_proc_leaf_names[k], mask, sg_proc_sgp);
2798         if (pdep) {
2799             pdep->read_proc = sg_proc_leaf_reads[k];
2800             if (sg_proc_leaf_writes[k])
2801                 pdep->write_proc = sg_proc_leaf_writes[k];
2802         }
2803     }
2804     return 0;
2805 }
2806
2807 static void sg_proc_cleanup()
2808 {
2809     int k;
2810     int leaves = sizeof(sg_proc_leaf_names) / sizeof(sg_proc_leaf_names[0]);
2811
2812     if ((! proc_scsi) || (! sg_proc_sgp))
2813         return;
2814     for (k = 0; k < leaves; ++k)
2815         remove_proc_entry(sg_proc_leaf_names[k], sg_proc_sgp);
2816     remove_proc_entry(sg_proc_sg_dirname, proc_scsi);
2817 }
2818
2819 static int sg_proc_adio_read(char * buffer, char ** start, off_t offset,
2820                                int size, int * eof, void * data)
2821 { SG_PROC_READ_FN(sg_proc_adio_info); }
2822
2823 static int sg_proc_adio_info(char * buffer, int * len, off_t * begin,
2824                              off_t offset, int size)
2825 {
2826     PRINT_PROC("%d\n", sg_allow_dio);
2827     return 1;
2828 }
2829
2830 static int sg_proc_adio_write(struct file * filp, const char * buffer,
2831                               unsigned long count, void * data)
2832 {
2833     int num;
2834     char buff[11];
2835
2836     if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2837         return -EACCES;
2838     num = (count < 10) ? count : 10;
2839     copy_from_user(buff, buffer, num);
2840     buff[num] = '\0';
2841     sg_allow_dio = simple_strtoul(buff, 0, 10) ? 1 : 0;
2842     return count;
2843 }
2844
2845 static int sg_proc_dressz_read(char * buffer, char ** start, off_t offset,
2846                                int size, int * eof, void * data)
2847 { SG_PROC_READ_FN(sg_proc_dressz_info); }
2848
2849 static int sg_proc_dressz_info(char * buffer, int * len, off_t * begin,
2850                                off_t offset, int size)
2851 {
2852     PRINT_PROC("%d\n", sg_big_buff);
2853     return 1;
2854 }
2855
2856 static int sg_proc_dressz_write(struct file * filp, const char * buffer,
2857                                 unsigned long count, void * data)
2858 {
2859     int num;
2860     unsigned long k = ULONG_MAX;
2861     char buff[11];
2862
2863     if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2864         return -EACCES;
2865     num = (count < 10) ? count : 10;
2866     copy_from_user(buff, buffer, num);
2867     buff[num] = '\0';
2868     k = simple_strtoul(buff, 0, 10);
2869     if (k <= 1048576) {
2870         sg_big_buff = k;
2871         return count;
2872     }
2873     return -ERANGE;
2874 }
2875
2876 static int sg_proc_debug_read(char * buffer, char ** start, off_t offset,
2877                               int size, int * eof, void * data)
2878 { SG_PROC_READ_FN(sg_proc_debug_info); }
2879
2880 static int sg_proc_debug_info(char * buffer, int * len, off_t * begin,
2881                               off_t offset, int size)
2882 {
2883     Sg_device * sdp;
2884     const sg_io_hdr_t * hp;
2885     int j, max_dev, new_interface;
2886
2887     if (NULL == sg_dev_arr) {
2888         PRINT_PROC("sg_dev_arr NULL, driver not initialized\n");
2889         return 1;
2890     }
2891     max_dev = sg_last_dev();
2892     PRINT_PROC("dev_max(currently)=%d max_active_device=%d (origin 1)\n",
2893                sg_template.dev_max, max_dev);
2894     PRINT_PROC(" scsi_dma_free_sectors=%u sg_pool_secs_aval=%d "
2895                "def_reserved_size=%d\n",
2896                scsi_dma_free_sectors, sg_pool_secs_avail, sg_big_buff);
2897     for (j = 0; j < max_dev; ++j) {
2898         if ((sdp = sg_get_dev(j))) {
2899             Sg_fd * fp;
2900             Sg_request * srp;
2901             struct scsi_device * scsidp;
2902             int dev, k, m, blen, usg;
2903
2904             scsidp = sdp->device;
2905             if (NULL == scsidp) {
2906                 PRINT_PROC("device %d detached ??\n", j);
2907                 continue;
2908             }
2909             dev = MINOR(sdp->i_rdev);
2910
2911             if (sg_get_nth_sfp(sdp, 0)) {
2912                 PRINT_PROC(" >>> device=sg%d ", dev);
2913                 if (sdp->detached)
2914                     PRINT_PROC("detached pending close ");
2915                 else
2916                     PRINT_PROC("scsi%d chan=%d id=%d lun=%d   em=%d",
2917                        scsidp->host->host_no, scsidp->channel,
2918                        scsidp->id, scsidp->lun, scsidp->host->hostt->emulated);
2919                 PRINT_PROC(" sg_tablesize=%d excl=%d\n", sdp->sg_tablesize,
2920                            sdp->exclude);
2921             }
2922             for (k = 0; (fp = sg_get_nth_sfp(sdp, k)); ++k) {
2923                 PRINT_PROC("   FD(%d): timeout=%dms bufflen=%d "
2924                            "(res)sgat=%d low_dma=%d\n", k + 1,
2925                            sg_jif_to_ms(fp->timeout), fp->reserve.bufflen,
2926                            (int)fp->reserve.k_use_sg, (int)fp->low_dma);
2927                 PRINT_PROC("   cmd_q=%d f_packid=%d k_orphan=%d closed=%d\n",
2928                            (int)fp->cmd_q, (int)fp->force_packid,
2929                            (int)fp->keep_orphan, (int)fp->closed);
2930                 for (m = 0; (srp = sg_get_nth_request(fp, m)); ++m) {
2931                     hp = &srp->header;
2932                     new_interface = (hp->interface_id == '\0') ? 0 : 1;
2933 /* stop indenting so far ... */
2934         PRINT_PROC(srp->res_used ? ((new_interface &&
2935             (SG_FLAG_MMAP_IO & hp->flags)) ? "     mmap>> " : "     rb>> ") :
2936             ((SG_INFO_DIRECT_IO_MASK & hp->info) ? "     dio>> " : "     "));
2937         blen = srp->my_cmdp ? srp->my_cmdp->sr_bufflen : srp->data.bufflen;
2938         usg = srp->my_cmdp ? srp->my_cmdp->sr_use_sg : srp->data.k_use_sg;
2939         PRINT_PROC(srp->done ? ((1 == srp->done) ? "rcv:" : "fin:")
2940                              : (srp->my_cmdp ? "act:" : "prior:"));
2941         PRINT_PROC(" id=%d blen=%d", srp->header.pack_id, blen);
2942         if (srp->done)
2943             PRINT_PROC(" dur=%d", hp->duration);
2944         else
2945             PRINT_PROC(" t_o/elap=%d/%d", new_interface ? hp->timeout :
2946                         sg_jif_to_ms(fp->timeout),
2947                   sg_jif_to_ms(hp->duration ? (jiffies - hp->duration) : 0));
2948         PRINT_PROC("ms sgat=%d op=0x%02x\n", usg, (int)srp->data.cmd_opcode);
2949 /* reset indenting */
2950                 }
2951                 if (0 == m)
2952                     PRINT_PROC("     No requests active\n");
2953             }
2954         }
2955     }
2956     return 1;
2957 }
2958
2959 static int sg_proc_dev_read(char * buffer, char ** start, off_t offset,
2960                             int size, int * eof, void * data)
2961 { SG_PROC_READ_FN(sg_proc_dev_info); }
2962
2963 static int sg_proc_dev_info(char * buffer, int * len, off_t * begin,
2964                             off_t offset, int size)
2965 {
2966     Sg_device * sdp;
2967     int j, max_dev;
2968     struct scsi_device * scsidp;
2969
2970     max_dev = sg_last_dev();
2971     for (j = 0; j < max_dev; ++j) {
2972         sdp = sg_get_dev(j);
2973         if (sdp && (scsidp = sdp->device) && (! sdp->detached))
2974             PRINT_PROC("%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",
2975                scsidp->host->host_no, scsidp->channel, scsidp->id,
2976                scsidp->lun, (int)scsidp->type, (int)scsidp->access_count,
2977                (int)scsidp->queue_depth, (int)scsidp->device_busy,
2978                (int)scsidp->online);
2979         else
2980             PRINT_PROC("-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\n");
2981     }
2982     return 1;
2983 }
2984
2985 static int sg_proc_devhdr_read(char * buffer, char ** start, off_t offset,
2986                                int size, int * eof, void * data)
2987 { SG_PROC_READ_FN(sg_proc_devhdr_info); }
2988
2989 static int sg_proc_devhdr_info(char * buffer, int * len, off_t * begin,
2990                                off_t offset, int size)
2991 {
2992     PRINT_PROC("host\tchan\tid\tlun\ttype\topens\tqdepth\tbusy\tonline\n");
2993     return 1;
2994 }
2995
2996 static int sg_proc_devstrs_read(char * buffer, char ** start, off_t offset,
2997                                 int size, int * eof, void * data)
2998 { SG_PROC_READ_FN(sg_proc_devstrs_info); }
2999
3000 static int sg_proc_devstrs_info(char * buffer, int * len, off_t * begin,
3001                                 off_t offset, int size)
3002 {
3003     Sg_device * sdp;
3004     int j, max_dev;
3005     struct scsi_device * scsidp;
3006
3007     max_dev = sg_last_dev();
3008     for (j = 0; j < max_dev; ++j) {
3009         sdp = sg_get_dev(j);
3010         if (sdp && (scsidp = sdp->device) && (! sdp->detached))
3011             PRINT_PROC("%8.8s\t%16.16s\t%4.4s\n",
3012                        scsidp->vendor, scsidp->model, scsidp->rev);
3013         else
3014             PRINT_PROC("<no active device>\n");
3015     }
3016     return 1;
3017 }
3018
3019 static int sg_proc_host_read(char * buffer, char ** start, off_t offset,
3020                              int size, int * eof, void * data)
3021 { SG_PROC_READ_FN(sg_proc_host_info); }
3022
3023 static int sg_proc_host_info(char * buffer, int * len, off_t * begin,
3024                              off_t offset, int size)
3025 {
3026     struct Scsi_Host * shp;
3027     int k;
3028
3029     for (k = 0, shp = scsi_hostlist; shp; shp = shp->next, ++k) {
3030         for ( ; k < shp->host_no; ++k)
3031             PRINT_PROC("-1\t-1\t-1\t-1\t-1\t-1\n");
3032         PRINT_PROC("%u\t%hu\t%hd\t%hu\t%d\t%d\n",
3033                    shp->unique_id, shp->host_busy, shp->cmd_per_lun,
3034                    shp->sg_tablesize, (int)shp->unchecked_isa_dma,
3035                    (int)shp->hostt->emulated);
3036     }
3037     return 1;
3038 }
3039
3040 static int sg_proc_hosthdr_read(char * buffer, char ** start, off_t offset,
3041                                 int size, int * eof, void * data)
3042 { SG_PROC_READ_FN(sg_proc_hosthdr_info); }
3043
3044 static int sg_proc_hosthdr_info(char * buffer, int * len, off_t * begin,
3045                                 off_t offset, int size)
3046 {
3047     PRINT_PROC("uid\tbusy\tcpl\tscatg\tisa\temul\n");
3048     return 1;
3049 }
3050
3051 static int sg_proc_hoststrs_read(char * buffer, char ** start, off_t offset,
3052                                  int size, int * eof, void * data)
3053 { SG_PROC_READ_FN(sg_proc_hoststrs_info); }
3054
3055 #define SG_MAX_HOST_STR_LEN 256
3056
3057 static int sg_proc_hoststrs_info(char * buffer, int * len, off_t * begin,
3058                                  off_t offset, int size)
3059 {
3060     struct Scsi_Host * shp;
3061     int k;
3062     char buff[SG_MAX_HOST_STR_LEN];
3063     char * cp;
3064
3065     for (k = 0, shp = scsi_hostlist; shp; shp = shp->next, ++k) {
3066         for ( ; k < shp->host_no; ++k)
3067             PRINT_PROC("<no active host>\n");
3068         strncpy(buff, shp->hostt->info ? shp->hostt->info(shp) :
3069                     (shp->hostt->name ? shp->hostt->name : "<no name>"),
3070                 SG_MAX_HOST_STR_LEN);
3071         buff[SG_MAX_HOST_STR_LEN - 1] = '\0';
3072         for (cp = buff; *cp; ++cp) {
3073             if ('\n' == *cp)
3074                 *cp = ' '; /* suppress imbedded newlines */
3075         }
3076         PRINT_PROC("%s\n", buff);
3077     }
3078     return 1;
3079 }
3080
3081 static int sg_proc_version_read(char * buffer, char ** start, off_t offset,
3082                                 int size, int * eof, void * data)
3083 { SG_PROC_READ_FN(sg_proc_version_info); }
3084
3085 static int sg_proc_version_info(char * buffer, int * len, off_t * begin,
3086                                 off_t offset, int size)
3087 {
3088     PRINT_PROC("%d\t%s\n", sg_version_num, sg_version_str);
3089     return 1;
3090 }
3091 #endif  /* CONFIG_PROC_FS */
3092
3093
3094 module_init(init_sg);
3095 module_exit(exit_sg);