sg.c 69.4 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

/*
 *  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>
41
#include <linux/slab.h>
L
Linus Torvalds 已提交
42 43 44 45 46
#include <linux/fcntl.h>
#include <linux/init.h>
#include <linux/poll.h>
#include <linux/moduleparam.h>
#include <linux/cdev.h>
47
#include <linux/idr.h>
L
Linus Torvalds 已提交
48 49 50
#include <linux/seq_file.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
51
#include <linux/blktrace_api.h>
52
#include <linux/mutex.h>
53
#include <linux/ratelimit.h>
L
Linus Torvalds 已提交
54 55

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

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;

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

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

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

107 108
static DEFINE_MUTEX(sg_mutex);

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

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

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

typedef struct sg_fd {		/* holds the state of a file descriptor */
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 172
} 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 */
173
	u32 index;		/* device index number */
174
	struct list_head sfds;
L
Linus Torvalds 已提交
175 176 177 178 179
	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>] */
180
	struct kref d_ref;
L
Linus Torvalds 已提交
181 182
} Sg_device;

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

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

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

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

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

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

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

	/* 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);
248 249
	if (retval)
		goto sg_put;
L
Linus Torvalds 已提交
250

251 252 253 254
	retval = scsi_autopm_get_device(sdp->device);
	if (retval)
		goto sdp_put;

L
Linus Torvalds 已提交
255 256 257 258 259 260 261 262 263 264 265 266
	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;
		}
267
		if (!list_empty(&sdp->sfds) && (flags & O_NONBLOCK)) {
L
Linus Torvalds 已提交
268 269 270
			retval = -EBUSY;
			goto error_out;
		}
271 272
		res = wait_event_interruptible(sdp->o_excl_wait,
					   ((!list_empty(&sdp->sfds) || sdp->exclude) ? 0 : (sdp->exclude = 1)));
L
Linus Torvalds 已提交
273 274 275 276 277 278 279 280 281
		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;
		}
282
		res = wait_event_interruptible(sdp->o_excl_wait, !sdp->exclude);
L
Linus Torvalds 已提交
283 284 285 286 287 288 289 290 291
		if (res) {
			retval = res;	/* -ERESTARTSYS because signal hit process */
			goto error_out;
		}
	}
	if (sdp->detached) {
		retval = -ENODEV;
		goto error_out;
	}
292
	if (list_empty(&sdp->sfds)) {	/* no existing opens on this device */
L
Linus Torvalds 已提交
293
		sdp->sgdebug = 0;
294
		q = sdp->device->request_queue;
295
		sdp->sg_tablesize = queue_max_segments(q);
L
Linus Torvalds 已提交
296 297 298 299
	}
	if ((sfp = sg_add_sfp(sdp, dev)))
		filp->private_data = sfp;
	else {
300
		if (flags & O_EXCL) {
L
Linus Torvalds 已提交
301
			sdp->exclude = 0;	/* undo if error */
302 303
			wake_up_interruptible(&sdp->o_excl_wait);
		}
L
Linus Torvalds 已提交
304 305 306
		retval = -ENOMEM;
		goto error_out;
	}
307 308
	retval = 0;
error_out:
309 310 311
	if (retval) {
		scsi_autopm_put_device(sdp->device);
sdp_put:
312
		scsi_device_put(sdp->device);
313
	}
314 315 316
sg_put:
	if (sdp)
		sg_put_dev(sdp);
317
	mutex_unlock(&sg_mutex);
L
Linus Torvalds 已提交
318 319 320 321 322 323 324 325 326 327 328 329 330
	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));
331 332 333 334

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

335
	scsi_autopm_put_device(sdp->device);
336
	kref_put(&sfp->f_ref, sg_remove_sfp);
L
Linus Torvalds 已提交
337 338 339 340 341 342 343 344 345 346 347
	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;
已提交
348 349
	struct sg_header *old_hdr = NULL;
	int retval = 0;
L
Linus Torvalds 已提交
350 351 352 353 354

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

L
Linus Torvalds 已提交
356 357 358
	if (!access_ok(VERIFY_WRITE, buf, count))
		return -EFAULT;
	if (sfp->force_packid && (count >= SZ_SG_HEADER)) {
已提交
359 360 361 362 363 364 365 366
		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 已提交
367
			if (count >= SZ_SG_IO_HDR) {
已提交
368 369 370 371 372 373 374 375 376 377 378 379 380 381
				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 已提交
382 383
			}
		} else
已提交
384
			req_pack_id = old_hdr->pack_id;
