sg.c 69.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 *  History:
 *  Started: Aug 9 by Lawrence Foard (entropy@world.std.com),
 *           to allow user process control of SCSI devices.
 *  Development Sponsored by Killy Corp. NY NY
 *
 * Original driver (sg.c):
 *        Copyright (C) 1992 Lawrence Foard
 * Version 2 and 3 extensions to driver:
 *        Copyright (C) 1998 - 2005 Douglas Gilbert
 *
 *  Modified  19-JAN-1998  Richard Gooch <rgooch@atnf.csiro.au>  Devfs support
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 */

21 22
static int sg_version_num = 30534;	/* 2 digits for each component */
#define SG_VERSION_STR "3.5.34"
L
Linus Torvalds 已提交
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

/*
 *  D. P. Gilbert (dgilbert@interlog.com, dougg@triode.net.au), notes:
 *      - scsi logging is available via SCSI_LOG_TIMEOUT macros. First
 *        the kernel/module needs to be built with CONFIG_SCSI_LOGGING
 *        (otherwise the macros compile to empty statements).
 *
 */
#include <linux/module.h>

#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/mm.h>
38
#include <linux/aio.h>
L
Linus Torvalds 已提交
39 40 41
#include <linux/errno.h>
#include <linux/mtio.h>
#include <linux/ioctl.h>
42
#include <linux/slab.h>
L
Linus Torvalds 已提交
43 44 45 46 47
#include <linux/fcntl.h>
#include <linux/init.h>
#include <linux/poll.h>
#include <linux/moduleparam.h>
#include <linux/cdev.h>
48
#include <linux/idr.h>
L
Linus Torvalds 已提交
49 50 51
#include <linux/seq_file.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
52
#include <linux/blktrace_api.h>
53
#include <linux/mutex.h>
54
#include <linux/ratelimit.h>
L
Linus Torvalds 已提交
55 56

#include "scsi.h"
已提交
57
#include <scsi/scsi_dbg.h>
L
Linus Torvalds 已提交
58 59 60 61 62 63 64 65 66
#include <scsi/scsi_host.h>
#include <scsi/scsi_driver.h>
#include <scsi/scsi_ioctl.h>
#include <scsi/sg.h>

#include "scsi_logging.h"

#ifdef CONFIG_SCSI_PROC_FS
#include <linux/proc_fs.h>
67
static char *sg_version_date = "20061027";
L
Linus Torvalds 已提交
68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99

static int sg_proc_init(void);
static void sg_proc_cleanup(void);
#endif

#define SG_ALLOW_DIO_DEF 0

#define SG_MAX_DEVS 32768

/*
 * Suppose you want to calculate the formula muldiv(x,m,d)=int(x * m / d)
 * Then when using 32 bit integers x * m may overflow during the calculation.
 * Replacing muldiv(x) by muldiv(x)=((x % d) * m) / d + int(x / d) * m
 * calculates the same, but prevents the overflow when both m and d
 * are "small" numbers (like HZ and USER_HZ).
 * Of course an overflow is inavoidable if the result of muldiv doesn't fit
 * in 32 bits.
 */
#define MULDIV(X,MUL,DIV) ((((X % DIV) * MUL) / DIV) + ((X / DIV) * MUL))

#define SG_DEFAULT_TIMEOUT MULDIV(SG_DEFAULT_TIMEOUT_USER, HZ, USER_HZ)

int sg_big_buff = SG_DEF_RESERVED_SIZE;
/* N.B. This variable is readable and writeable via
   /proc/scsi/sg/def_reserved_size . Each time sg_open() is called a buffer
   of this size (or less if there is not enough memory) will be reserved
   for use by this file descriptor. [Deprecated usage: this variable is also
   readable via /proc/sys/kernel/sg-big-buff if the sg driver is built into
   the kernel (i.e. it is not a module).] */
static int def_reserved_size = -1;	/* picks up init parameter */
static int sg_allow_dio = SG_ALLOW_DIO_DEF;

100 101 102
static int scatter_elem_sz = SG_SCATTER_SZ;
static int scatter_elem_sz_prev = SG_SCATTER_SZ;

L
Linus Torvalds 已提交
103 104
#define SG_SECTOR_SZ 512

105 106
static int sg_add(struct device *, struct class_interface *);
static void sg_remove(struct device *, struct class_interface *);
L
Linus Torvalds 已提交
107

108 109
static DEFINE_IDR(sg_index_idr);
static DEFINE_RWLOCK(sg_index_lock);	/* Also used to lock
L
Linus Torvalds 已提交
110 111 112
							   file descriptor list for device */

static struct class_interface sg_interface = {
113 114
	.add_dev	= sg_add,
	.remove_dev	= sg_remove,
L
Linus Torvalds 已提交
115 116 117 118
};

typedef struct sg_scatter_hold { /* holding area for scsi scatter gather info */
	unsigned short k_use_sg; /* Count of kernel scatter-gather pieces */
119
	unsigned sglist_len; /* size of malloc'd scatter-gather list ++ */
L
Linus Torvalds 已提交
120
	unsigned bufflen;	/* Size of (aggregate) data buffer */
121 122
	struct page **pages;
	int page_order;
L
Linus Torvalds 已提交
123 124 125 126 127 128 129 130 131 132 133 134
	char dio_in_use;	/* 0->indirect IO (or mmap), 1->dio */
	unsigned char cmd_opcode; /* first byte of command */
} Sg_scatter_hold;

struct sg_device;		/* forward declarations */
struct sg_fd;

typedef struct sg_request {	/* SG_MAX_QUEUE requests outstanding per file */
	struct sg_request *nextrp;	/* NULL -> tail request (slist) */
	struct sg_fd *parentfp;	/* NULL -> not in use */
	Sg_scatter_hold data;	/* hold buffer, perhaps scatter list */
	sg_io_hdr_t header;	/* scsi command+info, see <scsi/sg.h> */
135
	unsigned char sense_b[SCSI_SENSE_BUFFERSIZE];
L
Linus Torvalds 已提交
136 137 138
	char res_used;		/* 1 -> using reserve buffer, 0 -> not ... */
	char orphan;		/* 1 -> drop on sight, 0 -> normal */
	char sg_io_owned;	/* 1 -> packet belongs to SG_IO */
J
Jörn Engel 已提交
139 140
	/* done protected by rq_list_lock */
	char done;		/* 0->before bh, 1->before read, 2->read */
141
	struct request *rq;
142
	struct bio *bio;
143
	struct execute_work ew;
L
Linus Torvalds 已提交
144 145 146
} Sg_request;

typedef struct sg_fd {		/* holds the state of a file descriptor */
J
Jörn Engel 已提交
147
	/* sfd_siblings is protected by sg_index_lock */
148
	struct list_head sfd_siblings;
L
Linus Torvalds 已提交
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
	struct sg_device *parentdp;	/* owning device */
	wait_queue_head_t read_wait;	/* queue read until command done */
	rwlock_t rq_list_lock;	/* protect access to list in req_arr */
	int timeout;		/* defaults to SG_DEFAULT_TIMEOUT      */
	int timeout_user;	/* defaults to SG_DEFAULT_TIMEOUT_USER */
	Sg_scatter_hold reserve;	/* buffer held for this file descriptor */
	unsigned save_scat_len;	/* original length of trunc. scat. element */
	Sg_request *headrp;	/* head of request slist, NULL->empty */
	struct fasync_struct *async_qp;	/* used by asynchronous notification */
	Sg_request req_arr[SG_MAX_QUEUE];	/* used as singly-linked list */
	char low_dma;		/* as in parent but possibly overridden to 1 */
	char force_packid;	/* 1 -> pack_id input to read(), 0 -> ignored */
	char cmd_q;		/* 1 -> allow command queuing, 0 -> don't */
	char next_cmd_len;	/* 0 -> automatic (def), >0 -> use on next write() */
	char keep_orphan;	/* 0 -> drop orphan (def), 1 -> keep for read() */
	char mmap_called;	/* 0 -> mmap() never called on this fd */
165 166
	struct kref f_ref;
	struct execute_work ew;
L
Linus Torvalds 已提交
167 168 169 170 171
} Sg_fd;

typedef struct sg_device { /* holds the state of each scsi generic device */
	struct scsi_device *device;
	int sg_tablesize;	/* adapter's max scatter-gather table size */
172
	u32 index;		/* device index number */
J
Jörn Engel 已提交
173
	/* sfds is protected by sg_index_lock */
174
	struct list_head sfds;
175
	struct rw_semaphore o_sem;	/* exclude open should hold this rwsem */
L
Linus Torvalds 已提交
176
	volatile char detached;	/* 0->attached, 1->detached pending removal */
J
Jörn Engel 已提交
177
	char exclude;		/* opened for exclusive access */
L
Linus Torvalds 已提交
178 179 180
	char sgdebug;		/* 0->off, 1->sense, 9->dump dev, 10-> all devs */
	struct gendisk *disk;
	struct cdev * cdev;	/* char_dev [sysfs: /sys/cdev/major/sg<n>] */
181
	struct kref d_ref;
L
Linus Torvalds 已提交
182 183
} Sg_device;

184
/* tasklet or soft irq callback */
185
static void sg_rq_end_io(struct request *rq, int uptodate);
186
static int sg_start_req(Sg_request *srp, unsigned char *cmd);
187
static int sg_finish_rem_req(Sg_request * srp);
L
Linus Torvalds 已提交
188 189 190
static int sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size);
static ssize_t sg_new_read(Sg_fd * sfp, char __user *buf, size_t count,
			   Sg_request * srp);
191 192
static ssize_t sg_new_write(Sg_fd *sfp, struct file *file,
			const char __user *buf, size_t count, int blocking,
193
			int read_only, int sg_io_owned, Sg_request **o_srp);
L
Linus Torvalds 已提交
194 195 196 197 198 199 200 201
static int sg_common_write(Sg_fd * sfp, Sg_request * srp,
			   unsigned char *cmnd, int timeout, int blocking);
static int sg_read_oxfer(Sg_request * srp, char __user *outp, int num_read_xfer);
static void sg_remove_scat(Sg_scatter_hold * schp);
static void sg_build_reserve(Sg_fd * sfp, int req_size);
static void sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size);
static void sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp);
static Sg_fd *sg_add_sfp(Sg_device * sdp, int dev);
202
static void sg_remove_sfp(struct kref *);
L
Linus Torvalds 已提交
203 204 205 206 207
static Sg_request *sg_get_rq_mark(Sg_fd * sfp, int pack_id);
static Sg_request *sg_add_request(Sg_fd * sfp);
static int sg_remove_request(Sg_fd * sfp, Sg_request * srp);
static int sg_res_in_use(Sg_fd * sfp);
static Sg_device *sg_get_dev(int dev);
208
static void sg_put_dev(Sg_device *sdp);
L
Linus Torvalds 已提交
209 210 211 212 213 214

#define SZ_SG_HEADER sizeof(struct sg_header)
#define SZ_SG_IO_HDR sizeof(sg_io_hdr_t)
#define SZ_SG_IOVEC sizeof(sg_iovec_t)
#define SZ_SG_REQ_INFO sizeof(sg_req_info_t)

215 216
static int sg_allow_access(struct file *filp, unsigned char *cmd)
{
217
	struct sg_fd *sfp = filp->private_data;
218 219 220 221

	if (sfp->parentdp->device->type == TYPE_SCANNER)
		return 0;

222
	return blk_verify_command(cmd, filp->f_mode & FMODE_WRITE);
223 224
}

J
Jörn Engel 已提交
225 226 227 228 229 230 231 232 233 234 235
static int sfds_list_empty(Sg_device *sdp)
{
	unsigned long flags;
	int ret;

	read_lock_irqsave(&sg_index_lock, flags);
	ret = list_empty(&sdp->sfds);
	read_unlock_irqrestore(&sg_index_lock, flags);
	return ret;
}

L
Linus Torvalds 已提交
236 237 238 239 240
static int
sg_open(struct inode *inode, struct file *filp)
{
	int dev = iminor(inode);
	int flags = filp->f_flags;
241
	struct request_queue *q;
L
Linus Torvalds 已提交
242 243 244 245 246 247 248
	Sg_device *sdp;
	Sg_fd *sfp;
	int retval;

	nonseekable_open(inode, filp);
	SCSI_LOG_TIMEOUT(3, printk("sg_open: dev=%d, flags=0x%x\n", dev, flags));
	sdp = sg_get_dev(dev);
249 250 251 252
	if (IS_ERR(sdp)) {
		retval = PTR_ERR(sdp);
		sdp = NULL;
		goto sg_put;
253
	}
L
Linus Torvalds 已提交
254 255 256 257

	/* This driver's module count bumped by fops_get in <linux/fs.h> */
	/* Prevent the device driver from vanishing while we sleep */
	retval = scsi_device_get(sdp->device);
258 259
	if (retval)
		goto sg_put;
L
Linus Torvalds 已提交
260

261 262 263 264
	retval = scsi_autopm_get_device(sdp->device);
	if (retval)
		goto sdp_put;

L
Linus Torvalds 已提交
265 266 267 268 269 270 271
	if (!((flags & O_NONBLOCK) ||
	      scsi_block_when_processing_errors(sdp->device))) {
		retval = -ENXIO;
		/* we are in error recovery for this device */
		goto error_out;
	}

272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
	if ((flags & O_EXCL) && (O_RDONLY == (flags & O_ACCMODE))) {
		retval = -EPERM; /* Can't lock it with read only access */
		goto error_out;
	}
	if (flags & O_NONBLOCK) {
		if (flags & O_EXCL) {
			if (!down_write_trylock(&sdp->o_sem)) {
				retval = -EBUSY;
				goto error_out;
			}
		} else {
			if (!down_read_trylock(&sdp->o_sem)) {
				retval = -EBUSY;
				goto error_out;
			}
L
Linus Torvalds 已提交
287
		}
288 289 290 291 292
	} else {
		if (flags & O_EXCL)
			down_write(&sdp->o_sem);
		else
			down_read(&sdp->o_sem);
L
Linus Torvalds 已提交
293
	}
294 295
	/* Since write lock is held, no need to check sfd_list */
	if (flags & O_EXCL)
296
		sdp->exclude = 1;	/* used by release lock */
297

J
Jörn Engel 已提交
298
	if (sfds_list_empty(sdp)) {	/* no existing opens on this device */
L
Linus Torvalds 已提交
299
		sdp->sgdebug = 0;
300
		q = sdp->device->request_queue;
301
		sdp->sg_tablesize = queue_max_segments(q);
L
Linus Torvalds 已提交
302
	}
303 304
	sfp = sg_add_sfp(sdp, dev);
	if (!IS_ERR(sfp))
L
Linus Torvalds 已提交
305
		filp->private_data = sfp;
306 307 308
		/* retval is already provably zero at this point because of the
		 * check after retval = scsi_autopm_get_device(sdp->device))
		 */
L
Linus Torvalds 已提交
309
	else {
310 311
		retval = PTR_ERR(sfp);

312
		if (flags & O_EXCL) {
313
			sdp->exclude = 0;	/* undo if error */
314 315 316
			up_write(&sdp->o_sem);
		} else
			up_read(&sdp->o_sem);
317
error_out:
318 319
		scsi_autopm_put_device(sdp->device);
sdp_put:
320
		scsi_device_put(sdp->device);
321
	}
322 323 324
sg_put:
	if (sdp)
		sg_put_dev(sdp);
L
Linus Torvalds 已提交
325 326 327 328 329 330 331 332 333
	return retval;
}

