sg.c 69.3 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 38 39 40 41 42 43 44 45

/*
 *  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>
#include <linux/errno.h>
#include <linux/mtio.h>
#include <linux/ioctl.h>
#include <linux/fcntl.h>
#include <linux/init.h>
#include <linux/poll.h>
#include <linux/moduleparam.h>
#include <linux/cdev.h>
46
#include <linux/idr.h>
L
Linus Torvalds 已提交
47 48 49
#include <linux/seq_file.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
50
#include <linux/blktrace_api.h>
51
#include <linux/smp_lock.h>
L
Linus Torvalds 已提交
52 53

#include "scsi.h"
已提交
54
#include <scsi/scsi_dbg.h>
L
Linus Torvalds 已提交
55 56 57 58 59 60 61 62 63
#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>
64
static char *sg_version_date = "20061027";
L
Linus Torvalds 已提交
65 66 67 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

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;

97 98 99
static int scatter_elem_sz = SG_SCATTER_SZ;
static int scatter_elem_sz_prev = SG_SCATTER_SZ;

L
Linus Torvalds 已提交
100 101
#define SG_SECTOR_SZ 512

102 103
static int sg_add(struct device *, struct class_interface *);
static void sg_remove(struct device *, struct class_interface *);
L
Linus Torvalds 已提交
104

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

static struct class_interface sg_interface = {
110 111
	.add_dev	= sg_add,
	.remove_dev	= sg_remove,
L
Linus Torvalds 已提交
112 113 114 115
};

typedef struct sg_scatter_hold { /* holding area for scsi scatter gather info */
	unsigned short k_use_sg; /* Count of kernel scatter-gather pieces */
116
	unsigned sglist_len; /* size of malloc'd scatter-gather list ++ */
L
Linus Torvalds 已提交
117
	unsigned bufflen;	/* Size of (aggregate) data buffer */
118 119
	struct page **pages;
	int page_order;
L
Linus Torvalds 已提交
120 121 122 123 124 125 126 127 128 129 130 131
	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> */
132
	unsigned char sense_b[SCSI_SENSE_BUFFERSIZE];
L
Linus Torvalds 已提交
133 134 135 136
	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 */
	volatile char done;	/* 0->before bh, 1->before read, 2->read */
137
	struct request *rq;
138
	struct bio *bio;
139
	struct execute_work ew;
L
Linus Torvalds 已提交
140 141 142
} Sg_request;

typedef struct sg_fd {		/* holds the state of a file descriptor */
143
	struct list_head sfd_siblings;
L
Linus Torvalds 已提交
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
	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 */
	volatile char closed;	/* 1 -> fd closed but request(s) outstanding */
	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 */
161 162
	struct kref f_ref;
	struct execute_work ew;
L
Linus Torvalds 已提交
163 164 165 166 167 168
} Sg_fd;

typedef struct sg_device { /* holds the state of each scsi generic device */
	struct scsi_device *device;
	wait_queue_head_t o_excl_wait;	/* queue open() when O_EXCL in use */
	int sg_tablesize;	/* adapter's max scatter-gather table size */
169
	u32 index;		/* device index number */
170
	struct list_head sfds;
L
Linus Torvalds 已提交
171 172 173 174 175
	volatile char detached;	/* 0->attached, 1->detached pending removal */
	volatile char exclude;	/* opened for exclusive access */
	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>] */
176
	struct kref d_ref;
L
Linus Torvalds 已提交
177 178
} Sg_device;

179
/* tasklet or soft irq callback */
180
static void sg_rq_end_io(struct request *rq, int uptodate);
181
static int sg_start_req(Sg_request *srp, unsigned char *cmd);
182
static int sg_finish_rem_req(Sg_request * srp);
L
Linus Torvalds 已提交
183 184 185
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);
186 187
static ssize_t sg_new_write(Sg_fd *sfp, struct file *file,
			const char __user *buf, size_t count, int blocking,
188
			int read_only, int sg_io_owned, Sg_request **o_srp);
L
Linus Torvalds 已提交
189 190 191 192 193 194 195 196
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);
197
static void sg_remove_sfp(struct kref *);
L
Linus Torvalds 已提交
198 199 200 201 202
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);
203
static void sg_put_dev(Sg_device *sdp);
L
Linus Torvalds 已提交
204 205 206 207 208 209

#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)

210 211 212 213 214 215 216
static int sg_allow_access(struct file *filp, unsigned char *cmd)
{
	struct sg_fd *sfp = (struct sg_fd *)filp->private_data;

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

217
	return blk_verify_command(cmd, filp->f_mode & FMODE_WRITE);
218 219
}

L
Linus Torvalds 已提交
220 221 222 223 224
static int
sg_open(struct inode *inode, struct file *filp)
{
	int dev = iminor(inode);
	int flags = filp->f_flags;
225
	struct request_queue *q;
L
Linus Torvalds 已提交
226 227 228 229 230
	Sg_device *sdp;
	Sg_fd *sfp;
	int res;
	int retval;

231
	lock_kernel();
L
Linus Torvalds 已提交
232 233 234
	nonseekable_open(inode, filp);
	SCSI_LOG_TIMEOUT(3, printk("sg_open: dev=%d, flags=0x%x\n", dev, flags));
	sdp = sg_get_dev(dev);
235 236 237 238
	if (IS_ERR(sdp)) {
		retval = PTR_ERR(sdp);
		sdp = NULL;
		goto sg_put;
239
	}
L
Linus Torvalds 已提交
240 241 242 243

	/* 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);
244 245
	if (retval)
		goto sg_put;
L
Linus Torvalds 已提交
246 247 248 249 250 251 252 253 254 255 256 257 258

	if (!((flags & O_NONBLOCK) ||
	      scsi_block_when_processing_errors(sdp->device))) {
		retval = -ENXIO;
		/* we are in error recovery for this device */
		goto error_out;
	}

	if (flags & O_EXCL) {
		if (O_RDONLY == (flags & O_ACCMODE)) {
			retval = -EPERM; /* Can't lock it with read only access */
			goto error_out;
		}
259
		if (!list_empty(&sdp->sfds) && (flags & O_NONBLOCK)) {
L
Linus Torvalds 已提交
260 261 262 263 264
			retval = -EBUSY;
			goto error_out;
		}
		res = 0;
		__wait_event_interruptible(sdp->o_excl_wait,
265
					   ((!list_empty(&sdp->sfds) || sdp->exclude) ? 0 : (sdp->exclude = 1)), res);
L
Linus Torvalds 已提交
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
		if (res) {
			retval = res;	/* -ERESTARTSYS because signal hit process */
			goto error_out;
		}
	} else if (sdp->exclude) {	/* some other fd has an exclusive lock on dev */
		if (flags & O_NONBLOCK) {
			retval = -EBUSY;
			goto error_out;
		}
		res = 0;
		__wait_event_interruptible(sdp->o_excl_wait, (!sdp->exclude),
					   res);
		if (res) {
			retval = res;	/* -ERESTARTSYS because signal hit process */
			goto error_out;
		}
	}
	if (sdp->detached) {
		retval = -ENODEV;
		goto error_out;
	}