L
Linus Torvalds 已提交
385 386 387
	}
	srp = sg_get_rq_mark(sfp, req_pack_id);
	if (!srp) {		/* now wait on packet to arrive */
已提交
388 389 390 391 392 393 394 395
		if (sdp->detached) {
			retval = -ENODEV;
			goto free_old_hdr;
		}
		if (filp->f_flags & O_NONBLOCK) {
			retval = -EAGAIN;
			goto free_old_hdr;
		}
396
		retval = wait_event_interruptible(sfp->read_wait,
397
			(sdp->detached ||
398
			(srp = sg_get_rq_mark(sfp, req_pack_id))));
399 400 401 402 403
		if (sdp->detached) {
			retval = -ENODEV;
			goto free_old_hdr;
		}
		if (retval) {
已提交
404 405
			/* -ERESTARTSYS as signal hit process */
			goto free_old_hdr;
L
Linus Torvalds 已提交
406 407
		}
	}
已提交
408 409 410 411
	if (srp->header.interface_id != '\0') {
		retval = sg_new_read(sfp, buf, count, srp);
		goto free_old_hdr;
	}
L
Linus Torvalds 已提交
412 413

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

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

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

	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)
555 556
		return sg_new_write(sfp, filp, buf, count,
				    blocking, 0, 0, NULL);
L
Linus Torvalds 已提交
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 601
	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;
602 603 604 605
	if (hp->dxfer_direction == SG_DXFER_TO_DEV)
		hp->dxferp = (char __user *)buf + cmd_size;
	else
		hp->dxferp = NULL;
L
Linus Torvalds 已提交
606 607 608 609 610 611 612 613 614 615 616 617
	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.
	 */
618 619
	if (hp->dxfer_direction == SG_DXFER_TO_FROM_DEV) {
		static char cmd[TASK_COMM_LEN];
620 621 622 623 624 625 626 627 628
		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);
629 630 631
			strcpy(cmd, current->comm);
		}
	}
L
Linus Torvalds 已提交
632 633 634 635 636
	k = sg_common_write(sfp, srp, cmnd, sfp->timeout, blocking);
	return (k < 0) ? k : count;
}

static ssize_t
637
sg_new_write(Sg_fd *sfp, struct file *file, const char __user *buf,
638
		 size_t count, int blocking, int read_only, int sg_io_owned,
639
		 Sg_request **o_srp)
L
Linus Torvalds 已提交
640 641 642 643
{
	int k;
	Sg_request *srp;
	sg_io_hdr_t *hp;
644
	unsigned char cmnd[MAX_COMMAND_SIZE];
L
Linus Torvalds 已提交
645 646 647 648 649 650 651 652 653 654 655 656 657
	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;
	}
658
	srp->sg_io_owned = sg_io_owned;
L
Linus Torvalds 已提交
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 694 695
	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;
	}
696
	if (read_only && sg_allow_access(file, cmnd)) {
L
Linus Torvalds 已提交
697 698 699 700 701 702 703 704 705 706 707 708 709 710 711
		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)
{
712
	int k, data_dir;
L
Linus Torvalds 已提交
713 714 715 716 717 718 719 720 721 722 723 724 725 726
	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));

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

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

	srp->rq->timeout = timeout;
758
	kref_get(&sfp->f_ref); /* sg_rq_end_io() does kref_put(). */
759 760 761
	blk_execute_rq_nowait(sdp->device->request_queue, sdp->disk,
			      srp->rq, 1, sg_rq_end_io);
	return 0;
L
Linus Torvalds 已提交
762 763
}

J
Jörn Engel 已提交
764 765 766 767 768 769 770 771 772 773 774
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;
}

L
Linus Torvalds 已提交
775
static int
776
sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
L
Linus Torvalds 已提交
777 778 779 780 781 782 783 784 785 786 787
{
	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;
788

L
Linus Torvalds 已提交
789 790 791 792 793 794
	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:
795 796 797 798 799 800 801 802 803 804
		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;
805
		result = wait_event_interruptible(sfp->read_wait,
J
Jörn Engel 已提交
806
			(srp_done(sfp, srp) || sdp->detached));
807 808 809 810 811
		if (sdp->detached)
			return -ENODEV;
		write_lock_irq(&sfp->rq_list_lock);
		if (srp->done) {
			srp->done = 2;
812
			write_unlock_irq(&sfp->rq_list_lock);
813 814
			result = sg_new_read(sfp, p, SZ_SG_IO_HDR, srp);
			return (result < 0) ? result : 0;
L
Linus Torvalds 已提交
815
		}
816 817 818
		srp->orphan = 1;
		write_unlock_irq(&sfp->rq_list_lock);
		return result;	/* -ERESTARTSYS because signal hit process */
L
Linus Torvalds 已提交
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 909 910 911 912
	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;
913
		val = min_t(int, val,
914
			    queue_max_sectors(sdp->device->request_queue) * 512);
L
Linus Torvalds 已提交
915 916 917 918 919 920 921 922
		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:
923
		val = min_t(int, sfp->reserve.bufflen,
924
			    queue_max_sectors(sdp->device->request_queue) * 512);
L
Linus Torvalds 已提交
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 954 955 956 957
		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 {
已提交
958 959 960 961 962 963 964
			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 已提交
965 966 967 968 969 970 971 972 973 974
			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;
已提交
975 976 977 978 979 980 981 982 983
					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 已提交
984
					rinfo[val].orphan = srp->orphan;
已提交
985 986 987 988 989 990
					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 已提交
991 992 993
				}
			}
			read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