/* Following function was formerly called 'sg_close' */
static int
sg_release(struct inode *inode, struct file *filp)
{
	Sg_device *sdp;
	Sg_fd *sfp;
334
	int excl;
L
Linus Torvalds 已提交
335 336 337 338

	if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
		return -ENXIO;
	SCSI_LOG_TIMEOUT(3, printk("sg_release: %s\n", sdp->disk->disk_name));
339

340 341
	excl = sdp->exclude;
	sdp->exclude = 0;
342 343 344 345
	if (excl)
		up_write(&sdp->o_sem);
	else
		up_read(&sdp->o_sem);
346

347
	scsi_autopm_put_device(sdp->device);
348
	kref_put(&sfp->f_ref, sg_remove_sfp);
L
Linus Torvalds 已提交
349 350 351 352 353 354 355 356 357 358 359
	return 0;
}

static ssize_t
sg_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
{
	Sg_device *sdp;
	Sg_fd *sfp;
	Sg_request *srp;
	int req_pack_id = -1;
	sg_io_hdr_t *hp;
已提交
360 361
	struct sg_header *old_hdr = NULL;
	int retval = 0;
L
Linus Torvalds 已提交
362 363 364 365 366

	if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
		return -ENXIO;
	SCSI_LOG_TIMEOUT(3, printk("sg_read: %s, count=%d\n",
				   sdp->disk->disk_name, (int) count));
367

L
Linus Torvalds 已提交
368 369 370
	if (!access_ok(VERIFY_WRITE, buf, count))
		return -EFAULT;
	if (sfp->force_packid && (count >= SZ_SG_HEADER)) {
已提交
371 372 373 374 375 376 377 378
		old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL);
		if (!old_hdr)
			return -ENOMEM;
		if (__copy_from_user(old_hdr, buf, SZ_SG_HEADER)) {
			retval = -EFAULT;
			goto free_old_hdr;
		}
		if (old_hdr->reply_len < 0) {
L
Linus Torvalds 已提交
379
			if (count >= SZ_SG_IO_HDR) {
已提交
380 381 382 383 384 385 386 387 388 389 390 391 392 393
				sg_io_hdr_t *new_hdr;
				new_hdr = kmalloc(SZ_SG_IO_HDR, GFP_KERNEL);
				if (!new_hdr) {
					retval = -ENOMEM;
					goto free_old_hdr;
				}
				retval =__copy_from_user
				    (new_hdr, buf, SZ_SG_IO_HDR);
				req_pack_id = new_hdr->pack_id;
				kfree(new_hdr);
				if (retval) {
					retval = -EFAULT;
					goto free_old_hdr;
				}
L
Linus Torvalds 已提交
394 395
			}
		} else
已提交
396
			req_pack_id = old_hdr->pack_id;
L
Linus Torvalds 已提交
397 398 399
	}
	srp = sg_get_rq_mark(sfp, req_pack_id);
	if (!srp) {		/* now wait on packet to arrive */
已提交
400 401 402 403 404 405 406 407
		if (sdp->detached) {
			retval = -ENODEV;
			goto free_old_hdr;
		}
		if (filp->f_flags & O_NONBLOCK) {
			retval = -EAGAIN;
			goto free_old_hdr;
		}
408
		retval = wait_event_interruptible(sfp->read_wait,
409
			(sdp->detached ||
410
			(srp = sg_get_rq_mark(sfp, req_pack_id))));
411 412 413 414 415
		if (sdp->detached) {
			retval = -ENODEV;
			goto free_old_hdr;
		}
		if (retval) {
已提交
416 417
			/* -ERESTARTSYS as signal hit process */
			goto free_old_hdr;
L
Linus Torvalds 已提交
418 419
		}
	}
已提交
420 421 422 423
	if (srp->header.interface_id != '\0') {
		retval = sg_new_read(sfp, buf, count, srp);
		goto free_old_hdr;
	}
L
Linus Torvalds 已提交
424 425

	hp = &srp->header;
已提交
426 427 428 429 430 431 432 433 434 435 436 437
	if (old_hdr == NULL) {
		old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL);
		if (! old_hdr) {
			retval = -ENOMEM;
			goto free_old_hdr;
		}
	}
	memset(old_hdr, 0, SZ_SG_HEADER);
	old_hdr->reply_len = (int) hp->timeout;
	old_hdr->pack_len = old_hdr->reply_len; /* old, strange behaviour */
	old_hdr->pack_id = hp->pack_id;
	old_hdr->twelve_byte =
L
Linus Torvalds 已提交
438
	    ((srp->data.cmd_opcode >= 0xc0) && (12 == hp->cmd_len)) ? 1 : 0;
已提交
439 440 441
	old_hdr->target_status = hp->masked_status;
	old_hdr->host_status = hp->host_status;
	old_hdr->driver_status = hp->driver_status;
L
Linus Torvalds 已提交
442 443
	if ((CHECK_CONDITION & hp->masked_status) ||
	    (DRIVER_SENSE & hp->driver_status))
已提交
444 445
		memcpy(old_hdr->sense_buffer, srp->sense_b,
		       sizeof (old_hdr->sense_buffer));
L
Linus Torvalds 已提交
446 447 448 449 450 451
	switch (hp->host_status) {
	/* This setup of 'result' is for backward compatibility and is best
	   ignored by the user who should use target, host + driver status */
	case DID_OK:
	case DID_PASSTHROUGH:
	case DID_SOFT_ERROR:
已提交
452
		old_hdr->result = 0;
L
Linus Torvalds 已提交
453 454 455 456
		break;
	case DID_NO_CONNECT:
	case DID_BUS_BUSY:
	case DID_TIME_OUT:
已提交
457
		old_hdr->result = EBUSY;
L
Linus Torvalds 已提交
458 459 460 461 462 463
		break;
	case DID_BAD_TARGET:
	case DID_ABORT:
	case DID_PARITY:
	case DID_RESET:
	case DID_BAD_INTR:
已提交
464
		old_hdr->result = EIO;
L
Linus Torvalds 已提交
465 466
		break;
	case DID_ERROR:
已提交
467
		old_hdr->result = (srp->sense_b[0] == 0 && 
L
Linus Torvalds 已提交
468 469 470
				  hp->masked_status == GOOD) ? 0 : EIO;
		break;
	default:
已提交
471
		old_hdr->result = EIO;
L
Linus Torvalds 已提交
472 473 474 475 476
		break;
	}

	/* Now copy the result back to the user buffer.  */
	if (count >= SZ_SG_HEADER) {
已提交
477 478 479 480
		if (__copy_to_user(buf, old_hdr, SZ_SG_HEADER)) {
			retval = -EFAULT;
			goto free_old_hdr;
		}
L
Linus Torvalds 已提交
481
		buf += SZ_SG_HEADER;
已提交
482 483
		if (count > old_hdr->reply_len)
			count = old_hdr->reply_len;
L
Linus Torvalds 已提交
484
		if (count > SZ_SG_HEADER) {
已提交
485 486 487 488
			if (sg_read_oxfer(srp, buf, count - SZ_SG_HEADER)) {
				retval = -EFAULT;
				goto free_old_hdr;
			}
L
Linus Torvalds 已提交
489 490
		}
	} else
已提交
491
		count = (old_hdr->result == 0) ? 0 : -EIO;
L
Linus Torvalds 已提交
492
	sg_finish_rem_req(srp);
已提交
493 494
	retval = count;
free_old_hdr:
J
Jesper Juhl 已提交
495
	kfree(old_hdr);
已提交
496
	return retval;
L
Linus Torvalds 已提交
497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513
}

static ssize_t
sg_new_read(Sg_fd * sfp, char __user *buf, size_t count, Sg_request * srp)
{
	sg_io_hdr_t *hp = &srp->header;
	int err = 0;
	int len;

	if (count < SZ_SG_IO_HDR) {
		err = -EINVAL;
		goto err_out;
	}
	hp->sb_len_wr = 0;
	if ((hp->mx_sb_len > 0) && hp->sbp) {
		if ((CHECK_CONDITION & hp->masked_status) ||
		    (DRIVER_SENSE & hp->driver_status)) {
514
			int sb_len = SCSI_SENSE_BUFFERSIZE;
L
Linus Torvalds 已提交
515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530
			sb_len = (hp->mx_sb_len > sb_len) ? sb_len : hp->mx_sb_len;
			len = 8 + (int) srp->sense_b[7];	/* Additional sense length field */
			len = (len > sb_len) ? sb_len : len;
			if (copy_to_user(hp->sbp, srp->sense_b, len)) {
				err = -EFAULT;
				goto err_out;
			}
			hp->sb_len_wr = len;
		}
	}
	if (hp->masked_status || hp->host_status || hp->driver_status)
		hp->info |= SG_INFO_CHECK;
	if (copy_to_user(buf, hp, SZ_SG_IO_HDR)) {
		err = -EFAULT;
		goto err_out;
	}
F
FUJITA Tomonori 已提交
531
err_out:
532
	err = sg_finish_rem_req(srp);
L
Linus Torvalds 已提交
533 534 535 536 537 538 539 540 541 542 543 544 545 546
	return (0 == err) ? count : err;
}

static ssize_t
sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
{
	int mxsize, cmd_size, k;
	int input_size, blocking;
	unsigned char opcode;
	Sg_device *sdp;
	Sg_fd *sfp;
	Sg_request *srp;
	struct sg_header old_hdr;
	sg_io_hdr_t *hp;
547
	unsigned char cmnd[MAX_COMMAND_SIZE];
L
Linus Torvalds 已提交
548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566

	if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
		return -ENXIO;
	SCSI_LOG_TIMEOUT(3, printk("sg_write: %s, count=%d\n",
				   sdp->disk->disk_name, (int) count));
	if (sdp->detached)
		return -ENODEV;
	if (!((filp->f_flags & O_NONBLOCK) ||
	      scsi_block_when_processing_errors(sdp->device)))
		return -ENXIO;

	if (!access_ok(VERIFY_READ, buf, count))
		return -EFAULT;	/* protects following copy_from_user()s + get_user()s */
	if (count < SZ_SG_HEADER)
		return -EIO;
	if (__copy_from_user(&old_hdr, buf, SZ_SG_HEADER))
		return -EFAULT;
	blocking = !(filp->f_flags & O_NONBLOCK);
	if (old_hdr.reply_len < 0)
567 568
		return sg_new_write(sfp, filp, buf, count,
				    blocking, 0, 0, NULL);
L
Linus Torvalds 已提交
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613
	if (count < (SZ_SG_HEADER + 6))
		return -EIO;	/* The minimum scsi command length is 6 bytes. */

	if (!(srp = sg_add_request(sfp))) {
		SCSI_LOG_TIMEOUT(1, printk("sg_write: queue full\n"));
		return -EDOM;
	}
	buf += SZ_SG_HEADER;
	__get_user(opcode, buf);
	if (sfp->next_cmd_len > 0) {
		if (sfp->next_cmd_len > MAX_COMMAND_SIZE) {
			SCSI_LOG_TIMEOUT(1, printk("sg_write: command length too long\n"));
			sfp->next_cmd_len = 0;
			sg_remove_request(sfp, srp);
			return -EIO;
		}
		cmd_size = sfp->next_cmd_len;
		sfp->next_cmd_len = 0;	/* reset so only this write() effected */
	} else {
		cmd_size = COMMAND_SIZE(opcode);	/* based on SCSI command group */
		if ((opcode >= 0xc0) && old_hdr.twelve_byte)
			cmd_size = 12;
	}
	SCSI_LOG_TIMEOUT(4, printk(
		"sg_write:   scsi opcode=0x%02x, cmd_size=%d\n", (int) opcode, cmd_size));
/* Determine buffer size.  */
	input_size = count - cmd_size;
	mxsize = (input_size > old_hdr.reply_len) ? input_size : old_hdr.reply_len;
	mxsize -= SZ_SG_HEADER;
	input_size -= SZ_SG_HEADER;
	if (input_size < 0) {
		sg_remove_request(sfp, srp);
		return -EIO;	/* User did not pass enough bytes for this command. */
	}
	hp = &srp->header;
	hp->interface_id = '\0';	/* indicator of old interface tunnelled */
	hp->cmd_len = (unsigned char) cmd_size;
	hp->iovec_count = 0;
	hp->mx_sb_len = 0;
	if (input_size > 0)
		hp->dxfer_direction = (old_hdr.reply_len > SZ_SG_HEADER) ?
		    SG_DXFER_TO_FROM_DEV : SG_DXFER_TO_DEV;
	else
		hp->dxfer_direction = (mxsize > 0) ? SG_DXFER_FROM_DEV : SG_DXFER_NONE;
	hp->dxfer_len = mxsize;
614 615 616 617
	if (hp->dxfer_direction == SG_DXFER_TO_DEV)
		hp->dxferp = (char __user *)buf + cmd_size;
	else
		hp->dxferp = NULL;
L
Linus Torvalds 已提交
618 619 620 621 622 623 624 625 626 627 628 629
	hp->sbp = NULL;
	hp->timeout = old_hdr.reply_len;	/* structure abuse ... */
	hp->flags = input_size;	/* structure abuse ... */
	hp->pack_id = old_hdr.pack_id;
	hp->usr_ptr = NULL;
	if (__copy_from_user(cmnd, buf, cmd_size))
		return -EFAULT;
	/*
	 * SG_DXFER_TO_FROM_DEV is functionally equivalent to SG_DXFER_FROM_DEV,
	 * but is is possible that the app intended SG_DXFER_TO_DEV, because there
	 * is a non-zero input_size, so emit a warning.
	 */
630 631
	if (hp->dxfer_direction == SG_DXFER_TO_FROM_DEV) {
		static char cmd[TASK_COMM_LEN];
632 633 634 635 636 637 638 639 640
		if (strcmp(current->comm, cmd)) {
			printk_ratelimited(KERN_WARNING
					   "sg_write: data in/out %d/%d bytes "
					   "for SCSI command 0x%x-- guessing "
					   "data in;\n   program %s not setting "
					   "count and/or reply_len properly\n",
					   old_hdr.reply_len - (int)SZ_SG_HEADER,
					   input_size, (unsigned int) cmnd[0],
					   current->comm);
641 642 643
			strcpy(cmd, current->comm);
		}
	}
L
Linus Torvalds 已提交
644 645 646 647 648
	k = sg_common_write(sfp, srp, cmnd, sfp->timeout, blocking);
	return (k < 0) ? k : count;
}