287
	if (list_empty(&sdp->sfds)) {	/* no existing opens on this device */
L
Linus Torvalds 已提交
288
		sdp->sgdebug = 0;
289
		q = sdp->device->request_queue;
290 291
		sdp->sg_tablesize = min(queue_max_hw_segments(q),
					queue_max_phys_segments(q));
L
Linus Torvalds 已提交
292 293 294 295
	}
	if ((sfp = sg_add_sfp(sdp, dev)))
		filp->private_data = sfp;
	else {
296
		if (flags & O_EXCL) {
L
Linus Torvalds 已提交
297
			sdp->exclude = 0;	/* undo if error */
298 299
			wake_up_interruptible(&sdp->o_excl_wait);
		}
L
Linus Torvalds 已提交
300 301 302
		retval = -ENOMEM;
		goto error_out;
	}
303 304 305 306 307 308 309
	retval = 0;
error_out:
	if (retval)
		scsi_device_put(sdp->device);
sg_put:
	if (sdp)
		sg_put_dev(sdp);
310
	unlock_kernel();
L
Linus Torvalds 已提交
311 312 313 314 315 316 317 318 319 320 321 322 323
	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;

	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));
324 325 326 327 328 329 330

	sfp->closed = 1;

	sdp->exclude = 0;
	wake_up_interruptible(&sdp->o_excl_wait);

	kref_put(&sfp->f_ref, sg_remove_sfp);
L
Linus Torvalds 已提交
331 332 333 334 335 336 337 338 339 340 341
	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;
已提交
342 343
	struct sg_header *old_hdr = NULL;
	int retval = 0;
L
Linus Torvalds 已提交
344 345 346 347 348

	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));
349

L
Linus Torvalds 已提交
350 351 352
	if (!access_ok(VERIFY_WRITE, buf, count))
		return -EFAULT;
	if (sfp->force_packid && (count >= SZ_SG_HEADER)) {
已提交
353 354 355 356 357 358 359 360
		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 已提交
361
			if (count >= SZ_SG_IO_HDR) {
已提交
362 363 364 365 366 367 368 369 370 371 372 373 374 375
				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 已提交
376 377
			}
		} else
已提交
378
			req_pack_id = old_hdr->pack_id;
L
Linus Torvalds 已提交
379 380 381
	}
	srp = sg_get_rq_mark(sfp, req_pack_id);
	if (!srp) {		/* now wait on packet to arrive */
已提交
382 383 384 385 386 387 388 389
		if (sdp->detached) {
			retval = -ENODEV;
			goto free_old_hdr;
		}
		if (filp->f_flags & O_NONBLOCK) {
			retval = -EAGAIN;
			goto free_old_hdr;
		}
L
Linus Torvalds 已提交
390
		while (1) {
已提交
391
			retval = 0; /* following macro beats race condition */
L
Linus Torvalds 已提交
392
			__wait_event_interruptible(sfp->read_wait,
已提交
393 394 395 396 397 398 399 400
				(sdp->detached ||
				(srp = sg_get_rq_mark(sfp, req_pack_id))), 
				retval);
			if (sdp->detached) {
				retval = -ENODEV;
				goto free_old_hdr;
			}
			if (0 == retval)
L
Linus Torvalds 已提交
401
				break;
已提交
402 403 404

			/* -ERESTARTSYS as signal hit process */
			goto free_old_hdr;
L
Linus Torvalds 已提交
405 406
		}
	}
已提交
407 408 409 410
	if (srp->header.interface_id != '\0') {
		retval = sg_new_read(sfp, buf, count, srp);
		goto free_old_hdr;
	}
L
Linus Torvalds 已提交
411 412

	hp = &srp->header;
已提交
413 414 415 416 417 418 419 420 421 422 423 424
	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 已提交
425
	    ((srp->data.cmd_opcode >= 0xc0) && (12 == hp->cmd_len)) ? 1 : 0;
已提交
426 427 428
	old_hdr->target_status = hp->masked_status;
	old_hdr->host_status = hp->host_status;
	old_hdr->driver_status = hp->driver_status;
L
Linus Torvalds 已提交
429 430
	if ((CHECK_CONDITION & hp->masked_status) ||
	    (DRIVER_SENSE & hp->driver_status))
已提交
431 432
		memcpy(old_hdr->sense_buffer, srp->sense_b,
		       sizeof (old_hdr->sense_buffer));
L
Linus Torvalds 已提交
433 434 435 436 437 438
	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:
已提交
439
		old_hdr->result = 0;
L
Linus Torvalds 已提交
440 441 442 443
		break;
	case DID_NO_CONNECT:
	case DID_BUS_BUSY:
	case DID_TIME_OUT:
已提交
444
		old_hdr->result = EBUSY;
L
Linus Torvalds 已提交
445 446 447 448 449 450
		break;
	case DID_BAD_TARGET:
	case DID_ABORT:
	case DID_PARITY:
	case DID_RESET:
	case DID_BAD_INTR:
已提交
451
		old_hdr->result = EIO;
L
Linus Torvalds 已提交
452 453
		break;
	case DID_ERROR:
已提交
454
		old_hdr->result = (srp->sense_b[0] == 0 && 
L
Linus Torvalds 已提交
455 456 457
				  hp->masked_status == GOOD) ? 0 : EIO;
		break;
	default:
已提交
458
		old_hdr->result = EIO;
L
Linus Torvalds 已提交
459 460 461 462 463
		break;
	}

	/* Now copy the result back to the user buffer.  */
	if (count >= SZ_SG_HEADER) {
已提交
464 465 466 467
		if (__copy_to_user(buf, old_hdr, SZ_SG_HEADER)) {
			retval = -EFAULT;
			goto free_old_hdr;
		}
L
Linus Torvalds 已提交
468
		buf += SZ_SG_HEADER;
已提交
469 470
		if (count > old_hdr->reply_len)
			count = old_hdr->reply_len;
L
Linus Torvalds 已提交
471
		if (count > SZ_SG_HEADER) {
已提交
472 473 474 475
			if (sg_read_oxfer(srp, buf, count - SZ_SG_HEADER)) {
				retval = -EFAULT;
				goto free_old_hdr;
			}
L
Linus Torvalds 已提交
476 477
		}
	} else
已提交
478
		count = (old_hdr->result == 0) ? 0 : -EIO;
L
Linus Torvalds 已提交
479
	sg_finish_rem_req(srp);
已提交
480 481
	retval = count;
free_old_hdr:
J
Jesper Juhl 已提交
482
	kfree(old_hdr);
已提交
483
	return retval;
L
Linus Torvalds 已提交
484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500
}

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)) {
501
			int sb_len = SCSI_SENSE_BUFFERSIZE;
L
Linus Torvalds 已提交
502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517
			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 已提交
518
err_out:
519
	err = sg_finish_rem_req(srp);
L
Linus Torvalds 已提交
520 521 522 523 524 525 526 527 528 529 530 531 532 533
	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;
534
	unsigned char cmnd[MAX_COMMAND_SIZE];
L
Linus Torvalds 已提交
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553

	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)