已提交
994 995 996 997 998
			result = __copy_to_user(p, rinfo, 
						SZ_SG_REQ_INFO * SG_MAX_QUEUE);
			result = result ? -EFAULT : 0;
			kfree(rinfo);
			return result;
L
Linus Torvalds 已提交
999 1000 1001 1002 1003 1004 1005 1006 1007
		}
	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) {
1008
			if (scsi_host_in_recovery(sdp->device->host))
L
Linus Torvalds 已提交
1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020
				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 已提交
1021 1022 1023
		case SG_SCSI_RESET_TARGET:
			val = SCSI_TRY_RESET_TARGET;
			break;
L
Linus Torvalds 已提交
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
		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;
1046
			if (sg_allow_access(filp, &opcode))
L
Linus Torvalds 已提交
1047 1048
				return -EPERM;
		}
1049
		return sg_scsi_ioctl(sdp->device->request_queue, NULL, filp->f_mode, p);
L
Linus Torvalds 已提交
1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
	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);
1063
	case BLKSECTGET:
1064
		return put_user(queue_max_sectors(sdp->device->request_queue) * 512,
1065
				ip);
1066 1067 1068
	case BLKTRACESETUP:
		return blk_trace_setup(sdp->device->request_queue,
				       sdp->disk->disk_name,
1069
				       MKDEV(SCSI_GENERIC_MAJOR, sdp->index),
1070
				       NULL,
1071 1072 1073 1074 1075 1076 1077
				       (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 已提交
1078 1079 1080 1081 1082 1083 1084
	default:
		if (read_only)
			return -EPERM;	/* don't know so take safe approach */
		return scsi_ioctl(sdp->device, cmd_in, p);
	}
}

1085 1086 1087 1088 1089
static long
sg_unlocked_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
{
	int ret;

1090
	mutex_lock(&sg_mutex);
1091
	ret = sg_ioctl(filp, cmd_in, arg);
1092
	mutex_unlock(&sg_mutex);
1093 1094 1095 1096

	return ret;
}

L
Linus Torvalds 已提交
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
#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_RESERVED;
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,
1344
	.unlocked_ioctl = sg_unlocked_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

1373 1374
	if (!idr_pre_get(&sg_index_idr, GFP_KERNEL)) {
		printk(KERN_WARNING "idr expansion Sg_device failure\n");
1375
		error = -ENOMEM;
1376
		goto out;
L
Linus Torvalds 已提交
1377 1378
	}

1379
	write_lock_irqsave(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
1380

1381
	error = idr_get_new(&sg_index_idr, sdp, &k);
1382
	if (error) {
1383
		write_unlock_irqrestore(&sg_index_lock, iflags);
1384 1385 1386
		printk(KERN_WARNING "idr allocation Sg_device failure: %d\n",
		       error);
		goto out;
L
Linus Torvalds 已提交
1387 1388 1389 1390 1391 1392 1393 1394 1395 1396
	}

	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;
1397
	INIT_LIST_HEAD(&sdp->sfds);
L
Linus Torvalds 已提交
1398
	init_waitqueue_head(&sdp->o_excl_wait);
1399
	sdp->sg_tablesize = queue_max_segments(q);
1400
	sdp->index = k;
1401 1402 1403
	kref_init(&sdp->d_ref);

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

1405
	error = 0;
L
Linus Torvalds 已提交
1406
 out:
1407
	if (error) {
L
Linus Torvalds 已提交
1408
		kfree(sdp);
1409 1410 1411
		return ERR_PTR(error);
	}
	return sdp;
L
Linus Torvalds 已提交
1412 1413

 overflow:
1414 1415
	idr_remove(&sg_index_idr, k);
	write_unlock_irqrestore(&sg_index_lock, iflags);
1416 1417 1418
	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 已提交
1419 1420 1421 1422 1423
	error = -ENODEV;
	goto out;
}