static ssize_t
649
sg_new_write(Sg_fd *sfp, struct file *file, const char __user *buf,
650
		 size_t count, int blocking, int read_only, int sg_io_owned,
651
		 Sg_request **o_srp)
L
Linus Torvalds 已提交
652 653 654 655
{
	int k;
	Sg_request *srp;
	sg_io_hdr_t *hp;
656
	unsigned char cmnd[MAX_COMMAND_SIZE];
L
Linus Torvalds 已提交
657 658 659 660 661 662 663 664 665 666 667 668 669
	int timeout;
	unsigned long ul_timeout;

	if (count < SZ_SG_IO_HDR)
		return -EINVAL;
	if (!access_ok(VERIFY_READ, buf, count))
		return -EFAULT; /* protects following copy_from_user()s + get_user()s */

	sfp->cmd_q = 1;	/* when sg_io_hdr seen, set command queuing on */
	if (!(srp = sg_add_request(sfp))) {
		SCSI_LOG_TIMEOUT(1, printk("sg_new_write: queue full\n"));
		return -EDOM;
	}
670
	srp->sg_io_owned = sg_io_owned;
L
Linus Torvalds 已提交
671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707
	hp = &srp->header;
	if (__copy_from_user(hp, buf, SZ_SG_IO_HDR)) {
		sg_remove_request(sfp, srp);
		return -EFAULT;
	}
	if (hp->interface_id != 'S') {
		sg_remove_request(sfp, srp);
		return -ENOSYS;
	}
	if (hp->flags & SG_FLAG_MMAP_IO) {
		if (hp->dxfer_len > sfp->reserve.bufflen) {
			sg_remove_request(sfp, srp);
			return -ENOMEM;	/* MMAP_IO size must fit in reserve buffer */
		}
		if (hp->flags & SG_FLAG_DIRECT_IO) {
			sg_remove_request(sfp, srp);
			return -EINVAL;	/* either MMAP_IO or DIRECT_IO (not both) */
		}
		if (sg_res_in_use(sfp)) {
			sg_remove_request(sfp, srp);
			return -EBUSY;	/* reserve buffer already being used */
		}
	}
	ul_timeout = msecs_to_jiffies(srp->header.timeout);
	timeout = (ul_timeout < INT_MAX) ? ul_timeout : INT_MAX;
	if ((!hp->cmdp) || (hp->cmd_len < 6) || (hp->cmd_len > sizeof (cmnd))) {
		sg_remove_request(sfp, srp);
		return -EMSGSIZE;
	}
	if (!access_ok(VERIFY_READ, hp->cmdp, hp->cmd_len)) {
		sg_remove_request(sfp, srp);
		return -EFAULT;	/* protects following copy_from_user()s + get_user()s */
	}
	if (__copy_from_user(cmnd, hp->cmdp, hp->cmd_len)) {
		sg_remove_request(sfp, srp);
		return -EFAULT;
	}
708
	if (read_only && sg_allow_access(file, cmnd)) {
L
Linus Torvalds 已提交
709 710 711 712 713 714 715 716 717 718 719 720 721 722 723
		sg_remove_request(sfp, srp);
		return -EPERM;
	}
	k = sg_common_write(sfp, srp, cmnd, timeout, blocking);
	if (k < 0)
		return k;
	if (o_srp)
		*o_srp = srp;
	return count;
}

static int
sg_common_write(Sg_fd * sfp, Sg_request * srp,
		unsigned char *cmnd, int timeout, int blocking)
{
724
	int k, data_dir;
L
Linus Torvalds 已提交
725 726 727 728 729 730 731 732 733 734 735 736 737 738
	Sg_device *sdp = sfp->parentdp;
	sg_io_hdr_t *hp = &srp->header;

	srp->data.cmd_opcode = cmnd[0];	/* hold opcode of command */
	hp->status = 0;
	hp->masked_status = 0;
	hp->msg_status = 0;
	hp->info = 0;
	hp->host_status = 0;
	hp->driver_status = 0;
	hp->resid = 0;
	SCSI_LOG_TIMEOUT(4, printk("sg_common_write:  scsi opcode=0x%02x, cmd_size=%d\n",
			  (int) cmnd[0], (int) hp->cmd_len));

739 740
	k = sg_start_req(srp, cmnd);
	if (k) {
741
		SCSI_LOG_TIMEOUT(1, printk("sg_common_write: start_req err=%d\n", k));
L
Linus Torvalds 已提交
742 743 744 745
		sg_finish_rem_req(srp);
		return k;	/* probably out of space --> ENOMEM */
	}
	if (sdp->detached) {
746 747
		if (srp->bio)
			blk_end_request_all(srp->rq, -EIO);
L
Linus Torvalds 已提交
748 749 750 751 752 753 754
		sg_finish_rem_req(srp);
		return -ENODEV;
	}

	switch (hp->dxfer_direction) {
	case SG_DXFER_TO_FROM_DEV:
	case SG_DXFER_FROM_DEV:
755
		data_dir = DMA_FROM_DEVICE;
L
Linus Torvalds 已提交
756 757
		break;
	case SG_DXFER_TO_DEV:
758
		data_dir = DMA_TO_DEVICE;
L
Linus Torvalds 已提交
759 760
		break;
	case SG_DXFER_UNKNOWN:
761
		data_dir = DMA_BIDIRECTIONAL;
L
Linus Torvalds 已提交
762 763
		break;
	default:
764
		data_dir = DMA_NONE;
L
Linus Torvalds 已提交
765 766
		break;
	}
已提交
767
	hp->duration = jiffies_to_msecs(jiffies);
768 769

	srp->rq->timeout = timeout;
770
	kref_get(&sfp->f_ref); /* sg_rq_end_io() does kref_put(). */
771 772 773
	blk_execute_rq_nowait(sdp->device->request_queue, sdp->disk,
			      srp->rq, 1, sg_rq_end_io);
	return 0;
L
Linus Torvalds 已提交
774 775
}

J
Jörn Engel 已提交
776 777 778 779 780 781 782 783 784 785 786
static int srp_done(Sg_fd *sfp, Sg_request *srp)
{
	unsigned long flags;
	int ret;

	read_lock_irqsave(&sfp->rq_list_lock, flags);
	ret = srp->done;
	read_unlock_irqrestore(&sfp->rq_list_lock, flags);
	return ret;
}

J
Jörn Engel 已提交
787
static long
788
sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
L
Linus Torvalds 已提交
789 790 791 792 793 794 795 796 797 798 799
{
	void __user *p = (void __user *)arg;
	int __user *ip = p;
	int result, val, read_only;
	Sg_device *sdp;
	Sg_fd *sfp;
	Sg_request *srp;
	unsigned long iflags;

	if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
		return -ENXIO;
800

L
Linus Torvalds 已提交
801 802 803 804 805 806
	SCSI_LOG_TIMEOUT(3, printk("sg_ioctl: %s, cmd=0x%x\n",
				   sdp->disk->disk_name, (int) cmd_in));
	read_only = (O_RDWR != (filp->f_flags & O_ACCMODE));

	switch (cmd_in) {
	case SG_IO:
807 808 809 810 811 812 813 814 815 816
		if (sdp->detached)
			return -ENODEV;
		if (!scsi_block_when_processing_errors(sdp->device))
			return -ENXIO;
		if (!access_ok(VERIFY_WRITE, p, SZ_SG_IO_HDR))
			return -EFAULT;
		result = sg_new_write(sfp, filp, p, SZ_SG_IO_HDR,
				 1, read_only, 1, &srp);
		if (result < 0)
			return result;
817
		result = wait_event_interruptible(sfp->read_wait,
J
Jörn Engel 已提交
818
			(srp_done(sfp, srp) || sdp->detached));
819 820 821 822 823
		if (sdp->detached)
			return -ENODEV;
		write_lock_irq(&sfp->rq_list_lock);
		if (srp->done) {
			srp->done = 2;
824
			write_unlock_irq(&sfp->rq_list_lock);
825 826
			result = sg_new_read(sfp, p, SZ_SG_IO_HDR, srp);
			return (result < 0) ? result : 0;
L
Linus Torvalds 已提交
827
		}
828 829 830
		srp->orphan = 1;
		write_unlock_irq(&sfp->rq_list_lock);
		return result;	/* -ERESTARTSYS because signal hit process */
L
Linus Torvalds 已提交
831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924
	case SG_SET_TIMEOUT:
		result = get_user(val, ip);
		if (result)
			return result;
		if (val < 0)
			return -EIO;
		if (val >= MULDIV (INT_MAX, USER_HZ, HZ))
		    val = MULDIV (INT_MAX, USER_HZ, HZ);
		sfp->timeout_user = val;
		sfp->timeout = MULDIV (val, HZ, USER_HZ);

		return 0;
	case SG_GET_TIMEOUT:	/* N.B. User receives timeout as return value */
				/* strange ..., for backward compatibility */
		return sfp->timeout_user;
	case SG_SET_FORCE_LOW_DMA:
		result = get_user(val, ip);
		if (result)
			return result;
		if (val) {
			sfp->low_dma = 1;
			if ((0 == sfp->low_dma) && (0 == sg_res_in_use(sfp))) {
				val = (int) sfp->reserve.bufflen;
				sg_remove_scat(&sfp->reserve);
				sg_build_reserve(sfp, val);
			}
		} else {
			if (sdp->detached)
				return -ENODEV;
			sfp->low_dma = sdp->device->host->unchecked_isa_dma;
		}
		return 0;
	case SG_GET_LOW_DMA:
		return put_user((int) sfp->low_dma, ip);
	case SG_GET_SCSI_ID:
		if (!access_ok(VERIFY_WRITE, p, sizeof (sg_scsi_id_t)))
			return -EFAULT;
		else {
			sg_scsi_id_t __user *sg_idp = p;

			if (sdp->detached)
				return -ENODEV;
			__put_user((int) sdp->device->host->host_no,
				   &sg_idp->host_no);
			__put_user((int) sdp->device->channel,
				   &sg_idp->channel);
			__put_user((int) sdp->device->id, &sg_idp->scsi_id);
			__put_user((int) sdp->device->lun, &sg_idp->lun);
			__put_user((int) sdp->device->type, &sg_idp->scsi_type);
			__put_user((short) sdp->device->host->cmd_per_lun,
				   &sg_idp->h_cmd_per_lun);
			__put_user((short) sdp->device->queue_depth,
				   &sg_idp->d_queue_depth);
			__put_user(0, &sg_idp->unused[0]);
			__put_user(0, &sg_idp->unused[1]);
			return 0;
		}
	case SG_SET_FORCE_PACK_ID:
		result = get_user(val, ip);
		if (result)
			return result;
		sfp->force_packid = val ? 1 : 0;
		return 0;
	case SG_GET_PACK_ID:
		if (!access_ok(VERIFY_WRITE, ip, sizeof (int)))
			return -EFAULT;
		read_lock_irqsave(&sfp->rq_list_lock, iflags);
		for (srp = sfp->headrp; srp; srp = srp->nextrp) {
			if ((1 == srp->done) && (!srp->sg_io_owned)) {
				read_unlock_irqrestore(&sfp->rq_list_lock,
						       iflags);
				__put_user(srp->header.pack_id, ip);
				return 0;
			}
		}
		read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
		__put_user(-1, ip);
		return 0;
	case SG_GET_NUM_WAITING:
		read_lock_irqsave(&sfp->rq_list_lock, iflags);
		for (val = 0, srp = sfp->headrp; srp; srp = srp->nextrp) {
			if ((1 == srp->done) && (!srp->sg_io_owned))
				++val;
		}
		read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
		return put_user(val, ip);
	case SG_GET_SG_TABLESIZE:
		return put_user(sdp->sg_tablesize, ip);
	case SG_SET_RESERVED_SIZE:
		result = get_user(val, ip);
		if (result)
			return result;
                if (val < 0)
                        return -EINVAL;
925
		val = min_t(int, val,
926
			    queue_max_sectors(sdp->device->request_queue) * 512);
L
Linus Torvalds 已提交
927 928 929 930 931 932 933 934
		if (val != sfp->reserve.bufflen) {
			if (sg_res_in_use(sfp) || sfp->mmap_called)
				return -EBUSY;
			sg_remove_scat(&sfp->reserve);
			sg_build_reserve(sfp, val);
		}
		return 0;
	case SG_GET_RESERVED_SIZE:
935
		val = min_t(int, sfp->reserve.bufflen,
936
			    queue_max_sectors(sdp->device->request_queue) * 512);
L
Linus Torvalds 已提交
937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969
		return put_user(val, ip);
	case SG_SET_COMMAND_Q:
		result = get_user(val, ip);
		if (result)
			return result;
		sfp->cmd_q = val ? 1 : 0;
		return 0;
	case SG_GET_COMMAND_Q:
		return put_user((int) sfp->cmd_q, ip);
	case SG_SET_KEEP_ORPHAN:
		result = get_user(val, ip);
		if (result)
			return result;
		sfp->keep_orphan = val;
		return 0;
	case SG_GET_KEEP_ORPHAN:
		return put_user((int) sfp->keep_orphan, ip);
	case SG_NEXT_CMD_LEN:
		result = get_user(val, ip);
		if (result)
			return result;
		sfp->next_cmd_len = (val > 0) ? val : 0;
		return 0;
	case SG_GET_VERSION_NUM:
		return put_user(sg_version_num, ip);
	case SG_GET_ACCESS_COUNT:
		/* faked - we don't have a real access count anymore */
		val = (sdp->device ? 1 : 0);
		return put_user(val, ip);
	case SG_GET_REQUEST_TABLE:
		if (!access_ok(VERIFY_WRITE, p, SZ_SG_REQ_INFO * SG_MAX_QUEUE))
			return -EFAULT;
		else {
已提交
970 971 972 973 974 975 976
			sg_req_info_t *rinfo;
			unsigned int ms;

			rinfo = kmalloc(SZ_SG_REQ_INFO * SG_MAX_QUEUE,
								GFP_KERNEL);
			if (!rinfo)
				return -ENOMEM;
L
Linus Torvalds 已提交
977 978 979 980 981 982 983 984 985 986
			read_lock_irqsave(&sfp->rq_list_lock, iflags);
			for (srp = sfp->headrp, val = 0; val < SG_MAX_QUEUE;
			     ++val, srp = srp ? srp->nextrp : srp) {
				memset(&rinfo[val], 0, SZ_SG_REQ_INFO);
				if (srp) {
					rinfo[val].req_state = srp->done + 1;
					rinfo[val].problem =
					    srp->header.masked_status & 
					    srp->header.host_status & 
					    srp->header.driver_status;
已提交
987 988 989 990 991 992 993 994 995
					if (srp->done)
						rinfo[val].duration =
							srp->header.duration;
					else {
						ms = jiffies_to_msecs(jiffies);
						rinfo[val].duration =
						    (ms > srp->header.duration) ?
						    (ms - srp->header.duration) : 0;
					}
L
Linus Torvalds 已提交
996
					rinfo[val].orphan = srp->orphan;
已提交
997 998 999 1000 1001 1002
					rinfo[val].sg_io_owned =
							srp->sg_io_owned;
					rinfo[val].pack_id =
							srp->header.pack_id;
					rinfo[val].usr_ptr =
							srp->header.usr_ptr;
L
Linus Torvalds 已提交
1003 1004 1005
				}
			}
			read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
已提交
1006 1007 1008 1009 1010
			result = __copy_to_user(p, rinfo, 
						SZ_SG_REQ_INFO * SG_MAX_QUEUE);
			result = result ? -EFAULT : 0;
			kfree(rinfo);
			return result;
L
Linus Torvalds 已提交
1011 1012 1013 1014 1015 1016 1017 1018 1019
		}
	case SG_EMULATED_HOST:
		if (sdp->detached)
			return -ENODEV;
		return put_user(sdp->device->host->hostt->emulated, ip);
	case SG_SCSI_RESET:
		if (sdp->detached)
			return -ENODEV;
		if (filp->f_flags & O_NONBLOCK) {
1020
			if (scsi_host_in_recovery(sdp->device->host))
L
Linus Torvalds 已提交
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
				return -EBUSY;
		} else if (!scsi_block_when_processing_errors(sdp->device))
			return -EBUSY;
		result = get_user(val, ip);
		if (result)
			return result;
		if (SG_SCSI_RESET_NOTHING == val)
			return 0;
		switch (val) {
		case SG_SCSI_RESET_DEVICE:
			val = SCSI_TRY_RESET_DEVICE;
			break;
B
Brian King 已提交
1033 1034 1035
		case SG_SCSI_RESET_TARGET:
			val = SCSI_TRY_RESET_TARGET;
			break;
L
Linus Torvalds 已提交
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
		case SG_SCSI_RESET_BUS:
			val = SCSI_TRY_RESET_BUS;
			break;
		case SG_SCSI_RESET_HOST:
			val = SCSI_TRY_RESET_HOST;
			break;
		default:
			return -EINVAL;
		}
		if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
			return -EACCES;
		return (scsi_reset_provider(sdp->device, val) ==
			SUCCESS) ? 0 : -EIO;
	case SCSI_IOCTL_SEND_COMMAND:
		if (sdp->detached)
			return -ENODEV;
		if (read_only) {
			unsigned char opcode = WRITE_6;
			Scsi_Ioctl_Command __user *siocp = p;

			if (copy_from_user(&opcode, siocp->data, 1))
				return -EFAULT;
1058
			if (sg_allow_access(filp, &opcode))
L
Linus Torvalds 已提交
1059 1060
				return -EPERM;
		}
1061
		return sg_scsi_ioctl(sdp->device->request_queue, NULL, filp->f_mode, p);
L
Linus Torvalds 已提交
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
	case SG_SET_DEBUG:
		result = get_user(val, ip);
		if (result)
			return result;
		sdp->sgdebug = (char) val;
		return 0;
	case SCSI_IOCTL_GET_IDLUN:
	case SCSI_IOCTL_GET_BUS_NUMBER:
	case SCSI_IOCTL_PROBE_HOST:
	case SG_GET_TRANSFORM:
		if (sdp->detached)
			return -ENODEV;
		return scsi_ioctl(sdp->device, cmd_in, p);
1075
	case BLKSECTGET:
1076
		return put_user(queue_max_sectors(sdp->device->request_queue) * 512,
1077
				ip);
1078 1079 1080
	case BLKTRACESETUP:
		return blk_trace_setup(sdp->device->request_queue,
				       sdp->disk->disk_name,
1081
				       MKDEV(SCSI_GENERIC_MAJOR, sdp->index),
1082
				       NULL,
1083 1084 1085 1086 1087 1088 1089
				       (char *)arg);
	case BLKTRACESTART:
		return blk_trace_startstop(sdp->device->request_queue, 1);
	case BLKTRACESTOP:
		return blk_trace_startstop(sdp->device->request_queue, 0);
	case BLKTRACETEARDOWN:
		return blk_trace_remove(sdp->device->request_queue);
L
Linus Torvalds 已提交
1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129
	default:
		if (read_only)
			return -EPERM;	/* don't know so take safe approach */
		return scsi_ioctl(sdp->device, cmd_in, p);
	}
}