554 555
		return sg_new_write(sfp, filp, buf, count,
				    blocking, 0, 0, NULL);
L
Linus Torvalds 已提交
556 557 558 559 560 561 562 563 564 565 566 567 568 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
	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;
601 602 603 604
	if (hp->dxfer_direction == SG_DXFER_TO_DEV)
		hp->dxferp = (char __user *)buf + cmd_size;
	else
		hp->dxferp = NULL;
L
Linus Torvalds 已提交
605 606 607 608 609 610 611 612 613 614 615 616
	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.
	 */
617 618 619
	if (hp->dxfer_direction == SG_DXFER_TO_FROM_DEV) {
		static char cmd[TASK_COMM_LEN];
		if (strcmp(current->comm, cmd) && printk_ratelimit()) {
L
Linus Torvalds 已提交
620 621
			printk(KERN_WARNING
			       "sg_write: data in/out %d/%d bytes for SCSI command 0x%x--"
622
			       "guessing data in;\n   "
L
Linus Torvalds 已提交
623 624 625 626
			       "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);
627 628 629
			strcpy(cmd, current->comm);
		}
	}
L
Linus Torvalds 已提交
630 631 632 633 634
	k = sg_common_write(sfp, srp, cmnd, sfp->timeout, blocking);
	return (k < 0) ? k : count;
}

static ssize_t
635
sg_new_write(Sg_fd *sfp, struct file *file, const char __user *buf,
636
		 size_t count, int blocking, int read_only, int sg_io_owned,
637
		 Sg_request **o_srp)
L
Linus Torvalds 已提交
638 639 640 641
{
	int k;
	Sg_request *srp;
	sg_io_hdr_t *hp;
642
	unsigned char cmnd[MAX_COMMAND_SIZE];
L
Linus Torvalds 已提交
643 644 645 646 647 648 649 650 651 652 653 654 655
	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;
	}
656
	srp->sg_io_owned = sg_io_owned;
L
Linus Torvalds 已提交
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693
	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;
	}
694
	if (read_only && sg_allow_access(file, cmnd)) {
L
Linus Torvalds 已提交
695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
		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)
{
710
	int k, data_dir;
L
Linus Torvalds 已提交
711 712 713 714 715 716 717 718 719 720 721 722 723 724
	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));

725 726
	k = sg_start_req(srp, cmnd);
	if (k) {
727
		SCSI_LOG_TIMEOUT(1, printk("sg_common_write: start_req err=%d\n", k));
L
Linus Torvalds 已提交
728 729 730 731 732 733 734 735 736 737 738
		sg_finish_rem_req(srp);
		return k;	/* probably out of space --> ENOMEM */
	}
	if (sdp->detached) {
		sg_finish_rem_req(srp);
		return -ENODEV;
	}

	switch (hp->dxfer_direction) {
	case SG_DXFER_TO_FROM_DEV:
	case SG_DXFER_FROM_DEV:
739
		data_dir = DMA_FROM_DEVICE;
L
Linus Torvalds 已提交
740 741
		break;
	case SG_DXFER_TO_DEV:
742
		data_dir = DMA_TO_DEVICE;
L
Linus Torvalds 已提交
743 744
		break;
	case SG_DXFER_UNKNOWN:
745
		data_dir = DMA_BIDIRECTIONAL;
L
Linus Torvalds 已提交
746 747
		break;
	default:
748
		data_dir = DMA_NONE;
L
Linus Torvalds 已提交
749 750
		break;
	}
已提交
751
	hp->duration = jiffies_to_msecs(jiffies);
752 753

	srp->rq->timeout = timeout;
754
	kref_get(&sfp->f_ref); /* sg_rq_end_io() does kref_put(). */
755 756 757
	blk_execute_rq_nowait(sdp->device->request_queue, sdp->disk,
			      srp->rq, 1, sg_rq_end_io);
	return 0;
L
Linus Torvalds 已提交
758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773
}

static int
sg_ioctl(struct inode *inode, struct file *filp,
	 unsigned int cmd_in, unsigned long arg)
{
	void __user *p = (void __user *)arg;
	int __user *ip = p;
	int result, val, read_only;
	Sg_device *sdp;
	Sg_fd *sfp;
	Sg_request *srp;
	unsigned long iflags;

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

L
Linus Torvalds 已提交
775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790
	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:
		{
			int blocking = 1;	/* ignore O_NONBLOCK flag */

			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 =
791
			    sg_new_write(sfp, filp, p, SZ_SG_IO_HDR,
792
					 blocking, read_only, 1, &srp);
L
Linus Torvalds 已提交
793 794 795 796 797
			if (result < 0)
				return result;
			while (1) {
				result = 0;	/* following macro to beat race condition */
				__wait_event_interruptible(sfp->read_wait,
798 799
					(srp->done || sdp->detached),
					result);
L
Linus Torvalds 已提交
800 801
				if (sdp->detached)
					return -ENODEV;
802 803 804 805
				write_lock_irq(&sfp->rq_list_lock);
				if (srp->done) {
					srp->done = 2;
					write_unlock_irq(&sfp->rq_list_lock);
L
Linus Torvalds 已提交
806
					break;
807
				}
L
Linus Torvalds 已提交
808
				srp->orphan = 1;
809
				write_unlock_irq(&sfp->rq_list_lock);
L
Linus Torvalds 已提交
810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 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
				return result;	/* -ERESTARTSYS because signal hit process */
			}
			result = sg_new_read(sfp, p, SZ_SG_IO_HDR, srp);
			return (result < 0) ? result : 0;
		}
	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;
909
		val = min_t(int, val,
910
			    queue_max_sectors(sdp->device->request_queue) * 512);
L
Linus Torvalds 已提交
911 912 913 914 915 916 917 918
		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:
919
		val = min_t(int, sfp->reserve.bufflen,
920
			    queue_max_sectors(sdp->device->request_queue) * 512);
L
Linus Torvalds 已提交
921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953
		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 {
已提交
954 955 956 957 958 959 960
			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 已提交
961 962 963 964 965 966 967 968 969 970
			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;
已提交
971 972 973 974 975 976 977 978 979
					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 已提交
980
					rinfo[val].orphan = srp->orphan;
已提交
981 982 983 984 985 986
					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 已提交
987 988 989
				}
			}
			read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
已提交
990 991 992 993 994
			result = __copy_to_user(p, rinfo, 
						SZ_SG_REQ_INFO * SG_MAX_QUEUE);
			result = result ? -EFAULT : 0;
			kfree(rinfo);
			return result;
L
Linus Torvalds 已提交
995 996 997 998 999 1000 1001 1002 1003
		}
	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) {
1004
			if (scsi_host_in_recovery(sdp->device->host))
L
Linus Torvalds 已提交
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016
				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 已提交
1017 1018 1019
		case SG_SCSI_RESET_TARGET:
			val = SCSI_TRY_RESET_TARGET;
			break;
L
Linus Torvalds 已提交
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
		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;
1042
			if (sg_allow_access(filp, &opcode))
L
Linus Torvalds 已提交
1043 1044
				return -EPERM;
		}