static int
1424
sg_add(struct device *cl_dev, struct class_interface *cl_intf)
L
Linus Torvalds 已提交
1425
{
1426
	struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
L
Linus Torvalds 已提交
1427 1428 1429
	struct gendisk *disk;
	Sg_device *sdp = NULL;
	struct cdev * cdev = NULL;
1430
	int error;
1431
	unsigned long iflags;
L
Linus Torvalds 已提交
1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448

	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;

1449 1450
	sdp = sg_alloc(disk, scsidp);
	if (IS_ERR(sdp)) {
L
Linus Torvalds 已提交
1451
		printk(KERN_WARNING "sg_alloc failed\n");
1452
		error = PTR_ERR(sdp);
L
Linus Torvalds 已提交
1453 1454 1455
		goto out;
	}

1456
	error = cdev_add(cdev, MKDEV(SCSI_GENERIC_MAJOR, sdp->index), 1);
1457
	if (error)
1458
		goto cdev_add_err;
1459

L
Linus Torvalds 已提交
1460 1461
	sdp->cdev = cdev;
	if (sg_sysfs_valid) {
1462
		struct device *sg_class_member;
L
Linus Torvalds 已提交
1463

1464 1465 1466 1467
		sg_class_member = device_create(sg_sysfs_class, cl_dev->parent,
						MKDEV(SCSI_GENERIC_MAJOR,
						      sdp->index),
						sdp, "%s", disk->disk_name);
1468 1469
		if (IS_ERR(sg_class_member)) {
			printk(KERN_ERR "sg_add: "
1470
			       "device_create failed\n");
1471 1472 1473 1474
			error = PTR_ERR(sg_class_member);
			goto cdev_add_err;
		}
		error = sysfs_create_link(&scsidp->sdev_gendev.kobj,
L
Linus Torvalds 已提交
1475 1476 1477
					  &sg_class_member->kobj, "generic");
		if (error)
			printk(KERN_ERR "sg_add: unable to make symlink "
1478
					"'generic' back to sg%d\n", sdp->index);
L
Linus Torvalds 已提交
1479
	} else
1480
		printk(KERN_WARNING "sg_add: sg_sys Invalid\n");
L
Linus Torvalds 已提交
1481

1482
	sdev_printk(KERN_NOTICE, scsidp,
1483 1484
		    "Attached scsi generic sg%d type %d\n", sdp->index,
		    scsidp->type);
L
Linus Torvalds 已提交
1485

1486
	dev_set_drvdata(cl_dev, sdp);
1487

L
Linus Torvalds 已提交
1488 1489
	return 0;

1490
cdev_add_err:
1491 1492 1493 1494
	write_lock_irqsave(&sg_index_lock, iflags);
	idr_remove(&sg_index_idr, sdp->index);
	write_unlock_irqrestore(&sg_index_lock, iflags);
	kfree(sdp);
1495

L
Linus Torvalds 已提交
1496 1497 1498 1499 1500 1501 1502
out:
	put_disk(disk);
	if (cdev)
		cdev_del(cdev);
	return error;
}

1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
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 已提交
1526
{
1527 1528
	struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
	Sg_device *sdp = dev_get_drvdata(cl_dev);
L
Linus Torvalds 已提交
1529 1530 1531
	unsigned long iflags;
	Sg_fd *sfp;

1532
	if (!sdp || sdp->detached)
L
Linus Torvalds 已提交
1533
		return;
1534

1535 1536 1537
	SCSI_LOG_TIMEOUT(3, printk("sg_remove: %s\n", sdp->disk->disk_name));

	/* Need a write lock to set sdp->detached. */
1538
	write_lock_irqsave(&sg_index_lock, iflags);
1539
	sdp->detached = 1;
1540
	list_for_each_entry(sfp, &sdp->sfds, sfd_siblings) {
1541 1542
		wake_up_interruptible(&sfp->read_wait);
		kill_fasync(&sfp->async_qp, SIGPOLL, POLL_HUP);
1543 1544 1545 1546
	}
	write_unlock_irqrestore(&sg_index_lock, iflags);

	sysfs_remove_link(&scsidp->sdev_gendev.kobj, "generic");
1547
	device_destroy(sg_sysfs_class, MKDEV(SCSI_GENERIC_MAJOR, sdp->index));
1548 1549
	cdev_del(sdp->cdev);
	sdp->cdev = NULL;
L
Linus Torvalds 已提交
1550

1551
	sg_put_dev(sdp);
L
Linus Torvalds 已提交
1552 1553
}

1554 1555 1556
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 已提交
1557 1558 1559 1560 1561 1562
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);
1563
MODULE_ALIAS_CHARDEV_MAJOR(SCSI_GENERIC_MAJOR);
L
Linus Torvalds 已提交
1564