#ifdef CONFIG_COMPAT
static long sg_compat_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
{
	Sg_device *sdp;
	Sg_fd *sfp;
	struct scsi_device *sdev;

	if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
		return -ENXIO;

	sdev = sdp->device;
	if (sdev->host->hostt->compat_ioctl) { 
		int ret;

		ret = sdev->host->hostt->compat_ioctl(sdev, cmd_in, (void __user *)arg);

		return ret;
	}
	
	return -ENOIOCTLCMD;
}
#endif

static unsigned int
sg_poll(struct file *filp, poll_table * wait)
{
	unsigned int res = 0;
	Sg_device *sdp;
	Sg_fd *sfp;
	Sg_request *srp;
	int count = 0;
	unsigned long iflags;

J
Jörn Engel 已提交
1130 1131 1132 1133 1134
	sfp = filp->private_data;
	if (!sfp)
		return POLLERR;
	sdp = sfp->parentdp;
	if (!sdp)
L
Linus Torvalds 已提交
1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
		return POLLERR;
	poll_wait(filp, &sfp->read_wait, wait);
	read_lock_irqsave(&sfp->rq_list_lock, iflags);
	for (srp = sfp->headrp; srp; srp = srp->nextrp) {
		/* if any read waiting, flag it */
		if ((0 == res) && (1 == srp->done) && (!srp->sg_io_owned))
			res = POLLIN | POLLRDNORM;
		++count;
	}
	read_unlock_irqrestore(&sfp->rq_list_lock, iflags);

	if (sdp->detached)
		res |= POLLHUP;
	else if (!sfp->cmd_q) {
		if (0 == count)
			res |= POLLOUT | POLLWRNORM;
	} else if (count < SG_MAX_QUEUE)
		res |= POLLOUT | POLLWRNORM;
	SCSI_LOG_TIMEOUT(3, printk("sg_poll: %s, res=0x%x\n",
				   sdp->disk->disk_name, (int) res));
	return res;
}

static int
sg_fasync(int fd, struct file *filp, int mode)
{
	Sg_device *sdp;
	Sg_fd *sfp;

	if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
		return -ENXIO;
	SCSI_LOG_TIMEOUT(3, printk("sg_fasync: %s, mode=%d\n",
				   sdp->disk->disk_name, mode));

1169
	return fasync_helper(fd, filp, mode, &sfp->async_qp);
L
Linus Torvalds 已提交
1170 1171
}

N
Nick Piggin 已提交
1172 1173
static int
sg_vma_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
L
Linus Torvalds 已提交
1174 1175
{
	Sg_fd *sfp;
1176
	unsigned long offset, len, sa;
L
Linus Torvalds 已提交
1177
	Sg_scatter_hold *rsv_schp;
1178
	int k, length;
L
Linus Torvalds 已提交
1179 1180

	if ((NULL == vma) || (!(sfp = (Sg_fd *) vma->vm_private_data)))
N
Nick Piggin 已提交
1181
		return VM_FAULT_SIGBUS;
L
Linus Torvalds 已提交
1182
	rsv_schp = &sfp->reserve;
N
Nick Piggin 已提交
1183
	offset = vmf->pgoff << PAGE_SHIFT;
L
Linus Torvalds 已提交
1184
	if (offset >= rsv_schp->bufflen)
N
Nick Piggin 已提交
1185 1186
		return VM_FAULT_SIGBUS;
	SCSI_LOG_TIMEOUT(3, printk("sg_vma_fault: offset=%lu, scatg=%d\n",
L
Linus Torvalds 已提交
1187
				   offset, rsv_schp->k_use_sg));
1188
	sa = vma->vm_start;
1189 1190
	length = 1 << (PAGE_SHIFT + rsv_schp->page_order);
	for (k = 0; k < rsv_schp->k_use_sg && sa < vma->vm_end; k++) {
1191
		len = vma->vm_end - sa;
1192
		len = (len < length) ? len : length;
1193
		if (offset < len) {
1194 1195
			struct page *page = nth_page(rsv_schp->pages[k],
						     offset >> PAGE_SHIFT);
1196
			get_page(page);	/* increment page count */
N
Nick Piggin 已提交
1197 1198
			vmf->page = page;
			return 0; /* success */
L
Linus Torvalds 已提交
1199
		}
1200 1201
		sa += len;
		offset -= len;
L
Linus Torvalds 已提交
1202
	}
1203

N
Nick Piggin 已提交
1204
	return VM_FAULT_SIGBUS;
L
Linus Torvalds 已提交
1205 1206
}

1207
static const struct vm_operations_struct sg_mmap_vm_ops = {
N
Nick Piggin 已提交
1208
	.fault = sg_vma_fault,
L
Linus Torvalds 已提交
1209 1210 1211 1212 1213 1214
};

static int
sg_mmap(struct file *filp, struct vm_area_struct *vma)
{
	Sg_fd *sfp;
1215
	unsigned long req_sz, len, sa;
L
Linus Torvalds 已提交
1216
	Sg_scatter_hold *rsv_schp;
1217
	int k, length;
L
Linus Torvalds 已提交
1218 1219 1220

	if ((!filp) || (!vma) || (!(sfp = (Sg_fd *) filp->private_data)))
		return -ENXIO;
已提交
1221
	req_sz = vma->vm_end - vma->vm_start;
L
Linus Torvalds 已提交
1222 1223 1224 1225 1226 1227 1228 1229
	SCSI_LOG_TIMEOUT(3, printk("sg_mmap starting, vm_start=%p, len=%d\n",
				   (void *) vma->vm_start, (int) req_sz));
	if (vma->vm_pgoff)
		return -EINVAL;	/* want no offset */
	rsv_schp = &sfp->reserve;
	if (req_sz > rsv_schp->bufflen)
		return -ENOMEM;	/* cannot map more than reserved buffer */

1230
	sa = vma->vm_start;
1231 1232
	length = 1 << (PAGE_SHIFT + rsv_schp->page_order);
	for (k = 0; k < rsv_schp->k_use_sg && sa < vma->vm_end; k++) {
1233
		len = vma->vm_end - sa;
1234
		len = (len < length) ? len : length;
1235
		sa += len;
L
Linus Torvalds 已提交
1236
	}
1237

N
Nick Piggin 已提交
1238
	sfp->mmap_called = 1;
1239
	vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
L
Linus Torvalds 已提交
1240 1241 1242 1243 1244
	vma->vm_private_data = sfp;
	vma->vm_ops = &sg_mmap_vm_ops;
	return 0;
}

1245 1246 1247 1248 1249 1250 1251 1252 1253
static void sg_rq_end_io_usercontext(struct work_struct *work)
{
	struct sg_request *srp = container_of(work, struct sg_request, ew.work);
	struct sg_fd *sfp = srp->parentfp;

	sg_finish_rem_req(srp);
	kref_put(&sfp->f_ref, sg_remove_sfp);
}

1254 1255 1256 1257 1258
/*
 * This function is a "bottom half" handler that is called by the mid
 * level when a command is completed (or has failed).
 */
