1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20static const char *verstr = "20101219";
21
22#include <linux/module.h>
23
24#include <linux/fs.h>
25#include <linux/kernel.h>
26#include <linux/sched.h>
27#include <linux/mm.h>
28#include <linux/init.h>
29#include <linux/string.h>
30#include <linux/slab.h>
31#include <linux/errno.h>
32#include <linux/mtio.h>
33#include <linux/cdrom.h>
34#include <linux/ioctl.h>
35#include <linux/fcntl.h>
36#include <linux/spinlock.h>
37#include <linux/blkdev.h>
38#include <linux/moduleparam.h>
39#include <linux/cdev.h>
40#include <linux/idr.h>
41#include <linux/delay.h>
42#include <linux/mutex.h>
43
44#include <asm/uaccess.h>
45#include <asm/dma.h>
46
47#include <scsi/scsi.h>
48#include <scsi/scsi_dbg.h>
49#include <scsi/scsi_device.h>
50#include <scsi/scsi_driver.h>
51#include <scsi/scsi_eh.h>
52#include <scsi/scsi_host.h>
53#include <scsi/scsi_ioctl.h>
54#include <scsi/sg.h>
55
56
57
58
59#define DEBUG 0
60
61#if DEBUG
62
63
64
65#define ST_DEB_MSG KERN_NOTICE
66#define DEB(a) a
67#define DEBC(a) if (debugging) { a ; }
68#else
69#define DEB(a)
70#define DEBC(a)
71#endif
72
73#define ST_KILOBYTE 1024
74
75#include "st_options.h"
76#include "st.h"
77
78static int buffer_kbs;
79static int max_sg_segs;
80static int try_direct_io = TRY_DIRECT_IO;
81static int try_rdio = 1;
82static int try_wdio = 1;
83
84static struct class st_sysfs_class;
85static const struct attribute_group *st_dev_groups[];
86
87MODULE_AUTHOR("Kai Makisara");
88MODULE_DESCRIPTION("SCSI tape (st) driver");
89MODULE_LICENSE("GPL");
90MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR);
91MODULE_ALIAS_SCSI_DEVICE(TYPE_TAPE);
92
93
94
95
96
97module_param_named(buffer_kbs, buffer_kbs, int, 0);
98MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)");
99module_param_named(max_sg_segs, max_sg_segs, int, 0);
100MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
101module_param_named(try_direct_io, try_direct_io, int, 0);
102MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
103
104
105module_param_named(try_rdio, try_rdio, int, 0);
106MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible");
107module_param_named(try_wdio, try_wdio, int, 0);
108MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible");
109
110#ifndef MODULE
111static int write_threshold_kbs;
112static struct st_dev_parm {
113 char *name;
114 int *val;
115} parms[] __initdata = {
116 {
117 "buffer_kbs", &buffer_kbs
118 },
119 {
120 "write_threshold_kbs", &write_threshold_kbs
121 },
122 {
123 "max_sg_segs", NULL
124 },
125 {
126 "try_direct_io", &try_direct_io
127 }
128};
129#endif
130
131
132#if ST_NBR_MODES > 16
133#error "Maximum number of modes is 16"
134#endif
135
136
137static const char *st_formats[] = {
138 "", "r", "k", "s", "l", "t", "o", "u",
139 "m", "v", "p", "x", "a", "y", "q", "z"};
140
141
142
143#define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
144
145
146
147#if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
148#error "Buffer size should not exceed (2 << 24 - 1) bytes!"
149#endif
150
151static int debugging = DEBUG;
152
153#define MAX_RETRIES 0
154#define MAX_WRITE_RETRIES 0
155#define MAX_READY_RETRIES 0
156#define NO_TAPE NOT_READY
157
158#define ST_TIMEOUT (900 * HZ)
159#define ST_LONG_TIMEOUT (14000 * HZ)
160
161
162#define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
163 (iminor(x) & ~(-1 << ST_MODE_SHIFT)) )
164#define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
165
166
167#define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
168 (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
169
170
171
172#define SET_DENS_AND_BLK 0x10001
173
174static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
175static int st_max_sg_segs = ST_MAX_SG;
176
177static int modes_defined;
178
179static int enlarge_buffer(struct st_buffer *, int, int);
180static void clear_buffer(struct st_buffer *);
181static void normalize_buffer(struct st_buffer *);
182static int append_to_buffer(const char __user *, struct st_buffer *, int);
183static int from_buffer(struct st_buffer *, char __user *, int);
184static void move_buffer_data(struct st_buffer *, int);
185
186static int sgl_map_user_pages(struct st_buffer *, const unsigned int,
187 unsigned long, size_t, int);
188static int sgl_unmap_user_pages(struct st_buffer *, const unsigned int, int);
189
190static int st_probe(struct device *);
191static int st_remove(struct device *);
192
193static int do_create_sysfs_files(void);
194static void do_remove_sysfs_files(void);
195
196static struct scsi_driver st_template = {
197 .owner = THIS_MODULE,
198 .gendrv = {
199 .name = "st",
200 .probe = st_probe,
201 .remove = st_remove,
202 },
203};
204
205static int st_compression(struct scsi_tape *, int);
206
207static int find_partition(struct scsi_tape *);
208static int switch_partition(struct scsi_tape *);
209
210static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
211
212static void scsi_tape_release(struct kref *);
213
214#define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
215
216static DEFINE_MUTEX(st_ref_mutex);
217static DEFINE_SPINLOCK(st_index_lock);
218static DEFINE_SPINLOCK(st_use_lock);
219static DEFINE_IDR(st_index_idr);
220
221
222
223#include "osst_detect.h"
224#ifndef SIGS_FROM_OSST
225#define SIGS_FROM_OSST \
226 {"OnStream", "SC-", "", "osst"}, \
227 {"OnStream", "DI-", "", "osst"}, \
228 {"OnStream", "DP-", "", "osst"}, \
229 {"OnStream", "USB", "", "osst"}, \
230 {"OnStream", "FW-", "", "osst"}
231#endif
232
233static struct scsi_tape *scsi_tape_get(int dev)
234{
235 struct scsi_tape *STp = NULL;
236
237 mutex_lock(&st_ref_mutex);
238 spin_lock(&st_index_lock);
239
240 STp = idr_find(&st_index_idr, dev);
241 if (!STp) goto out;
242
243 kref_get(&STp->kref);
244
245 if (!STp->device)
246 goto out_put;
247
248 if (scsi_device_get(STp->device))
249 goto out_put;
250
251 goto out;
252
253out_put:
254 kref_put(&STp->kref, scsi_tape_release);
255 STp = NULL;
256out:
257 spin_unlock(&st_index_lock);
258 mutex_unlock(&st_ref_mutex);
259 return STp;
260}
261
262static void scsi_tape_put(struct scsi_tape *STp)
263{
264 struct scsi_device *sdev = STp->device;
265
266 mutex_lock(&st_ref_mutex);
267 kref_put(&STp->kref, scsi_tape_release);
268 scsi_device_put(sdev);
269 mutex_unlock(&st_ref_mutex);
270}
271
272struct st_reject_data {
273 char *vendor;
274 char *model;
275 char *rev;
276 char *driver_hint;
277};
278
279static struct st_reject_data reject_list[] = {
280
281 SIGS_FROM_OSST,
282 {NULL, }};
283
284
285
286static char * st_incompatible(struct scsi_device* SDp)
287{
288 struct st_reject_data *rp;
289
290 for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
291 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
292 !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
293 !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
294 if (rp->driver_hint)
295 return rp->driver_hint;
296 else
297 return "unknown";
298 }
299 return NULL;
300}
301
302
303static inline char *tape_name(struct scsi_tape *tape)
304{
305 return tape->disk->disk_name;
306}
307
308
309static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
310{
311 const u8 *ucp;
312 const u8 *sense = SRpnt->sense;
313
314 s->have_sense = scsi_normalize_sense(SRpnt->sense,
315 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
316 s->flags = 0;
317
318 if (s->have_sense) {
319 s->deferred = 0;
320 s->remainder_valid =
321 scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
322 switch (sense[0] & 0x7f) {
323 case 0x71:
324 s->deferred = 1;
325 case 0x70:
326 s->fixed_format = 1;
327 s->flags = sense[2] & 0xe0;
328 break;
329 case 0x73:
330 s->deferred = 1;
331 case 0x72:
332 s->fixed_format = 0;
333 ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
334 s->flags = ucp ? (ucp[3] & 0xe0) : 0;
335 break;
336 }
337 }
338}
339
340
341
342static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
343{
344 int result = SRpnt->result;
345 u8 scode;
346 DEB(const char *stp;)
347 char *name = tape_name(STp);
348 struct st_cmdstatus *cmdstatp;
349
350 if (!result)
351 return 0;
352
353 cmdstatp = &STp->buffer->cmdstat;
354 st_analyze_sense(SRpnt, cmdstatp);
355
356 if (cmdstatp->have_sense)
357 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
358 else
359 scode = 0;
360
361 DEB(
362 if (debugging) {
363 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n",
364 name, result,
365 SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
366 SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
367 if (cmdstatp->have_sense)
368 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
369 } )
370 if (!debugging) {
371 if (!cmdstatp->have_sense)
372 printk(KERN_WARNING
373 "%s: Error %x (driver bt 0x%x, host bt 0x%x).\n",
374 name, result, driver_byte(result),
375 host_byte(result));
376 else if (cmdstatp->have_sense &&
377 scode != NO_SENSE &&
378 scode != RECOVERED_ERROR &&
379
380 scode != BLANK_CHECK &&
381 scode != VOLUME_OVERFLOW &&
382 SRpnt->cmd[0] != MODE_SENSE &&
383 SRpnt->cmd[0] != TEST_UNIT_READY) {
384
385 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
386 }
387 }
388
389 if (cmdstatp->fixed_format &&
390 STp->cln_mode >= EXTENDED_SENSE_START) {
391 if (STp->cln_sense_value)
392 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
393 STp->cln_sense_mask) == STp->cln_sense_value);
394 else
395 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
396 STp->cln_sense_mask) != 0);
397 }
398 if (cmdstatp->have_sense &&
399 cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
400 STp->cleaning_req = 1;
401
402 STp->pos_unknown |= STp->device->was_reset;
403
404 if (cmdstatp->have_sense &&
405 scode == RECOVERED_ERROR
406#if ST_RECOVERED_WRITE_FATAL
407 && SRpnt->cmd[0] != WRITE_6
408 && SRpnt->cmd[0] != WRITE_FILEMARKS
409#endif
410 ) {
411 STp->recover_count++;
412 STp->recover_reg++;
413
414 DEB(
415 if (debugging) {
416 if (SRpnt->cmd[0] == READ_6)
417 stp = "read";
418 else if (SRpnt->cmd[0] == WRITE_6)
419 stp = "write";
420 else
421 stp = "ioctl";
422 printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
423 STp->recover_count);
424 } )
425
426 if (cmdstatp->flags == 0)
427 return 0;
428 }
429 return (-EIO);
430}
431
432static struct st_request *st_allocate_request(struct scsi_tape *stp)
433{
434 struct st_request *streq;
435
436 streq = kzalloc(sizeof(*streq), GFP_KERNEL);
437 if (streq)
438 streq->stp = stp;
439 else {
440 DEBC(printk(KERN_ERR "%s: Can't get SCSI request.\n",
441 tape_name(stp)););
442 if (signal_pending(current))
443 stp->buffer->syscall_result = -EINTR;
444 else
445 stp->buffer->syscall_result = -EBUSY;
446 }
447
448 return streq;
449}
450
451static void st_release_request(struct st_request *streq)
452{
453 kfree(streq);
454}
455
456static void st_scsi_execute_end(struct request *req, int uptodate)
457{
458 struct st_request *SRpnt = req->end_io_data;
459 struct scsi_tape *STp = SRpnt->stp;
460 struct bio *tmp;
461
462 STp->buffer->cmdstat.midlevel_result = SRpnt->result = req->errors;
463 STp->buffer->cmdstat.residual = req->resid_len;
464
465 tmp = SRpnt->bio;
466 if (SRpnt->waiting)
467 complete(SRpnt->waiting);
468
469 blk_rq_unmap_user(tmp);
470 __blk_put_request(req->q, req);
471}
472
473static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
474 int data_direction, void *buffer, unsigned bufflen,
475 int timeout, int retries)
476{
477 struct request *req;
478 struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data;
479 int err = 0;
480 int write = (data_direction == DMA_TO_DEVICE);
481
482 req = blk_get_request(SRpnt->stp->device->request_queue, write,
483 GFP_KERNEL);
484 if (!req)
485 return DRIVER_ERROR << 24;
486
487 req->cmd_type = REQ_TYPE_BLOCK_PC;
488 req->cmd_flags |= REQ_QUIET;
489
490 mdata->null_mapped = 1;
491
492 if (bufflen) {
493 err = blk_rq_map_user(req->q, req, mdata, NULL, bufflen,
494 GFP_KERNEL);
495 if (err) {
496 blk_put_request(req);
497 return DRIVER_ERROR << 24;
498 }
499 }
500
501 SRpnt->bio = req->bio;
502 req->cmd_len = COMMAND_SIZE(cmd[0]);
503 memset(req->cmd, 0, BLK_MAX_CDB);
504 memcpy(req->cmd, cmd, req->cmd_len);
505 req->sense = SRpnt->sense;
506 req->sense_len = 0;
507 req->timeout = timeout;
508 req->retries = retries;
509 req->end_io_data = SRpnt;
510
511 blk_execute_rq_nowait(req->q, NULL, req, 1, st_scsi_execute_end);
512 return 0;
513}
514
515
516
517
518static struct st_request *
519st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
520 int bytes, int direction, int timeout, int retries, int do_wait)
521{
522 struct completion *waiting;
523 struct rq_map_data *mdata = &STp->buffer->map_data;
524 int ret;
525
526
527 if (!do_wait && ((STp->buffer)->last_SRpnt)) {
528 printk(KERN_ERR "%s: Async command already active.\n",
529 tape_name(STp));
530 if (signal_pending(current))
531 (STp->buffer)->syscall_result = (-EINTR);
532 else
533 (STp->buffer)->syscall_result = (-EBUSY);
534 return NULL;
535 }
536
537 if (!SRpnt) {
538 SRpnt = st_allocate_request(STp);
539 if (!SRpnt)
540 return NULL;
541 }
542
543
544
545 if (!do_wait)
546 (STp->buffer)->last_SRpnt = SRpnt;
547
548 waiting = &STp->wait;
549 init_completion(waiting);
550 SRpnt->waiting = waiting;
551
552 if (STp->buffer->do_dio) {
553 mdata->page_order = 0;
554 mdata->nr_entries = STp->buffer->sg_segs;
555 mdata->pages = STp->buffer->mapped_pages;
556 } else {
557 mdata->page_order = STp->buffer->reserved_page_order;
558 mdata->nr_entries =
559 DIV_ROUND_UP(bytes, PAGE_SIZE << mdata->page_order);
560 mdata->pages = STp->buffer->reserved_pages;
561 mdata->offset = 0;
562 }
563
564 memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
565 STp->buffer->cmdstat.have_sense = 0;
566 STp->buffer->syscall_result = 0;
567
568 ret = st_scsi_execute(SRpnt, cmd, direction, NULL, bytes, timeout,
569 retries);
570 if (ret) {
571
572 (STp->buffer)->syscall_result = (-EBUSY);
573 (STp->buffer)->last_SRpnt = NULL;
574 } else if (do_wait) {
575 wait_for_completion(waiting);
576 SRpnt->waiting = NULL;
577 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
578 }
579
580 return SRpnt;
581}
582
583
584
585
586
587
588static int write_behind_check(struct scsi_tape * STp)
589{
590 int retval = 0;
591 struct st_buffer *STbuffer;
592 struct st_partstat *STps;
593 struct st_cmdstatus *cmdstatp;
594 struct st_request *SRpnt;
595
596 STbuffer = STp->buffer;
597 if (!STbuffer->writing)
598 return 0;
599
600 DEB(
601 if (STp->write_pending)
602 STp->nbr_waits++;
603 else
604 STp->nbr_finished++;
605 )
606
607 wait_for_completion(&(STp->wait));
608 SRpnt = STbuffer->last_SRpnt;
609 STbuffer->last_SRpnt = NULL;
610 SRpnt->waiting = NULL;
611
612 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
613 st_release_request(SRpnt);
614
615 STbuffer->buffer_bytes -= STbuffer->writing;
616 STps = &(STp->ps[STp->partition]);
617 if (STps->drv_block >= 0) {
618 if (STp->block_size == 0)
619 STps->drv_block++;
620 else
621 STps->drv_block += STbuffer->writing / STp->block_size;
622 }
623
624 cmdstatp = &STbuffer->cmdstat;
625 if (STbuffer->syscall_result) {
626 retval = -EIO;
627 if (cmdstatp->have_sense && !cmdstatp->deferred &&
628 (cmdstatp->flags & SENSE_EOM) &&
629 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
630 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) {
631
632 if (!cmdstatp->remainder_valid ||
633 cmdstatp->uremainder64 == 0)
634 retval = -ENOSPC;
635 }
636 if (retval == -EIO)
637 STps->drv_block = -1;
638 }
639 STbuffer->writing = 0;
640
641 DEB(if (debugging && retval)
642 printk(ST_DEB_MSG "%s: Async write error %x, return value %d.\n",
643 tape_name(STp), STbuffer->cmdstat.midlevel_result, retval);)
644
645 return retval;
646}
647
648
649
650
651static int cross_eof(struct scsi_tape * STp, int forward)
652{
653 struct st_request *SRpnt;
654 unsigned char cmd[MAX_COMMAND_SIZE];
655
656 cmd[0] = SPACE;
657 cmd[1] = 0x01;
658 if (forward) {
659 cmd[2] = cmd[3] = 0;
660 cmd[4] = 1;
661 } else
662 cmd[2] = cmd[3] = cmd[4] = 0xff;
663 cmd[5] = 0;
664
665 DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n",
666 tape_name(STp), forward ? "forward" : "backward"));
667
668 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
669 STp->device->request_queue->rq_timeout,
670 MAX_RETRIES, 1);
671 if (!SRpnt)
672 return (STp->buffer)->syscall_result;
673
674 st_release_request(SRpnt);
675 SRpnt = NULL;
676
677 if ((STp->buffer)->cmdstat.midlevel_result != 0)
678 printk(KERN_ERR "%s: Stepping over filemark %s failed.\n",
679 tape_name(STp), forward ? "forward" : "backward");
680
681 return (STp->buffer)->syscall_result;
682}
683
684
685
686static int st_flush_write_buffer(struct scsi_tape * STp)
687{
688 int transfer, blks;
689 int result;
690 unsigned char cmd[MAX_COMMAND_SIZE];
691 struct st_request *SRpnt;
692 struct st_partstat *STps;
693
694 result = write_behind_check(STp);
695 if (result)
696 return result;
697
698 result = 0;
699 if (STp->dirty == 1) {
700
701 transfer = STp->buffer->buffer_bytes;
702 DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n",
703 tape_name(STp), transfer));
704
705 memset(cmd, 0, MAX_COMMAND_SIZE);
706 cmd[0] = WRITE_6;
707 cmd[1] = 1;
708 blks = transfer / STp->block_size;
709 cmd[2] = blks >> 16;
710 cmd[3] = blks >> 8;
711 cmd[4] = blks;
712
713 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
714 STp->device->request_queue->rq_timeout,
715 MAX_WRITE_RETRIES, 1);
716 if (!SRpnt)
717 return (STp->buffer)->syscall_result;
718
719 STps = &(STp->ps[STp->partition]);
720 if ((STp->buffer)->syscall_result != 0) {
721 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
722
723 if (cmdstatp->have_sense && !cmdstatp->deferred &&
724 (cmdstatp->flags & SENSE_EOM) &&
725 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
726 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
727 (!cmdstatp->remainder_valid ||
728 cmdstatp->uremainder64 == 0)) {
729 STp->dirty = 0;
730 (STp->buffer)->buffer_bytes = 0;
731 if (STps->drv_block >= 0)
732 STps->drv_block += blks;
733 result = (-ENOSPC);
734 } else {
735 printk(KERN_ERR "%s: Error on flush.\n",
736 tape_name(STp));
737 STps->drv_block = (-1);
738 result = (-EIO);
739 }
740 } else {
741 if (STps->drv_block >= 0)
742 STps->drv_block += blks;
743 STp->dirty = 0;
744 (STp->buffer)->buffer_bytes = 0;
745 }
746 st_release_request(SRpnt);
747 SRpnt = NULL;
748 }
749 return result;
750}
751
752
753
754
755static int flush_buffer(struct scsi_tape *STp, int seek_next)
756{
757 int backspace, result;
758 struct st_buffer *STbuffer;
759 struct st_partstat *STps;
760
761 STbuffer = STp->buffer;
762
763
764
765
766
767 if (STp->pos_unknown)
768 return (-EIO);
769
770 if (STp->ready != ST_READY)
771 return 0;
772 STps = &(STp->ps[STp->partition]);
773 if (STps->rw == ST_WRITING)
774 return st_flush_write_buffer(STp);
775
776 if (STp->block_size == 0)
777 return 0;
778
779 backspace = ((STp->buffer)->buffer_bytes +
780 (STp->buffer)->read_pointer) / STp->block_size -
781 ((STp->buffer)->read_pointer + STp->block_size - 1) /
782 STp->block_size;
783 (STp->buffer)->buffer_bytes = 0;
784 (STp->buffer)->read_pointer = 0;
785 result = 0;
786 if (!seek_next) {
787 if (STps->eof == ST_FM_HIT) {
788 result = cross_eof(STp, 0);
789 if (!result)
790 STps->eof = ST_NOEOF;
791 else {
792 if (STps->drv_file >= 0)
793 STps->drv_file++;
794 STps->drv_block = 0;
795 }
796 }
797 if (!result && backspace > 0)
798 result = st_int_ioctl(STp, MTBSR, backspace);
799 } else if (STps->eof == ST_FM_HIT) {
800 if (STps->drv_file >= 0)
801 STps->drv_file++;
802 STps->drv_block = 0;
803 STps->eof = ST_NOEOF;
804 }
805 return result;
806
807}
808
809
810static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
811{
812 int set_it = 0;
813 unsigned long arg;
814 char *name = tape_name(STp);
815
816 if (!STp->density_changed &&
817 STm->default_density >= 0 &&
818 STm->default_density != STp->density) {
819 arg = STm->default_density;
820 set_it = 1;
821 } else
822 arg = STp->density;
823 arg <<= MT_ST_DENSITY_SHIFT;
824 if (!STp->blksize_changed &&
825 STm->default_blksize >= 0 &&
826 STm->default_blksize != STp->block_size) {
827 arg |= STm->default_blksize;
828 set_it = 1;
829 } else
830 arg |= STp->block_size;
831 if (set_it &&
832 st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
833 printk(KERN_WARNING
834 "%s: Can't set default block size to %d bytes and density %x.\n",
835 name, STm->default_blksize, STm->default_density);
836 if (modes_defined)
837 return (-EINVAL);
838 }
839 return 0;
840}
841
842
843
844static int do_door_lock(struct scsi_tape * STp, int do_lock)
845{
846 int retval, cmd;
847 DEB(char *name = tape_name(STp);)
848
849
850 cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
851 DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name,
852 do_lock ? "L" : "Unl"));
853 retval = scsi_ioctl(STp->device, cmd, NULL);
854 if (!retval) {
855 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
856 }
857 else {
858 STp->door_locked = ST_LOCK_FAILS;
859 }
860 return retval;
861}
862
863
864
865static void reset_state(struct scsi_tape *STp)
866{
867 int i;
868 struct st_partstat *STps;
869
870 STp->pos_unknown = 0;
871 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
872 STps = &(STp->ps[i]);
873 STps->rw = ST_IDLE;
874 STps->eof = ST_NOEOF;
875 STps->at_sm = 0;
876 STps->last_block_valid = 0;
877 STps->drv_block = -1;
878 STps->drv_file = -1;
879 }
880 if (STp->can_partitions) {
881 STp->partition = find_partition(STp);
882 if (STp->partition < 0)
883 STp->partition = 0;
884 STp->new_partition = STp->partition;
885 }
886}
887
888
889
890#define CHKRES_READY 0
891#define CHKRES_NEW_SESSION 1
892#define CHKRES_NOT_READY 2
893#define CHKRES_NO_TAPE 3
894
895#define MAX_ATTENTIONS 10
896
897static int test_ready(struct scsi_tape *STp, int do_wait)
898{
899 int attentions, waits, max_wait, scode;
900 int retval = CHKRES_READY, new_session = 0;
901 unsigned char cmd[MAX_COMMAND_SIZE];
902 struct st_request *SRpnt = NULL;
903 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
904
905 max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
906
907 for (attentions=waits=0; ; ) {
908 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
909 cmd[0] = TEST_UNIT_READY;
910 SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
911 STp->long_timeout, MAX_READY_RETRIES, 1);
912
913 if (!SRpnt) {
914 retval = (STp->buffer)->syscall_result;
915 break;
916 }
917
918 if (cmdstatp->have_sense) {
919
920 scode = cmdstatp->sense_hdr.sense_key;
921
922 if (scode == UNIT_ATTENTION) {
923 new_session = 1;
924 if (attentions < MAX_ATTENTIONS) {
925 attentions++;
926 continue;
927 }
928 else {
929 retval = (-EIO);
930 break;
931 }
932 }
933
934 if (scode == NOT_READY) {
935 if (waits < max_wait) {
936 if (msleep_interruptible(1000)) {
937 retval = (-EINTR);
938 break;
939 }
940 waits++;
941 continue;
942 }
943 else {
944 if ((STp->device)->scsi_level >= SCSI_2 &&
945 cmdstatp->sense_hdr.asc == 0x3a)
946 retval = CHKRES_NO_TAPE;
947 else
948 retval = CHKRES_NOT_READY;
949 break;
950 }
951 }
952 }
953
954 retval = (STp->buffer)->syscall_result;
955 if (!retval)
956 retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
957 break;
958 }
959
960 if (SRpnt != NULL)
961 st_release_request(SRpnt);
962 return retval;
963}
964
965
966
967
968
969
970
971static int check_tape(struct scsi_tape *STp, struct file *filp)
972{
973 int i, retval, new_session = 0, do_wait;
974 unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
975 unsigned short st_flags = filp->f_flags;
976 struct st_request *SRpnt = NULL;
977 struct st_modedef *STm;
978 struct st_partstat *STps;
979 char *name = tape_name(STp);
980 struct inode *inode = file_inode(filp);
981 int mode = TAPE_MODE(inode);
982
983 STp->ready = ST_READY;
984
985 if (mode != STp->current_mode) {
986 DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n",
987 name, STp->current_mode, mode));
988 new_session = 1;
989 STp->current_mode = mode;
990 }
991 STm = &(STp->modes[STp->current_mode]);
992
993 saved_cleaning = STp->cleaning_req;
994 STp->cleaning_req = 0;
995
996 do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
997 retval = test_ready(STp, do_wait);
998
999 if (retval < 0)
1000 goto err_out;
1001
1002 if (retval == CHKRES_NEW_SESSION) {
1003 STp->pos_unknown = 0;
1004 STp->partition = STp->new_partition = 0;
1005 if (STp->can_partitions)
1006 STp->nbr_partitions = 1;
1007
1008 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1009 STps = &(STp->ps[i]);
1010 STps->rw = ST_IDLE;
1011 STps->eof = ST_NOEOF;
1012 STps->at_sm = 0;
1013 STps->last_block_valid = 0;
1014 STps->drv_block = 0;
1015 STps->drv_file = 0;
1016 }
1017 new_session = 1;
1018 }
1019 else {
1020 STp->cleaning_req |= saved_cleaning;
1021
1022 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
1023 if (retval == CHKRES_NO_TAPE)
1024 STp->ready = ST_NO_TAPE;
1025 else
1026 STp->ready = ST_NOT_READY;
1027
1028 STp->density = 0;
1029 STp->write_prot = 0;
1030 STp->block_size = 0;
1031 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
1032 STp->partition = STp->new_partition = 0;
1033 STp->door_locked = ST_UNLOCKED;
1034 return CHKRES_NOT_READY;
1035 }
1036 }
1037
1038 if (STp->omit_blklims)
1039 STp->min_block = STp->max_block = (-1);
1040 else {
1041 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1042 cmd[0] = READ_BLOCK_LIMITS;
1043
1044 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
1045 STp->device->request_queue->rq_timeout,
1046 MAX_READY_RETRIES, 1);
1047 if (!SRpnt) {
1048 retval = (STp->buffer)->syscall_result;
1049 goto err_out;
1050 }
1051
1052 if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) {
1053 STp->max_block = ((STp->buffer)->b_data[1] << 16) |
1054 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
1055 STp->min_block = ((STp->buffer)->b_data[4] << 8) |
1056 (STp->buffer)->b_data[5];
1057 if ( DEB( debugging || ) !STp->inited)
1058 printk(KERN_INFO
1059 "%s: Block limits %d - %d bytes.\n", name,
1060 STp->min_block, STp->max_block);
1061 } else {
1062 STp->min_block = STp->max_block = (-1);
1063 DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n",
1064 name));
1065 }
1066 }
1067
1068 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1069 cmd[0] = MODE_SENSE;
1070 cmd[4] = 12;
1071
1072 SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
1073 STp->device->request_queue->rq_timeout,
1074 MAX_READY_RETRIES, 1);
1075 if (!SRpnt) {
1076 retval = (STp->buffer)->syscall_result;
1077 goto err_out;
1078 }
1079
1080 if ((STp->buffer)->syscall_result != 0) {
1081 DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name));
1082 STp->block_size = ST_DEFAULT_BLOCK;
1083 (STp->buffer)->syscall_result = 0;
1084 STp->drv_write_prot = 0;
1085 } else {
1086 DEBC(printk(ST_DEB_MSG
1087 "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
1088 name,
1089 (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
1090 (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]));
1091
1092 if ((STp->buffer)->b_data[3] >= 8) {
1093 STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
1094 STp->density = (STp->buffer)->b_data[4];
1095 STp->block_size = (STp->buffer)->b_data[9] * 65536 +
1096 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
1097 DEBC(printk(ST_DEB_MSG
1098 "%s: Density %x, tape length: %x, drv buffer: %d\n",
1099 name, STp->density, (STp->buffer)->b_data[5] * 65536 +
1100 (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
1101 STp->drv_buffer));
1102 }
1103 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
1104 if (!STp->drv_buffer && STp->immediate_filemark) {
1105 printk(KERN_WARNING
1106 "%s: non-buffered tape: disabling writing immediate filemarks\n",
1107 name);
1108 STp->immediate_filemark = 0;
1109 }
1110 }
1111 st_release_request(SRpnt);
1112 SRpnt = NULL;
1113 STp->inited = 1;
1114
1115 if (STp->block_size > 0)
1116 (STp->buffer)->buffer_blocks =
1117 (STp->buffer)->buffer_size / STp->block_size;
1118 else
1119 (STp->buffer)->buffer_blocks = 1;
1120 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1121
1122 DEBC(printk(ST_DEB_MSG
1123 "%s: Block size: %d, buffer size: %d (%d blocks).\n", name,
1124 STp->block_size, (STp->buffer)->buffer_size,
1125 (STp->buffer)->buffer_blocks));
1126
1127 if (STp->drv_write_prot) {
1128 STp->write_prot = 1;
1129
1130 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
1131
1132 if (do_wait &&
1133 ((st_flags & O_ACCMODE) == O_WRONLY ||
1134 (st_flags & O_ACCMODE) == O_RDWR)) {
1135 retval = (-EROFS);
1136 goto err_out;
1137 }
1138 }
1139
1140 if (STp->can_partitions && STp->nbr_partitions < 1) {
1141
1142
1143
1144 DEBC(printk(ST_DEB_MSG
1145 "%s: Updating partition number in status.\n", name));
1146 if ((STp->partition = find_partition(STp)) < 0) {
1147 retval = STp->partition;
1148 goto err_out;
1149 }
1150 STp->new_partition = STp->partition;
1151 STp->nbr_partitions = 1;
1152 }
1153
1154 if (new_session) {
1155 STp->density_changed = STp->blksize_changed = 0;
1156 STp->compression_changed = 0;
1157 if (!(STm->defaults_for_writes) &&
1158 (retval = set_mode_densblk(STp, STm)) < 0)
1159 goto err_out;
1160
1161 if (STp->default_drvbuffer != 0xff) {
1162 if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1163 printk(KERN_WARNING
1164 "%s: Can't set default drive buffering to %d.\n",
1165 name, STp->default_drvbuffer);
1166 }
1167 }
1168
1169 return CHKRES_READY;
1170
1171 err_out:
1172 return retval;
1173}
1174
1175
1176
1177
1178static int st_open(struct inode *inode, struct file *filp)
1179{
1180 int i, retval = (-EIO);
1181 int resumed = 0;
1182 struct scsi_tape *STp;
1183 struct st_partstat *STps;
1184 int dev = TAPE_NR(inode);
1185 char *name;
1186
1187
1188
1189
1190
1191
1192 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1193
1194 if (!(STp = scsi_tape_get(dev))) {
1195 return -ENXIO;
1196 }
1197
1198 filp->private_data = STp;
1199 name = tape_name(STp);
1200
1201 spin_lock(&st_use_lock);
1202 if (STp->in_use) {
1203 spin_unlock(&st_use_lock);
1204 scsi_tape_put(STp);
1205 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1206 return (-EBUSY);
1207 }
1208
1209 STp->in_use = 1;
1210 spin_unlock(&st_use_lock);
1211 STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1212
1213 if (scsi_autopm_get_device(STp->device) < 0) {
1214 retval = -EIO;
1215 goto err_out;
1216 }
1217 resumed = 1;
1218 if (!scsi_block_when_processing_errors(STp->device)) {
1219 retval = (-ENXIO);
1220 goto err_out;
1221 }
1222
1223
1224 if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1225 printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n",
1226 name);
1227 retval = (-EOVERFLOW);
1228 goto err_out;
1229 }
1230
1231 (STp->buffer)->cleared = 0;
1232 (STp->buffer)->writing = 0;
1233 (STp->buffer)->syscall_result = 0;
1234
1235 STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1236
1237 STp->dirty = 0;
1238 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1239 STps = &(STp->ps[i]);
1240 STps->rw = ST_IDLE;
1241 }
1242 STp->try_dio_now = STp->try_dio;
1243 STp->recover_count = 0;
1244 DEB( STp->nbr_waits = STp->nbr_finished = 0;
1245 STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; )
1246
1247 retval = check_tape(STp, filp);
1248 if (retval < 0)
1249 goto err_out;
1250 if ((filp->f_flags & O_NONBLOCK) == 0 &&
1251 retval != CHKRES_READY) {
1252 if (STp->ready == NO_TAPE)
1253 retval = (-ENOMEDIUM);
1254 else
1255 retval = (-EIO);
1256 goto err_out;
1257 }
1258 return 0;
1259
1260 err_out:
1261 normalize_buffer(STp->buffer);
1262 spin_lock(&st_use_lock);
1263 STp->in_use = 0;
1264 spin_unlock(&st_use_lock);
1265 scsi_tape_put(STp);
1266 if (resumed)
1267 scsi_autopm_put_device(STp->device);
1268 return retval;
1269
1270}
1271
1272
1273
1274static int st_flush(struct file *filp, fl_owner_t id)
1275{
1276 int result = 0, result2;
1277 unsigned char cmd[MAX_COMMAND_SIZE];
1278 struct st_request *SRpnt;
1279 struct scsi_tape *STp = filp->private_data;
1280 struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1281 struct st_partstat *STps = &(STp->ps[STp->partition]);
1282 char *name = tape_name(STp);
1283
1284 if (file_count(filp) > 1)
1285 return 0;
1286
1287 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1288 result = st_flush_write_buffer(STp);
1289 if (result != 0 && result != (-ENOSPC))
1290 goto out;
1291 }
1292
1293 if (STp->can_partitions &&
1294 (result2 = switch_partition(STp)) < 0) {
1295 DEBC(printk(ST_DEB_MSG
1296 "%s: switch_partition at close failed.\n", name));
1297 if (result == 0)
1298 result = result2;
1299 goto out;
1300 }
1301
1302 DEBC( if (STp->nbr_requests)
1303 printk(KERN_DEBUG "%s: Number of r/w requests %d, dio used in %d, pages %d.\n",
1304 name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages));
1305
1306 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1307 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1308
1309 DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1310 name, STp->nbr_waits, STp->nbr_finished);
1311 )
1312
1313 memset(cmd, 0, MAX_COMMAND_SIZE);
1314 cmd[0] = WRITE_FILEMARKS;
1315 if (STp->immediate_filemark)
1316 cmd[1] = 1;
1317 cmd[4] = 1 + STp->two_fm;
1318
1319 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1320 STp->device->request_queue->rq_timeout,
1321 MAX_WRITE_RETRIES, 1);
1322 if (!SRpnt) {
1323 result = (STp->buffer)->syscall_result;
1324 goto out;
1325 }
1326
1327 if (STp->buffer->syscall_result == 0 ||
1328 (cmdstatp->have_sense && !cmdstatp->deferred &&
1329 (cmdstatp->flags & SENSE_EOM) &&
1330 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1331 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1332 (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1333
1334 st_release_request(SRpnt);
1335 SRpnt = NULL;
1336 if (STps->drv_file >= 0)
1337 STps->drv_file++;
1338 STps->drv_block = 0;
1339 if (STp->two_fm)
1340 cross_eof(STp, 0);
1341 STps->eof = ST_FM;
1342 }
1343 else {
1344 st_release_request(SRpnt);
1345 SRpnt = NULL;
1346 printk(KERN_ERR "%s: Error on write filemark.\n", name);
1347 if (result == 0)
1348 result = (-EIO);
1349 }
1350
1351 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1352 name, cmd[4]));
1353 } else if (!STp->rew_at_close) {
1354 STps = &(STp->ps[STp->partition]);
1355 if (!STm->sysv || STps->rw != ST_READING) {
1356 if (STp->can_bsr)
1357 result = flush_buffer(STp, 0);
1358 else if (STps->eof == ST_FM_HIT) {
1359 result = cross_eof(STp, 0);
1360 if (result) {
1361 if (STps->drv_file >= 0)
1362 STps->drv_file++;
1363 STps->drv_block = 0;
1364 STps->eof = ST_FM;
1365 } else
1366 STps->eof = ST_NOEOF;
1367 }
1368 } else if ((STps->eof == ST_NOEOF &&
1369 !(result = cross_eof(STp, 1))) ||
1370 STps->eof == ST_FM_HIT) {
1371 if (STps->drv_file >= 0)
1372 STps->drv_file++;
1373 STps->drv_block = 0;
1374 STps->eof = ST_FM;
1375 }
1376 }
1377
1378 out:
1379 if (STp->rew_at_close) {
1380 result2 = st_int_ioctl(STp, MTREW, 1);
1381 if (result == 0)
1382 result = result2;
1383 }
1384 return result;
1385}
1386
1387
1388
1389
1390static int st_release(struct inode *inode, struct file *filp)
1391{
1392 int result = 0;
1393 struct scsi_tape *STp = filp->private_data;
1394
1395 if (STp->door_locked == ST_LOCKED_AUTO)
1396 do_door_lock(STp, 0);
1397
1398 normalize_buffer(STp->buffer);
1399 spin_lock(&st_use_lock);
1400 STp->in_use = 0;
1401 spin_unlock(&st_use_lock);
1402 scsi_autopm_put_device(STp->device);
1403 scsi_tape_put(STp);
1404
1405 return result;
1406}
1407
1408
1409static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1410{
1411 ssize_t retval = 0;
1412
1413
1414
1415
1416
1417
1418
1419 if (!scsi_block_when_processing_errors(STp->device)) {
1420 retval = (-ENXIO);
1421 goto out;
1422 }
1423
1424 if (STp->ready != ST_READY) {
1425 if (STp->ready == ST_NO_TAPE)
1426 retval = (-ENOMEDIUM);
1427 else
1428 retval = (-EIO);
1429 goto out;
1430 }
1431
1432 if (! STp->modes[STp->current_mode].defined) {
1433 retval = (-ENXIO);
1434 goto out;
1435 }
1436
1437
1438
1439
1440
1441
1442 if (STp->pos_unknown) {
1443 retval = (-EIO);
1444 goto out;
1445 }
1446
1447 if (count == 0)
1448 goto out;
1449
1450 DEB(
1451 if (!STp->in_use) {
1452 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1453 retval = (-EIO);
1454 goto out;
1455 } )
1456
1457 if (STp->can_partitions &&
1458 (retval = switch_partition(STp)) < 0)
1459 goto out;
1460
1461 if (STp->block_size == 0 && STp->max_block > 0 &&
1462 (count < STp->min_block || count > STp->max_block)) {
1463 retval = (-EINVAL);
1464 goto out;
1465 }
1466
1467 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1468 !do_door_lock(STp, 1))
1469 STp->door_locked = ST_LOCKED_AUTO;
1470
1471 out:
1472 return retval;
1473}
1474
1475
1476static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1477 size_t count, int is_read)
1478{
1479 int i, bufsize, retval = 0;
1480 struct st_buffer *STbp = STp->buffer;
1481
1482 if (is_read)
1483 i = STp->try_dio_now && try_rdio;
1484 else
1485 i = STp->try_dio_now && try_wdio;
1486
1487 if (i && ((unsigned long)buf & queue_dma_alignment(
1488 STp->device->request_queue)) == 0) {
1489 i = sgl_map_user_pages(STbp, STbp->use_sg, (unsigned long)buf,
1490 count, (is_read ? READ : WRITE));
1491 if (i > 0) {
1492 STbp->do_dio = i;
1493 STbp->buffer_bytes = 0;
1494 }
1495 else
1496 STbp->do_dio = 0;
1497 STbp->sg_segs = STbp->do_dio;
1498 DEB(
1499 if (STbp->do_dio) {
1500 STp->nbr_dio++;
1501 STp->nbr_pages += STbp->do_dio;
1502 }
1503 )
1504 } else
1505 STbp->do_dio = 0;
1506 DEB( STp->nbr_requests++; )
1507
1508 if (!STbp->do_dio) {
1509 if (STp->block_size)
1510 bufsize = STp->block_size > st_fixed_buffer_size ?
1511 STp->block_size : st_fixed_buffer_size;
1512 else {
1513 bufsize = count;
1514
1515
1516 if (is_read && STp->sili && !STbp->cleared)
1517 clear_buffer(STbp);
1518 }
1519
1520 if (bufsize > STbp->buffer_size &&
1521 !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1522 printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1523 tape_name(STp), bufsize);
1524 retval = (-EOVERFLOW);
1525 goto out;
1526 }
1527 if (STp->block_size)
1528 STbp->buffer_blocks = bufsize / STp->block_size;
1529 }
1530
1531 out:
1532 return retval;
1533}
1534
1535
1536
1537static void release_buffering(struct scsi_tape *STp, int is_read)
1538{
1539 struct st_buffer *STbp;
1540
1541 STbp = STp->buffer;
1542 if (STbp->do_dio) {
1543 sgl_unmap_user_pages(STbp, STbp->do_dio, is_read);
1544 STbp->do_dio = 0;
1545 STbp->sg_segs = 0;
1546 }
1547}
1548
1549
1550
1551static ssize_t
1552st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1553{
1554 ssize_t total;
1555 ssize_t i, do_count, blks, transfer;
1556 ssize_t retval;
1557 int undone, retry_eot = 0, scode;
1558 int async_write;
1559 unsigned char cmd[MAX_COMMAND_SIZE];
1560 const char __user *b_point;
1561 struct st_request *SRpnt = NULL;
1562 struct scsi_tape *STp = filp->private_data;
1563 struct st_modedef *STm;
1564 struct st_partstat *STps;
1565 struct st_buffer *STbp;
1566 char *name = tape_name(STp);
1567
1568 if (mutex_lock_interruptible(&STp->lock))
1569 return -ERESTARTSYS;
1570
1571 retval = rw_checks(STp, filp, count);
1572 if (retval || count == 0)
1573 goto out;
1574
1575
1576 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1577 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1578 name);
1579 retval = (-EINVAL);
1580 goto out;
1581 }
1582
1583 STm = &(STp->modes[STp->current_mode]);
1584 STps = &(STp->ps[STp->partition]);
1585
1586 if (STp->write_prot) {
1587 retval = (-EACCES);
1588 goto out;
1589 }
1590
1591
1592 if (STps->rw == ST_READING) {
1593 retval = flush_buffer(STp, 0);
1594 if (retval)
1595 goto out;
1596 STps->rw = ST_WRITING;
1597 } else if (STps->rw != ST_WRITING &&
1598 STps->drv_file == 0 && STps->drv_block == 0) {
1599 if ((retval = set_mode_densblk(STp, STm)) < 0)
1600 goto out;
1601 if (STm->default_compression != ST_DONT_TOUCH &&
1602 !(STp->compression_changed)) {
1603 if (st_compression(STp, (STm->default_compression == ST_YES))) {
1604 printk(KERN_WARNING "%s: Can't set default compression.\n",
1605 name);
1606 if (modes_defined) {
1607 retval = (-EINVAL);
1608 goto out;
1609 }
1610 }
1611 }
1612 }
1613
1614 STbp = STp->buffer;
1615 i = write_behind_check(STp);
1616 if (i) {
1617 if (i == -ENOSPC)
1618 STps->eof = ST_EOM_OK;
1619 else
1620 STps->eof = ST_EOM_ERROR;
1621 }
1622
1623 if (STps->eof == ST_EOM_OK) {
1624 STps->eof = ST_EOD_1;
1625 retval = (-ENOSPC);
1626 goto out;
1627 }
1628 else if (STps->eof == ST_EOM_ERROR) {
1629 retval = (-EIO);
1630 goto out;
1631 }
1632
1633
1634
1635 if (STp->block_size != 0 &&
1636 !STbp->do_dio &&
1637 (copy_from_user(&i, buf, 1) != 0 ||
1638 copy_from_user(&i, buf + count - 1, 1) != 0)) {
1639 retval = (-EFAULT);
1640 goto out;
1641 }
1642
1643 retval = setup_buffering(STp, buf, count, 0);
1644 if (retval)
1645 goto out;
1646
1647 total = count;
1648
1649 memset(cmd, 0, MAX_COMMAND_SIZE);
1650 cmd[0] = WRITE_6;
1651 cmd[1] = (STp->block_size != 0);
1652
1653 STps->rw = ST_WRITING;
1654
1655 b_point = buf;
1656 while (count > 0 && !retry_eot) {
1657
1658 if (STbp->do_dio) {
1659 do_count = count;
1660 }
1661 else {
1662 if (STp->block_size == 0)
1663 do_count = count;
1664 else {
1665 do_count = STbp->buffer_blocks * STp->block_size -
1666 STbp->buffer_bytes;
1667 if (do_count > count)
1668 do_count = count;
1669 }
1670
1671 i = append_to_buffer(b_point, STbp, do_count);
1672 if (i) {
1673 retval = i;
1674 goto out;
1675 }
1676 }
1677 count -= do_count;
1678 b_point += do_count;
1679
1680 async_write = STp->block_size == 0 && !STbp->do_dio &&
1681 STm->do_async_writes && STps->eof < ST_EOM_OK;
1682
1683 if (STp->block_size != 0 && STm->do_buffer_writes &&
1684 !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK &&
1685 STbp->buffer_bytes < STbp->buffer_size) {
1686 STp->dirty = 1;
1687
1688 if (!async_write && count == 0)
1689 break;
1690 }
1691
1692 retry_write:
1693 if (STp->block_size == 0)
1694 blks = transfer = do_count;
1695 else {
1696 if (!STbp->do_dio)
1697 blks = STbp->buffer_bytes;
1698 else
1699 blks = do_count;
1700 blks /= STp->block_size;
1701 transfer = blks * STp->block_size;
1702 }
1703 cmd[2] = blks >> 16;
1704 cmd[3] = blks >> 8;
1705 cmd[4] = blks;
1706
1707 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1708 STp->device->request_queue->rq_timeout,
1709 MAX_WRITE_RETRIES, !async_write);
1710 if (!SRpnt) {
1711 retval = STbp->syscall_result;
1712 goto out;
1713 }
1714 if (async_write && !STbp->syscall_result) {
1715 STbp->writing = transfer;
1716 STp->dirty = !(STbp->writing ==
1717 STbp->buffer_bytes);
1718 SRpnt = NULL;
1719 DEB( STp->write_pending = 1; )
1720 break;
1721 }
1722
1723 if (STbp->syscall_result != 0) {
1724 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1725
1726 DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1727 if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1728 scode = cmdstatp->sense_hdr.sense_key;
1729 if (cmdstatp->remainder_valid)
1730 undone = (int)cmdstatp->uremainder64;
1731 else if (STp->block_size == 0 &&
1732 scode == VOLUME_OVERFLOW)
1733 undone = transfer;
1734 else
1735 undone = 0;
1736 if (STp->block_size != 0)
1737 undone *= STp->block_size;
1738 if (undone <= do_count) {
1739
1740 count += undone;
1741 b_point -= undone;
1742 do_count -= undone;
1743 if (STp->block_size)
1744 blks = (transfer - undone) / STp->block_size;
1745 STps->eof = ST_EOM_OK;
1746
1747
1748
1749
1750 if (STp->block_size == 0 ||
1751 undone > 0 || count == 0)
1752 retval = (-ENOSPC);
1753 DEBC(printk(ST_DEB_MSG
1754 "%s: EOM with %d bytes unwritten.\n",
1755 name, (int)count));
1756 } else {
1757
1758
1759 if (!retry_eot && !cmdstatp->deferred &&
1760 (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1761 move_buffer_data(STp->buffer, transfer - undone);
1762 retry_eot = 1;
1763 if (STps->drv_block >= 0) {
1764 STps->drv_block += (transfer - undone) /
1765 STp->block_size;
1766 }
1767 STps->eof = ST_EOM_OK;
1768 DEBC(printk(ST_DEB_MSG
1769 "%s: Retry write of %d bytes at EOM.\n",
1770 name, STp->buffer->buffer_bytes));
1771 goto retry_write;
1772 }
1773 else {
1774
1775
1776 count -= do_count;
1777 blks = do_count = 0;
1778 STps->eof = ST_EOM_ERROR;
1779 STps->drv_block = (-1);
1780 retval = (-EIO);
1781 DEBC(printk(ST_DEB_MSG
1782 "%s: EOM with lost data.\n",
1783 name));
1784 }
1785 }
1786 } else {
1787 count += do_count;
1788 STps->drv_block = (-1);
1789 retval = STbp->syscall_result;
1790 }
1791
1792 }
1793
1794 if (STps->drv_block >= 0) {
1795 if (STp->block_size == 0)
1796 STps->drv_block += (do_count > 0);
1797 else
1798 STps->drv_block += blks;
1799 }
1800
1801 STbp->buffer_bytes = 0;
1802 STp->dirty = 0;
1803
1804 if (retval || retry_eot) {
1805 if (count < total)
1806 retval = total - count;
1807 goto out;
1808 }
1809 }
1810
1811 if (STps->eof == ST_EOD_1)
1812 STps->eof = ST_EOM_OK;
1813 else if (STps->eof != ST_EOM_OK)
1814 STps->eof = ST_NOEOF;
1815 retval = total - count;
1816
1817 out:
1818 if (SRpnt != NULL)
1819 st_release_request(SRpnt);
1820 release_buffering(STp, 0);
1821 mutex_unlock(&STp->lock);
1822
1823 return retval;
1824}
1825
1826
1827
1828
1829
1830
1831
1832static long read_tape(struct scsi_tape *STp, long count,
1833 struct st_request ** aSRpnt)
1834{
1835 int transfer, blks, bytes;
1836 unsigned char cmd[MAX_COMMAND_SIZE];
1837 struct st_request *SRpnt;
1838 struct st_modedef *STm;
1839 struct st_partstat *STps;
1840 struct st_buffer *STbp;
1841 int retval = 0;
1842 char *name = tape_name(STp);
1843
1844 if (count == 0)
1845 return 0;
1846
1847 STm = &(STp->modes[STp->current_mode]);
1848 STps = &(STp->ps[STp->partition]);
1849 if (STps->eof == ST_FM_HIT)
1850 return 1;
1851 STbp = STp->buffer;
1852
1853 if (STp->block_size == 0)
1854 blks = bytes = count;
1855 else {
1856 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
1857 blks = (STp->buffer)->buffer_blocks;
1858 bytes = blks * STp->block_size;
1859 } else {
1860 bytes = count;
1861 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1862 bytes = (STp->buffer)->buffer_size;
1863 blks = bytes / STp->block_size;
1864 bytes = blks * STp->block_size;
1865 }
1866 }
1867
1868 memset(cmd, 0, MAX_COMMAND_SIZE);
1869 cmd[0] = READ_6;
1870 cmd[1] = (STp->block_size != 0);
1871 if (!cmd[1] && STp->sili)
1872 cmd[1] |= 2;
1873 cmd[2] = blks >> 16;
1874 cmd[3] = blks >> 8;
1875 cmd[4] = blks;
1876
1877 SRpnt = *aSRpnt;
1878 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1879 STp->device->request_queue->rq_timeout,
1880 MAX_RETRIES, 1);
1881 release_buffering(STp, 1);
1882 *aSRpnt = SRpnt;
1883 if (!SRpnt)
1884 return STbp->syscall_result;
1885
1886 STbp->read_pointer = 0;
1887 STps->at_sm = 0;
1888
1889
1890 if (STbp->syscall_result) {
1891 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1892
1893 retval = 1;
1894 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1895 name,
1896 SRpnt->sense[0], SRpnt->sense[1],
1897 SRpnt->sense[2], SRpnt->sense[3],
1898 SRpnt->sense[4], SRpnt->sense[5],
1899 SRpnt->sense[6], SRpnt->sense[7]));
1900 if (cmdstatp->have_sense) {
1901
1902 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1903 cmdstatp->flags &= 0xcf;
1904
1905 if (cmdstatp->flags != 0) {
1906
1907 if (cmdstatp->remainder_valid)
1908 transfer = (int)cmdstatp->uremainder64;
1909 else
1910 transfer = 0;
1911 if (STp->block_size == 0 &&
1912 cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1913 transfer = bytes;
1914
1915 if (cmdstatp->flags & SENSE_ILI) {
1916 if (STp->block_size == 0) {
1917 if (transfer <= 0) {
1918 if (transfer < 0)
1919 printk(KERN_NOTICE
1920 "%s: Failed to read %d byte block with %d byte transfer.\n",
1921 name, bytes - transfer, bytes);
1922 if (STps->drv_block >= 0)
1923 STps->drv_block += 1;
1924 STbp->buffer_bytes = 0;
1925 return (-ENOMEM);
1926 }
1927 STbp->buffer_bytes = bytes - transfer;
1928 } else {
1929 st_release_request(SRpnt);
1930 SRpnt = *aSRpnt = NULL;
1931 if (transfer == blks) {
1932 printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1933 if (STps->drv_block >= 0)
1934 STps->drv_block += blks - transfer + 1;
1935 st_int_ioctl(STp, MTBSR, 1);
1936 return (-EIO);
1937 }
1938
1939 STbp->buffer_bytes = (blks - transfer) *
1940 STp->block_size;
1941 DEBC(printk(ST_DEB_MSG
1942 "%s: ILI but enough data received %ld %d.\n",
1943 name, count, STbp->buffer_bytes));
1944 if (STps->drv_block >= 0)
1945 STps->drv_block += 1;
1946 if (st_int_ioctl(STp, MTBSR, 1))
1947 return (-EIO);
1948 }
1949 } else if (cmdstatp->flags & SENSE_FMK) {
1950 if (STps->eof != ST_FM_HIT)
1951 STps->eof = ST_FM_HIT;
1952 else
1953 STps->eof = ST_EOD_2;
1954 if (STp->block_size == 0)
1955 STbp->buffer_bytes = 0;
1956 else
1957 STbp->buffer_bytes =
1958 bytes - transfer * STp->block_size;
1959 DEBC(printk(ST_DEB_MSG
1960 "%s: EOF detected (%d bytes read).\n",
1961 name, STbp->buffer_bytes));
1962 } else if (cmdstatp->flags & SENSE_EOM) {
1963 if (STps->eof == ST_FM)
1964 STps->eof = ST_EOD_1;
1965 else
1966 STps->eof = ST_EOM_OK;
1967 if (STp->block_size == 0)
1968 STbp->buffer_bytes = bytes - transfer;
1969 else
1970 STbp->buffer_bytes =
1971 bytes - transfer * STp->block_size;
1972
1973 DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1974 name, STbp->buffer_bytes));
1975 }
1976 }
1977
1978 else {
1979 DEBC(printk(ST_DEB_MSG
1980 "%s: Tape error while reading.\n", name));
1981 STps->drv_block = (-1);
1982 if (STps->eof == ST_FM &&
1983 cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
1984 DEBC(printk(ST_DEB_MSG
1985 "%s: Zero returned for first BLANK CHECK after EOF.\n",
1986 name));
1987 STps->eof = ST_EOD_2;
1988 } else
1989 retval = (-EIO);
1990 }
1991
1992 if (STbp->buffer_bytes < 0)
1993 STbp->buffer_bytes = 0;
1994 }
1995
1996 else {
1997 retval = STbp->syscall_result;
1998 }
1999
2000 }
2001
2002 else {
2003 STbp->buffer_bytes = bytes;
2004 if (STp->sili)
2005 STbp->buffer_bytes -= STp->buffer->cmdstat.residual;
2006 }
2007
2008 if (STps->drv_block >= 0) {
2009 if (STp->block_size == 0)
2010 STps->drv_block++;
2011 else
2012 STps->drv_block += STbp->buffer_bytes / STp->block_size;
2013 }
2014 return retval;
2015}
2016
2017
2018
2019static ssize_t
2020st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
2021{
2022 ssize_t total;
2023 ssize_t retval = 0;
2024 ssize_t i, transfer;
2025 int special, do_dio = 0;
2026 struct st_request *SRpnt = NULL;
2027 struct scsi_tape *STp = filp->private_data;
2028 struct st_modedef *STm;
2029 struct st_partstat *STps;
2030 struct st_buffer *STbp = STp->buffer;
2031 DEB( char *name = tape_name(STp); )
2032
2033 if (mutex_lock_interruptible(&STp->lock))
2034 return -ERESTARTSYS;
2035
2036 retval = rw_checks(STp, filp, count);
2037 if (retval || count == 0)
2038 goto out;
2039
2040 STm = &(STp->modes[STp->current_mode]);
2041 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
2042 if (!STm->do_read_ahead) {
2043 retval = (-EINVAL);
2044 goto out;
2045 }
2046 STp->try_dio_now = 0;
2047 }
2048
2049 STps = &(STp->ps[STp->partition]);
2050 if (STps->rw == ST_WRITING) {
2051 retval = flush_buffer(STp, 0);
2052 if (retval)
2053 goto out;
2054 STps->rw = ST_READING;
2055 }
2056 DEB(
2057 if (debugging && STps->eof != ST_NOEOF)
2058 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
2059 STps->eof, STbp->buffer_bytes);
2060 )
2061
2062 retval = setup_buffering(STp, buf, count, 1);
2063 if (retval)
2064 goto out;
2065 do_dio = STbp->do_dio;
2066
2067 if (STbp->buffer_bytes == 0 &&
2068 STps->eof >= ST_EOD_1) {
2069 if (STps->eof < ST_EOD) {
2070 STps->eof += 1;
2071 retval = 0;
2072 goto out;
2073 }
2074 retval = (-EIO);
2075 goto out;
2076 }
2077
2078 if (do_dio) {
2079
2080
2081 if (copy_from_user(&i, buf, 1) != 0 ||
2082 copy_to_user(buf, &i, 1) != 0 ||
2083 copy_from_user(&i, buf + count - 1, 1) != 0 ||
2084 copy_to_user(buf + count - 1, &i, 1) != 0) {
2085 retval = (-EFAULT);
2086 goto out;
2087 }
2088 }
2089
2090 STps->rw = ST_READING;
2091
2092
2093
2094 for (total = 0, special = 0; total < count && !special;) {
2095
2096
2097 if (STbp->buffer_bytes == 0) {
2098 special = read_tape(STp, count - total, &SRpnt);
2099 if (special < 0) {
2100 retval = special;
2101 goto out;
2102 }
2103 }
2104
2105
2106 if (STbp->buffer_bytes > 0) {
2107 DEB(
2108 if (debugging && STps->eof != ST_NOEOF)
2109 printk(ST_DEB_MSG
2110 "%s: EOF up (%d). Left %d, needed %d.\n", name,
2111 STps->eof, STbp->buffer_bytes,
2112 (int)(count - total));
2113 )
2114 transfer = STbp->buffer_bytes < count - total ?
2115 STbp->buffer_bytes : count - total;
2116 if (!do_dio) {
2117 i = from_buffer(STbp, buf, transfer);
2118 if (i) {
2119 retval = i;
2120 goto out;
2121 }
2122 }
2123 buf += transfer;
2124 total += transfer;
2125 }
2126
2127 if (STp->block_size == 0)
2128 break;
2129
2130 }
2131
2132
2133
2134 if (total == 0) {
2135 if (STps->eof == ST_FM_HIT) {
2136 STps->eof = ST_FM;
2137 STps->drv_block = 0;
2138 if (STps->drv_file >= 0)
2139 STps->drv_file++;
2140 } else if (STps->eof == ST_EOD_1) {
2141 STps->eof = ST_EOD_2;
2142 STps->drv_block = 0;
2143 if (STps->drv_file >= 0)
2144 STps->drv_file++;
2145 } else if (STps->eof == ST_EOD_2)
2146 STps->eof = ST_EOD;
2147 } else if (STps->eof == ST_FM)
2148 STps->eof = ST_NOEOF;
2149 retval = total;
2150
2151 out:
2152 if (SRpnt != NULL) {
2153 st_release_request(SRpnt);
2154 SRpnt = NULL;
2155 }
2156 if (do_dio) {
2157 release_buffering(STp, 1);
2158 STbp->buffer_bytes = 0;
2159 }
2160 mutex_unlock(&STp->lock);
2161
2162 return retval;
2163}
2164
2165
2166
2167DEB(
2168
2169static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2170{
2171 if (debugging) {
2172 printk(KERN_INFO
2173 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2174 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2175 STm->do_read_ahead);
2176 printk(KERN_INFO
2177 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2178 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2179 printk(KERN_INFO
2180 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2181 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2182 STp->scsi2_logical);
2183 printk(KERN_INFO
2184 "%s: sysv: %d nowait: %d sili: %d nowait_filemark: %d\n",
2185 name, STm->sysv, STp->immediate, STp->sili,
2186 STp->immediate_filemark);
2187 printk(KERN_INFO "%s: debugging: %d\n",
2188 name, debugging);
2189 }
2190}
2191 )
2192
2193
2194static int st_set_options(struct scsi_tape *STp, long options)
2195{
2196 int value;
2197 long code;
2198 struct st_modedef *STm;
2199 char *name = tape_name(STp);
2200 struct cdev *cd0, *cd1;
2201
2202 STm = &(STp->modes[STp->current_mode]);
2203 if (!STm->defined) {
2204 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2205 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2206 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2207 modes_defined = 1;
2208 DEBC(printk(ST_DEB_MSG
2209 "%s: Initialized mode %d definition from mode 0\n",
2210 name, STp->current_mode));
2211 }
2212
2213 code = options & MT_ST_OPTIONS;
2214 if (code == MT_ST_BOOLEANS) {
2215 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2216 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2217 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2218 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2219 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2220 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2221 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2222 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2223 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2224 if ((STp->device)->scsi_level >= SCSI_2)
2225 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2226 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2227 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2228 STp->immediate_filemark = (options & MT_ST_NOWAIT_EOF) != 0;
2229 STm->sysv = (options & MT_ST_SYSV) != 0;
2230 STp->sili = (options & MT_ST_SILI) != 0;
2231 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2232 st_log_options(STp, STm, name); )
2233 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2234 value = (code == MT_ST_SETBOOLEANS);
2235 if ((options & MT_ST_BUFFER_WRITES) != 0)
2236 STm->do_buffer_writes = value;
2237 if ((options & MT_ST_ASYNC_WRITES) != 0)
2238 STm->do_async_writes = value;
2239 if ((options & MT_ST_DEF_WRITES) != 0)
2240 STm->defaults_for_writes = value;
2241 if ((options & MT_ST_READ_AHEAD) != 0)
2242 STm->do_read_ahead = value;
2243 if ((options & MT_ST_TWO_FM) != 0)
2244 STp->two_fm = value;
2245 if ((options & MT_ST_FAST_MTEOM) != 0)
2246 STp->fast_mteom = value;
2247 if ((options & MT_ST_AUTO_LOCK) != 0)
2248 STp->do_auto_lock = value;
2249 if ((options & MT_ST_CAN_BSR) != 0)
2250 STp->can_bsr = value;
2251 if ((options & MT_ST_NO_BLKLIMS) != 0)
2252 STp->omit_blklims = value;
2253 if ((STp->device)->scsi_level >= SCSI_2 &&
2254 (options & MT_ST_CAN_PARTITIONS) != 0)
2255 STp->can_partitions = value;
2256 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2257 STp->scsi2_logical = value;
2258 if ((options & MT_ST_NOWAIT) != 0)
2259 STp->immediate = value;
2260 if ((options & MT_ST_NOWAIT_EOF) != 0)
2261 STp->immediate_filemark = value;
2262 if ((options & MT_ST_SYSV) != 0)
2263 STm->sysv = value;
2264 if ((options & MT_ST_SILI) != 0)
2265 STp->sili = value;
2266 DEB(
2267 if ((options & MT_ST_DEBUGGING) != 0)
2268 debugging = value;
2269 st_log_options(STp, STm, name); )
2270 } else if (code == MT_ST_WRITE_THRESHOLD) {
2271
2272 } else if (code == MT_ST_DEF_BLKSIZE) {
2273 value = (options & ~MT_ST_OPTIONS);
2274 if (value == ~MT_ST_OPTIONS) {
2275 STm->default_blksize = (-1);
2276 DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2277 } else {
2278 STm->default_blksize = value;
2279 DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2280 name, STm->default_blksize));
2281 if (STp->ready == ST_READY) {
2282 STp->blksize_changed = 0;
2283 set_mode_densblk(STp, STm);
2284 }
2285 }
2286 } else if (code == MT_ST_TIMEOUTS) {
2287 value = (options & ~MT_ST_OPTIONS);
2288 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2289 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2290 DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2291 (value & ~MT_ST_SET_LONG_TIMEOUT)));
2292 } else {
2293 blk_queue_rq_timeout(STp->device->request_queue,
2294 value * HZ);
2295 DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2296 name, value) );
2297 }
2298 } else if (code == MT_ST_SET_CLN) {
2299 value = (options & ~MT_ST_OPTIONS) & 0xff;
2300 if (value != 0 &&
2301 (value < EXTENDED_SENSE_START ||
2302 value >= SCSI_SENSE_BUFFERSIZE))
2303 return (-EINVAL);
2304 STp->cln_mode = value;
2305 STp->cln_sense_mask = (options >> 8) & 0xff;
2306 STp->cln_sense_value = (options >> 16) & 0xff;
2307 printk(KERN_INFO
2308 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2309 name, value, STp->cln_sense_mask, STp->cln_sense_value);
2310 } else if (code == MT_ST_DEF_OPTIONS) {
2311 code = (options & ~MT_ST_CLEAR_DEFAULT);
2312 value = (options & MT_ST_CLEAR_DEFAULT);
2313 if (code == MT_ST_DEF_DENSITY) {
2314 if (value == MT_ST_CLEAR_DEFAULT) {
2315 STm->default_density = (-1);
2316 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2317 name));
2318 } else {
2319 STm->default_density = value & 0xff;
2320 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2321 name, STm->default_density));
2322 if (STp->ready == ST_READY) {
2323 STp->density_changed = 0;
2324 set_mode_densblk(STp, STm);
2325 }
2326 }
2327 } else if (code == MT_ST_DEF_DRVBUFFER) {
2328 if (value == MT_ST_CLEAR_DEFAULT) {
2329 STp->default_drvbuffer = 0xff;
2330 DEBC( printk(KERN_INFO
2331 "%s: Drive buffer default disabled.\n", name));
2332 } else {
2333 STp->default_drvbuffer = value & 7;
2334 DEBC( printk(KERN_INFO
2335 "%s: Drive buffer default set to %x\n",
2336 name, STp->default_drvbuffer));
2337 if (STp->ready == ST_READY)
2338 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2339 }
2340 } else if (code == MT_ST_DEF_COMPRESSION) {
2341 if (value == MT_ST_CLEAR_DEFAULT) {
2342 STm->default_compression = ST_DONT_TOUCH;
2343 DEBC( printk(KERN_INFO
2344 "%s: Compression default disabled.\n", name));
2345 } else {
2346 if ((value & 0xff00) != 0) {
2347 STp->c_algo = (value & 0xff00) >> 8;
2348 DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2349 name, STp->c_algo));
2350 }
2351 if ((value & 0xff) != 0xff) {
2352 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2353 DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2354 name, (value & 1)));
2355 if (STp->ready == ST_READY) {
2356 STp->compression_changed = 0;
2357 st_compression(STp, (STm->default_compression == ST_YES));
2358 }
2359 }
2360 }
2361 }
2362 } else
2363 return (-EIO);
2364
2365 return 0;
2366}
2367
2368#define MODE_HEADER_LENGTH 4
2369
2370
2371#define MH_OFF_DATA_LENGTH 0
2372#define MH_OFF_MEDIUM_TYPE 1
2373#define MH_OFF_DEV_SPECIFIC 2
2374#define MH_OFF_BDESCS_LENGTH 3
2375#define MP_OFF_PAGE_NBR 0
2376#define MP_OFF_PAGE_LENGTH 1
2377
2378
2379#define MH_BIT_WP 0x80
2380#define MP_MSK_PAGE_NBR 0x3f
2381
2382
2383#define MODE_SENSE_OMIT_BDESCS 0x08
2384
2385#define MODE_SELECT_PAGE_FORMAT 0x10
2386
2387
2388
2389
2390static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2391{
2392 unsigned char cmd[MAX_COMMAND_SIZE];
2393 struct st_request *SRpnt;
2394
2395 memset(cmd, 0, MAX_COMMAND_SIZE);
2396 cmd[0] = MODE_SENSE;
2397 if (omit_block_descs)
2398 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2399 cmd[2] = page;
2400 cmd[4] = 255;
2401
2402 SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2403 STp->device->request_queue->rq_timeout, 0, 1);
2404 if (SRpnt == NULL)
2405 return (STp->buffer)->syscall_result;
2406
2407 st_release_request(SRpnt);
2408
2409 return STp->buffer->syscall_result;
2410}
2411
2412
2413
2414
2415static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2416{
2417 int pgo;
2418 unsigned char cmd[MAX_COMMAND_SIZE];
2419 struct st_request *SRpnt;
2420 int timeout;
2421
2422 memset(cmd, 0, MAX_COMMAND_SIZE);
2423 cmd[0] = MODE_SELECT;
2424 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2425 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2426 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2427
2428
2429 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2430 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2431 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2432 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2433
2434 timeout = slow ?
2435 STp->long_timeout : STp->device->request_queue->rq_timeout;
2436 SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_TO_DEVICE,
2437 timeout, 0, 1);
2438 if (SRpnt == NULL)
2439 return (STp->buffer)->syscall_result;
2440
2441 st_release_request(SRpnt);
2442
2443 return STp->buffer->syscall_result;
2444}
2445
2446
2447#define COMPRESSION_PAGE 0x0f
2448#define COMPRESSION_PAGE_LENGTH 16
2449
2450#define CP_OFF_DCE_DCC 2
2451#define CP_OFF_C_ALGO 7
2452
2453#define DCE_MASK 0x80
2454#define DCC_MASK 0x40
2455#define RED_MASK 0x60
2456
2457
2458
2459
2460
2461
2462
2463
2464static int st_compression(struct scsi_tape * STp, int state)
2465{
2466 int retval;
2467 int mpoffs;
2468 unsigned char *b_data = (STp->buffer)->b_data;
2469 DEB( char *name = tape_name(STp); )
2470
2471 if (STp->ready != ST_READY)
2472 return (-EIO);
2473
2474
2475 retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2476 if (retval) {
2477 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2478 name));
2479 return (-EIO);
2480 }
2481
2482 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2483 DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2484 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2485
2486
2487 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2488 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2489 return (-EIO);
2490 }
2491
2492
2493 if (state) {
2494 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2495 if (STp->c_algo != 0)
2496 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2497 }
2498 else {
2499 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2500 if (STp->c_algo != 0)
2501 b_data[mpoffs + CP_OFF_C_ALGO] = 0;
2502 }
2503
2504 retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2505 if (retval) {
2506 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2507 return (-EIO);
2508 }
2509 DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2510 name, state));
2511
2512 STp->compression_changed = 1;
2513 return 0;
2514}
2515
2516
2517
2518static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2519{
2520 int retval = (-EIO), timeout;
2521 DEB( char *name = tape_name(STp); )
2522 unsigned char cmd[MAX_COMMAND_SIZE];
2523 struct st_partstat *STps;
2524 struct st_request *SRpnt;
2525
2526 if (STp->ready != ST_READY && !load_code) {
2527 if (STp->ready == ST_NO_TAPE)
2528 return (-ENOMEDIUM);
2529 else
2530 return (-EIO);
2531 }
2532
2533 memset(cmd, 0, MAX_COMMAND_SIZE);
2534 cmd[0] = START_STOP;
2535 if (load_code)
2536 cmd[4] |= 1;
2537
2538
2539
2540 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2541 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2542 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2543 name, (cmd[4]) ? "" : "un",
2544 load_code - MT_ST_HPLOADER_OFFSET));
2545 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET;
2546 }
2547 if (STp->immediate) {
2548 cmd[1] = 1;
2549 timeout = STp->device->request_queue->rq_timeout;
2550 }
2551 else
2552 timeout = STp->long_timeout;
2553
2554 DEBC(
2555 if (!load_code)
2556 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2557 else
2558 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2559 );
2560
2561 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2562 timeout, MAX_RETRIES, 1);
2563 if (!SRpnt)
2564 return (STp->buffer)->syscall_result;
2565
2566 retval = (STp->buffer)->syscall_result;
2567 st_release_request(SRpnt);
2568
2569 if (!retval) {
2570
2571 if (!load_code) {
2572 STp->rew_at_close = 0;
2573 STp->ready = ST_NO_TAPE;
2574 }
2575 else {
2576 STp->rew_at_close = STp->autorew_dev;
2577 retval = check_tape(STp, filp);
2578 if (retval > 0)
2579 retval = 0;
2580 }
2581 }
2582 else {
2583 STps = &(STp->ps[STp->partition]);
2584 STps->drv_file = STps->drv_block = (-1);
2585 }
2586
2587 return retval;
2588}
2589
2590#if DEBUG
2591#define ST_DEB_FORWARD 0
2592#define ST_DEB_BACKWARD 1
2593static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2594{
2595 s32 sc;
2596
2597 sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2598 sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2599 if (direction)
2600 sc = -sc;
2601 printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2602 direction ? "backward" : "forward", sc, units);
2603}
2604#endif
2605
2606
2607
2608static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2609{
2610 int timeout;
2611 long ltmp;
2612 int ioctl_result;
2613 int chg_eof = 1;
2614 unsigned char cmd[MAX_COMMAND_SIZE];
2615 struct st_request *SRpnt;
2616 struct st_partstat *STps;
2617 int fileno, blkno, at_sm, undone;
2618 int datalen = 0, direction = DMA_NONE;
2619 char *name = tape_name(STp);
2620
2621 WARN_ON(STp->buffer->do_dio != 0);
2622 if (STp->ready != ST_READY) {
2623 if (STp->ready == ST_NO_TAPE)
2624 return (-ENOMEDIUM);
2625 else
2626 return (-EIO);
2627 }
2628 timeout = STp->long_timeout;
2629 STps = &(STp->ps[STp->partition]);
2630 fileno = STps->drv_file;
2631 blkno = STps->drv_block;
2632 at_sm = STps->at_sm;
2633
2634 memset(cmd, 0, MAX_COMMAND_SIZE);
2635 switch (cmd_in) {
2636 case MTFSFM:
2637 chg_eof = 0;
2638 case MTFSF:
2639 cmd[0] = SPACE;
2640 cmd[1] = 0x01;
2641 cmd[2] = (arg >> 16);
2642 cmd[3] = (arg >> 8);
2643 cmd[4] = arg;
2644 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2645 if (fileno >= 0)
2646 fileno += arg;
2647 blkno = 0;
2648 at_sm &= (arg == 0);
2649 break;
2650 case MTBSFM:
2651 chg_eof = 0;
2652 case MTBSF:
2653 cmd[0] = SPACE;
2654 cmd[1] = 0x01;
2655 ltmp = (-arg);
2656 cmd[2] = (ltmp >> 16);
2657 cmd[3] = (ltmp >> 8);
2658 cmd[4] = ltmp;
2659 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2660 if (fileno >= 0)
2661 fileno -= arg;
2662 blkno = (-1);
2663 at_sm &= (arg == 0);
2664 break;
2665 case MTFSR:
2666 cmd[0] = SPACE;
2667 cmd[1] = 0x00;
2668 cmd[2] = (arg >> 16);
2669 cmd[3] = (arg >> 8);
2670 cmd[4] = arg;
2671 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2672 if (blkno >= 0)
2673 blkno += arg;
2674 at_sm &= (arg == 0);
2675 break;
2676 case MTBSR:
2677 cmd[0] = SPACE;
2678 cmd[1] = 0x00;
2679 ltmp = (-arg);
2680 cmd[2] = (ltmp >> 16);
2681 cmd[3] = (ltmp >> 8);
2682 cmd[4] = ltmp;
2683 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2684 if (blkno >= 0)
2685 blkno -= arg;
2686 at_sm &= (arg == 0);
2687 break;
2688 case MTFSS:
2689 cmd[0] = SPACE;
2690 cmd[1] = 0x04;
2691 cmd[2] = (arg >> 16);
2692 cmd[3] = (arg >> 8);
2693 cmd[4] = arg;
2694 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2695 if (arg != 0) {
2696 blkno = fileno = (-1);
2697 at_sm = 1;
2698 }
2699 break;
2700 case MTBSS:
2701 cmd[0] = SPACE;
2702 cmd[1] = 0x04;
2703 ltmp = (-arg);
2704 cmd[2] = (ltmp >> 16);
2705 cmd[3] = (ltmp >> 8);
2706 cmd[4] = ltmp;
2707 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2708 if (arg != 0) {
2709 blkno = fileno = (-1);
2710 at_sm = 1;
2711 }
2712 break;
2713 case MTWEOF:
2714 case MTWEOFI:
2715 case MTWSM:
2716 if (STp->write_prot)
2717 return (-EACCES);
2718 cmd[0] = WRITE_FILEMARKS;
2719 if (cmd_in == MTWSM)
2720 cmd[1] = 2;
2721 if (cmd_in == MTWEOFI ||
2722 (cmd_in == MTWEOF && STp->immediate_filemark))
2723 cmd[1] |= 1;
2724 cmd[2] = (arg >> 16);
2725 cmd[3] = (arg >> 8);
2726 cmd[4] = arg;
2727 timeout = STp->device->request_queue->rq_timeout;
2728 DEBC(
2729 if (cmd_in != MTWSM)
2730 printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2731 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2732 else
2733 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2734 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2735 )
2736 if (fileno >= 0)
2737 fileno += arg;
2738 blkno = 0;
2739 at_sm = (cmd_in == MTWSM);
2740 break;
2741 case MTREW:
2742 cmd[0] = REZERO_UNIT;
2743 if (STp->immediate) {
2744 cmd[1] = 1;
2745 timeout = STp->device->request_queue->rq_timeout;
2746 }
2747 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2748 fileno = blkno = at_sm = 0;
2749 break;
2750 case MTNOP:
2751 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2752 return 0;
2753 break;
2754 case MTRETEN:
2755 cmd[0] = START_STOP;
2756 if (STp->immediate) {
2757 cmd[1] = 1;
2758 timeout = STp->device->request_queue->rq_timeout;
2759 }
2760 cmd[4] = 3;
2761 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2762 fileno = blkno = at_sm = 0;
2763 break;
2764 case MTEOM:
2765 if (!STp->fast_mteom) {
2766
2767 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2768 fileno = STps->drv_file;
2769 if (STps->eof >= ST_EOD_1)
2770 return 0;
2771
2772
2773
2774
2775 } else
2776 fileno = (-1);
2777 cmd[0] = SPACE;
2778 cmd[1] = 3;
2779 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2780 name));
2781 blkno = -1;
2782 at_sm = 0;
2783 break;
2784 case MTERASE:
2785 if (STp->write_prot)
2786 return (-EACCES);
2787 cmd[0] = ERASE;
2788 cmd[1] = (arg ? 1 : 0);
2789 if (STp->immediate) {
2790 cmd[1] |= 2;
2791 timeout = STp->device->request_queue->rq_timeout;
2792 }
2793 else
2794 timeout = STp->long_timeout * 8;
2795
2796 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2797 fileno = blkno = at_sm = 0;
2798 break;
2799 case MTSETBLK:
2800 case MTSETDENSITY:
2801 case MTSETDRVBUFFER:
2802 case SET_DENS_AND_BLK:
2803 chg_eof = 0;
2804 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2805 return (-EIO);
2806 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2807 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2808 STp->max_block > 0 &&
2809 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2810 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2811 printk(KERN_WARNING "%s: Illegal block size.\n", name);
2812 return (-EINVAL);
2813 }
2814 cmd[0] = MODE_SELECT;
2815 if ((STp->use_pf & USE_PF))
2816 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2817 cmd[4] = datalen = 12;
2818 direction = DMA_TO_DEVICE;
2819
2820 memset((STp->buffer)->b_data, 0, 12);
2821 if (cmd_in == MTSETDRVBUFFER)
2822 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2823 else
2824 (STp->buffer)->b_data[2] =
2825 STp->drv_buffer << 4;
2826 (STp->buffer)->b_data[3] = 8;
2827 if (cmd_in == MTSETDENSITY) {
2828 (STp->buffer)->b_data[4] = arg;
2829 STp->density_changed = 1;
2830 } else if (cmd_in == SET_DENS_AND_BLK)
2831 (STp->buffer)->b_data[4] = arg >> 24;
2832 else
2833 (STp->buffer)->b_data[4] = STp->density;
2834 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2835 ltmp = arg & MT_ST_BLKSIZE_MASK;
2836 if (cmd_in == MTSETBLK)
2837 STp->blksize_changed = 1;
2838 } else
2839 ltmp = STp->block_size;
2840 (STp->buffer)->b_data[9] = (ltmp >> 16);
2841 (STp->buffer)->b_data[10] = (ltmp >> 8);
2842 (STp->buffer)->b_data[11] = ltmp;
2843 timeout = STp->device->request_queue->rq_timeout;
2844 DEBC(
2845 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2846 printk(ST_DEB_MSG
2847 "%s: Setting block size to %d bytes.\n", name,
2848 (STp->buffer)->b_data[9] * 65536 +
2849 (STp->buffer)->b_data[10] * 256 +
2850 (STp->buffer)->b_data[11]);
2851 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2852 printk(ST_DEB_MSG
2853 "%s: Setting density code to %x.\n", name,
2854 (STp->buffer)->b_data[4]);
2855 if (cmd_in == MTSETDRVBUFFER)
2856 printk(ST_DEB_MSG
2857 "%s: Setting drive buffer code to %d.\n", name,
2858 ((STp->buffer)->b_data[2] >> 4) & 7);
2859 )
2860 break;
2861 default:
2862 return (-ENOSYS);
2863 }
2864
2865 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2866 timeout, MAX_RETRIES, 1);
2867 if (!SRpnt)
2868 return (STp->buffer)->syscall_result;
2869
2870 ioctl_result = (STp->buffer)->syscall_result;
2871
2872 if (!ioctl_result) {
2873 st_release_request(SRpnt);
2874 SRpnt = NULL;
2875 STps->drv_block = blkno;
2876 STps->drv_file = fileno;
2877 STps->at_sm = at_sm;
2878
2879 if (cmd_in == MTBSFM)
2880 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2881 else if (cmd_in == MTFSFM)
2882 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2883
2884 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2885 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2886 if (STp->block_size != 0) {
2887 (STp->buffer)->buffer_blocks =
2888 (STp->buffer)->buffer_size / STp->block_size;
2889 }
2890 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2891 if (cmd_in == SET_DENS_AND_BLK)
2892 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2893 } else if (cmd_in == MTSETDRVBUFFER)
2894 STp->drv_buffer = (arg & 7);
2895 else if (cmd_in == MTSETDENSITY)
2896 STp->density = arg;
2897
2898 if (cmd_in == MTEOM)
2899 STps->eof = ST_EOD;
2900 else if (cmd_in == MTFSF)
2901 STps->eof = ST_FM;
2902 else if (chg_eof)
2903 STps->eof = ST_NOEOF;
2904
2905 if (cmd_in == MTWEOF || cmd_in == MTWEOFI)
2906 STps->rw = ST_IDLE;
2907 } else {
2908
2909 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2910
2911 if (cmdstatp->flags & SENSE_EOM) {
2912 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2913 cmd_in != MTBSR && cmd_in != MTBSS)
2914 STps->eof = ST_EOM_OK;
2915 STps->drv_block = 0;
2916 }
2917
2918 if (cmdstatp->remainder_valid)
2919 undone = (int)cmdstatp->uremainder64;
2920 else
2921 undone = 0;
2922
2923 if ((cmd_in == MTWEOF || cmd_in == MTWEOFI) &&
2924 cmdstatp->have_sense &&
2925 (cmdstatp->flags & SENSE_EOM)) {
2926 if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2927 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
2928 ioctl_result = 0;
2929 STps->eof = ST_NOEOF;
2930 } else {
2931 if (fileno >= 0)
2932 fileno -= undone;
2933 if (undone < arg)
2934 STps->eof = ST_NOEOF;
2935 }
2936 STps->drv_file = fileno;
2937 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2938 if (fileno >= 0)
2939 STps->drv_file = fileno - undone;
2940 else
2941 STps->drv_file = fileno;
2942 STps->drv_block = -1;
2943 STps->eof = ST_NOEOF;
2944 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2945 if (arg > 0 && undone < 0)
2946 undone = (-undone);
2947 if (STps->drv_file >= 0)
2948 STps->drv_file = fileno + undone;
2949 STps->drv_block = 0;
2950 STps->eof = ST_NOEOF;
2951 } else if (cmd_in == MTFSR) {
2952 if (cmdstatp->flags & SENSE_FMK) {
2953 if (STps->drv_file >= 0)
2954 STps->drv_file++;
2955 STps->drv_block = 0;
2956 STps->eof = ST_FM;
2957 } else {
2958 if (blkno >= undone)
2959 STps->drv_block = blkno - undone;
2960 else
2961 STps->drv_block = (-1);
2962 STps->eof = ST_NOEOF;
2963 }
2964 } else if (cmd_in == MTBSR) {
2965 if (cmdstatp->flags & SENSE_FMK) {
2966 STps->drv_file--;
2967 STps->drv_block = (-1);
2968 } else {
2969 if (arg > 0 && undone < 0)
2970 undone = (-undone);
2971 if (STps->drv_block >= 0)
2972 STps->drv_block = blkno + undone;
2973 }
2974 STps->eof = ST_NOEOF;
2975 } else if (cmd_in == MTEOM) {
2976 STps->drv_file = (-1);
2977 STps->drv_block = (-1);
2978 STps->eof = ST_EOD;
2979 } else if (cmd_in == MTSETBLK ||
2980 cmd_in == MTSETDENSITY ||
2981 cmd_in == MTSETDRVBUFFER ||
2982 cmd_in == SET_DENS_AND_BLK) {
2983 if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2984 !(STp->use_pf & PF_TESTED)) {
2985
2986
2987 STp->use_pf = (STp->use_pf ^ USE_PF) | PF_TESTED;
2988 st_release_request(SRpnt);
2989 SRpnt = NULL;
2990 return st_int_ioctl(STp, cmd_in, arg);
2991 }
2992 } else if (chg_eof)
2993 STps->eof = ST_NOEOF;
2994
2995 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
2996 STps->eof = ST_EOD;
2997
2998 st_release_request(SRpnt);
2999 SRpnt = NULL;
3000 }
3001
3002 return ioctl_result;
3003}
3004
3005
3006
3007
3008
3009static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
3010 int logical)
3011{
3012 int result;
3013 unsigned char scmd[MAX_COMMAND_SIZE];
3014 struct st_request *SRpnt;
3015 DEB( char *name = tape_name(STp); )
3016
3017 if (STp->ready != ST_READY)
3018 return (-EIO);
3019
3020 memset(scmd, 0, MAX_COMMAND_SIZE);
3021 if ((STp->device)->scsi_level < SCSI_2) {
3022 scmd[0] = QFA_REQUEST_BLOCK;
3023 scmd[4] = 3;
3024 } else {
3025 scmd[0] = READ_POSITION;
3026 if (!logical && !STp->scsi2_logical)
3027 scmd[1] = 1;
3028 }
3029 SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
3030 STp->device->request_queue->rq_timeout,
3031 MAX_READY_RETRIES, 1);
3032 if (!SRpnt)
3033 return (STp->buffer)->syscall_result;
3034
3035 if ((STp->buffer)->syscall_result != 0 ||
3036 (STp->device->scsi_level >= SCSI_2 &&
3037 ((STp->buffer)->b_data[0] & 4) != 0)) {
3038 *block = *partition = 0;
3039 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
3040 result = (-EIO);
3041 } else {
3042 result = 0;
3043 if ((STp->device)->scsi_level < SCSI_2) {
3044 *block = ((STp->buffer)->b_data[0] << 16)
3045 + ((STp->buffer)->b_data[1] << 8)
3046 + (STp->buffer)->b_data[2];
3047 *partition = 0;
3048 } else {
3049 *block = ((STp->buffer)->b_data[4] << 24)
3050 + ((STp->buffer)->b_data[5] << 16)
3051 + ((STp->buffer)->b_data[6] << 8)
3052 + (STp->buffer)->b_data[7];
3053 *partition = (STp->buffer)->b_data[1];
3054 if (((STp->buffer)->b_data[0] & 0x80) &&
3055 (STp->buffer)->b_data[1] == 0)
3056 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
3057 }
3058 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
3059 *block, *partition));
3060 }
3061 st_release_request(SRpnt);
3062 SRpnt = NULL;
3063
3064 return result;
3065}
3066
3067
3068
3069
3070static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
3071 int logical)
3072{
3073 struct st_partstat *STps;
3074 int result, p;
3075 unsigned int blk;
3076 int timeout;
3077 unsigned char scmd[MAX_COMMAND_SIZE];
3078 struct st_request *SRpnt;
3079 DEB( char *name = tape_name(STp); )
3080
3081 if (STp->ready != ST_READY)
3082 return (-EIO);
3083 timeout = STp->long_timeout;
3084 STps = &(STp->ps[STp->partition]);
3085
3086 DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
3087 name, block, partition));
3088 DEB(if (partition < 0)
3089 return (-EIO); )
3090
3091
3092 if ((!STp->can_partitions && partition != 0) ||
3093 partition >= ST_NBR_PARTITIONS)
3094 return (-EINVAL);
3095 if (partition != STp->partition) {
3096 if (get_location(STp, &blk, &p, 1))
3097 STps->last_block_valid = 0;
3098 else {
3099 STps->last_block_valid = 1;
3100 STps->last_block_visited = blk;
3101 DEBC(printk(ST_DEB_MSG
3102 "%s: Visited block %d for partition %d saved.\n",
3103 name, blk, STp->partition));
3104 }
3105 }
3106
3107 memset(scmd, 0, MAX_COMMAND_SIZE);
3108 if ((STp->device)->scsi_level < SCSI_2) {
3109 scmd[0] = QFA_SEEK_BLOCK;
3110 scmd[2] = (block >> 16);
3111 scmd[3] = (block >> 8);
3112 scmd[4] = block;
3113 scmd[5] = 0;
3114 } else {
3115 scmd[0] = SEEK_10;
3116 scmd[3] = (block >> 24);
3117 scmd[4] = (block >> 16);
3118 scmd[5] = (block >> 8);
3119 scmd[6] = block;
3120 if (!logical && !STp->scsi2_logical)
3121 scmd[1] = 4;
3122 if (STp->partition != partition) {
3123 scmd[1] |= 2;
3124 scmd[8] = partition;
3125 DEBC(printk(ST_DEB_MSG
3126 "%s: Trying to change partition from %d to %d\n",
3127 name, STp->partition, partition));
3128 }
3129 }
3130 if (STp->immediate) {
3131 scmd[1] |= 1;
3132 timeout = STp->device->request_queue->rq_timeout;
3133 }
3134
3135 SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3136 timeout, MAX_READY_RETRIES, 1);
3137 if (!SRpnt)
3138 return (STp->buffer)->syscall_result;
3139
3140 STps->drv_block = STps->drv_file = (-1);
3141 STps->eof = ST_NOEOF;
3142 if ((STp->buffer)->syscall_result != 0) {
3143 result = (-EIO);
3144 if (STp->can_partitions &&
3145 (STp->device)->scsi_level >= SCSI_2 &&
3146 (p = find_partition(STp)) >= 0)
3147 STp->partition = p;
3148 } else {
3149 if (STp->can_partitions) {
3150 STp->partition = partition;
3151 STps = &(STp->ps[partition]);
3152 if (!STps->last_block_valid ||
3153 STps->last_block_visited != block) {
3154 STps->at_sm = 0;
3155 STps->rw = ST_IDLE;
3156 }
3157 } else
3158 STps->at_sm = 0;
3159 if (block == 0)
3160 STps->drv_block = STps->drv_file = 0;
3161 result = 0;
3162 }
3163
3164 st_release_request(SRpnt);
3165 SRpnt = NULL;
3166
3167 return result;
3168}
3169
3170
3171
3172
3173static int find_partition(struct scsi_tape *STp)
3174{
3175 int i, partition;
3176 unsigned int block;
3177
3178 if ((i = get_location(STp, &block, &partition, 1)) < 0)
3179 return i;
3180 if (partition >= ST_NBR_PARTITIONS)
3181 return (-EIO);
3182 return partition;
3183}
3184
3185
3186
3187static int switch_partition(struct scsi_tape *STp)
3188{
3189 struct st_partstat *STps;
3190
3191 if (STp->partition == STp->new_partition)
3192 return 0;
3193 STps = &(STp->ps[STp->new_partition]);
3194 if (!STps->last_block_valid)
3195 STps->last_block_visited = 0;
3196 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3197}
3198
3199
3200
3201#define PART_PAGE 0x11
3202#define PART_PAGE_FIXED_LENGTH 8
3203
3204#define PP_OFF_MAX_ADD_PARTS 2
3205#define PP_OFF_NBR_ADD_PARTS 3
3206#define PP_OFF_FLAGS 4
3207#define PP_OFF_PART_UNITS 6
3208#define PP_OFF_RESERVED 7
3209
3210#define PP_BIT_IDP 0x20
3211#define PP_MSK_PSUM_MB 0x10
3212
3213
3214
3215static int nbr_partitions(struct scsi_tape *STp)
3216{
3217 int result;
3218 DEB( char *name = tape_name(STp); )
3219
3220 if (STp->ready != ST_READY)
3221 return (-EIO);
3222
3223 result = read_mode_page(STp, PART_PAGE, 1);
3224
3225 if (result) {
3226 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3227 name));
3228 result = (-EIO);
3229 } else {
3230 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3231 PP_OFF_NBR_ADD_PARTS] + 1;
3232 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3233 }
3234
3235 return result;
3236}
3237
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254
3255
3256
3257
3258static int partition_tape(struct scsi_tape *STp, int size)
3259{
3260 char *name = tape_name(STp);
3261 int result;
3262 int pgo, psd_cnt, psdo;
3263 unsigned char *bp;
3264
3265 result = read_mode_page(STp, PART_PAGE, 0);
3266 if (result) {
3267 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3268 return result;
3269 }
3270
3271 bp = (STp->buffer)->b_data;
3272 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3273 DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3274 name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3275
3276 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3277 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3278 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3279 bp[psdo] = bp[psdo + 1] = 0xff;
3280 psdo += 2;
3281 }
3282 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3283
3284 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3285 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3286 bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3287
3288 if (size <= 0) {
3289 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3290 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3291 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3292 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3293 name));
3294 } else {
3295 bp[psdo] = (size >> 8) & 0xff;
3296 bp[psdo + 1] = size & 0xff;
3297 bp[pgo + 3] = 1;
3298 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3299 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3300 DEBC(printk(ST_DEB_MSG
3301 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3302 name, size));
3303 }
3304 bp[pgo + PP_OFF_PART_UNITS] = 0;
3305 bp[pgo + PP_OFF_RESERVED] = 0;
3306 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3307
3308 result = write_mode_page(STp, PART_PAGE, 1);
3309 if (result) {
3310 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3311 result = (-EIO);
3312 }
3313
3314 return result;
3315}
3316
3317
3318
3319
3320static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
3321{
3322 int i, cmd_nr, cmd_type, bt;
3323 int retval = 0;
3324 unsigned int blk;
3325 struct scsi_tape *STp = file->private_data;
3326 struct st_modedef *STm;
3327 struct st_partstat *STps;
3328 char *name = tape_name(STp);
3329 void __user *p = (void __user *)arg;
3330
3331 if (mutex_lock_interruptible(&STp->lock))
3332 return -ERESTARTSYS;
3333
3334 DEB(
3335 if (debugging && !STp->in_use) {
3336 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3337 retval = (-EIO);
3338 goto out;
3339 } )
3340
3341 STm = &(STp->modes[STp->current_mode]);
3342 STps = &(STp->ps[STp->partition]);
3343
3344
3345
3346
3347
3348
3349
3350 retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p,
3351 file->f_flags & O_NDELAY);
3352 if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3353 goto out;
3354 retval = 0;
3355
3356 cmd_type = _IOC_TYPE(cmd_in);
3357 cmd_nr = _IOC_NR(cmd_in);
3358
3359 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3360 struct mtop mtc;
3361
3362 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3363 retval = (-EINVAL);
3364 goto out;
3365 }
3366
3367 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3368 if (i) {
3369 retval = (-EFAULT);
3370 goto out;
3371 }
3372
3373 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3374 printk(KERN_WARNING
3375 "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3376 retval = (-EPERM);
3377 goto out;
3378 }
3379 if (!STm->defined &&
3380 (mtc.mt_op != MTSETDRVBUFFER &&
3381 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3382 retval = (-ENXIO);
3383 goto out;
3384 }
3385
3386 if (!STp->pos_unknown) {
3387
3388 if (STps->eof == ST_FM_HIT) {
3389 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3390 mtc.mt_op == MTEOM) {
3391 mtc.mt_count -= 1;
3392 if (STps->drv_file >= 0)
3393 STps->drv_file += 1;
3394 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3395 mtc.mt_count += 1;
3396 if (STps->drv_file >= 0)
3397 STps->drv_file += 1;
3398 }
3399 }
3400
3401 if (mtc.mt_op == MTSEEK) {
3402
3403
3404 i = !STp->can_partitions ||
3405 (STp->new_partition != STp->partition);
3406 } else {
3407 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3408 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3409 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3410 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3411 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3412 mtc.mt_op == MTCOMPRESSION;
3413 }
3414 i = flush_buffer(STp, i);
3415 if (i < 0) {
3416 retval = i;
3417 goto out;
3418 }
3419 if (STps->rw == ST_WRITING &&
3420 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3421 mtc.mt_op == MTSEEK ||
3422 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3423 i = st_int_ioctl(STp, MTWEOF, 1);
3424 if (i < 0) {
3425 retval = i;
3426 goto out;
3427 }
3428 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3429 mtc.mt_count++;
3430 STps->rw = ST_IDLE;
3431 }
3432
3433 } else {
3434
3435
3436
3437
3438
3439 if (mtc.mt_op != MTREW &&
3440 mtc.mt_op != MTOFFL &&
3441 mtc.mt_op != MTRETEN &&
3442 mtc.mt_op != MTERASE &&
3443 mtc.mt_op != MTSEEK &&
3444 mtc.mt_op != MTEOM) {
3445 retval = (-EIO);
3446 goto out;
3447 }
3448 reset_state(STp);
3449
3450 STp->device->was_reset = 0;
3451 }
3452
3453 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3454 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3455 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3456 STps->rw = ST_IDLE;
3457
3458 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3459 do_door_lock(STp, 0);
3460
3461 if (mtc.mt_op == MTSETDRVBUFFER &&
3462 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3463 retval = st_set_options(STp, mtc.mt_count);
3464 goto out;
3465 }
3466
3467 if (mtc.mt_op == MTSETPART) {
3468 if (!STp->can_partitions ||
3469 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3470 retval = (-EINVAL);
3471 goto out;
3472 }
3473 if (mtc.mt_count >= STp->nbr_partitions &&
3474 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3475 retval = (-EIO);
3476 goto out;
3477 }
3478 if (mtc.mt_count >= STp->nbr_partitions) {
3479 retval = (-EINVAL);
3480 goto out;
3481 }
3482 STp->new_partition = mtc.mt_count;
3483 retval = 0;
3484 goto out;
3485 }
3486
3487 if (mtc.mt_op == MTMKPART) {
3488 if (!STp->can_partitions) {
3489 retval = (-EINVAL);
3490 goto out;
3491 }
3492 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3493 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3494 retval = i;
3495 goto out;
3496 }
3497 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3498 STp->ps[i].rw = ST_IDLE;
3499 STp->ps[i].at_sm = 0;
3500 STp->ps[i].last_block_valid = 0;
3501 }
3502 STp->partition = STp->new_partition = 0;
3503 STp->nbr_partitions = 1;
3504 STps->drv_block = STps->drv_file = 0;
3505 retval = 0;
3506 goto out;
3507 }
3508
3509 if (mtc.mt_op == MTSEEK) {
3510 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3511 if (!STp->can_partitions)
3512 STp->ps[0].rw = ST_IDLE;
3513 retval = i;
3514 goto out;
3515 }
3516
3517 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3518 retval = do_load_unload(STp, file, 0);
3519 goto out;
3520 }
3521
3522 if (mtc.mt_op == MTLOAD) {
3523 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3524 goto out;
3525 }
3526
3527 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3528 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3529 goto out;
3530 }
3531
3532 if (STp->can_partitions && STp->ready == ST_READY &&
3533 (i = switch_partition(STp)) < 0) {
3534 retval = i;
3535 goto out;
3536 }
3537
3538 if (mtc.mt_op == MTCOMPRESSION)
3539 retval = st_compression(STp, (mtc.mt_count & 1));
3540 else
3541 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3542 goto out;
3543 }
3544 if (!STm->defined) {
3545 retval = (-ENXIO);
3546 goto out;
3547 }
3548
3549 if ((i = flush_buffer(STp, 0)) < 0) {
3550 retval = i;
3551 goto out;
3552 }
3553 if (STp->can_partitions &&
3554 (i = switch_partition(STp)) < 0) {
3555 retval = i;
3556 goto out;
3557 }
3558
3559 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3560 struct mtget mt_status;
3561
3562 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3563 retval = (-EINVAL);
3564 goto out;
3565 }
3566
3567 mt_status.mt_type = STp->tape_type;
3568 mt_status.mt_dsreg =
3569 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3570 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3571 mt_status.mt_blkno = STps->drv_block;
3572 mt_status.mt_fileno = STps->drv_file;
3573 if (STp->block_size != 0) {
3574 if (STps->rw == ST_WRITING)
3575 mt_status.mt_blkno +=
3576 (STp->buffer)->buffer_bytes / STp->block_size;
3577 else if (STps->rw == ST_READING)
3578 mt_status.mt_blkno -=
3579 ((STp->buffer)->buffer_bytes +
3580 STp->block_size - 1) / STp->block_size;
3581 }
3582
3583 mt_status.mt_gstat = 0;
3584 if (STp->drv_write_prot)
3585 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3586 if (mt_status.mt_blkno == 0) {
3587 if (mt_status.mt_fileno == 0)
3588 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3589 else
3590 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3591 }
3592 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3593 mt_status.mt_resid = STp->partition;
3594 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3595 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3596 else if (STps->eof >= ST_EOM_OK)
3597 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3598 if (STp->density == 1)
3599 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3600 else if (STp->density == 2)
3601 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3602 else if (STp->density == 3)
3603 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3604 if (STp->ready == ST_READY)
3605 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3606 if (STp->ready == ST_NO_TAPE)
3607 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3608 if (STps->at_sm)
3609 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3610 if (STm->do_async_writes ||
3611 (STm->do_buffer_writes && STp->block_size != 0) ||
3612 STp->drv_buffer != 0)
3613 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3614 if (STp->cleaning_req)
3615 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3616
3617 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3618 if (i) {
3619 retval = (-EFAULT);
3620 goto out;
3621 }
3622
3623 STp->recover_reg = 0;
3624 retval = 0;
3625 goto out;
3626 }
3627 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3628 struct mtpos mt_pos;
3629 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3630 retval = (-EINVAL);
3631 goto out;
3632 }
3633 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3634 retval = i;
3635 goto out;
3636 }
3637 mt_pos.mt_blkno = blk;
3638 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3639 if (i)
3640 retval = (-EFAULT);
3641 goto out;
3642 }
3643 mutex_unlock(&STp->lock);
3644 switch (cmd_in) {
3645 case SCSI_IOCTL_GET_IDLUN:
3646 case SCSI_IOCTL_GET_BUS_NUMBER:
3647 break;
3648 default:
3649 if ((cmd_in == SG_IO ||
3650 cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3651 cmd_in == CDROM_SEND_PACKET) &&
3652 !capable(CAP_SYS_RAWIO))
3653 i = -EPERM;
3654 else
3655 i = scsi_cmd_ioctl(STp->disk->queue, STp->disk,
3656 file->f_mode, cmd_in, p);
3657 if (i != -ENOTTY)
3658 return i;
3659 break;
3660 }
3661 retval = scsi_ioctl(STp->device, cmd_in, p);
3662 if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) {
3663 STp->rew_at_close = 0;
3664 STp->ready = ST_NO_TAPE;
3665 }
3666 return retval;
3667
3668 out:
3669 mutex_unlock(&STp->lock);
3670 return retval;
3671}
3672
3673#ifdef CONFIG_COMPAT
3674static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3675{
3676 struct scsi_tape *STp = file->private_data;
3677 struct scsi_device *sdev = STp->device;
3678 int ret = -ENOIOCTLCMD;
3679 if (sdev->host->hostt->compat_ioctl) {
3680
3681 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3682
3683 }
3684 return ret;
3685}
3686#endif
3687
3688
3689
3690
3691
3692static struct st_buffer *new_tape_buffer(int need_dma, int max_sg)
3693{
3694 struct st_buffer *tb;
3695
3696 tb = kzalloc(sizeof(struct st_buffer), GFP_ATOMIC);
3697 if (!tb) {
3698 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3699 return NULL;
3700 }
3701 tb->frp_segs = 0;
3702 tb->use_sg = max_sg;
3703 tb->dma = need_dma;
3704 tb->buffer_size = 0;
3705
3706 tb->reserved_pages = kzalloc(max_sg * sizeof(struct page *),
3707 GFP_ATOMIC);
3708 if (!tb->reserved_pages) {
3709 kfree(tb);
3710 return NULL;
3711 }
3712
3713 return tb;
3714}
3715
3716
3717
3718#define ST_MAX_ORDER 6
3719
3720static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3721{
3722 int segs, nbr, max_segs, b_size, order, got;
3723 gfp_t priority;
3724
3725 if (new_size <= STbuffer->buffer_size)
3726 return 1;
3727
3728 if (STbuffer->buffer_size <= PAGE_SIZE)
3729 normalize_buffer(STbuffer);
3730
3731 max_segs = STbuffer->use_sg;
3732 nbr = max_segs - STbuffer->frp_segs;
3733 if (nbr <= 0)
3734 return 0;
3735
3736 priority = GFP_KERNEL | __GFP_NOWARN;
3737 if (need_dma)
3738 priority |= GFP_DMA;
3739
3740 if (STbuffer->cleared)
3741 priority |= __GFP_ZERO;
3742
3743 if (STbuffer->frp_segs) {
3744 order = STbuffer->reserved_page_order;
3745 b_size = PAGE_SIZE << order;
3746 } else {
3747 for (b_size = PAGE_SIZE, order = 0;
3748 order < ST_MAX_ORDER &&
3749 max_segs * (PAGE_SIZE << order) < new_size;
3750 order++, b_size *= 2)
3751 ;
3752 STbuffer->reserved_page_order = order;
3753 }
3754 if (max_segs * (PAGE_SIZE << order) < new_size) {
3755 if (order == ST_MAX_ORDER)
3756 return 0;
3757 normalize_buffer(STbuffer);
3758 return enlarge_buffer(STbuffer, new_size, need_dma);
3759 }
3760
3761 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3762 segs < max_segs && got < new_size;) {
3763 struct page *page;
3764
3765 page = alloc_pages(priority, order);
3766 if (!page) {
3767 DEB(STbuffer->buffer_size = got);
3768 normalize_buffer(STbuffer);
3769 return 0;
3770 }
3771
3772 STbuffer->frp_segs += 1;
3773 got += b_size;
3774 STbuffer->buffer_size = got;
3775 STbuffer->reserved_pages[segs] = page;
3776 segs++;
3777 }
3778 STbuffer->b_data = page_address(STbuffer->reserved_pages[0]);
3779
3780 return 1;
3781}
3782
3783
3784
3785static void clear_buffer(struct st_buffer * st_bp)
3786{
3787 int i;
3788
3789 for (i=0; i < st_bp->frp_segs; i++)
3790 memset(page_address(st_bp->reserved_pages[i]), 0,
3791 PAGE_SIZE << st_bp->reserved_page_order);
3792 st_bp->cleared = 1;
3793}
3794
3795
3796
3797static void normalize_buffer(struct st_buffer * STbuffer)
3798{
3799 int i, order = STbuffer->reserved_page_order;
3800
3801 for (i = 0; i < STbuffer->frp_segs; i++) {
3802 __free_pages(STbuffer->reserved_pages[i], order);
3803 STbuffer->buffer_size -= (PAGE_SIZE << order);
3804 }
3805 STbuffer->frp_segs = 0;
3806 STbuffer->sg_segs = 0;
3807 STbuffer->reserved_page_order = 0;
3808 STbuffer->map_data.offset = 0;
3809}
3810
3811
3812
3813
3814static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3815{
3816 int i, cnt, res, offset;
3817 int length = PAGE_SIZE << st_bp->reserved_page_order;
3818
3819 for (i = 0, offset = st_bp->buffer_bytes;
3820 i < st_bp->frp_segs && offset >= length; i++)
3821 offset -= length;
3822 if (i == st_bp->frp_segs) {
3823 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3824 return (-EIO);
3825 }
3826 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3827 struct page *page = st_bp->reserved_pages[i];
3828 cnt = length - offset < do_count ? length - offset : do_count;
3829 res = copy_from_user(page_address(page) + offset, ubp, cnt);
3830 if (res)
3831 return (-EFAULT);
3832 do_count -= cnt;
3833 st_bp->buffer_bytes += cnt;
3834 ubp += cnt;
3835 offset = 0;
3836 }
3837 if (do_count)
3838 return (-EIO);
3839
3840 return 0;
3841}
3842
3843
3844
3845
3846static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3847{
3848 int i, cnt, res, offset;
3849 int length = PAGE_SIZE << st_bp->reserved_page_order;
3850
3851 for (i = 0, offset = st_bp->read_pointer;
3852 i < st_bp->frp_segs && offset >= length; i++)
3853 offset -= length;
3854 if (i == st_bp->frp_segs) {
3855 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3856 return (-EIO);
3857 }
3858 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3859 struct page *page = st_bp->reserved_pages[i];
3860 cnt = length - offset < do_count ? length - offset : do_count;
3861 res = copy_to_user(ubp, page_address(page) + offset, cnt);
3862 if (res)
3863 return (-EFAULT);
3864 do_count -= cnt;
3865 st_bp->buffer_bytes -= cnt;
3866 st_bp->read_pointer += cnt;
3867 ubp += cnt;
3868 offset = 0;
3869 }
3870 if (do_count)
3871 return (-EIO);
3872
3873 return 0;
3874}
3875
3876
3877
3878static void move_buffer_data(struct st_buffer * st_bp, int offset)
3879{
3880 int src_seg, dst_seg, src_offset = 0, dst_offset;
3881 int count, total;
3882 int length = PAGE_SIZE << st_bp->reserved_page_order;
3883
3884 if (offset == 0)
3885 return;
3886
3887 total=st_bp->buffer_bytes - offset;
3888 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3889 src_offset = offset;
3890 if (src_offset < length)
3891 break;
3892 offset -= length;
3893 }
3894
3895 st_bp->buffer_bytes = st_bp->read_pointer = total;
3896 for (dst_seg=dst_offset=0; total > 0; ) {
3897 struct page *dpage = st_bp->reserved_pages[dst_seg];
3898 struct page *spage = st_bp->reserved_pages[src_seg];
3899
3900 count = min(length - dst_offset, length - src_offset);
3901 memmove(page_address(dpage) + dst_offset,
3902 page_address(spage) + src_offset, count);
3903 src_offset += count;
3904 if (src_offset >= length) {
3905 src_seg++;
3906 src_offset = 0;
3907 }
3908 dst_offset += count;
3909 if (dst_offset >= length) {
3910 dst_seg++;
3911 dst_offset = 0;
3912 }
3913 total -= count;
3914 }
3915}
3916
3917
3918static void validate_options(void)
3919{
3920 if (buffer_kbs > 0)
3921 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3922 if (max_sg_segs >= ST_FIRST_SG)
3923 st_max_sg_segs = max_sg_segs;
3924}
3925
3926#ifndef MODULE
3927
3928
3929static int __init st_setup(char *str)
3930{
3931 int i, len, ints[5];
3932 char *stp;
3933
3934 stp = get_options(str, ARRAY_SIZE(ints), ints);
3935
3936 if (ints[0] > 0) {
3937 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3938 if (parms[i].val)
3939 *parms[i].val = ints[i + 1];
3940 } else {
3941 while (stp != NULL) {
3942 for (i = 0; i < ARRAY_SIZE(parms); i++) {
3943 len = strlen(parms[i].name);
3944 if (!strncmp(stp, parms[i].name, len) &&
3945 (*(stp + len) == ':' || *(stp + len) == '=')) {
3946 if (parms[i].val)
3947 *parms[i].val =
3948 simple_strtoul(stp + len + 1, NULL, 0);
3949 else
3950 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3951 parms[i].name);
3952 break;
3953 }
3954 }
3955 if (i >= ARRAY_SIZE(parms))
3956 printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3957 stp);
3958 stp = strchr(stp, ',');
3959 if (stp)
3960 stp++;
3961 }
3962 }
3963
3964 validate_options();
3965
3966 return 1;
3967}
3968
3969__setup("st=", st_setup);
3970
3971#endif
3972
3973static const struct file_operations st_fops =
3974{
3975 .owner = THIS_MODULE,
3976 .read = st_read,
3977 .write = st_write,
3978 .unlocked_ioctl = st_ioctl,
3979#ifdef CONFIG_COMPAT
3980 .compat_ioctl = st_compat_ioctl,
3981#endif
3982 .open = st_open,
3983 .flush = st_flush,
3984 .release = st_release,
3985 .llseek = noop_llseek,
3986};
3987
3988static int create_one_cdev(struct scsi_tape *tape, int mode, int rew)
3989{
3990 int i, error;
3991 dev_t cdev_devno;
3992 struct cdev *cdev;
3993 struct device *dev;
3994 struct st_modedef *STm = &(tape->modes[mode]);
3995 char name[10];
3996 int dev_num = tape->index;
3997
3998 cdev_devno = MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, rew));
3999
4000 cdev = cdev_alloc();
4001 if (!cdev) {
4002 pr_err("st%d: out of memory. Device not attached.\n", dev_num);
4003 error = -ENOMEM;
4004 goto out;
4005 }
4006 cdev->owner = THIS_MODULE;
4007 cdev->ops = &st_fops;
4008
4009 error = cdev_add(cdev, cdev_devno, 1);
4010 if (error) {
4011 pr_err("st%d: Can't add %s-rewind mode %d\n", dev_num,
4012 rew ? "non" : "auto", mode);
4013 pr_err("st%d: Device not attached.\n", dev_num);
4014 goto out_free;
4015 }
4016 STm->cdevs[rew] = cdev;
4017
4018 i = mode << (4 - ST_NBR_MODE_BITS);
4019 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4020 tape->disk->disk_name, st_formats[i]);
4021
4022 dev = device_create(&st_sysfs_class, &tape->device->sdev_gendev,
4023 cdev_devno, &tape->modes[mode], "%s", name);
4024 if (IS_ERR(dev)) {
4025 pr_err("st%d: device_create failed\n", dev_num);
4026 error = PTR_ERR(dev);
4027 goto out_free;
4028 }
4029
4030 STm->devs[rew] = dev;
4031
4032 return 0;
4033out_free:
4034 cdev_del(STm->cdevs[rew]);
4035 STm->cdevs[rew] = NULL;
4036out:
4037 return error;
4038}
4039
4040static int create_cdevs(struct scsi_tape *tape)
4041{
4042 int mode, error;
4043 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4044 error = create_one_cdev(tape, mode, 0);
4045 if (error)
4046 return error;
4047 error = create_one_cdev(tape, mode, 1);
4048 if (error)
4049 return error;
4050 }
4051
4052 return sysfs_create_link(&tape->device->sdev_gendev.kobj,
4053 &tape->modes[0].devs[0]->kobj, "tape");
4054}
4055
4056static void remove_cdevs(struct scsi_tape *tape)
4057{
4058 int mode, rew;
4059 sysfs_remove_link(&tape->device->sdev_gendev.kobj, "tape");
4060 for (mode = 0; mode < ST_NBR_MODES; mode++) {
4061 struct st_modedef *STm = &(tape->modes[mode]);
4062 for (rew = 0; rew < 2; rew++) {
4063 if (STm->cdevs[rew])
4064 cdev_del(STm->cdevs[rew]);
4065 if (STm->devs[rew])
4066 device_unregister(STm->devs[rew]);
4067 }
4068 }
4069}
4070
4071static int st_probe(struct device *dev)
4072{
4073 struct scsi_device *SDp = to_scsi_device(dev);
4074 struct gendisk *disk = NULL;
4075 struct scsi_tape *tpnt = NULL;
4076 struct st_modedef *STm;
4077 struct st_partstat *STps;
4078 struct st_buffer *buffer;
4079 int i, error;
4080 char *stp;
4081
4082 if (SDp->type != TYPE_TAPE)
4083 return -ENODEV;
4084 if ((stp = st_incompatible(SDp))) {
4085 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
4086 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
4087 return -ENODEV;
4088 }
4089
4090 i = queue_max_segments(SDp->request_queue);
4091 if (st_max_sg_segs < i)
4092 i = st_max_sg_segs;
4093 buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i);
4094 if (buffer == NULL) {
4095 printk(KERN_ERR
4096 "st: Can't allocate new tape buffer. Device not attached.\n");
4097 goto out;
4098 }
4099
4100 disk = alloc_disk(1);
4101 if (!disk) {
4102 printk(KERN_ERR "st: out of memory. Device not attached.\n");
4103 goto out_buffer_free;
4104 }
4105
4106 tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
4107 if (tpnt == NULL) {
4108 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
4109 goto out_put_disk;
4110 }
4111 kref_init(&tpnt->kref);
4112 tpnt->disk = disk;
4113 disk->private_data = &tpnt->driver;
4114 disk->queue = SDp->request_queue;
4115
4116
4117 if (!blk_get_queue(disk->queue))
4118 goto out_put_disk;
4119 tpnt->driver = &st_template;
4120
4121 tpnt->device = SDp;
4122 if (SDp->scsi_level <= 2)
4123 tpnt->tape_type = MT_ISSCSI1;
4124 else
4125 tpnt->tape_type = MT_ISSCSI2;
4126
4127 tpnt->buffer = buffer;
4128 tpnt->buffer->last_SRpnt = NULL;
4129
4130 tpnt->inited = 0;
4131 tpnt->dirty = 0;
4132 tpnt->in_use = 0;
4133 tpnt->drv_buffer = 1;
4134 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
4135 tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4136 tpnt->density = 0;
4137 tpnt->do_auto_lock = ST_AUTO_LOCK;
4138 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS);
4139 tpnt->can_partitions = 0;
4140 tpnt->two_fm = ST_TWO_FM;
4141 tpnt->fast_mteom = ST_FAST_MTEOM;
4142 tpnt->scsi2_logical = ST_SCSI2LOGICAL;
4143 tpnt->sili = ST_SILI;
4144 tpnt->immediate = ST_NOWAIT;
4145 tpnt->immediate_filemark = 0;
4146 tpnt->default_drvbuffer = 0xff;
4147 tpnt->partition = 0;
4148 tpnt->new_partition = 0;
4149 tpnt->nbr_partitions = 0;
4150 blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT);
4151 tpnt->long_timeout = ST_LONG_TIMEOUT;
4152 tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
4153
4154 for (i = 0; i < ST_NBR_MODES; i++) {
4155 STm = &(tpnt->modes[i]);
4156 STm->defined = 0;
4157 STm->sysv = ST_SYSV;
4158 STm->defaults_for_writes = 0;
4159 STm->do_async_writes = ST_ASYNC_WRITES;
4160 STm->do_buffer_writes = ST_BUFFER_WRITES;
4161 STm->do_read_ahead = ST_READ_AHEAD;
4162 STm->default_compression = ST_DONT_TOUCH;
4163 STm->default_blksize = (-1);
4164 STm->default_density = (-1);
4165 STm->tape = tpnt;
4166 }
4167
4168 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4169 STps = &(tpnt->ps[i]);
4170 STps->rw = ST_IDLE;
4171 STps->eof = ST_NOEOF;
4172 STps->at_sm = 0;
4173 STps->last_block_valid = 0;
4174 STps->drv_block = (-1);
4175 STps->drv_file = (-1);
4176 }
4177
4178 tpnt->current_mode = 0;
4179 tpnt->modes[0].defined = 1;
4180
4181 tpnt->density_changed = tpnt->compression_changed =
4182 tpnt->blksize_changed = 0;
4183 mutex_init(&tpnt->lock);
4184
4185 idr_preload(GFP_KERNEL);
4186 spin_lock(&st_index_lock);
4187 error = idr_alloc(&st_index_idr, tpnt, 0, ST_MAX_TAPES + 1, GFP_NOWAIT);
4188 spin_unlock(&st_index_lock);
4189 idr_preload_end();
4190 if (error < 0) {
4191 pr_warn("st: idr allocation failed: %d\n", error);
4192 goto out_put_queue;
4193 }
4194 tpnt->index = error;
4195 sprintf(disk->disk_name, "st%d", tpnt->index);
4196
4197 dev_set_drvdata(dev, tpnt);
4198
4199
4200 error = create_cdevs(tpnt);
4201 if (error)
4202 goto out_remove_devs;
4203 scsi_autopm_put_device(SDp);
4204
4205 sdev_printk(KERN_NOTICE, SDp,
4206 "Attached scsi tape %s\n", tape_name(tpnt));
4207 sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4208 tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4209 queue_dma_alignment(SDp->request_queue) + 1);
4210
4211 return 0;
4212
4213out_remove_devs:
4214 remove_cdevs(tpnt);
4215 spin_lock(&st_index_lock);
4216 idr_remove(&st_index_idr, tpnt->index);
4217 spin_unlock(&st_index_lock);
4218out_put_queue:
4219 blk_put_queue(disk->queue);
4220out_put_disk:
4221 put_disk(disk);
4222 kfree(tpnt);
4223out_buffer_free:
4224 kfree(buffer);
4225out:
4226 return -ENODEV;
4227};
4228
4229
4230static int st_remove(struct device *dev)
4231{
4232 struct scsi_tape *tpnt = dev_get_drvdata(dev);
4233 int index = tpnt->index;
4234
4235 scsi_autopm_get_device(to_scsi_device(dev));
4236 remove_cdevs(tpnt);
4237
4238 mutex_lock(&st_ref_mutex);
4239 kref_put(&tpnt->kref, scsi_tape_release);
4240 mutex_unlock(&st_ref_mutex);
4241 spin_lock(&st_index_lock);
4242 idr_remove(&st_index_idr, index);
4243 spin_unlock(&st_index_lock);
4244 return 0;
4245}
4246
4247
4248
4249
4250
4251
4252
4253
4254
4255
4256static void scsi_tape_release(struct kref *kref)
4257{
4258 struct scsi_tape *tpnt = to_scsi_tape(kref);
4259 struct gendisk *disk = tpnt->disk;
4260
4261 tpnt->device = NULL;
4262
4263 if (tpnt->buffer) {
4264 normalize_buffer(tpnt->buffer);
4265 kfree(tpnt->buffer->reserved_pages);
4266 kfree(tpnt->buffer);
4267 }
4268
4269 disk->private_data = NULL;
4270 put_disk(disk);
4271 kfree(tpnt);
4272 return;
4273}
4274
4275static struct class st_sysfs_class = {
4276 .name = "scsi_tape",
4277 .dev_groups = st_dev_groups,
4278};
4279
4280static int __init init_st(void)
4281{
4282 int err;
4283
4284 validate_options();
4285
4286 printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4287 verstr, st_fixed_buffer_size, st_max_sg_segs);
4288
4289 err = class_register(&st_sysfs_class);
4290 if (err) {
4291 pr_err("Unable register sysfs class for SCSI tapes\n");
4292 return err;
4293 }
4294
4295 err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4296 ST_MAX_TAPE_ENTRIES, "st");
4297 if (err) {
4298 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4299 SCSI_TAPE_MAJOR);
4300 goto err_class;
4301 }
4302
4303 err = scsi_register_driver(&st_template.gendrv);
4304 if (err)
4305 goto err_chrdev;
4306
4307 err = do_create_sysfs_files();
4308 if (err)
4309 goto err_scsidrv;
4310
4311 return 0;
4312
4313err_scsidrv:
4314 scsi_unregister_driver(&st_template.gendrv);
4315err_chrdev:
4316 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4317 ST_MAX_TAPE_ENTRIES);
4318err_class:
4319 class_unregister(&st_sysfs_class);
4320 return err;
4321}
4322
4323static void __exit exit_st(void)
4324{
4325 do_remove_sysfs_files();
4326 scsi_unregister_driver(&st_template.gendrv);
4327 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4328 ST_MAX_TAPE_ENTRIES);
4329 class_unregister(&st_sysfs_class);
4330 printk(KERN_INFO "st: Unloaded.\n");
4331}
4332
4333module_init(init_st);
4334module_exit(exit_st);
4335
4336
4337
4338static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4339{
4340 return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4341}
4342static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4343
4344static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4345{
4346 return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4347}
4348static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4349
4350static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4351{
4352 return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4353}
4354static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4355
4356static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4357{
4358 return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4359}
4360static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4361
4362static int do_create_sysfs_files(void)
4363{
4364 struct device_driver *sysfs = &st_template.gendrv;
4365 int err;
4366
4367 err = driver_create_file(sysfs, &driver_attr_try_direct_io);
4368 if (err)
4369 return err;
4370 err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size);
4371 if (err)
4372 goto err_try_direct_io;
4373 err = driver_create_file(sysfs, &driver_attr_max_sg_segs);
4374 if (err)
4375 goto err_attr_fixed_buf;
4376 err = driver_create_file(sysfs, &driver_attr_version);
4377 if (err)
4378 goto err_attr_max_sg;
4379
4380 return 0;
4381
4382err_attr_max_sg:
4383 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4384err_attr_fixed_buf:
4385 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4386err_try_direct_io:
4387 driver_remove_file(sysfs, &driver_attr_try_direct_io);
4388 return err;
4389}
4390
4391static void do_remove_sysfs_files(void)
4392{
4393 struct device_driver *sysfs = &st_template.gendrv;
4394
4395 driver_remove_file(sysfs, &driver_attr_version);
4396 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4397 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4398 driver_remove_file(sysfs, &driver_attr_try_direct_io);
4399}
4400
4401
4402static ssize_t
4403defined_show(struct device *dev, struct device_attribute *attr, char *buf)
4404{
4405 struct st_modedef *STm = dev_get_drvdata(dev);
4406 ssize_t l = 0;
4407
4408 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4409 return l;
4410}
4411static DEVICE_ATTR_RO(defined);
4412
4413static ssize_t
4414default_blksize_show(struct device *dev, struct device_attribute *attr,
4415 char *buf)
4416{
4417 struct st_modedef *STm = dev_get_drvdata(dev);
4418 ssize_t l = 0;
4419
4420 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4421 return l;
4422}
4423static DEVICE_ATTR_RO(default_blksize);
4424
4425static ssize_t
4426default_density_show(struct device *dev, struct device_attribute *attr,
4427 char *buf)
4428{
4429 struct st_modedef *STm = dev_get_drvdata(dev);
4430 ssize_t l = 0;
4431 char *fmt;
4432
4433 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4434 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4435 return l;
4436}
4437static DEVICE_ATTR_RO(default_density);
4438
4439static ssize_t
4440default_compression_show(struct device *dev, struct device_attribute *attr,
4441 char *buf)
4442{
4443 struct st_modedef *STm = dev_get_drvdata(dev);
4444 ssize_t l = 0;
4445
4446 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4447 return l;
4448}
4449static DEVICE_ATTR_RO(default_compression);
4450
4451static ssize_t
4452options_show(struct device *dev, struct device_attribute *attr, char *buf)
4453{
4454 struct st_modedef *STm = dev_get_drvdata(dev);
4455 struct scsi_tape *STp = STm->tape;
4456 int options;
4457 ssize_t l = 0;
4458
4459 options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4460 options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4461 options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4462 DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4463 options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4464 options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4465 options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4466 options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4467 options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4468 options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4469 options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4470 options |= STm->sysv ? MT_ST_SYSV : 0;
4471 options |= STp->immediate ? MT_ST_NOWAIT : 0;
4472 options |= STp->immediate_filemark ? MT_ST_NOWAIT_EOF : 0;
4473 options |= STp->sili ? MT_ST_SILI : 0;
4474
4475 l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4476 return l;
4477}
4478static DEVICE_ATTR_RO(options);
4479
4480static struct attribute *st_dev_attrs[] = {
4481 &dev_attr_defined.attr,
4482 &dev_attr_default_blksize.attr,
4483 &dev_attr_default_density.attr,
4484 &dev_attr_default_compression.attr,
4485 &dev_attr_options.attr,
4486 NULL,
4487};
4488ATTRIBUTE_GROUPS(st_dev);
4489
4490
4491static int sgl_map_user_pages(struct st_buffer *STbp,
4492 const unsigned int max_pages, unsigned long uaddr,
4493 size_t count, int rw)
4494{
4495 unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4496 unsigned long start = uaddr >> PAGE_SHIFT;
4497 const int nr_pages = end - start;
4498 int res, i, j;
4499 struct page **pages;
4500 struct rq_map_data *mdata = &STbp->map_data;
4501
4502
4503 if ((uaddr + count) < uaddr)
4504 return -EINVAL;
4505
4506
4507 if (nr_pages > max_pages)
4508 return -ENOMEM;
4509
4510
4511 if (count == 0)
4512 return 0;
4513
4514 if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4515 return -ENOMEM;
4516
4517
4518 down_read(¤t->mm->mmap_sem);
4519
4520 res = get_user_pages(
4521 current,
4522 current->mm,
4523 uaddr,
4524 nr_pages,
4525 rw == READ,
4526 0,
4527 pages,
4528 NULL);
4529 up_read(¤t->mm->mmap_sem);
4530
4531
4532 if (res < nr_pages)
4533 goto out_unmap;
4534
4535 for (i=0; i < nr_pages; i++) {
4536
4537
4538
4539 flush_dcache_page(pages[i]);
4540 }
4541
4542 mdata->offset = uaddr & ~PAGE_MASK;
4543 STbp->mapped_pages = pages;
4544
4545 return nr_pages;
4546 out_unmap:
4547 if (res > 0) {
4548 for (j=0; j < res; j++)
4549 page_cache_release(pages[j]);
4550 res = 0;
4551 }
4552 kfree(pages);
4553 return res;
4554}
4555
4556
4557
4558static int sgl_unmap_user_pages(struct st_buffer *STbp,
4559 const unsigned int nr_pages, int dirtied)
4560{
4561 int i;
4562
4563 for (i=0; i < nr_pages; i++) {
4564 struct page *page = STbp->mapped_pages[i];
4565
4566 if (dirtied)
4567 SetPageDirty(page);
4568
4569
4570
4571 page_cache_release(page);
4572 }
4573 kfree(STbp->mapped_pages);
4574 STbp->mapped_pages = NULL;
4575
4576 return 0;
4577}
4578