1045
		return sg_scsi_ioctl(sdp->device->request_queue, NULL, filp->f_mode, p);
L
Linus Torvalds 已提交
1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
	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);
1059
	case BLKSECTGET:
1060
		return put_user(queue_max_sectors(sdp->device->request_queue) * 512,
1061
				ip);
1062 1063 1064
	case BLKTRACESETUP:
		return blk_trace_setup(sdp->device->request_queue,
				       sdp->disk->disk_name,
1065
				       MKDEV(SCSI_GENERIC_MAJOR, sdp->index),
1066
				       NULL,
1067 1068 1069 1070 1071 1072 1073
				       (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 已提交
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 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 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149
	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;

	if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp))
	    || sfp->closed)
		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));

1150
	return fasync_helper(fd, filp, mode, &sfp->async_qp);
L
Linus Torvalds 已提交
1151 1152
}

N
Nick Piggin 已提交
1153 1154
static int
sg_vma_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
L
Linus Torvalds 已提交
1155 1156
{
	Sg_fd *sfp;
1157
	unsigned long offset, len, sa;
L
Linus Torvalds 已提交
1158
	Sg_scatter_hold *rsv_schp;
1159
	int k, length;
L
Linus Torvalds 已提交
1160 1161

	if ((NULL == vma) || (!(sfp = (Sg_fd *) vma->vm_private_data)))
N
Nick Piggin 已提交
1162
		return VM_FAULT_SIGBUS;
L
Linus Torvalds 已提交
1163
	rsv_schp = &sfp->reserve;
N
Nick Piggin 已提交
1164
	offset = vmf->pgoff << PAGE_SHIFT;
L
Linus Torvalds 已提交
1165
	if (offset >= rsv_schp->bufflen)
N
Nick Piggin 已提交
1166 1167
		return VM_FAULT_SIGBUS;
	SCSI_LOG_TIMEOUT(3, printk("sg_vma_fault: offset=%lu, scatg=%d\n",
L
Linus Torvalds 已提交
1168
				   offset, rsv_schp->k_use_sg));
1169
	sa = vma->vm_start;
1170 1171
	length = 1 << (PAGE_SHIFT + rsv_schp->page_order);
	for (k = 0; k < rsv_schp->k_use_sg && sa < vma->vm_end; k++) {
1172
		len = vma->vm_end - sa;
1173
		len = (len < length) ? len : length;
1174
		if (offset < len) {
1175 1176
			struct page *page = nth_page(rsv_schp->pages[k],
						     offset >> PAGE_SHIFT);
1177
			get_page(page);	/* increment page count */
N
Nick Piggin 已提交
1178 1179
			vmf->page = page;
			return 0; /* success */
L
Linus Torvalds 已提交
1180
		}
1181 1182
		sa += len;
		offset -= len;
L
Linus Torvalds 已提交
1183
	}
1184

N
Nick Piggin 已提交
1185
	return VM_FAULT_SIGBUS;
L
Linus Torvalds 已提交
1186 1187
}

1188
static const struct vm_operations_struct sg_mmap_vm_ops = {
N
Nick Piggin 已提交
1189
	.fault = sg_vma_fault,
L
Linus Torvalds 已提交
1190 1191 1192 1193 1194 1195
};

static int
sg_mmap(struct file *filp, struct vm_area_struct *vma)
{
	Sg_fd *sfp;
1196
	unsigned long req_sz, len, sa;
L
Linus Torvalds 已提交
1197
	Sg_scatter_hold *rsv_schp;
1198
	int k, length;
L
Linus Torvalds 已提交
1199 1200 1201

	if ((!filp) || (!vma) || (!(sfp = (Sg_fd *) filp->private_data)))
		return -ENXIO;
已提交
1202
	req_sz = vma->vm_end - vma->vm_start;
L
Linus Torvalds 已提交
1203 1204 1205 1206 1207 1208 1209 1210
	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 */

1211
	sa = vma->vm_start;
1212 1213
	length = 1 << (PAGE_SHIFT + rsv_schp->page_order);
	for (k = 0; k < rsv_schp->k_use_sg && sa < vma->vm_end; k++) {
1214
		len = vma->vm_end - sa;
1215
		len = (len < length) ? len : length;
1216
		sa += len;
L
Linus Torvalds 已提交
1217
	}
1218

N
Nick Piggin 已提交
1219
	sfp->mmap_called = 1;
1220
	vma->vm_flags |= VM_RESERVED;
L
Linus Torvalds 已提交
1221 1222 1223 1224 1225
	vma->vm_private_data = sfp;
	vma->vm_ops = &sg_mmap_vm_ops;
	return 0;
}

1226 1227 1228 1229 1230 1231 1232 1233 1234
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);
}

1235 1236 1237 1238 1239
/*
 * 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 已提交
1240
{
1241
	struct sg_request *srp = rq->end_io_data;
1242
	Sg_device *sdp;
L
Linus Torvalds 已提交
1243 1244
	Sg_fd *sfp;
	unsigned long iflags;
已提交
1245
	unsigned int ms;
1246
	char *sense;
1247
	int result, resid, done = 1;
L
Linus Torvalds 已提交
1248

1249
	if (WARN_ON(srp->done != 0))
L
Linus Torvalds 已提交
1250
		return;
1251

L
Linus Torvalds 已提交
1252
	sfp = srp->parentfp;
1253
	if (WARN_ON(sfp == NULL))
L
Linus Torvalds 已提交
1254
		return;
1255 1256 1257 1258

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

1260 1261
	sense = rq->sense;
	result = rq->errors;
T
Tejun Heo 已提交
1262
	resid = rq->resid_len;
L
Linus Torvalds 已提交
1263 1264

	SCSI_LOG_TIMEOUT(4, printk("sg_cmd_done: %s, pack_id=%d, res=0x%x\n",
1265 1266
		sdp->disk->disk_name, srp->header.pack_id, result));
	srp->header.resid = resid;
已提交
1267 1268 1269
	ms = jiffies_to_msecs(jiffies);
	srp->header.duration = (ms > srp->header.duration) ?
				(ms - srp->header.duration) : 0;
1270
	if (0 != result) {
L
Linus Torvalds 已提交
1271 1272
		struct scsi_sense_hdr sshdr;

1273 1274 1275 1276 1277
		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 已提交
1278 1279 1280
		if ((sdp->sgdebug > 0) &&
		    ((CHECK_CONDITION == srp->header.masked_status) ||
		     (COMMAND_TERMINATED == srp->header.masked_status)))
1281 1282
			__scsi_print_sense("sg_cmd_done", sense,
					   SCSI_SENSE_BUFFERSIZE);
L
Linus Torvalds 已提交
1283 1284

		/* Following if statement is a patch supplied by Eric Youngdale */