static void sg_rq_end_io(struct request *rq, int uptodate)
L
Linus Torvalds 已提交
1259
{
1260
	struct sg_request *srp = rq->end_io_data;
1261
	Sg_device *sdp;
L
Linus Torvalds 已提交
1262 1263
	Sg_fd *sfp;
	unsigned long iflags;
已提交
1264
	unsigned int ms;
1265
	char *sense;
1266
	int result, resid, done = 1;
L
Linus Torvalds 已提交
1267

1268
	if (WARN_ON(srp->done != 0))
L
Linus Torvalds 已提交
1269
		return;
1270

L
Linus Torvalds 已提交
1271
	sfp = srp->parentfp;
1272
	if (WARN_ON(sfp == NULL))
L
Linus Torvalds 已提交
1273
		return;
1274 1275 1276 1277

	sdp = sfp->parentdp;
	if (unlikely(sdp->detached))
		printk(KERN_INFO "sg_rq_end_io: device detached\n");
L
Linus Torvalds 已提交
1278

1279 1280
	sense = rq->sense;
	result = rq->errors;
T
Tejun Heo 已提交
1281
	resid = rq->resid_len;
L
Linus Torvalds 已提交
1282 1283

	SCSI_LOG_TIMEOUT(4, printk("sg_cmd_done: %s, pack_id=%d, res=0x%x\n",
1284 1285
		sdp->disk->disk_name, srp->header.pack_id, result));
	srp->header.resid = resid;
已提交
1286 1287 1288
	ms = jiffies_to_msecs(jiffies);
	srp->header.duration = (ms > srp->header.duration) ?
				(ms - srp->header.duration) : 0;
1289
	if (0 != result) {
L
Linus Torvalds 已提交
1290 1291
		struct scsi_sense_hdr sshdr;

1292 1293 1294 1295 1296
		srp->header.status = 0xff & result;
		srp->header.masked_status = status_byte(result);
		srp->header.msg_status = msg_byte(result);
		srp->header.host_status = host_byte(result);
		srp->header.driver_status = driver_byte(result);
L
Linus Torvalds 已提交
1297 1298 1299
		if ((sdp->sgdebug > 0) &&
		    ((CHECK_CONDITION == srp->header.masked_status) ||
		     (COMMAND_TERMINATED == srp->header.masked_status)))
1300 1301
			__scsi_print_sense("sg_cmd_done", sense,
					   SCSI_SENSE_BUFFERSIZE);
L
Linus Torvalds 已提交
1302 1303

		/* Following if statement is a patch supplied by Eric Youngdale */
1304 1305
		if (driver_byte(result) != 0
		    && scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr)
L
Linus Torvalds 已提交
1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
		    && !scsi_sense_is_deferred(&sshdr)
		    && sshdr.sense_key == UNIT_ATTENTION
		    && sdp->device->removable) {
			/* Detected possible disc change. Set the bit - this */
			/* may be used if there are filesystems using this device */
			sdp->device->changed = 1;
		}
	}
	/* Rely on write phase to clean out srp status values, so no "else" */

1316 1317
	write_lock_irqsave(&sfp->rq_list_lock, iflags);
	if (unlikely(srp->orphan)) {
L
Linus Torvalds 已提交
1318 1319
		if (sfp->keep_orphan)
			srp->sg_io_owned = 0;
1320 1321
		else
			done = 0;
L
Linus Torvalds 已提交
1322
	}
1323 1324 1325 1326 1327 1328 1329
	srp->done = done;
	write_unlock_irqrestore(&sfp->rq_list_lock, iflags);

	if (likely(done)) {
		/* Now wake up any sg_read() that is waiting for this
		 * packet.
		 */
L
Linus Torvalds 已提交
1330
		wake_up_interruptible(&sfp->read_wait);
1331
		kill_fasync(&sfp->async_qp, SIGPOLL, POLL_IN);
1332
		kref_put(&sfp->f_ref, sg_remove_sfp);
1333 1334 1335 1336
	} else {
		INIT_WORK(&srp->ew.work, sg_rq_end_io_usercontext);
		schedule_work(&srp->ew.work);
	}
L
Linus Torvalds 已提交
1337 1338
}

1339
static const struct file_operations sg_fops = {
L
Linus Torvalds 已提交
1340 1341 1342 1343
	.owner = THIS_MODULE,
	.read = sg_read,
	.write = sg_write,
	.poll = sg_poll,
J
Jörn Engel 已提交
1344
	.unlocked_ioctl = sg_ioctl,
L
Linus Torvalds 已提交
1345 1346 1347 1348 1349 1350 1351
#ifdef CONFIG_COMPAT
	.compat_ioctl = sg_compat_ioctl,
#endif
	.open = sg_open,
	.mmap = sg_mmap,
	.release = sg_release,
	.fasync = sg_fasync,
1352
	.llseek = no_llseek,
L
Linus Torvalds 已提交
1353 1354
};

1355
static struct class *sg_sysfs_class;
L
Linus Torvalds 已提交
1356 1357 1358

static int sg_sysfs_valid = 0;

1359
static Sg_device *sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
L
Linus Torvalds 已提交
1360
{
1361
	struct request_queue *q = scsidp->request_queue;
L
Linus Torvalds 已提交
1362 1363
	Sg_device *sdp;
	unsigned long iflags;
1364 1365
	int error;
	u32 k;
L
Linus Torvalds 已提交
1366

J
Jes Sorensen 已提交
1367
	sdp = kzalloc(sizeof(Sg_device), GFP_KERNEL);
L
Linus Torvalds 已提交
1368 1369
	if (!sdp) {
		printk(KERN_WARNING "kmalloc Sg_device failure\n");
1370 1371
		return ERR_PTR(-ENOMEM);
	}
1372

T
Tejun Heo 已提交
1373
	idr_preload(GFP_KERNEL);
1374
	write_lock_irqsave(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
1375

T
Tejun Heo 已提交
1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387
	error = idr_alloc(&sg_index_idr, sdp, 0, SG_MAX_DEVS, GFP_NOWAIT);
	if (error < 0) {
		if (error == -ENOSPC) {
			sdev_printk(KERN_WARNING, scsidp,
				    "Unable to attach sg device type=%d, minor number exceeds %d\n",
				    scsidp->type, SG_MAX_DEVS - 1);
			error = -ENODEV;
		} else {
			printk(KERN_WARNING
			       "idr allocation Sg_device failure: %d\n", error);
		}
		goto out_unlock;
L
Linus Torvalds 已提交
1388
	}
T
Tejun Heo 已提交
1389
	k = error;
L
Linus Torvalds 已提交
1390 1391 1392 1393 1394 1395

	SCSI_LOG_TIMEOUT(3, printk("sg_alloc: dev=%d \n", k));
	sprintf(disk->disk_name, "sg%d", k);
	disk->first_minor = k;
	sdp->disk = disk;
	sdp->device = scsidp;
1396
	INIT_LIST_HEAD(&sdp->sfds);
1397
	init_rwsem(&sdp->o_sem);
1398
	sdp->sg_tablesize = queue_max_segments(q);
1399
	sdp->index = k;
1400
	kref_init(&sdp->d_ref);
T
Tejun Heo 已提交
1401
	error = 0;
1402

T
Tejun Heo 已提交
1403
out_unlock:
1404
	write_unlock_irqrestore(&sg_index_lock, iflags);
T
Tejun Heo 已提交
1405
	idr_preload_end();
L
Linus Torvalds 已提交
1406

1407
	if (error) {
L
Linus Torvalds 已提交
1408
		kfree(sdp);
1409 1410 1411
		return ERR_PTR(error);
	}
	return sdp;
L
Linus Torvalds 已提交
1412 1413 1414
}

static int
1415
sg_add(struct device *cl_dev, struct class_interface *cl_intf)
L
Linus Torvalds 已提交
1416
{
1417
	struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
L
Linus Torvalds 已提交
1418 1419 1420
	struct gendisk *disk;
	Sg_device *sdp = NULL;
	struct cdev * cdev = NULL;
1421
	int error;
1422
	unsigned long iflags;
L
Linus Torvalds 已提交
1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439

	disk = alloc_disk(1);
	if (!disk) {
		printk(KERN_WARNING "alloc_disk failed\n");
		return -ENOMEM;
	}
	disk->major = SCSI_GENERIC_MAJOR;

	error = -ENOMEM;
	cdev = cdev_alloc();
	if (!cdev) {
		printk(KERN_WARNING "cdev_alloc failed\n");
		goto out;
	}
	cdev->owner = THIS_MODULE;
	cdev->ops = &sg_fops;

1440 1441
	sdp = sg_alloc(disk, scsidp);
	if (IS_ERR(sdp)) {
L
Linus Torvalds 已提交
1442
		printk(KERN_WARNING "sg_alloc failed\n");
1443
		error = PTR_ERR(sdp);
L
Linus Torvalds 已提交
1444 1445 1446
		goto out;
	}

1447
	error = cdev_add(cdev, MKDEV(SCSI_GENERIC_MAJOR, sdp->index), 1);
1448
	if (error)
1449
		goto cdev_add_err;
1450

L
Linus Torvalds 已提交
1451 1452
	sdp->cdev = cdev;
	if (sg_sysfs_valid) {
1453
		struct device *sg_class_member;
L
Linus Torvalds 已提交
1454

1455 1456 1457 1458
		sg_class_member = device_create(sg_sysfs_class, cl_dev->parent,
						MKDEV(SCSI_GENERIC_MAJOR,
						      sdp->index),
						sdp, "%s", disk->disk_name);
1459 1460
		if (IS_ERR(sg_class_member)) {
			printk(KERN_ERR "sg_add: "
1461
			       "device_create failed\n");
1462 1463 1464 1465
			error = PTR_ERR(sg_class_member);
			goto cdev_add_err;
		}
		error = sysfs_create_link(&scsidp->sdev_gendev.kobj,
L
Linus Torvalds 已提交
1466 1467 1468
					  &sg_class_member->kobj, "generic");
		if (error)
			printk(KERN_ERR "sg_add: unable to make symlink "
1469
					"'generic' back to sg%d\n", sdp->index);
L
Linus Torvalds 已提交
1470
	} else
1471
		printk(KERN_WARNING "sg_add: sg_sys Invalid\n");
L
Linus Torvalds 已提交
1472

1473
	sdev_printk(KERN_NOTICE, scsidp,
1474 1475
		    "Attached scsi generic sg%d type %d\n", sdp->index,
		    scsidp->type);
L
Linus Torvalds 已提交
1476

1477
	dev_set_drvdata(cl_dev, sdp);
1478

L
Linus Torvalds 已提交
1479 1480
	return 0;

1481
cdev_add_err:
1482 1483 1484 1485
	write_lock_irqsave(&sg_index_lock, iflags);
	idr_remove(&sg_index_idr, sdp->index);
	write_unlock_irqrestore(&sg_index_lock, iflags);
	kfree(sdp);
1486

L
Linus Torvalds 已提交
1487 1488 1489 1490 1491 1492 1493
out:
	put_disk(disk);
	if (cdev)
		cdev_del(cdev);
	return error;
}

1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516
static void sg_device_destroy(struct kref *kref)
{
	struct sg_device *sdp = container_of(kref, struct sg_device, d_ref);
	unsigned long flags;

	/* CAUTION!  Note that the device can still be found via idr_find()
	 * even though the refcount is 0.  Therefore, do idr_remove() BEFORE
	 * any other cleanup.
	 */

	write_lock_irqsave(&sg_index_lock, flags);
	idr_remove(&sg_index_idr, sdp->index);
	write_unlock_irqrestore(&sg_index_lock, flags);

	SCSI_LOG_TIMEOUT(3,
		printk("sg_device_destroy: %s\n",
			sdp->disk->disk_name));

	put_disk(sdp->disk);
	kfree(sdp);
}

static void sg_remove(struct device *cl_dev, struct class_interface *cl_intf)
L
Linus Torvalds 已提交
1517
{
1518 1519
	struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
	Sg_device *sdp = dev_get_drvdata(cl_dev);
L
Linus Torvalds 已提交
1520 1521 1522
	unsigned long iflags;
	Sg_fd *sfp;

1523
	if (!sdp || sdp->detached)
L
Linus Torvalds 已提交
1524
		return;
1525

1526 1527 1528
	SCSI_LOG_TIMEOUT(3, printk("sg_remove: %s\n", sdp->disk->disk_name));

	/* Need a write lock to set sdp->detached. */
1529
	write_lock_irqsave(&sg_index_lock, iflags);
1530
	sdp->detached = 1;
1531
	list_for_each_entry(sfp, &sdp->sfds, sfd_siblings) {
1532 1533
		wake_up_interruptible(&sfp->read_wait);
		kill_fasync(&sfp->async_qp, SIGPOLL, POLL_HUP);
1534 1535 1536 1537
	}
	write_unlock_irqrestore(&sg_index_lock, iflags);

	sysfs_remove_link(&scsidp->sdev_gendev.kobj, "generic");
1538
	device_destroy(sg_sysfs_class, MKDEV(SCSI_GENERIC_MAJOR, sdp->index));
1539 1540
	cdev_del(sdp->cdev);
	sdp->cdev = NULL;
L
Linus Torvalds 已提交
1541

1542
	sg_put_dev(sdp);
L
Linus Torvalds 已提交
1543 1544
}

1545 1546 1547
module_param_named(scatter_elem_sz, scatter_elem_sz, int, S_IRUGO | S_IWUSR);
module_param_named(def_reserved_size, def_reserved_size, int,
		   S_IRUGO | S_IWUSR);
L
Linus Torvalds 已提交
1548 1549 1550 1551 1552 1553
module_param_named(allow_dio, sg_allow_dio, int, S_IRUGO | S_IWUSR);

MODULE_AUTHOR("Douglas Gilbert");
MODULE_DESCRIPTION("SCSI generic (sg) driver");
MODULE_LICENSE("GPL");
MODULE_VERSION(SG_VERSION_STR);
1554
MODULE_ALIAS_CHARDEV_MAJOR(SCSI_GENERIC_MAJOR);
L
Linus Torvalds 已提交
1555

1556 1557
MODULE_PARM_DESC(scatter_elem_sz, "scatter gather element "
                "size (default: max(SG_SCATTER_SZ, PAGE_SIZE))");
L
Linus Torvalds 已提交
1558 1559 1560 1561 1562 1563 1564 1565
MODULE_PARM_DESC(def_reserved_size, "size of buffer reserved for each fd");
MODULE_PARM_DESC(allow_dio, "allow direct I/O (default: 0 (disallow))");

static int __init
init_sg(void)
{
	int rc;

1566 1567 1568 1569
	if (scatter_elem_sz < PAGE_SIZE) {
		scatter_elem_sz = PAGE_SIZE;
		scatter_elem_sz_prev = scatter_elem_sz;
	}
L
Linus Torvalds 已提交
1570 1571
	if (def_reserved_size >= 0)
		sg_big_buff = def_reserved_size;
1572 1573
	else
		def_reserved_size = sg_big_buff;
L
Linus Torvalds 已提交
1574 1575 1576 1577 1578

	rc = register_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0), 
				    SG_MAX_DEVS, "sg");
	if (rc)
		return rc;