1565 1566
MODULE_PARM_DESC(scatter_elem_sz, "scatter gather element "
                "size (default: max(SG_SCATTER_SZ, PAGE_SIZE))");
L
Linus Torvalds 已提交
1567 1568 1569 1570 1571 1572 1573 1574
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;

1575 1576 1577 1578
	if (scatter_elem_sz < PAGE_SIZE) {
		scatter_elem_sz = PAGE_SIZE;
		scatter_elem_sz_prev = scatter_elem_sz;
	}
L
Linus Torvalds 已提交
1579 1580
	if (def_reserved_size >= 0)
		sg_big_buff = def_reserved_size;
1581 1582
	else
		def_reserved_size = sg_big_buff;
L
Linus Torvalds 已提交
1583 1584 1585 1586 1587

	rc = register_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0), 
				    SG_MAX_DEVS, "sg");
	if (rc)
		return rc;
1588
        sg_sysfs_class = class_create(THIS_MODULE, "scsi_generic");
L
Linus Torvalds 已提交
1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600
        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;
	}
1601
	class_destroy(sg_sysfs_class);
L
Linus Torvalds 已提交
1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613
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);
1614
	class_destroy(sg_sysfs_class);
L
Linus Torvalds 已提交
1615 1616 1617
	sg_sysfs_valid = 0;
	unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0),
				 SG_MAX_DEVS);
1618
	idr_destroy(&sg_index_idr);
L
Linus Torvalds 已提交
1619 1620
}

F
FUJITA Tomonori 已提交
1621
static int sg_start_req(Sg_request *srp, unsigned char *cmd)
1622
{
1623
	int res;
1624
	struct request *rq;
F
FUJITA Tomonori 已提交
1625 1626 1627 1628
	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;
1629
	unsigned int iov_count = hp->iovec_count;
F
FUJITA Tomonori 已提交
1630 1631 1632
	Sg_scatter_hold *req_schp = &srp->data;
	Sg_scatter_hold *rsv_schp = &sfp->reserve;
	struct request_queue *q = sfp->parentdp->device->request_queue;
1633
	struct rq_map_data *md, map_data;
1634 1635
	int rw = hp->dxfer_direction == SG_DXFER_TO_DEV ? WRITE : READ;

F
FUJITA Tomonori 已提交
1636 1637 1638
	SCSI_LOG_TIMEOUT(4, printk(KERN_INFO "sg_start_req: dxfer_len=%d\n",
				   dxfer_len));

1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652
	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 已提交
1653
	if ((dxfer_len <= 0) || (dxfer_dir == SG_DXFER_NONE))
1654
		return 0;
1655

1656 1657 1658
	if (sg_allow_dio && hp->flags & SG_FLAG_DIRECT_IO &&
	    dxfer_dir != SG_DXFER_UNKNOWN && !iov_count &&
	    !sfp->parentdp->device->host->unchecked_isa_dma &&
1659
	    blk_rq_aligned(q, (unsigned long)hp->dxferp, dxfer_len))
1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671
		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;
		}
1672

1673 1674 1675
		md->pages = req_schp->pages;
		md->page_order = req_schp->page_order;
		md->nr_entries = req_schp->k_use_sg;
1676
		md->offset = 0;
1677
		md->null_mapped = hp->dxferp ? 0 : 1;
1678 1679 1680 1681
		if (dxfer_dir == SG_DXFER_TO_FROM_DEV)
			md->from_user = 1;
		else
			md->from_user = 0;
1682 1683
	}

1684 1685 1686 1687
	if (iov_count) {
		int len, size = sizeof(struct sg_iovec) * iov_count;
		struct iovec *iov;

J
Julia Lawall 已提交
1688 1689 1690
		iov = memdup_user(hp->dxferp, size);
		if (IS_ERR(iov))
			return PTR_ERR(iov);
1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702

		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
1703 1704
		res = blk_rq_map_user(q, rq, md, hp->dxferp,
				      hp->dxfer_len, GFP_ATOMIC);
1705 1706

	if (!res) {
1707
		srp->bio = rq->bio;
1708

1709 1710 1711 1712 1713
		if (!md) {
			req_schp->dio_in_use = 1;
			hp->info |= SG_INFO_DIRECT_IO;
		}
	}
1714
	return res;
L
Linus Torvalds 已提交
1715 1716
}

1717
static int sg_finish_rem_req(Sg_request * srp)
L
Linus Torvalds 已提交
1718
{
1719 1720
	int ret = 0;

L
Linus Torvalds 已提交
1721 1722 1723 1724
	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));
1725 1726
	if (srp->rq) {
		if (srp->bio)
1727
			ret = blk_rq_unmap_user(srp->bio);
1728

1729
		blk_put_request(srp->rq);
1730
	}
1731

