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