1579
        sg_sysfs_class = class_create(THIS_MODULE, "scsi_generic");
L
Linus Torvalds 已提交
1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591
        if ( IS_ERR(sg_sysfs_class) ) {
		rc = PTR_ERR(sg_sysfs_class);
		goto err_out;
        }
	sg_sysfs_valid = 1;
	rc = scsi_register_interface(&sg_interface);
	if (0 == rc) {
#ifdef CONFIG_SCSI_PROC_FS
		sg_proc_init();
#endif				/* CONFIG_SCSI_PROC_FS */
		return 0;
	}
1592
	class_destroy(sg_sysfs_class);
L
Linus Torvalds 已提交
1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604
err_out:
	unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0), SG_MAX_DEVS);
	return rc;
}

static void __exit
exit_sg(void)
{
#ifdef CONFIG_SCSI_PROC_FS
	sg_proc_cleanup();
#endif				/* CONFIG_SCSI_PROC_FS */
	scsi_unregister_interface(&sg_interface);
1605
	class_destroy(sg_sysfs_class);
L
Linus Torvalds 已提交
1606 1607 1608
	sg_sysfs_valid = 0;
	unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0),
				 SG_MAX_DEVS);
1609
	idr_destroy(&sg_index_idr);
L
Linus Torvalds 已提交
1610 1611
}

F
FUJITA Tomonori 已提交
1612
static int sg_start_req(Sg_request *srp, unsigned char *cmd)
1613
{
1614
	int res;
1615
	struct request *rq;
F
FUJITA Tomonori 已提交
1616 1617 1618 1619
	Sg_fd *sfp = srp->parentfp;
	sg_io_hdr_t *hp = &srp->header;
	int dxfer_len = (int) hp->dxfer_len;
	int dxfer_dir = hp->dxfer_direction;
1620
	unsigned int iov_count = hp->iovec_count;
F
FUJITA Tomonori 已提交
1621 1622 1623
	Sg_scatter_hold *req_schp = &srp->data;
	Sg_scatter_hold *rsv_schp = &sfp->reserve;
	struct request_queue *q = sfp->parentdp->device->request_queue;
1624
	struct rq_map_data *md, map_data;
1625 1626
	int rw = hp->dxfer_direction == SG_DXFER_TO_DEV ? WRITE : READ;

F
FUJITA Tomonori 已提交
1627 1628 1629
	SCSI_LOG_TIMEOUT(4, printk(KERN_INFO "sg_start_req: dxfer_len=%d\n",
				   dxfer_len));

1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643
	rq = blk_get_request(q, rw, GFP_ATOMIC);
	if (!rq)
		return -ENOMEM;

	memcpy(rq->cmd, cmd, hp->cmd_len);

	rq->cmd_len = hp->cmd_len;
	rq->cmd_type = REQ_TYPE_BLOCK_PC;

	srp->rq = rq;
	rq->end_io_data = srp;
	rq->sense = srp->sense_b;
	rq->retries = SG_DEFAULT_RETRIES;

L
Linus Torvalds 已提交
1644
	if ((dxfer_len <= 0) || (dxfer_dir == SG_DXFER_NONE))
1645
		return 0;
1646

1647 1648 1649
	if (sg_allow_dio && hp->flags & SG_FLAG_DIRECT_IO &&
	    dxfer_dir != SG_DXFER_UNKNOWN && !iov_count &&
	    !sfp->parentdp->device->host->unchecked_isa_dma &&
1650
	    blk_rq_aligned(q, (unsigned long)hp->dxferp, dxfer_len))
1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662
		md = NULL;
	else
		md = &map_data;

	if (md) {
		if (!sg_res_in_use(sfp) && dxfer_len <= rsv_schp->bufflen)
			sg_link_reserve(sfp, srp, dxfer_len);
		else {
			res = sg_build_indirect(req_schp, sfp, dxfer_len);
			if (res)
				return res;
		}
1663

1664 1665 1666
		md->pages = req_schp->pages;
		md->page_order = req_schp->page_order;
		md->nr_entries = req_schp->k_use_sg;
1667
		md->offset = 0;
1668
		md->null_mapped = hp->dxferp ? 0 : 1;
1669 1670 1671 1672
		if (dxfer_dir == SG_DXFER_TO_FROM_DEV)
			md->from_user = 1;
		else
			md->from_user = 0;
1673 1674
	}

1675 1676 1677 1678
	if (iov_count) {
		int len, size = sizeof(struct sg_iovec) * iov_count;
		struct iovec *iov;

J
Julia Lawall 已提交
1679 1680 1681
		iov = memdup_user(hp->dxferp, size);
		if (IS_ERR(iov))
			return PTR_ERR(iov);
1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693

		len = iov_length(iov, iov_count);
		if (hp->dxfer_len < len) {
			iov_count = iov_shorten(iov, iov_count, hp->dxfer_len);
			len = hp->dxfer_len;
		}

		res = blk_rq_map_user_iov(q, rq, md, (struct sg_iovec *)iov,
					  iov_count,
					  len, GFP_ATOMIC);
		kfree(iov);
	} else
1694 1695
		res = blk_rq_map_user(q, rq, md, hp->dxferp,
				      hp->dxfer_len, GFP_ATOMIC);
1696 1697

	if (!res) {
1698
		srp->bio = rq->bio;
1699

1700 1701 1702 1703 1704
		if (!md) {
			req_schp->dio_in_use = 1;
			hp->info |= SG_INFO_DIRECT_IO;
		}
	}
1705
	return res;
L
Linus Torvalds 已提交
1706 1707
}

1708
static int sg_finish_rem_req(Sg_request * srp)
L
Linus Torvalds 已提交
1709
{
1710 1711
	int ret = 0;

L
Linus Torvalds 已提交
1712 1713 1714 1715
	Sg_fd *sfp = srp->parentfp;
	Sg_scatter_hold *req_schp = &srp->data;

	SCSI_LOG_TIMEOUT(4, printk("sg_finish_rem_req: res_used=%d\n", (int) srp->res_used));
1716 1717
	if (srp->rq) {
		if (srp->bio)
1718
			ret = blk_rq_unmap_user(srp->bio);
1719

1720
		blk_put_request(srp->rq);
1721
	}
1722

1723 1724 1725 1726 1727
	if (srp->res_used)
		sg_unlink_reserve(sfp, srp);
	else
		sg_remove_scat(req_schp);

L
Linus Torvalds 已提交
1728
	sg_remove_request(sfp, srp);
1729 1730

	return ret;
L
Linus Torvalds 已提交
1731 1732 1733 1734 1735
}

static int
sg_build_sgat(Sg_scatter_hold * schp, const Sg_fd * sfp, int tablesize)
{
1736
	int sg_bufflen = tablesize * sizeof(struct page *);
A
Al Viro 已提交
1737
	gfp_t gfp_flags = GFP_ATOMIC | __GFP_NOWARN;
L
Linus Torvalds 已提交
1738

1739 1740
	schp->pages = kzalloc(sg_bufflen, gfp_flags);
	if (!schp->pages)
L
Linus Torvalds 已提交
1741 1742
		return -ENOMEM;
	schp->sglist_len = sg_bufflen;
1743
	return tablesize;	/* number of scat_gath elements allocated */
L
Linus Torvalds 已提交
1744 1745 1746 1747 1748
}

static int
sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size)
{
1749
	int ret_sz = 0, i, k, rem_sz, num, mx_sc_elems;
1750
	int sg_tablesize = sfp->parentdp->sg_tablesize;
1751 1752
	int blk_size = buff_size, order;
	gfp_t gfp_mask = GFP_ATOMIC | __GFP_COMP | __GFP_NOWARN;
L
Linus Torvalds 已提交
1753

1754
	if (blk_size < 0)
L
Linus Torvalds 已提交
1755 1756 1757
		return -EFAULT;
	if (0 == blk_size)
		++blk_size;	/* don't know why */
F
FUJITA Tomonori 已提交
1758 1759
	/* round request up to next highest SG_SECTOR_SZ byte boundary */
	blk_size = ALIGN(blk_size, SG_SECTOR_SZ);
L
Linus Torvalds 已提交
1760 1761
	SCSI_LOG_TIMEOUT(4, printk("sg_build_indirect: buff_size=%d, blk_size=%d\n",
				   buff_size, blk_size));
1762 1763 1764 1765 1766 1767

	/* N.B. ret_sz carried into this block ... */
	mx_sc_elems = sg_build_sgat(schp, sfp, sg_tablesize);
	if (mx_sc_elems < 0)
		return mx_sc_elems;	/* most likely -ENOMEM */

1768 1769 1770 1771 1772 1773 1774 1775
	num = scatter_elem_sz;
	if (unlikely(num != scatter_elem_sz_prev)) {
		if (num < PAGE_SIZE) {
			scatter_elem_sz = PAGE_SIZE;
			scatter_elem_sz_prev = PAGE_SIZE;
		} else
			scatter_elem_sz_prev = num;
	}
1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789

	if (sfp->low_dma)
		gfp_mask |= GFP_DMA;

	if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
		gfp_mask |= __GFP_ZERO;

	order = get_order(num);
retry:
	ret_sz = 1 << (PAGE_SHIFT + order);

	for (k = 0, rem_sz = blk_size; rem_sz > 0 && k < mx_sc_elems;
	     k++, rem_sz -= ret_sz) {

1790
		num = (rem_sz > scatter_elem_sz_prev) ?
1791 1792 1793 1794 1795
			scatter_elem_sz_prev : rem_sz;

		schp->pages[k] = alloc_pages(gfp_mask, order);
		if (!schp->pages[k])
			goto out;
1796

1797 1798 1799 1800 1801 1802
		if (num == scatter_elem_sz_prev) {
			if (unlikely(ret_sz > scatter_elem_sz_prev)) {
				scatter_elem_sz = ret_sz;
				scatter_elem_sz_prev = ret_sz;
			}
		}
1803

1804 1805
		SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k=%d, num=%d, "
				 "ret_sz=%d\n", k, num, ret_sz));
1806 1807
	}		/* end of for loop */

1808
	schp->page_order = order;
1809
	schp->k_use_sg = k;
1810 1811
	SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k_use_sg=%d, "
			 "rem_sz=%d\n", k, rem_sz));
1812 1813 1814 1815

	schp->bufflen = blk_size;
	if (rem_sz > 0)	/* must have failed */
		return -ENOMEM;
L
Linus Torvalds 已提交
1816
	return 0;
1817 1818
out:
	for (i = 0; i < k; i++)
1819
		__free_pages(schp->pages[i], order);
1820 1821 1822 1823 1824

	if (--order >= 0)
		goto retry;

	return -ENOMEM;
L
Linus Torvalds 已提交
1825 1826 1827 1828 1829 1830
}

static void
sg_remove_scat(Sg_scatter_hold * schp)
{
	SCSI_LOG_TIMEOUT(4, printk("sg_remove_scat: k_use_sg=%d\n", schp->k_use_sg));
1831
	if (schp->pages && schp->sglist_len > 0) {
1832
		if (!schp->dio_in_use) {
L
Linus Torvalds 已提交
1833 1834
			int k;

1835
			for (k = 0; k < schp->k_use_sg && schp->pages[k]; k++) {
L
Linus Torvalds 已提交
1836
				SCSI_LOG_TIMEOUT(5, printk(
1837 1838 1839
				    "sg_remove_scat: k=%d, pg=0x%p\n",
				    k, schp->pages[k]));
				__free_pages(schp->pages[k], schp->page_order);
L
Linus Torvalds 已提交
1840
			}
1841

1842
			kfree(schp->pages);
L
Linus Torvalds 已提交
1843
		}
1844
	}
L
Linus Torvalds 已提交
1845 1846 1847 1848 1849 1850 1851
	memset(schp, 0, sizeof (*schp));
}

static int
sg_read_oxfer(Sg_request * srp, char __user *outp, int num_read_xfer)
{
	Sg_scatter_hold *schp = &srp->data;
1852
	int k, num;
L
Linus Torvalds 已提交
1853 1854 1855 1856 1857

	SCSI_LOG_TIMEOUT(4, printk("sg_read_oxfer: num_read_xfer=%d\n",
				   num_read_xfer));
	if ((!outp) || (num_read_xfer <= 0))
		return 0;
1858

1859 1860
	num = 1 << (PAGE_SHIFT + schp->page_order);
	for (k = 0; k < schp->k_use_sg && schp->pages[k]; k++) {
1861
		if (num > num_read_xfer) {
1862
			if (__copy_to_user(outp, page_address(schp->pages[k]),
1863 1864 1865 1866
					   num_read_xfer))
				return -EFAULT;
			break;
		} else {
1867
			if (__copy_to_user(outp, page_address(schp->pages[k]),
1868 1869 1870 1871
					   num))
				return -EFAULT;
			num_read_xfer -= num;
			if (num_read_xfer <= 0)
L
Linus Torvalds 已提交
1872
				break;
1873
			outp += num;
L
Linus Torvalds 已提交
1874 1875
		}
	}
1876

L
Linus Torvalds 已提交
1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901
	return 0;
}

static void
sg_build_reserve(Sg_fd * sfp, int req_size)
{
	Sg_scatter_hold *schp = &sfp->reserve;

	SCSI_LOG_TIMEOUT(4, printk("sg_build_reserve: req_size=%d\n", req_size));
	do {
		if (req_size < PAGE_SIZE)
			req_size = PAGE_SIZE;
		if (0 == sg_build_indirect(schp, sfp, req_size))
			return;
		else
			sg_remove_scat(schp);
		req_size >>= 1;	/* divide by 2 */
	} while (req_size > (PAGE_SIZE / 2));
}