1732 1733 1734 1735 1736
	if (srp->res_used)
		sg_unlink_reserve(sfp, srp);
	else
		sg_remove_scat(req_schp);

L
Linus Torvalds 已提交
1737
	sg_remove_request(sfp, srp);
1738 1739

	return ret;
L
Linus Torvalds 已提交
1740 1741 1742 1743 1744
}

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

1748 1749
	schp->pages = kzalloc(sg_bufflen, gfp_flags);
	if (!schp->pages)
L
Linus Torvalds 已提交
1750 1751
		return -ENOMEM;
	schp->sglist_len = sg_bufflen;
1752
	return tablesize;	/* number of scat_gath elements allocated */
L
Linus Torvalds 已提交
1753 1754 1755 1756 1757
}

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

1763
	if (blk_size < 0)
L
Linus Torvalds 已提交
1764 1765 1766
		return -EFAULT;
	if (0 == blk_size)
		++blk_size;	/* don't know why */
F
FUJITA Tomonori 已提交
1767 1768
	/* round request up to next highest SG_SECTOR_SZ byte boundary */
	blk_size = ALIGN(blk_size, SG_SECTOR_SZ);
L
Linus Torvalds 已提交
1769 1770
	SCSI_LOG_TIMEOUT(4, printk("sg_build_indirect: buff_size=%d, blk_size=%d\n",
				   buff_size, blk_size));
1771 1772 1773 1774 1775 1776

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

1777 1778 1779 1780 1781 1782 1783 1784
	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;
	}
1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798

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

1799
		num = (rem_sz > scatter_elem_sz_prev) ?
1800 1801 1802 1803 1804
			scatter_elem_sz_prev : rem_sz;

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

1806 1807 1808 1809 1810 1811
		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;
			}
		}
1812

1813 1814
		SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k=%d, num=%d, "
				 "ret_sz=%d\n", k, num, ret_sz));
1815 1816
	}		/* end of for loop */

1817
	schp->page_order = order;
1818
	schp->k_use_sg = k;
1819 1820
	SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k_use_sg=%d, "
			 "rem_sz=%d\n", k, rem_sz));
1821 1822 1823 1824

	schp->bufflen = blk_size;
	if (rem_sz > 0)	/* must have failed */
		return -ENOMEM;
L
Linus Torvalds 已提交
1825
	return 0;
1826 1827
out:
	for (i = 0; i < k; i++)
1828
		__free_pages(schp->pages[i], order);
1829 1830 1831 1832 1833

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

	return -ENOMEM;
L
Linus Torvalds 已提交
1834 1835 1836 1837 1838 1839
}

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));
1840
	if (schp->pages && schp->sglist_len > 0) {
1841
		if (!schp->dio_in_use) {
L
Linus Torvalds 已提交
1842 1843
			int k;

1844
			for (k = 0; k < schp->k_use_sg && schp->pages[k]; k++) {
L
Linus Torvalds 已提交
1845
				SCSI_LOG_TIMEOUT(5, printk(
1846 1847 1848
				    "sg_remove_scat: k=%d, pg=0x%p\n",
				    k, schp->pages[k]));
				__free_pages(schp->pages[k], schp->page_order);
L
Linus Torvalds 已提交
1849
			}
1850

1851
			kfree(schp->pages);
L
Linus Torvalds 已提交
1852
		}
1853
	}
L
Linus Torvalds 已提交
1854 1855 1856 1857 1858 1859 1860
	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;
1861
	int k, num;
L
Linus Torvalds 已提交
1862 1863 1864 1865 1866

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

1868 1869
	num = 1 << (PAGE_SHIFT + schp->page_order);
	for (k = 0; k < schp->k_use_sg && schp->pages[k]; k++) {
1870
		if (num > num_read_xfer) {
1871
			if (__copy_to_user(outp, page_address(schp->pages[k]),
1872 1873 1874 1875
					   num_read_xfer))
				return -EFAULT;
			break;
		} else {
1876
			if (__copy_to_user(outp, page_address(schp->pages[k]),
1877 1878 1879 1880
					   num))
				return -EFAULT;
			num_read_xfer -= num;
			if (num_read_xfer <= 0)
L
Linus Torvalds 已提交
1881
				break;
1882
			outp += num;
L
Linus Torvalds 已提交
1883 1884
		}
	}
1885

L
Linus Torvalds 已提交
1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910
	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;
1911
	int k, num, rem;
L
Linus Torvalds 已提交
1912 1913 1914

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