1285 1286
		if (driver_byte(result) != 0
		    && scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr)
L
Linus Torvalds 已提交
1287 1288 1289 1290 1291 1292 1293 1294 1295 1296
		    && !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" */

1297 1298
	write_lock_irqsave(&sfp->rq_list_lock, iflags);
	if (unlikely(srp->orphan)) {
L
Linus Torvalds 已提交
1299 1300
		if (sfp->keep_orphan)
			srp->sg_io_owned = 0;
1301 1302
		else
			done = 0;
L
Linus Torvalds 已提交
1303
	}
1304 1305 1306 1307 1308 1309 1310
	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 已提交
1311
		wake_up_interruptible(&sfp->read_wait);
1312
		kill_fasync(&sfp->async_qp, SIGPOLL, POLL_IN);
1313
		kref_put(&sfp->f_ref, sg_remove_sfp);
1314 1315 1316 1317
	} else {
		INIT_WORK(&srp->ew.work, sg_rq_end_io_usercontext);
		schedule_work(&srp->ew.work);
	}
L
Linus Torvalds 已提交
1318 1319
}

1320
static const struct file_operations sg_fops = {
L
Linus Torvalds 已提交
1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334
	.owner = THIS_MODULE,
	.read = sg_read,
	.write = sg_write,
	.poll = sg_poll,
	.ioctl = sg_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = sg_compat_ioctl,
#endif
	.open = sg_open,
	.mmap = sg_mmap,
	.release = sg_release,
	.fasync = sg_fasync,
};

1335
static struct class *sg_sysfs_class;
L
Linus Torvalds 已提交
1336 1337 1338

static int sg_sysfs_valid = 0;

1339
static Sg_device *sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
L
Linus Torvalds 已提交
1340
{
1341
	struct request_queue *q = scsidp->request_queue;
L
Linus Torvalds 已提交
1342 1343
	Sg_device *sdp;
	unsigned long iflags;
1344 1345
	int error;
	u32 k;
L
Linus Torvalds 已提交
1346

J
Jes Sorensen 已提交
1347
	sdp = kzalloc(sizeof(Sg_device), GFP_KERNEL);
L
Linus Torvalds 已提交
1348 1349
	if (!sdp) {
		printk(KERN_WARNING "kmalloc Sg_device failure\n");
1350 1351
		return ERR_PTR(-ENOMEM);
	}
1352

1353 1354
	if (!idr_pre_get(&sg_index_idr, GFP_KERNEL)) {
		printk(KERN_WARNING "idr expansion Sg_device failure\n");
1355
		error = -ENOMEM;
1356
		goto out;
L
Linus Torvalds 已提交
1357 1358
	}

1359
	write_lock_irqsave(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
1360

1361
	error = idr_get_new(&sg_index_idr, sdp, &k);
1362
	if (error) {
1363
		write_unlock_irqrestore(&sg_index_lock, iflags);
1364 1365 1366
		printk(KERN_WARNING "idr allocation Sg_device failure: %d\n",
		       error);
		goto out;
L
Linus Torvalds 已提交
1367 1368 1369 1370 1371 1372 1373 1374 1375 1376
	}

	if (unlikely(k >= SG_MAX_DEVS))
		goto overflow;

	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;
1377
	INIT_LIST_HEAD(&sdp->sfds);
L
Linus Torvalds 已提交
1378
	init_waitqueue_head(&sdp->o_excl_wait);
1379 1380
	sdp->sg_tablesize = min(queue_max_hw_segments(q),
				queue_max_phys_segments(q));
1381
	sdp->index = k;
1382 1383 1384
	kref_init(&sdp->d_ref);

	write_unlock_irqrestore(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
1385

1386
	error = 0;
L
Linus Torvalds 已提交
1387
 out:
1388
	if (error) {
L
Linus Torvalds 已提交
1389
		kfree(sdp);
1390 1391 1392
		return ERR_PTR(error);
	}
	return sdp;
L
Linus Torvalds 已提交
1393 1394

 overflow:
1395 1396
	idr_remove(&sg_index_idr, k);
	write_unlock_irqrestore(&sg_index_lock, iflags);
1397 1398 1399
	sdev_printk(KERN_WARNING, scsidp,
		    "Unable to attach sg device type=%d, minor "
		    "number exceeds %d\n", scsidp->type, SG_MAX_DEVS - 1);
L
Linus Torvalds 已提交
1400 1401 1402 1403 1404
	error = -ENODEV;
	goto out;
}

static int
1405
sg_add(struct device *cl_dev, struct class_interface *cl_intf)
L
Linus Torvalds 已提交
1406
{
1407
	struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
L
Linus Torvalds 已提交
1408 1409 1410
	struct gendisk *disk;
	Sg_device *sdp = NULL;
	struct cdev * cdev = NULL;
1411
	int error;
1412
	unsigned long iflags;
L
Linus Torvalds 已提交
1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429

	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;

1430 1431
	sdp = sg_alloc(disk, scsidp);
	if (IS_ERR(sdp)) {
L
Linus Torvalds 已提交
1432
		printk(KERN_WARNING "sg_alloc failed\n");
1433
		error = PTR_ERR(sdp);
L
Linus Torvalds 已提交
1434 1435 1436
		goto out;
	}

1437
	error = cdev_add(cdev, MKDEV(SCSI_GENERIC_MAJOR, sdp->index), 1);
1438
	if (error)
1439
		goto cdev_add_err;
1440

L
Linus Torvalds 已提交
1441 1442
	sdp->cdev = cdev;
	if (sg_sysfs_valid) {
1443
		struct device *sg_class_member;
L
Linus Torvalds 已提交
1444

1445 1446 1447 1448
		sg_class_member = device_create(sg_sysfs_class, cl_dev->parent,
						MKDEV(SCSI_GENERIC_MAJOR,
						      sdp->index),
						sdp, "%s", disk->disk_name);
1449 1450
		if (IS_ERR(sg_class_member)) {
			printk(KERN_ERR "sg_add: "
1451
			       "device_create failed\n");
1452 1453 1454 1455
			error = PTR_ERR(sg_class_member);
			goto cdev_add_err;
		}
		error = sysfs_create_link(&scsidp->sdev_gendev.kobj,
L
Linus Torvalds 已提交
1456 1457 1458
					  &sg_class_member->kobj, "generic");
		if (error)
			printk(KERN_ERR "sg_add: unable to make symlink "
1459
					"'generic' back to sg%d\n", sdp->index);
L
Linus Torvalds 已提交
1460
	} else
1461
		printk(KERN_WARNING "sg_add: sg_sys Invalid\n");
L
Linus Torvalds 已提交
1462

1463
	sdev_printk(KERN_NOTICE, scsidp,
1464 1465
		    "Attached scsi generic sg%d type %d\n", sdp->index,
		    scsidp->type);
L
Linus Torvalds 已提交
1466

1467
	dev_set_drvdata(cl_dev, sdp);
1468

L
Linus Torvalds 已提交
1469 1470
	return 0;

1471
cdev_add_err:
1472 1473 1474 1475
	write_lock_irqsave(&sg_index_lock, iflags);
	idr_remove(&sg_index_idr, sdp->index);
	write_unlock_irqrestore(&sg_index_lock, iflags);
	kfree(sdp);
1476

L
Linus Torvalds 已提交
1477 1478 1479 1480 1481 1482 1483
out:
	put_disk(disk);
	if (cdev)
		cdev_del(cdev);
	return error;
}

1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506
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 已提交
1507
{
1508 1509
	struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
	Sg_device *sdp = dev_get_drvdata(cl_dev);
L
Linus Torvalds 已提交
1510 1511 1512
	unsigned long iflags;
	Sg_fd *sfp;

1513
	if (!sdp || sdp->detached)
L
Linus Torvalds 已提交
1514
		return;
1515

1516 1517 1518
	SCSI_LOG_TIMEOUT(3, printk("sg_remove: %s\n", sdp->disk->disk_name));

	/* Need a write lock to set sdp->detached. */
1519
	write_lock_irqsave(&sg_index_lock, iflags);
1520
	sdp->detached = 1;
1521
	list_for_each_entry(sfp, &sdp->sfds, sfd_siblings) {
1522 1523
		wake_up_interruptible(&sfp->read_wait);
		kill_fasync(&sfp->async_qp, SIGPOLL, POLL_HUP);
1524 1525 1526 1527
	}
	write_unlock_irqrestore(&sg_index_lock, iflags);

	sysfs_remove_link(&scsidp->sdev_gendev.kobj, "generic");
1528
	device_destroy(sg_sysfs_class, MKDEV(SCSI_GENERIC_MAJOR, sdp->index));
1529 1530
	cdev_del(sdp->cdev);
	sdp->cdev = NULL;
L
Linus Torvalds 已提交
1531

1532
	sg_put_dev(sdp);
L
Linus Torvalds 已提交
1533 1534
}

1535 1536 1537
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 已提交
1538 1539 1540 1541 1542 1543
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);
1544
MODULE_ALIAS_CHARDEV_MAJOR(SCSI_GENERIC_MAJOR);
L
Linus Torvalds 已提交
1545

1546 1547
MODULE_PARM_DESC(scatter_elem_sz, "scatter gather element "
                "size (default: max(SG_SCATTER_SZ, PAGE_SIZE))");
L
Linus Torvalds 已提交
1548 1549 1550 1551 1552 1553 1554 1555
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;

1556 1557 1558 1559
	if (scatter_elem_sz < PAGE_SIZE) {
		scatter_elem_sz = PAGE_SIZE;
		scatter_elem_sz_prev = scatter_elem_sz;
	}
L
Linus Torvalds 已提交
1560 1561
	if (def_reserved_size >= 0)
		sg_big_buff = def_reserved_size;
1562 1563
	else
		def_reserved_size = sg_big_buff;
L
Linus Torvalds 已提交
1564 1565 1566 1567 1568

	rc = register_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0), 
				    SG_MAX_DEVS, "sg");
	if (rc)
		return rc;