static void
sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size)
{
	Sg_scatter_hold *req_schp = &srp->data;
	Sg_scatter_hold *rsv_schp = &sfp->reserve;
1902
	int k, num, rem;
L
Linus Torvalds 已提交
1903 1904 1905

	srp->res_used = 1;
	SCSI_LOG_TIMEOUT(4, printk("sg_link_reserve: size=%d\n", size));
B
Brian King 已提交
1906
	rem = size;
1907

1908 1909
	num = 1 << (PAGE_SHIFT + rsv_schp->page_order);
	for (k = 0; k < rsv_schp->k_use_sg; k++) {
1910 1911 1912
		if (rem <= num) {
			req_schp->k_use_sg = k + 1;
			req_schp->sglist_len = rsv_schp->sglist_len;
1913
			req_schp->pages = rsv_schp->pages;
1914 1915

			req_schp->bufflen = size;
1916
			req_schp->page_order = rsv_schp->page_order;
1917 1918 1919
			break;
		} else
			rem -= num;
L
Linus Torvalds 已提交
1920
	}
1921 1922 1923

	if (k >= rsv_schp->k_use_sg)
		SCSI_LOG_TIMEOUT(1, printk("sg_link_reserve: BAD size\n"));
L
Linus Torvalds 已提交
1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934
}

static void
sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp)
{
	Sg_scatter_hold *req_schp = &srp->data;

	SCSI_LOG_TIMEOUT(4, printk("sg_unlink_reserve: req->k_use_sg=%d\n",
				   (int) req_schp->k_use_sg));
	req_schp->k_use_sg = 0;
	req_schp->bufflen = 0;
1935 1936
	req_schp->pages = NULL;
	req_schp->page_order = 0;
L
Linus Torvalds 已提交
1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997
	req_schp->sglist_len = 0;
	sfp->save_scat_len = 0;
	srp->res_used = 0;
}

static Sg_request *
sg_get_rq_mark(Sg_fd * sfp, int pack_id)
{
	Sg_request *resp;
	unsigned long iflags;

	write_lock_irqsave(&sfp->rq_list_lock, iflags);
	for (resp = sfp->headrp; resp; resp = resp->nextrp) {
		/* look for requests that are ready + not SG_IO owned */
		if ((1 == resp->done) && (!resp->sg_io_owned) &&
		    ((-1 == pack_id) || (resp->header.pack_id == pack_id))) {
			resp->done = 2;	/* guard against other readers */
			break;
		}
	}
	write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
	return resp;
}

/* always adds to end of list */
static Sg_request *
sg_add_request(Sg_fd * sfp)
{
	int k;
	unsigned long iflags;
	Sg_request *resp;
	Sg_request *rp = sfp->req_arr;

	write_lock_irqsave(&sfp->rq_list_lock, iflags);
	resp = sfp->headrp;
	if (!resp) {
		memset(rp, 0, sizeof (Sg_request));
		rp->parentfp = sfp;
		resp = rp;
		sfp->headrp = resp;
	} else {
		if (0 == sfp->cmd_q)
			resp = NULL;	/* command queuing disallowed */
		else {
			for (k = 0; k < SG_MAX_QUEUE; ++k, ++rp) {
				if (!rp->parentfp)
					break;
			}
			if (k < SG_MAX_QUEUE) {
				memset(rp, 0, sizeof (Sg_request));
				rp->parentfp = sfp;
				while (resp->nextrp)
					resp = resp->nextrp;
				resp->nextrp = rp;
				resp = rp;
			} else
				resp = NULL;
		}
	}
	if (resp) {
		resp->nextrp = NULL;
已提交
1998
		resp->header.duration = jiffies_to_msecs(jiffies);
L
Linus Torvalds 已提交
1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040
	}
	write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
	return resp;
}

/* Return of 1 for found; 0 for not found */
static int
sg_remove_request(Sg_fd * sfp, Sg_request * srp)
{
	Sg_request *prev_rp;
	Sg_request *rp;
	unsigned long iflags;
	int res = 0;

	if ((!sfp) || (!srp) || (!sfp->headrp))
		return res;
	write_lock_irqsave(&sfp->rq_list_lock, iflags);
	prev_rp = sfp->headrp;
	if (srp == prev_rp) {
		sfp->headrp = prev_rp->nextrp;
		prev_rp->parentfp = NULL;
		res = 1;
	} else {
		while ((rp = prev_rp->nextrp)) {
			if (srp == rp) {
				prev_rp->nextrp = rp->nextrp;
				rp->parentfp = NULL;
				res = 1;
				break;
			}
			prev_rp = rp;
		}
	}
	write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
	return res;
}

static Sg_fd *
sg_add_sfp(Sg_device * sdp, int dev)
{
	Sg_fd *sfp;
	unsigned long iflags;
2041
	int bufflen;
L
Linus Torvalds 已提交
2042

2043
	sfp = kzalloc(sizeof(*sfp), GFP_ATOMIC | __GFP_NOWARN);
L
Linus Torvalds 已提交
2044
	if (!sfp)
2045
		return ERR_PTR(-ENOMEM);
2046

L
Linus Torvalds 已提交
2047 2048 2049
	init_waitqueue_head(&sfp->read_wait);
	rwlock_init(&sfp->rq_list_lock);

2050
	kref_init(&sfp->f_ref);
L
Linus Torvalds 已提交
2051 2052 2053 2054 2055 2056 2057 2058
	sfp->timeout = SG_DEFAULT_TIMEOUT;
	sfp->timeout_user = SG_DEFAULT_TIMEOUT_USER;
	sfp->force_packid = SG_DEF_FORCE_PACK_ID;
	sfp->low_dma = (SG_DEF_FORCE_LOW_DMA == 0) ?
	    sdp->device->host->unchecked_isa_dma : 1;
	sfp->cmd_q = SG_DEF_COMMAND_Q;
	sfp->keep_orphan = SG_DEF_KEEP_ORPHAN;
	sfp->parentdp = sdp;
2059
	write_lock_irqsave(&sg_index_lock, iflags);
2060 2061 2062 2063
	if (sdp->detached) {
		write_unlock_irqrestore(&sg_index_lock, iflags);
		return ERR_PTR(-ENODEV);
	}
2064
	list_add_tail(&sfp->sfd_siblings, &sdp->sfds);
2065
	write_unlock_irqrestore(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
2066
	SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp: sfp=0x%p\n", sfp));
2067 2068 2069
	if (unlikely(sg_big_buff != def_reserved_size))
		sg_big_buff = def_reserved_size;

2070
	bufflen = min_t(int, sg_big_buff,
2071
			queue_max_sectors(sdp->device->request_queue) * 512);
2072
	sg_build_reserve(sfp, bufflen);
L
Linus Torvalds 已提交
2073 2074
	SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp:   bufflen=%d, k_use_sg=%d\n",
			   sfp->reserve.bufflen, sfp->reserve.k_use_sg));
2075 2076 2077

	kref_get(&sdp->d_ref);
	__module_get(THIS_MODULE);
L
Linus Torvalds 已提交
2078 2079 2080
	return sfp;
}

2081
static void sg_remove_sfp_usercontext(struct work_struct *work)
L
Linus Torvalds 已提交
2082
{
2083 2084 2085 2086 2087 2088
	struct sg_fd *sfp = container_of(work, struct sg_fd, ew.work);
	struct sg_device *sdp = sfp->parentdp;

	/* Cleanup any responses which were never read(). */
	while (sfp->headrp)
		sg_finish_rem_req(sfp->headrp);
L
Linus Torvalds 已提交
2089 2090

	if (sfp->reserve.bufflen > 0) {
2091 2092 2093 2094
		SCSI_LOG_TIMEOUT(6,
			printk("sg_remove_sfp:    bufflen=%d, k_use_sg=%d\n",
				(int) sfp->reserve.bufflen,
				(int) sfp->reserve.k_use_sg));
L
Linus Torvalds 已提交
2095 2096
		sg_remove_scat(&sfp->reserve);
	}
2097 2098 2099 2100 2101

	SCSI_LOG_TIMEOUT(6,
		printk("sg_remove_sfp: %s, sfp=0x%p\n",
			sdp->disk->disk_name,
			sfp));
2102
	kfree(sfp);
2103 2104 2105 2106

	scsi_device_put(sdp->device);
	sg_put_dev(sdp);
	module_put(THIS_MODULE);
L
Linus Torvalds 已提交
2107 2108
}