1917 1918
	num = 1 << (PAGE_SHIFT + rsv_schp->page_order);
	for (k = 0; k < rsv_schp->k_use_sg; k++) {
1919 1920 1921
		if (rem <= num) {
			req_schp->k_use_sg = k + 1;
			req_schp->sglist_len = rsv_schp->sglist_len;
1922
			req_schp->pages = rsv_schp->pages;
1923 1924

			req_schp->bufflen = size;
1925
			req_schp->page_order = rsv_schp->page_order;
1926 1927 1928
			break;
		} else
			rem -= num;
L
Linus Torvalds 已提交
1929
	}
1930 1931 1932

	if (k >= rsv_schp->k_use_sg)
		SCSI_LOG_TIMEOUT(1, printk("sg_link_reserve: BAD size\n"));
L
Linus Torvalds 已提交
1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943
}

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;
1944 1945
	req_schp->pages = NULL;
	req_schp->page_order = 0;
L
Linus Torvalds 已提交
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 1998 1999 2000 2001 2002 2003 2004 2005 2006
	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;
已提交
2007
		resp->header.duration = jiffies_to_msecs(jiffies);
L
Linus Torvalds 已提交
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 2041 2042 2043 2044 2045 2046 2047 2048 2049
	}
	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;
2050
	int bufflen;
L
Linus Torvalds 已提交
2051

2052
	sfp = kzalloc(sizeof(*sfp), GFP_ATOMIC | __GFP_NOWARN);
L
Linus Torvalds 已提交
2053 2054
	if (!sfp)
		return NULL;
2055

L
Linus Torvalds 已提交
2056 2057 2058
	init_waitqueue_head(&sfp->read_wait);
	rwlock_init(&sfp->rq_list_lock);

2059
	kref_init(&sfp->f_ref);
L
Linus Torvalds 已提交
2060 2061 2062 2063 2064 2065 2066 2067
	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;
2068
	write_lock_irqsave(&sg_index_lock, iflags);
2069
	list_add_tail(&sfp->sfd_siblings, &sdp->sfds);
2070
	write_unlock_irqrestore(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
2071
	SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp: sfp=0x%p\n", sfp));
2072 2073 2074
	if (unlikely(sg_big_buff != def_reserved_size))
		sg_big_buff = def_reserved_size;

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

	kref_get(&sdp->d_ref);
	__module_get(THIS_MODULE);
L
Linus Torvalds 已提交
2083 2084 2085
	return sfp;
}

2086
static void sg_remove_sfp_usercontext(struct work_struct *work)
L
Linus Torvalds 已提交
2087
{
2088 2089 2090 2091 2092 2093
	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 已提交
2094 2095

	if (sfp->reserve.bufflen > 0) {
2096 2097 2098 2099
		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 已提交
2100 2101
		sg_remove_scat(&sfp->reserve);
	}
2102 2103 2104 2105 2106

	SCSI_LOG_TIMEOUT(6,
		printk("sg_remove_sfp: %s, sfp=0x%p\n",
			sdp->disk->disk_name,
			sfp));
2107
	kfree(sfp);
2108 2109 2110 2111

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

2114
static void sg_remove_sfp(struct kref *kref)
L
Linus Torvalds 已提交
2115
{
2116 2117 2118
	struct sg_fd *sfp = container_of(kref, struct sg_fd, f_ref);
	struct sg_device *sdp = sfp->parentdp;
	unsigned long iflags;
L
Linus Torvalds 已提交
2119

2120
	write_lock_irqsave(&sg_index_lock, iflags);
2121
	list_del(&sfp->sfd_siblings);
2122 2123
	write_unlock_irqrestore(&sg_index_lock, iflags);
	wake_up_interruptible(&sdp->o_excl_wait);
L
Linus Torvalds 已提交
2124

2125 2126
	INIT_WORK(&sfp->ew.work, sg_remove_sfp_usercontext);
	schedule_work(&sfp->ew.work);
L
Linus Torvalds 已提交
2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143
}

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
2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154
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 已提交
2155 2156 2157
static int
sg_last_dev(void)
{
2158
	int k = -1;
L
Linus Torvalds 已提交
2159 2160
	unsigned long iflags;

2161 2162 2163
	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 已提交
2164 2165 2166 2167
	return k + 1;		/* origin 1 */
}
#endif

2168 2169
/* must be called with sg_index_lock held */
static Sg_device *sg_lookup_dev(int dev)
L
Linus Torvalds 已提交
2170
{
2171 2172
	return idr_find(&sg_index_idr, dev);
}
L
Linus Torvalds 已提交
2173

2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190
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);
2191

L
Linus Torvalds 已提交
2192 2193 2194
	return sdp;
}