1569
        sg_sysfs_class = class_create(THIS_MODULE, "scsi_generic");
L
Linus Torvalds 已提交
1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581
        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;
	}
1582
	class_destroy(sg_sysfs_class);
L
Linus Torvalds 已提交
1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594
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);
1595
	class_destroy(sg_sysfs_class);
L
Linus Torvalds 已提交
1596 1597 1598
	sg_sysfs_valid = 0;
	unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0),
				 SG_MAX_DEVS);
1599
	idr_destroy(&sg_index_idr);
L
Linus Torvalds 已提交
1600 1601
}

F
FUJITA Tomonori 已提交
1602
static int sg_start_req(Sg_request *srp, unsigned char *cmd)
1603
{
1604
	int res;
1605
	struct request *rq;
F
FUJITA Tomonori 已提交
1606 1607 1608 1609
	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;
1610
	unsigned int iov_count = hp->iovec_count;
F
FUJITA Tomonori 已提交
1611 1612 1613
	Sg_scatter_hold *req_schp = &srp->data;
	Sg_scatter_hold *rsv_schp = &sfp->reserve;
	struct request_queue *q = sfp->parentdp->device->request_queue;
1614
	struct rq_map_data *md, map_data;
1615 1616
	int rw = hp->dxfer_direction == SG_DXFER_TO_DEV ? WRITE : READ;

F
FUJITA Tomonori 已提交
1617 1618 1619
	SCSI_LOG_TIMEOUT(4, printk(KERN_INFO "sg_start_req: dxfer_len=%d\n",
				   dxfer_len));

1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633
	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 已提交
1634
	if ((dxfer_len <= 0) || (dxfer_dir == SG_DXFER_NONE))
1635
		return 0;
1636

1637 1638 1639
	if (sg_allow_dio && hp->flags & SG_FLAG_DIRECT_IO &&
	    dxfer_dir != SG_DXFER_UNKNOWN && !iov_count &&
	    !sfp->parentdp->device->host->unchecked_isa_dma &&
1640
	    blk_rq_aligned(q, hp->dxferp, dxfer_len))
1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652
		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;
		}
1653

1654 1655 1656
		md->pages = req_schp->pages;
		md->page_order = req_schp->page_order;
		md->nr_entries = req_schp->k_use_sg;
1657
		md->offset = 0;
1658
		md->null_mapped = hp->dxferp ? 0 : 1;
1659 1660 1661 1662
		if (dxfer_dir == SG_DXFER_TO_FROM_DEV)
			md->from_user = 1;
		else
			md->from_user = 0;
1663 1664
	}

1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688
	if (iov_count) {
		int len, size = sizeof(struct sg_iovec) * iov_count;
		struct iovec *iov;

		iov = kmalloc(size, GFP_ATOMIC);
		if (!iov)
			return -ENOMEM;

		if (copy_from_user(iov, hp->dxferp, size)) {
			kfree(iov);
			return -EFAULT;
		}

		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
1689 1690
		res = blk_rq_map_user(q, rq, md, hp->dxferp,
				      hp->dxfer_len, GFP_ATOMIC);
1691 1692

	if (!res) {
1693
		srp->bio = rq->bio;
1694

1695 1696 1697 1698 1699
		if (!md) {
			req_schp->dio_in_use = 1;
			hp->info |= SG_INFO_DIRECT_IO;
		}
	}
1700
	return res;
L
Linus Torvalds 已提交
1701 1702
}

1703
static int sg_finish_rem_req(Sg_request * srp)
L
Linus Torvalds 已提交
1704
{
1705 1706
	int ret = 0;

L
Linus Torvalds 已提交
1707 1708 1709 1710
	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));
1711 1712
	if (srp->rq) {
		if (srp->bio)
1713
			ret = blk_rq_unmap_user(srp->bio);
1714

1715
		blk_put_request(srp->rq);
1716
	}
1717

1718 1719 1720 1721 1722
	if (srp->res_used)
		sg_unlink_reserve(sfp, srp);
	else
		sg_remove_scat(req_schp);