2109
static void sg_remove_sfp(struct kref *kref)
L
Linus Torvalds 已提交
2110
{
2111 2112
	struct sg_fd *sfp = container_of(kref, struct sg_fd, f_ref);
	unsigned long iflags;
L
Linus Torvalds 已提交
2113

2114
	write_lock_irqsave(&sg_index_lock, iflags);
2115
	list_del(&sfp->sfd_siblings);
2116
	write_unlock_irqrestore(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
2117

2118 2119
	INIT_WORK(&sfp->ew.work, sg_remove_sfp_usercontext);
	schedule_work(&sfp->ew.work);
L
Linus Torvalds 已提交
2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136
}

static int
sg_res_in_use(Sg_fd * sfp)
{
	const Sg_request *srp;
	unsigned long iflags;

	read_lock_irqsave(&sfp->rq_list_lock, iflags);
	for (srp = sfp->headrp; srp; srp = srp->nextrp)
		if (srp->res_used)
			break;
	read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
	return srp ? 1 : 0;
}

#ifdef CONFIG_SCSI_PROC_FS
2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147
static int
sg_idr_max_id(int id, void *p, void *data)
{
	int *k = data;

	if (*k < id)
		*k = id;

	return 0;
}

L
Linus Torvalds 已提交
2148 2149 2150
static int
sg_last_dev(void)
{
2151
	int k = -1;
L
Linus Torvalds 已提交
2152 2153
	unsigned long iflags;

2154 2155 2156
	read_lock_irqsave(&sg_index_lock, iflags);
	idr_for_each(&sg_index_idr, sg_idr_max_id, &k);
	read_unlock_irqrestore(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
2157 2158 2159 2160
	return k + 1;		/* origin 1 */
}
#endif

2161 2162
/* must be called with sg_index_lock held */
static Sg_device *sg_lookup_dev(int dev)
L
Linus Torvalds 已提交
2163
{
2164 2165
	return idr_find(&sg_index_idr, dev);
}
L
Linus Torvalds 已提交
2166

2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183
static Sg_device *sg_get_dev(int dev)
{
	struct sg_device *sdp;
	unsigned long flags;

	read_lock_irqsave(&sg_index_lock, flags);
	sdp = sg_lookup_dev(dev);
	if (!sdp)
		sdp = ERR_PTR(-ENXIO);
	else if (sdp->detached) {
		/* If sdp->detached, then the refcount may already be 0, in
		 * which case it would be a bug to do kref_get().
		 */
		sdp = ERR_PTR(-ENODEV);
	} else
		kref_get(&sdp->d_ref);
	read_unlock_irqrestore(&sg_index_lock, flags);
2184

L
Linus Torvalds 已提交
2185 2186 2187
	return sdp;
}

2188 2189 2190 2191 2192
static void sg_put_dev(struct sg_device *sdp)
{
	kref_put(&sdp->d_ref, sg_device_destroy);
}

L
Linus Torvalds 已提交
2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203
#ifdef CONFIG_SCSI_PROC_FS

static struct proc_dir_entry *sg_proc_sgp = NULL;

static char sg_proc_sg_dirname[] = "scsi/sg";

static int sg_proc_seq_show_int(struct seq_file *s, void *v);

static int sg_proc_single_open_adio(struct inode *inode, struct file *file);
static ssize_t sg_proc_write_adio(struct file *filp, const char __user *buffer,
			          size_t count, loff_t *off);
2204 2205
static const struct file_operations adio_fops = {
	.owner = THIS_MODULE,
L
Linus Torvalds 已提交
2206
	.open = sg_proc_single_open_adio,
2207 2208
	.read = seq_read,
	.llseek = seq_lseek,
L
Linus Torvalds 已提交
2209 2210 2211 2212 2213 2214 2215
	.write = sg_proc_write_adio,
	.release = single_release,
};

static int sg_proc_single_open_dressz(struct inode *inode, struct file *file);
static ssize_t sg_proc_write_dressz(struct file *filp, 
		const char __user *buffer, size_t count, loff_t *off);
2216 2217
static const struct file_operations dressz_fops = {
	.owner = THIS_MODULE,
L
Linus Torvalds 已提交
2218
	.open = sg_proc_single_open_dressz,
2219 2220
	.read = seq_read,
	.llseek = seq_lseek,
L
Linus Torvalds 已提交
2221 2222 2223 2224 2225 2226
	.write = sg_proc_write_dressz,
	.release = single_release,
};

static int sg_proc_seq_show_version(struct seq_file *s, void *v);
static int sg_proc_single_open_version(struct inode *inode, struct file *file);
2227 2228
static const struct file_operations version_fops = {
	.owner = THIS_MODULE,
L
Linus Torvalds 已提交
2229
	.open = sg_proc_single_open_version,
2230 2231
	.read = seq_read,
	.llseek = seq_lseek,
L
Linus Torvalds 已提交
2232 2233 2234 2235 2236
	.release = single_release,
};

static int sg_proc_seq_show_devhdr(struct seq_file *s, void *v);
static int sg_proc_single_open_devhdr(struct inode *inode, struct file *file);
2237 2238
static const struct file_operations devhdr_fops = {
	.owner = THIS_MODULE,
L
Linus Torvalds 已提交
2239
	.open = sg_proc_single_open_devhdr,
2240 2241
	.read = seq_read,
	.llseek = seq_lseek,
L
Linus Torvalds 已提交
2242 2243 2244 2245 2246 2247 2248 2249
	.release = single_release,
};

static int sg_proc_seq_show_dev(struct seq_file *s, void *v);
static int sg_proc_open_dev(struct inode *inode, struct file *file);
static void * dev_seq_start(struct seq_file *s, loff_t *pos);
static void * dev_seq_next(struct seq_file *s, void *v, loff_t *pos);
static void dev_seq_stop(struct seq_file *s, void *v);
2250 2251
static const struct file_operations dev_fops = {
	.owner = THIS_MODULE,
L
Linus Torvalds 已提交
2252
	.open = sg_proc_open_dev,
2253 2254
	.read = seq_read,
	.llseek = seq_lseek,
L
Linus Torvalds 已提交
2255 2256
	.release = seq_release,
};
J
James Morris 已提交
2257
static const struct seq_operations dev_seq_ops = {
L
Linus Torvalds 已提交
2258 2259 2260 2261 2262 2263 2264 2265
	.start = dev_seq_start,
	.next  = dev_seq_next,
	.stop  = dev_seq_stop,
	.show  = sg_proc_seq_show_dev,
};

static int sg_proc_seq_show_devstrs(struct seq_file *s, void *v);
static int sg_proc_open_devstrs(struct inode *inode, struct file *file);
2266 2267
static const struct file_operations devstrs_fops = {
	.owner = THIS_MODULE,
L
Linus Torvalds 已提交
2268
	.open = sg_proc_open_devstrs,
2269 2270
	.read = seq_read,
	.llseek = seq_lseek,
L
Linus Torvalds 已提交
2271 2272
	.release = seq_release,
};
J
James Morris 已提交
2273
static const struct seq_operations devstrs_seq_ops = {
L
Linus Torvalds 已提交
2274 2275 2276 2277 2278 2279 2280 2281
	.start = dev_seq_start,
	.next  = dev_seq_next,
	.stop  = dev_seq_stop,
	.show  = sg_proc_seq_show_devstrs,
};

static int sg_proc_seq_show_debug(struct seq_file *s, void *v);
static int sg_proc_open_debug(struct inode *inode, struct file *file);
2282 2283
static const struct file_operations debug_fops = {
	.owner = THIS_MODULE,
L
Linus Torvalds 已提交
2284
	.open = sg_proc_open_debug,
2285 2286
	.read = seq_read,
	.llseek = seq_lseek,
L
Linus Torvalds 已提交
2287 2288
	.release = seq_release,
};
J
James Morris 已提交
2289
static const struct seq_operations debug_seq_ops = {
L
Linus Torvalds 已提交
2290 2291 2292 2293 2294 2295 2296 2297 2298
	.start = dev_seq_start,
	.next  = dev_seq_next,
	.stop  = dev_seq_stop,
	.show  = sg_proc_seq_show_debug,
};


struct sg_proc_leaf {
	const char * name;
2299
	const struct file_operations * fops;
L
Linus Torvalds 已提交
2300 2301
};

2302
static const struct sg_proc_leaf sg_proc_leaf_arr[] = {
L
Linus Torvalds 已提交
2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314
	{"allow_dio", &adio_fops},
	{"debug", &debug_fops},
	{"def_reserved_size", &dressz_fops},
	{"device_hdr", &devhdr_fops},
	{"devices", &dev_fops},
	{"device_strs", &devstrs_fops},
	{"version", &version_fops}
};

static int
sg_proc_init(void)
{
2315
	int num_leaves = ARRAY_SIZE(sg_proc_leaf_arr);
A
Al Viro 已提交
2316
	int k;
L
Linus Torvalds 已提交
2317

2318
	sg_proc_sgp = proc_mkdir(sg_proc_sg_dirname, NULL);
L
Linus Torvalds 已提交
2319 2320 2321
	if (!sg_proc_sgp)
		return 1;
	for (k = 0; k < num_leaves; ++k) {
2322
		const struct sg_proc_leaf *leaf = &sg_proc_leaf_arr[k];
A
Al Viro 已提交
2323
		umode_t mask = leaf->fops->write ? S_IRUGO | S_IWUSR : S_IRUGO;
2324
		proc_create(leaf->name, mask, sg_proc_sgp, leaf->fops);
L
Linus Torvalds 已提交
2325 2326 2327 2328 2329 2330 2331 2332
	}
	return 0;
}

static void
sg_proc_cleanup(void)
{
	int k;
2333
	int num_leaves = ARRAY_SIZE(sg_proc_leaf_arr);
L
Linus Torvalds 已提交
2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357

	if (!sg_proc_sgp)
		return;
	for (k = 0; k < num_leaves; ++k)
		remove_proc_entry(sg_proc_leaf_arr[k].name, sg_proc_sgp);
	remove_proc_entry(sg_proc_sg_dirname, NULL);
}


static int sg_proc_seq_show_int(struct seq_file *s, void *v)
{
	seq_printf(s, "%d\n", *((int *)s->private));
	return 0;
}

static int sg_proc_single_open_adio(struct inode *inode, struct file *file)
{
	return single_open(file, sg_proc_seq_show_int, &sg_allow_dio);
}

static ssize_t 
sg_proc_write_adio(struct file *filp, const char __user *buffer,
		   size_t count, loff_t *off)
{
2358 2359
	int err;
	unsigned long num;
L
Linus Torvalds 已提交
2360 2361 2362

	if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
		return -EACCES;
2363 2364 2365 2366
	err = kstrtoul_from_user(buffer, count, 0, &num);
	if (err)
		return err;
	sg_allow_dio = num ? 1 : 0;
L
Linus Torvalds 已提交
2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378
	return count;
}

static int sg_proc_single_open_dressz(struct inode *inode, struct file *file)
{
	return single_open(file, sg_proc_seq_show_int, &sg_big_buff);
}

static ssize_t 
sg_proc_write_dressz(struct file *filp, const char __user *buffer,
		     size_t count, loff_t *off)
{
2379
	int err;
L
Linus Torvalds 已提交
2380 2381 2382 2383
	unsigned long k = ULONG_MAX;

	if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
		return -EACCES;
2384 2385 2386 2387

	err = kstrtoul_from_user(buffer, count, 0, &k);
	if (err)
		return err;
L
Linus Torvalds 已提交
2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427
	if (k <= 1048576) {	/* limit "big buff" to 1 MB */
		sg_big_buff = k;
		return count;
	}
	return -ERANGE;
}

static int sg_proc_seq_show_version(struct seq_file *s, void *v)
{
	seq_printf(s, "%d\t%s [%s]\n", sg_version_num, SG_VERSION_STR,
		   sg_version_date);
	return 0;
}

static int sg_proc_single_open_version(struct inode *inode, struct file *file)
{
	return single_open(file, sg_proc_seq_show_version, NULL);
}

static int sg_proc_seq_show_devhdr(struct seq_file *s, void *v)
{
	seq_printf(s, "host\tchan\tid\tlun\ttype\topens\tqdepth\tbusy\t"
		   "online\n");
	return 0;
}

static int sg_proc_single_open_devhdr(struct inode *inode, struct file *file)
{
	return single_open(file, sg_proc_seq_show_devhdr, NULL);
}

struct sg_proc_deviter {
	loff_t	index;
	size_t	max;
};

static void * dev_seq_start(struct seq_file *s, loff_t *pos)
{
	struct sg_proc_deviter * it = kmalloc(sizeof(*it), GFP_KERNEL);

2428
	s->private = it;
L
Linus Torvalds 已提交
2429 2430
	if (! it)
		return NULL;
2431

L
Linus Torvalds 已提交
2432 2433 2434
	it->index = *pos;
	it->max = sg_last_dev();
	if (it->index >= it->max)
2435
		return NULL;
L
Linus Torvalds 已提交
2436 2437 2438 2439 2440
	return it;
}

static void * dev_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
2441
	struct sg_proc_deviter * it = s->private;
L
Linus Torvalds 已提交
2442 2443 2444 2445 2446 2447 2448

	*pos = ++it->index;
	return (it->index < it->max) ? it : NULL;
}

static void dev_seq_stop(struct seq_file *s, void *v)
{
2449
	kfree(s->private);
L
Linus Torvalds 已提交
2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461
}

static int sg_proc_open_dev(struct inode *inode, struct file *file)
{
        return seq_open(file, &dev_seq_ops);
}

static int sg_proc_seq_show_dev(struct seq_file *s, void *v)
{
	struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
	Sg_device *sdp;
	struct scsi_device *scsidp;
2462
	unsigned long iflags;
L
Linus Torvalds 已提交
2463

2464 2465
	read_lock_irqsave(&sg_index_lock, iflags);
	sdp = it ? sg_lookup_dev(it->index) : NULL;
L
Linus Torvalds 已提交
2466 2467 2468 2469 2470 2471 2472 2473 2474 2475
	if (sdp && (scsidp = sdp->device) && (!sdp->detached))
		seq_printf(s, "%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",
			      scsidp->host->host_no, scsidp->channel,
			      scsidp->id, scsidp->lun, (int) scsidp->type,
			      1,
			      (int) scsidp->queue_depth,
			      (int) scsidp->device_busy,
			      (int) scsi_device_online(scsidp));
	else
		seq_printf(s, "-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\n");
2476
	read_unlock_irqrestore(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489
	return 0;
}

static int sg_proc_open_devstrs(struct inode *inode, struct file *file)
{
        return seq_open(file, &devstrs_seq_ops);
}

static int sg_proc_seq_show_devstrs(struct seq_file *s, void *v)
{
	struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
	Sg_device *sdp;
	struct scsi_device *scsidp;
2490
	unsigned long iflags;
L
Linus Torvalds 已提交
2491

2492 2493
	read_lock_irqsave(&sg_index_lock, iflags);
	sdp = it ? sg_lookup_dev(it->index) : NULL;
L
Linus Torvalds 已提交
2494 2495 2496 2497 2498
	if (sdp && (scsidp = sdp->device) && (!sdp->detached))
		seq_printf(s, "%8.8s\t%16.16s\t%4.4s\n",
			   scsidp->vendor, scsidp->model, scsidp->rev);
	else
		seq_printf(s, "<no active device>\n");
2499
	read_unlock_irqrestore(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
2500 2501 2502
	return 0;
}

2503
/* must be called while holding sg_index_lock */
L
Linus Torvalds 已提交
2504 2505 2506 2507 2508 2509 2510
static void sg_proc_debug_helper(struct seq_file *s, Sg_device * sdp)
{
	int k, m, new_interface, blen, usg;
	Sg_request *srp;
	Sg_fd *fp;
	const sg_io_hdr_t *hp;
	const char * cp;
已提交
2511
	unsigned int ms;
L
Linus Torvalds 已提交
2512

2513 2514 2515
	k = 0;
	list_for_each_entry(fp, &sdp->sfds, sfd_siblings) {
		k++;
2516
		read_lock(&fp->rq_list_lock); /* irqs already disabled */
L
Linus Torvalds 已提交
2517
		seq_printf(s, "   FD(%d): timeout=%dms bufflen=%d "
2518
			   "(res)sgat=%d low_dma=%d\n", k,
L
Linus Torvalds 已提交
2519 2520 2521 2522
			   jiffies_to_msecs(fp->timeout),
			   fp->reserve.bufflen,
			   (int) fp->reserve.k_use_sg,
			   (int) fp->low_dma);
J
Jörn Engel 已提交
2523
		seq_printf(s, "   cmd_q=%d f_packid=%d k_orphan=%d closed=0\n",
L
Linus Torvalds 已提交
2524
			   (int) fp->cmd_q, (int) fp->force_packid,
J
Jörn Engel 已提交
2525
			   (int) fp->keep_orphan);
2526 2527 2528
		for (m = 0, srp = fp->headrp;
				srp != NULL;
				++m, srp = srp->nextrp) {
L
Linus Torvalds 已提交
2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543
			hp = &srp->header;
			new_interface = (hp->interface_id == '\0') ? 0 : 1;
			if (srp->res_used) {
				if (new_interface && 
				    (SG_FLAG_MMAP_IO & hp->flags))
					cp = "     mmap>> ";
				else
					cp = "     rb>> ";
			} else {
				if (SG_INFO_DIRECT_IO_MASK & hp->info)
					cp = "     dio>> ";
				else
					cp = "     ";
			}
			seq_printf(s, cp);
2544 2545
			blen = srp->data.bufflen;
			usg = srp->data.k_use_sg;
L
Linus Torvalds 已提交
2546 2547
			seq_printf(s, srp->done ? 
				   ((1 == srp->done) ?  "rcv:" : "fin:")
2548
				   : "act:");
L
Linus Torvalds 已提交
2549 2550 2551 2552
			seq_printf(s, " id=%d blen=%d",
				   srp->header.pack_id, blen);
			if (srp->done)
				seq_printf(s, " dur=%d", hp->duration);
已提交
2553 2554
			else {
				ms = jiffies_to_msecs(jiffies);
L
Linus Torvalds 已提交
2555
				seq_printf(s, " t_o/elap=%d/%d",
已提交
2556 2557 2558 2559
					(new_interface ? hp->timeout :
						  jiffies_to_msecs(fp->timeout)),
					(ms > hp->duration ? ms - hp->duration : 0));
			}
L
Linus Torvalds 已提交
2560 2561 2562 2563 2564
			seq_printf(s, "ms sgat=%d op=0x%02x\n", usg,
				   (int) srp->data.cmd_opcode);
		}
		if (0 == m)
			seq_printf(s, "     No requests active\n");
2565
		read_unlock(&fp->rq_list_lock);
L
Linus Torvalds 已提交
2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577
	}
}

static int sg_proc_open_debug(struct inode *inode, struct file *file)
{
        return seq_open(file, &debug_seq_ops);
}

static int sg_proc_seq_show_debug(struct seq_file *s, void *v)
{
	struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
	Sg_device *sdp;
2578
	unsigned long iflags;
L
Linus Torvalds 已提交
2579 2580

	if (it && (0 == it->index)) {
2581 2582
		seq_printf(s, "max_active_device=%d(origin 1)\n",
			   (int)it->max);
L
Linus Torvalds 已提交
2583 2584 2585
		seq_printf(s, " def_reserved_size=%d\n", sg_big_buff);
	}

2586 2587
	read_lock_irqsave(&sg_index_lock, iflags);
	sdp = it ? sg_lookup_dev(it->index) : NULL;
2588
	if (sdp && !list_empty(&sdp->sfds)) {
2589
		struct scsi_device *scsidp = sdp->device;
L
Linus Torvalds 已提交
2590

2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601
		seq_printf(s, " >>> device=%s ", sdp->disk->disk_name);
		if (sdp->detached)
			seq_printf(s, "detached pending close ");
		else
			seq_printf
			    (s, "scsi%d chan=%d id=%d lun=%d   em=%d",
			     scsidp->host->host_no,
			     scsidp->channel, scsidp->id,
			     scsidp->lun,
			     scsidp->host->hostt->emulated);
		seq_printf(s, " sg_tablesize=%d excl=%d\n",
2602
			   sdp->sg_tablesize, sdp->exclude);
L
Linus Torvalds 已提交
2603 2604
		sg_proc_debug_helper(s, sdp);
	}
2605
	read_unlock_irqrestore(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
2606 2607 2608 2609 2610 2611 2612
	return 0;
}

#endif				/* CONFIG_SCSI_PROC_FS */

module_init(init_sg);
module_exit(exit_sg);