2195 2196 2197 2198 2199
static void sg_put_dev(struct sg_device *sdp)
{
	kref_put(&sdp->d_ref, sg_device_destroy);
}

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

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)
{
2322
	int num_leaves = ARRAY_SIZE(sg_proc_leaf_arr);
A
Al Viro 已提交
2323
	int k;
L
Linus Torvalds 已提交
2324

2325
	sg_proc_sgp = proc_mkdir(sg_proc_sg_dirname, NULL);
L
Linus Torvalds 已提交
2326 2327 2328
	if (!sg_proc_sgp)
		return 1;
	for (k = 0; k < num_leaves; ++k) {
A
Al Viro 已提交
2329 2330
		struct sg_proc_leaf *leaf = &sg_proc_leaf_arr[k];
		umode_t mask = leaf->fops->write ? S_IRUGO | S_IWUSR : S_IRUGO;
2331
		proc_create(leaf->name, mask, sg_proc_sgp, leaf->fops);
L
Linus Torvalds 已提交
2332 2333 2334 2335 2336 2337 2338 2339
	}
	return 0;
}

static void
sg_proc_cleanup(void)
{
	int k;
2340
	int num_leaves = ARRAY_SIZE(sg_proc_leaf_arr);
L
Linus Torvalds 已提交
2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364

	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)
{
2365 2366
	int err;
	unsigned long num;
L
Linus Torvalds 已提交
2367 2368 2369

	if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
		return -EACCES;
2370 2371 2372 2373
	err = kstrtoul_from_user(buffer, count, 0, &num);
	if (err)
		return err;
	sg_allow_dio = num ? 1 : 0;
L
Linus Torvalds 已提交
2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385
	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)
{
2386
	int err;
L
Linus Torvalds 已提交
2387 2388 2389 2390
	unsigned long k = ULONG_MAX;

	if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
		return -EACCES;
2391 2392 2393 2394

	err = kstrtoul_from_user(buffer, count, 0, &k);
	if (err)
		return err;
L
Linus Torvalds 已提交
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 2428 2429 2430 2431 2432 2433 2434
	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);

2435
	s->private = it;
L
Linus Torvalds 已提交
2436 2437
	if (! it)
		return NULL;
2438

L
Linus Torvalds 已提交
2439 2440 2441
	it->index = *pos;
	it->max = sg_last_dev();
	if (it->index >= it->max)
2442
		return NULL;
L
Linus Torvalds 已提交
2443 2444 2445 2446 2447
	return it;
}

static void * dev_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
2448
	struct sg_proc_deviter * it = s->private;
L
Linus Torvalds 已提交
2449 2450 2451 2452 2453 2454 2455

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

static void dev_seq_stop(struct seq_file *s, void *v)
{
2456
	kfree(s->private);
L
Linus Torvalds 已提交
2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468
}

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

2471 2472
	read_lock_irqsave(&sg_index_lock, iflags);
	sdp = it ? sg_lookup_dev(it->index) : NULL;
L
Linus Torvalds 已提交
2473 2474 2475 2476 2477 2478 2479 2480 2481 2482
	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");
2483
	read_unlock_irqrestore(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496
	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;
2497
	unsigned long iflags;
L
Linus Torvalds 已提交
2498

2499 2500
	read_lock_irqsave(&sg_index_lock, iflags);
	sdp = it ? sg_lookup_dev(it->index) : NULL;
L
Linus Torvalds 已提交
2501 2502 2503 2504 2505
	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");
2506
	read_unlock_irqrestore(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
2507 2508 2509
	return 0;
}

2510
/* must be called while holding sg_index_lock */
L
Linus Torvalds 已提交
2511 2512 2513 2514 2515 2516 2517
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;
已提交
2518
	unsigned int ms;
L
Linus Torvalds 已提交
2519

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

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;
2585
	unsigned long iflags;
L
Linus Torvalds 已提交
2586 2587

	if (it && (0 == it->index)) {
2588 2589
		seq_printf(s, "max_active_device=%d(origin 1)\n",
			   (int)it->max);
L
Linus Torvalds 已提交
2590 2591 2592
		seq_printf(s, " def_reserved_size=%d\n", sg_big_buff);
	}

2593 2594
	read_lock_irqsave(&sg_index_lock, iflags);
	sdp = it ? sg_lookup_dev(it->index) : NULL;
2595
	if (sdp && !list_empty(&sdp->sfds)) {
2596
		struct scsi_device *scsidp = sdp->device;
L
Linus Torvalds 已提交
2597

2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609
		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 已提交
2610 2611
		sg_proc_debug_helper(s, sdp);
	}
2612
	read_unlock_irqrestore(&sg_index_lock, iflags);
L
Linus Torvalds 已提交
2613 2614 2615 2616 2617 2618 2619
	return 0;
}

#endif				/* CONFIG_SCSI_PROC_FS */

module_init(init_sg);
module_exit(exit_sg);