L
Linus Torvalds 已提交
1723
	sg_remove_request(sfp, srp);
1724 1725

	return ret;
L
Linus Torvalds 已提交
1726 1727 1728 1729 1730
}

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

1734 1735
	schp->pages = kzalloc(sg_bufflen, gfp_flags);
	if (!schp->pages)
L
Linus Torvalds 已提交
1736 1737
		return -ENOMEM;
	schp->sglist_len = sg_bufflen;
1738
	return tablesize;	/* number of scat_gath elements allocated */
L
Linus Torvalds 已提交
1739 1740 1741 1742 1743
}

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

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

	/* 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 */

1763 1764 1765 1766 1767 1768 1769 1770
	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;
	}
1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784

	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) {

1785
		num = (rem_sz > scatter_elem_sz_prev) ?
1786 1787 1788 1789 1790
			scatter_elem_sz_prev : rem_sz;

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

1792 1793 1794 1795 1796 1797
		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;
			}
		}
1798

1799 1800
		SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k=%d, num=%d, "
				 "ret_sz=%d\n", k, num, ret_sz));
1801 1802
	}		/* end of for loop */

1803
	schp->page_order = order;
1804
	schp->k_use_sg = k;
1805 1806
	SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k_use_sg=%d, "
			 "rem_sz=%d\n", k, rem_sz));
1807 1808 1809 1810

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

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

	return -ENOMEM;
L
Linus Torvalds 已提交
1820 1821 1822 1823 1824 1825
}

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));
1826
	if (schp->pages && schp->sglist_len > 0) {
1827
		if (!schp->dio_in_use) {
L
Linus Torvalds 已提交
1828 1829
			int k;

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

1837
			kfree(schp->pages);
L
Linus Torvalds 已提交
1838
		}
1839
	}
L
Linus Torvalds 已提交
1840 1841 1842 1843 1844 1845 1846
	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;
1847
	int k, num;
L
Linus Torvalds 已提交
1848 1849 1850 1851 1852

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

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

L
Linus Torvalds 已提交
1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896
	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;
1897
	int k, num, rem;
L
Linus Torvalds 已提交
1898 1899 1900

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

1903 1904
	num = 1 << (PAGE_SHIFT + rsv_schp->page_order);
	for (k = 0; k < rsv_schp->k_use_sg; k++) {
1905 1906 1907
		if (rem <= num) {
			req_schp->k_use_sg = k + 1;
			req_schp->sglist_len = rsv_schp->sglist_len;
1908
			req_schp->pages = rsv_schp->pages;
1909 1910

			req_schp->bufflen = size;
1911
			req_schp->page_order = rsv_schp->page_order;
1912 1913 1914
			break;
		} else
			rem -= num;
L
Linus Torvalds 已提交
1915
	}
1916 1917 1918

	if (k >= rsv_schp->k_use_sg)
		SCSI_LOG_TIMEOUT(1, printk("sg_link_reserve: BAD size\n"));
L
Linus Torvalds 已提交
1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929
}

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;
1930 1931
	req_schp->pages = NULL;
	req_schp->page_order = 0;
L
Linus Torvalds 已提交
1932 1933 1934 1935 1936 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
	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;
已提交
1993
		resp->header.duration = jiffies_to_msecs(jiffies);
L
Linus Torvalds 已提交
1994 1995 1996 1997 1998 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
	}
	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;
2036
	int bufflen;
L
Linus Torvalds 已提交
2037

2038
	sfp = kzalloc(sizeof(*sfp), GFP_ATOMIC | __GFP_NOWARN);
L
Linus Torvalds 已提交
2039 2040
	if (!sfp)
		return NULL;
2041

L
Linus Torvalds 已提交
2042 2043 2044
	init_waitqueue_head(&sfp->read_wait);
	rwlock_init(&sfp->rq_list_lock);

2045
	kref_init(&sfp->f_ref);
L
Linus Torvalds 已提交
2046 2047 2048 2049 2050 2051 2052 2053
	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;
2054
	write_lock_irqsave(&sg_index_lock, iflags);
2055
	list_add_tail(&sfp->sfd_siblings, &sdp->sfds);
2056
	write_unlock_irqrestore(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
2057
	SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp: sfp=0x%p\n", sfp));
2058 2059 2060
	if (unlikely(sg_big_buff != def_reserved_size))
		sg_big_buff = def_reserved_size;

2061
	bufflen = min_t(int, sg_big_buff,
2062
			queue_max_sectors(sdp->device->request_queue) * 512);
2063
	sg_build_reserve(sfp, bufflen);
L
Linus Torvalds 已提交
2064 2065
	SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp:   bufflen=%d, k_use_sg=%d\n",
			   sfp->reserve.bufflen, sfp->reserve.k_use_sg));
2066 2067 2068

	kref_get(&sdp->d_ref);
	__module_get(THIS_MODULE);
L
Linus Torvalds 已提交
2069 2070 2071
	return sfp;
}

2072
static void sg_remove_sfp_usercontext(struct work_struct *work)
L
Linus Torvalds 已提交
2073
{
2074 2075 2076 2077 2078 2079
	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 已提交
2080 2081

	if (sfp->reserve.bufflen > 0) {
2082 2083 2084 2085
		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 已提交
2086 2087
		sg_remove_scat(&sfp->reserve);
	}
2088 2089 2090 2091 2092

	SCSI_LOG_TIMEOUT(6,
		printk("sg_remove_sfp: %s, sfp=0x%p\n",
			sdp->disk->disk_name,
			sfp));
2093
	kfree(sfp);
2094 2095 2096 2097

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

2100
static void sg_remove_sfp(struct kref *kref)
L
Linus Torvalds 已提交
2101
{
2102 2103 2104
	struct sg_fd *sfp = container_of(kref, struct sg_fd, f_ref);
	struct sg_device *sdp = sfp->parentdp;
	unsigned long iflags;
L
Linus Torvalds 已提交
2105

2106
	write_lock_irqsave(&sg_index_lock, iflags);
2107
	list_del(&sfp->sfd_siblings);
2108 2109
	write_unlock_irqrestore(&sg_index_lock, iflags);
	wake_up_interruptible(&sdp->o_excl_wait);
L
Linus Torvalds 已提交
2110

2111 2112
	INIT_WORK(&sfp->ew.work, sg_remove_sfp_usercontext);
	schedule_work(&sfp->ew.work);
L
Linus Torvalds 已提交
2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129
}

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
2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140
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 已提交
2141 2142 2143
static int
sg_last_dev(void)
{
2144
	int k = -1;
L
Linus Torvalds 已提交
2145 2146
	unsigned long iflags;

2147 2148 2149
	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 已提交
2150 2151 2152 2153
	return k + 1;		/* origin 1 */
}
#endif

2154 2155
/* must be called with sg_index_lock held */
static Sg_device *sg_lookup_dev(int dev)
L
Linus Torvalds 已提交
2156
{
2157 2158
	return idr_find(&sg_index_idr, dev);
}
L
Linus Torvalds 已提交
2159

2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176
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);
2177

L
Linus Torvalds 已提交
2178 2179 2180
	return sdp;
}

2181 2182 2183 2184 2185
static void sg_put_dev(struct sg_device *sdp)
{
	kref_put(&sdp->d_ref, sg_device_destroy);
}

L
Linus Torvalds 已提交
2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196
#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);
2197 2198
static const struct file_operations adio_fops = {
	.owner = THIS_MODULE,
L
Linus Torvalds 已提交
2199
	.open = sg_proc_single_open_adio,
2200 2201
	.read = seq_read,
	.llseek = seq_lseek,
L
Linus Torvalds 已提交
2202 2203 2204 2205 2206 2207 2208
	.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);
2209 2210
static const struct file_operations dressz_fops = {
	.owner = THIS_MODULE,
L
Linus Torvalds 已提交
2211
	.open = sg_proc_single_open_dressz,
2212 2213
	.read = seq_read,
	.llseek = seq_lseek,
L
Linus Torvalds 已提交
2214 2215 2216 2217 2218 2219
	.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);
2220 2221
static const struct file_operations version_fops = {
	.owner = THIS_MODULE,
L
Linus Torvalds 已提交
2222
	.open = sg_proc_single_open_version,
2223 2224
	.read = seq_read,
	.llseek = seq_lseek,
L
Linus Torvalds 已提交
2225 2226 2227 2228 2229
	.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);
2230 2231
static const struct file_operations devhdr_fops = {
	.owner = THIS_MODULE,
L
Linus Torvalds 已提交
2232
	.open = sg_proc_single_open_devhdr,
2233 2234
	.read = seq_read,
	.llseek = seq_lseek,
L
Linus Torvalds 已提交
2235 2236 2237 2238 2239 2240 2241 2242
	.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);
2243 2244
static const struct file_operations dev_fops = {
	.owner = THIS_MODULE,
L
Linus Torvalds 已提交
2245
	.open = sg_proc_open_dev,
2246 2247
	.read = seq_read,
	.llseek = seq_lseek,
L
Linus Torvalds 已提交
2248 2249
	.release = seq_release,
};
J
James Morris 已提交
2250
static const struct seq_operations dev_seq_ops = {
L
Linus Torvalds 已提交
2251 2252 2253 2254 2255 2256 2257 2258
	.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);
2259 2260
static const struct file_operations devstrs_fops = {
	.owner = THIS_MODULE,
L
Linus Torvalds 已提交
2261
	.open = sg_proc_open_devstrs,
2262 2263
	.read = seq_read,
	.llseek = seq_lseek,
L
Linus Torvalds 已提交
2264 2265
	.release = seq_release,
};
J
James Morris 已提交
2266
static const struct seq_operations devstrs_seq_ops = {
L
Linus Torvalds 已提交
2267 2268 2269 2270 2271 2272 2273 2274
	.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);
2275 2276
static const struct file_operations debug_fops = {
	.owner = THIS_MODULE,
L
Linus Torvalds 已提交
2277
	.open = sg_proc_open_debug,
2278 2279
	.read = seq_read,
	.llseek = seq_lseek,
L
Linus Torvalds 已提交
2280 2281
	.release = seq_release,
};
J
James Morris 已提交
2282
static const struct seq_operations debug_seq_ops = {
L
Linus Torvalds 已提交
2283 2284 2285 2286 2287 2288 2289 2290 2291
	.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;
2292
	const struct file_operations * fops;
L
Linus Torvalds 已提交
2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308
};

static struct sg_proc_leaf sg_proc_leaf_arr[] = {
	{"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)
{
	int k, mask;
2309
	int num_leaves = ARRAY_SIZE(sg_proc_leaf_arr);
L
Linus Torvalds 已提交
2310 2311
	struct sg_proc_leaf * leaf;

2312
	sg_proc_sgp = proc_mkdir(sg_proc_sg_dirname, NULL);
L
Linus Torvalds 已提交
2313 2314 2315 2316 2317
	if (!sg_proc_sgp)
		return 1;
	for (k = 0; k < num_leaves; ++k) {
		leaf = &sg_proc_leaf_arr[k];
		mask = leaf->fops->write ? S_IRUGO | S_IWUSR : S_IRUGO;
2318
		proc_create(leaf->name, mask, sg_proc_sgp, leaf->fops);
L
Linus Torvalds 已提交
2319 2320 2321 2322 2323 2324 2325 2326
	}
	return 0;
}

static void
sg_proc_cleanup(void)
{
	int k;
2327
	int num_leaves = ARRAY_SIZE(sg_proc_leaf_arr);
L
Linus Torvalds 已提交
2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 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

	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)
{
	int num;
	char buff[11];

	if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
		return -EACCES;
	num = (count < 10) ? count : 10;
	if (copy_from_user(buff, buffer, num))
		return -EFAULT;
	buff[num] = '\0';
	sg_allow_dio = simple_strtoul(buff, NULL, 10) ? 1 : 0;
	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)
{
	int num;
	unsigned long k = ULONG_MAX;
	char buff[11];

	if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
		return -EACCES;
	num = (count < 10) ? count : 10;
	if (copy_from_user(buff, buffer, num))
		return -EFAULT;
	buff[num] = '\0';
	k = simple_strtoul(buff, NULL, 10);
	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);

2425
	s->private = it;
L
Linus Torvalds 已提交
2426 2427
	if (! it)
		return NULL;
2428

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

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

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

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

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;
2459
	unsigned long iflags;
L
Linus Torvalds 已提交
2460

2461 2462
	read_lock_irqsave(&sg_index_lock, iflags);
	sdp = it ? sg_lookup_dev(it->index) : NULL;
L
Linus Torvalds 已提交
2463 2464 2465 2466 2467 2468 2469 2470 2471 2472
	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");
2473
	read_unlock_irqrestore(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486
	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;
2487
	unsigned long iflags;
L
Linus Torvalds 已提交
2488

2489 2490
	read_lock_irqsave(&sg_index_lock, iflags);
	sdp = it ? sg_lookup_dev(it->index) : NULL;
L
Linus Torvalds 已提交
2491 2492 2493 2494 2495
	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");
2496
	read_unlock_irqrestore(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
2497 2498 2499
	return 0;
}

2500
/* must be called while holding sg_index_lock */
L
Linus Torvalds 已提交
2501 2502 2503 2504 2505 2506 2507
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;
已提交
2508
	unsigned int ms;
L
Linus Torvalds 已提交
2509

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

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;
2575
	unsigned long iflags;
L
Linus Torvalds 已提交
2576 2577

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

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

2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599
		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",
			   sdp->sg_tablesize, sdp->exclude);
L
Linus Torvalds 已提交
2600 2601
		sg_proc_debug_helper(s, sdp);
	}
2602
	read_unlock_irqrestore(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
2603 2604 2605 2606 2607 2608 2609
	return 0;
}

#endif				/* CONFIG_SCSI_PROC_FS */

module_init(init_sg);
module_exit(exit_sg);