![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scsi_debug.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi|
Return to scsi_debug.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi |
1.1 root 1: /* $Id: scsi_debug.c,v 1.1.1.1 1997/02/25 21:27:51 thomas Exp $
2: * linux/kernel/scsi_debug.c
3: *
4: * Copyright (C) 1992 Eric Youngdale
5: * Simulate a host adapter with 2 disks attached. Do a lot of checking
6: * to make sure that we are not getting blocks mixed up, and panic if
7: * anything out of the ordinary is seen.
8: */
9:
10: #include <linux/module.h>
11:
12: #include <linux/kernel.h>
13: #include <linux/sched.h>
14: #include <linux/errno.h>
15: #include <linux/timer.h>
16: #include <linux/head.h>
17: #include <linux/types.h>
18: #include <linux/string.h>
19: #include <linux/genhd.h>
20: #include <linux/fs.h>
21: #include <linux/proc_fs.h>
22:
23: #include <asm/system.h>
24: #include <asm/io.h>
25:
26: #ifdef MODULE
27: #include <linux/module.h>
28: #endif
29:
30: #include <linux/blk.h>
31: #include "scsi.h"
32: #include "hosts.h"
33:
34: #include "sd.h"
35:
36: #include<linux/stat.h>
37:
38: struct proc_dir_entry proc_scsi_scsi_debug = {
39: PROC_SCSI_SCSI_DEBUG, 10, "scsi_debug",
40: S_IFDIR | S_IRUGO | S_IXUGO, 2
41: };
42:
43:
44: /* A few options that we want selected */
45:
46: /* Do not attempt to use a timer to simulate a real disk with latency */
47: /* Only use this in the actual kernel, not in the simulator. */
48: #define IMMEDIATE
49:
50: /* Skip some consistency checking. Good for benchmarking */
51: #define SPEEDY
52:
53: /* Number of real scsi disks that will be detected ahead of time */
54: static int NR_REAL=-1;
55:
56: #define NR_BLK_DEV 12
57: #ifndef MAJOR_NR
58: #define MAJOR_NR 8
59: #endif
60: #define START_PARTITION 4
61: #define SCSI_DEBUG_TIMER 20
62: /* Number of jiffies to wait before completing a command */
63: #define DISK_SPEED 10
64: #define CAPACITY (0x80000)
65:
66: static int starts[] = {4, 1000, 50000, CAPACITY, 0};
67: static int npart = 0;
68:
69: #include "scsi_debug.h"
70: #ifdef DEBUG
71: #define DEB(x) x
72: #else
73: #define DEB(x)
74: #endif
75:
76: #ifdef SPEEDY
77: #define VERIFY1_DEBUG(RW) 1
78: #define VERIFY_DEBUG(RW) 1
79: #else
80:
81: #define VERIFY1_DEBUG(RW) \
82: if (bufflen != 1024) {printk("%d", bufflen); panic("(1)Bad bufflen");}; \
83: start = 0; \
84: if ((MINOR(SCpnt->request.rq_dev) & 0xf) != 0) start = starts[(MINOR(SCpnt->request.rq_dev) & 0xf) - 1]; \
85: if (bh){ \
86: if (bh->b_size != 1024) panic ("Wrong bh size"); \
87: if ((bh->b_blocknr << 1) + start != block) \
88: { printk("Wrong bh block# %d %d ",bh->b_blocknr, block); \
89: panic ("Wrong bh block#"); \
90: }; \
91: if (bh->b_dev != SCpnt->request.rq_dev) \
92: panic ("Bad bh target"); \
93: };
94:
95: #define VERIFY_DEBUG(RW) \
96: if (bufflen != 1024 && (!SCpnt->use_sg)) {printk("%x %d\n ",bufflen, SCpnt->use_sg); panic("Bad bufflen");}; \
97: start = 0; \
98: if ((MINOR(SCpnt->request.rq_dev) & 0xf) > npart) panic ("Bad partition"); \
99: if ((MINOR(SCpnt->request.rq_dev) & 0xf) != 0) start = starts[(MINOR(SCpnt->request.rq_dev) & 0xf) - 1]; \
100: if (SCpnt->request.cmd != RW) panic ("Wrong operation"); \
101: if (SCpnt->request.sector + start != block) panic("Wrong block."); \
102: if (SCpnt->request.current_nr_sectors != 2 && (!SCpnt->use_sg)) panic ("Wrong # blocks"); \
103: if (SCpnt->request.bh){ \
104: if (SCpnt->request.bh->b_size != 1024) panic ("Wrong bh size"); \
105: if ((SCpnt->request.bh->b_blocknr << 1) + start != block) \
106: { printk("Wrong bh block# %d %d ",SCpnt->request.bh->b_blocknr, block); \
107: panic ("Wrong bh block#"); \
108: }; \
109: if (SCpnt->request.bh->b_dev != SCpnt->request.rq_dev) \
110: panic ("Bad bh target");\
111: };
112: #endif
113:
114: static volatile void (*do_done[SCSI_DEBUG_MAILBOXES])(Scsi_Cmnd *) = {NULL, };
115: extern void scsi_debug_interrupt();
116:
117: volatile Scsi_Cmnd * SCint[SCSI_DEBUG_MAILBOXES] = {NULL,};
118: static char SCrst[SCSI_DEBUG_MAILBOXES] = {0,};
119: static volatile unsigned int timeout[8] ={0,};
120:
121: /*
122: * Semaphore used to simulate bus lockups.
123: */
124: static int scsi_debug_lockup = 0;
125:
126: static char sense_buffer[128] = {0,};
127:
128: static void scsi_dump(Scsi_Cmnd * SCpnt, int flag){
129: int i;
130: #if 0
131: unsigned char * pnt;
132: #endif
133: unsigned int * lpnt;
134: struct scatterlist * sgpnt = NULL;
135: printk("use_sg: %d",SCpnt->use_sg);
136: if (SCpnt->use_sg){
137: sgpnt = (struct scatterlist *) SCpnt->buffer;
138: for(i=0; i<SCpnt->use_sg; i++) {
139: lpnt = (int *) sgpnt[i].alt_address;
140: printk(":%x %x %d\n",sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
141: if (lpnt) printk(" (Alt %x) ",lpnt[15]);
142: };
143: } else {
144: printk("nosg: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
145: SCpnt->bufflen);
146: lpnt = (int *) SCpnt->request.buffer;
147: if (lpnt) printk(" (Alt %x) ",lpnt[15]);
148: };
149: lpnt = (unsigned int *) SCpnt;
150: for (i=0;i<sizeof(Scsi_Cmnd)/4+1; i++) {
151: if ((i & 7) == 0) printk("\n");
152: printk("%x ",*lpnt++);
153: };
154: printk("\n");
155: if (flag == 0) return;
156: lpnt = (unsigned int *) sgpnt[0].alt_address;
157: for (i=0;i<sizeof(Scsi_Cmnd)/4+1; i++) {
158: if ((i & 7) == 0) printk("\n");
159: printk("%x ",*lpnt++);
160: };
161: #if 0
162: printk("\n");
163: lpnt = (unsigned int *) sgpnt[0].address;
164: for (i=0;i<sizeof(Scsi_Cmnd)/4+1; i++) {
165: if ((i & 7) == 0) printk("\n");
166: printk("%x ",*lpnt++);
167: };
168: printk("\n");
169: #endif
170: printk("DMA free %d sectors.\n", dma_free_sectors);
171: }
172:
173: int scsi_debug_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
174: {
175: unchar *cmd = (unchar *) SCpnt->cmnd;
176: struct partition * p;
177: int block, start;
178: struct buffer_head * bh = NULL;
179: unsigned char * buff;
180: int nbytes, sgcount;
181: int scsi_debug_errsts;
182: struct scatterlist * sgpnt;
183: int target = SCpnt->target;
184: int bufflen = SCpnt->request_bufflen;
185: unsigned long flags;
186: int i;
187: sgcount = 0;
188: sgpnt = NULL;
189:
190: DEB(if (target > 1) { SCpnt->result = DID_TIME_OUT << 16;done(SCpnt);return 0;});
191:
192: buff = (unsigned char *) SCpnt->request_buffer;
193:
194: if(target>=1 || SCpnt->lun != 0) {
195: SCpnt->result = DID_NO_CONNECT << 16;
196: done(SCpnt);
197: return 0;
198: };
199:
200: if( SCrst[target] != 0 && !scsi_debug_lockup )
201: {
202: SCrst[target] = 0;
203: memset(SCpnt->sense_buffer, 0, sizeof(SCpnt->sense_buffer));
204: SCpnt->sense_buffer[0] = 0x70;
205: SCpnt->sense_buffer[2] = UNIT_ATTENTION;
206: SCpnt->result = (CHECK_CONDITION << 1);
207: done(SCpnt);
208: }
209: switch(*cmd){
210: case REQUEST_SENSE:
211: printk("Request sense...\n");
212: #ifndef DEBUG
213: {
214: int i;
215: printk("scsi_debug: Requesting sense buffer (%x %x %x %d):", SCpnt, buff, done, bufflen);
216: for(i=0;i<12;i++) printk("%d ",sense_buffer[i]);
217: printk("\n");
218: };
219: #endif
220: memset(buff, 0, bufflen);
221: memcpy(buff, sense_buffer, bufflen);
222: memset(sense_buffer, 0, sizeof(sense_buffer));
223: SCpnt->result = 0;
224: done(SCpnt);
225: return 0;
226: case ALLOW_MEDIUM_REMOVAL:
227: if(cmd[4]) printk("Medium removal inhibited...");
228: else printk("Medium removal enabled...");
229: scsi_debug_errsts = 0;
230: break;
231: case INQUIRY:
232: printk("Inquiry...(%x %d)\n", buff, bufflen);
233: memset(buff, 0, bufflen);
234: buff[0] = TYPE_DISK;
235: buff[1] = 0x80; /* Removable disk */
236: buff[2] = 1;
237: buff[4] = 33 - 5;
238: memcpy(&buff[8],"Foo Inc",7);
239: memcpy(&buff[16],"XYZZY",5);
240: memcpy(&buff[32],"1",1);
241: scsi_debug_errsts = 0;
242: break;
243: case TEST_UNIT_READY:
244: printk("Test unit ready(%x %d)\n", buff, bufflen);
245: if (buff)
246: memset(buff, 0, bufflen);
247: scsi_debug_errsts = 0;
248: break;
249: case READ_CAPACITY:
250: printk("Read Capacity\n");
251: if(NR_REAL < 0) NR_REAL = (MINOR(SCpnt->request.rq_dev) >> 4) & 0x0f;
252: memset(buff, 0, bufflen);
253: buff[0] = (CAPACITY >> 24);
254: buff[1] = (CAPACITY >> 16) & 0xff;
255: buff[2] = (CAPACITY >> 8) & 0xff;
256: buff[3] = CAPACITY & 0xff;
257: buff[6] = 2; /* 512 byte sectors */
258: scsi_debug_errsts = 0;
259: break;
260: case READ_10:
261: case READ_6:
262: #ifdef DEBUG
263: printk("Read...");
264: #endif
265: if ((*cmd) == READ_10)
266: block = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24);
267: else
268: block = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
269: VERIFY_DEBUG(READ);
270: #if defined(SCSI_SETUP_LATENCY) || defined(SCSI_DATARATE)
271: {
272: int delay = SCSI_SETUP_LATENCY;
273: double usec;
274:
275: usec = 0.0;
276: usec = (SCpnt->request.nr_sectors << 9) * 1.0e6 / SCSI_DATARATE;
277: delay += usec;
278: if(delay) usleep(delay);
279: };
280: #endif
281:
282: #ifdef DEBUG
283: printk("(r%d)",SCpnt->request.nr_sectors);
284: #endif
285: nbytes = bufflen;
286: if(SCpnt->use_sg){
287: sgcount = 0;
288: sgpnt = (struct scatterlist *) buff;
289: buff = sgpnt[sgcount].address;
290: bufflen = sgpnt[sgcount].length;
291: bh = SCpnt->request.bh;
292: };
293: scsi_debug_errsts = 0;
294: do{
295: VERIFY1_DEBUG(READ);
296: /* For the speedy test, we do not even want to fill the buffer with anything */
297: #ifndef SPEEDY
298: memset(buff, 0, bufflen);
299: #endif
300: /* If this is block 0, then we want to read the partition table for this
301: * device. Let's make one up */
302: if(block == 0 && target == 0) {
303: memset(buff, 0, bufflen);
304: *((unsigned short *) (buff+510)) = 0xAA55;
305: p = (struct partition* ) (buff + 0x1be);
306: npart = 0;
307: while(starts[npart+1]){
308: p->start_sect = starts[npart];
309: p->nr_sects = starts[npart+1] - starts [npart];
310: p->sys_ind = 0x81; /* Linux partition */
311: p++;
312: npart++;
313: };
314: scsi_debug_errsts = 0;
315: break;
316: };
317: #ifdef DEBUG
318: if (SCpnt->use_sg) printk("Block %x (%d %d)\n",block, SCpnt->request.nr_sectors,
319: SCpnt->request.current_nr_sectors);
320: #endif
321:
322: #if 0
323: /* Simulate a disk change */
324: if(block == 0xfff0) {
325: sense_buffer[0] = 0x70;
326: sense_buffer[2] = UNIT_ATTENTION;
327: starts[0] += 10;
328: starts[1] += 10;
329: starts[2] += 10;
330:
331: #ifdef DEBUG
332: {
333: int i;
334: printk("scsi_debug: Filling sense buffer:");
335: for(i=0;i<12;i++) printk("%d ",sense_buffer[i]);
336: printk("\n");
337: };
338: #endif
339: scsi_debug_errsts = (COMMAND_COMPLETE << 8) | (CHECK_CONDITION << 1);
340: break;
341: } /* End phony disk change code */
342: #endif
343:
344: #ifndef SPEEDY
345: memcpy(buff, &target, sizeof(target));
346: memcpy(buff+sizeof(target), cmd, 24);
347: memcpy(buff+60, &block, sizeof(block));
348: memcpy(buff+64, SCpnt, sizeof(Scsi_Cmnd));
349: #endif
350: nbytes -= bufflen;
351: if(SCpnt->use_sg){
352: #ifndef SPEEDY
353: memcpy(buff+128, bh, sizeof(struct buffer_head));
354: #endif
355: block += bufflen >> 9;
356: bh = bh->b_reqnext;
357: sgcount++;
358: if (nbytes) {
359: if(!bh) panic("Too few blocks for linked request.");
360: buff = sgpnt[sgcount].address;
361: bufflen = sgpnt[sgcount].length;
362: };
363: }
364: } while(nbytes);
365:
366: SCpnt->result = 0;
367: (done)(SCpnt);
368: return;
369:
370: if (SCpnt->use_sg && !scsi_debug_errsts)
371: if(bh) scsi_dump(SCpnt, 0);
372: break;
373: case WRITE_10:
374: case WRITE_6:
375: #ifdef DEBUG
376: printk("Write\n");
377: #endif
378: if ((*cmd) == WRITE_10)
379: block = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24);
380: else
381: block = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
382: VERIFY_DEBUG(WRITE);
383: /* printk("(w%d)",SCpnt->request.nr_sectors); */
384: if (SCpnt->use_sg){
385: if ((bufflen >> 9) != SCpnt->request.nr_sectors)
386: panic ("Trying to write wrong number of blocks\n");
387: sgpnt = (struct scatterlist *) buff;
388: buff = sgpnt[sgcount].address;
389: };
390: #if 0
391: if (block != *((unsigned long *) (buff+60))) {
392: printk("%x %x :",block, *((unsigned long *) (buff+60)));
393: scsi_dump(SCpnt,1);
394: panic("Bad block written.\n");
395: };
396: #endif
397: scsi_debug_errsts = 0;
398: break;
399: default:
400: printk("Unknown command %d\n",*cmd);
401: SCpnt->result = DID_NO_CONNECT << 16;
402: done(SCpnt);
403: return 0;
404: };
405:
406: save_flags(flags);
407: cli();
408: for(i=0;i<SCSI_DEBUG_MAILBOXES; i++){
409: if (SCint[i] == 0) break;
410: };
411:
412: if (i >= SCSI_DEBUG_MAILBOXES || SCint[i] != 0)
413: panic("Unable to find empty SCSI_DEBUG command slot.\n");
414:
415: SCint[i] = SCpnt;
416:
417: if (done) {
418: DEB(printk("scsi_debug_queuecommand: now waiting for interrupt "););
419: if (do_done[i])
420: printk("scsi_debug_queuecommand: Two concurrent queuecommand?\n");
421: else
422: do_done[i] = done;
423: }
424: else
425: printk("scsi_debug_queuecommand: done cant be NULL\n");
426:
427: #ifdef IMMEDIATE
428: if( !scsi_debug_lockup )
429: {
430: SCpnt->result = scsi_debug_errsts;
431: scsi_debug_intr_handle(); /* No timer - do this one right away */
432: }
433: restore_flags(flags);
434: #else
435: timeout[i] = jiffies+DISK_SPEED;
436:
437: /* If no timers active, then set this one */
438: if ((timer_active & (1 << SCSI_DEBUG_TIMER)) == 0) {
439: timer_table[SCSI_DEBUG_TIMER].expires = timeout[i];
440: timer_active |= 1 << SCSI_DEBUG_TIMER;
441: };
442:
443: SCpnt->result = scsi_debug_errsts;
444: restore_flags(flags);
445:
446: #if 0
447: printk("Sending command (%d %x %d %d)...", i, done, timeout[i],jiffies);
448: #endif
449: #endif
450:
451: return 0;
452: }
453:
454: volatile static int internal_done_flag = 0;
455: volatile static int internal_done_errcode = 0;
456: static void internal_done(Scsi_Cmnd * SCpnt)
457: {
458: internal_done_errcode = SCpnt->result;
459: ++internal_done_flag;
460: }
461:
462: int scsi_debug_command(Scsi_Cmnd * SCpnt)
463: {
464: DEB(printk("scsi_debug_command: ..calling scsi_debug_queuecommand\n"));
465: scsi_debug_queuecommand(SCpnt, internal_done);
466:
467: while (!internal_done_flag);
468: internal_done_flag = 0;
469: return internal_done_errcode;
470: }
471:
472: /* A "high" level interrupt handler. This should be called once per jiffy
473: * to simulate a regular scsi disk. We use a timer to do this. */
474:
475: static void scsi_debug_intr_handle(void)
476: {
477: Scsi_Cmnd * SCtmp;
478: int i, pending;
479: void (*my_done)(Scsi_Cmnd *);
480: unsigned long flags;
481: int to;
482:
483: #ifndef IMMEDIATE
484: timer_table[SCSI_DEBUG_TIMER].expires = 0;
485: timer_active &= ~(1 << SCSI_DEBUG_TIMER);
486: #endif
487:
488: repeat:
489: save_flags(flags);
490: cli();
491: for(i=0;i<SCSI_DEBUG_MAILBOXES; i++) {
492: if (SCint[i] == 0) continue;
493: #ifndef IMMEDIATE
494: if (timeout[i] == 0) continue;
495: if (timeout[i] <= jiffies) break;
496: #else
497: break;
498: #endif
499: };
500:
501: if(i == SCSI_DEBUG_MAILBOXES){
502: #ifndef IMMEDIATE
503: pending = INT_MAX;
504: for(i=0;i<SCSI_DEBUG_MAILBOXES; i++) {
505: if (SCint[i] == 0) continue;
506: if (timeout[i] == 0) continue;
507: if (timeout[i] <= jiffies) {restore_flags(flags); goto repeat;};
508: if (timeout[i] > jiffies) {
509: if (pending > timeout[i]) pending = timeout[i];
510: continue;
511: };
512: };
513: if (pending && pending != INT_MAX) {
514: timer_table[SCSI_DEBUG_TIMER].expires =
515: (pending <= jiffies ? jiffies+1 : pending);
516: timer_active |= 1 << SCSI_DEBUG_TIMER;
517: };
518: restore_flags(flags);
519: #endif
520: return;
521: };
522:
523: if(i < SCSI_DEBUG_MAILBOXES){
524: timeout[i] = 0;
525: my_done = do_done[i];
526: do_done[i] = NULL;
527: to = timeout[i];
528: timeout[i] = 0;
529: SCtmp = (Scsi_Cmnd *) SCint[i];
530: SCint[i] = NULL;
531: restore_flags(flags);
532:
533: if (!my_done) {
534: printk("scsi_debug_intr_handle: Unexpected interrupt\n");
535: return;
536: }
537:
538: #ifdef DEBUG
539: printk("In intr_handle...");
540: printk("...done %d %x %d %d\n",i , my_done, to, jiffies);
541: printk("In intr_handle: %d %x %x\n",i, SCtmp, my_done);
542: #endif
543:
544: my_done(SCtmp);
545: #ifdef DEBUG
546: printk("Called done.\n");
547: #endif
548: };
549: goto repeat;
550: }
551:
552:
553: int scsi_debug_detect(Scsi_Host_Template * tpnt)
554: {
555: tpnt->proc_dir = &proc_scsi_scsi_debug;
556: #ifndef IMMEDIATE
557: timer_table[SCSI_DEBUG_TIMER].fn = scsi_debug_intr_handle;
558: timer_table[SCSI_DEBUG_TIMER].expires = 0;
559: #endif
560: return 1;
561: }
562:
563: int scsi_debug_abort(Scsi_Cmnd * SCpnt)
564: {
565: int j;
566: void (*my_done)(Scsi_Cmnd *);
567: unsigned long flags;
568:
569: DEB(printk("scsi_debug_abort\n"));
570: #if 0
571: SCpnt->result = SCpnt->abort_reason << 16;
572: for(j=0;j<SCSI_DEBUG_MAILBOXES; j++) {
573: if(SCpnt == SCint[j]) {
574: my_done = do_done[j];
575: my_done(SCpnt);
576: save_flags(flags);
577: cli();
578: timeout[j] = 0;
579: SCint[j] = NULL;
580: do_done[j] = NULL;
581: restore_flags(flags);
582: };
583: };
584: #endif
585: return SCSI_ABORT_SNOOZE;
586: }
587:
588: int scsi_debug_biosparam(Disk * disk, kdev_t dev, int* info){
589: int size = disk->capacity;
590: info[0] = 32;
591: info[1] = 64;
592: info[2] = (size + 2047) >> 11;
593: if (info[2] >= 1024) info[2] = 1024;
594: return 0;
595: }
596:
597: int scsi_debug_reset(Scsi_Cmnd * SCpnt)
598: {
599: int i;
600: unsigned long flags;
601:
602: void (*my_done)(Scsi_Cmnd *);
603: printk("Bus unlocked by reset(%d)\n", SCpnt->host->suggest_bus_reset);
604: scsi_debug_lockup = 0;
605: DEB(printk("scsi_debug_reset called\n"));
606: for(i=0;i<SCSI_DEBUG_MAILBOXES; i++) {
607: if (SCint[i] == NULL) continue;
608: SCint[i]->result = DID_RESET << 16;
609: my_done = do_done[i];
610: my_done(SCint[i]);
611: save_flags(flags);
612: cli();
613: SCint[i] = NULL;
614: do_done[i] = NULL;
615: timeout[i] = 0;
616: restore_flags(flags);
617: }
618: return SCSI_RESET_SUCCESS;
619: }
620:
621: const char *scsi_debug_info(void)
622: {
623: static char buffer[] = " "; /* looks nicer without anything here */
624: return buffer;
625: }
626:
627: /* scsi_debug_proc_info
628: * Used if the driver currently has no own support for /proc/scsi
629: */
630: int scsi_debug_proc_info(char *buffer, char **start, off_t offset,
631: int length, int inode, int inout)
632: {
633: int len, pos, begin;
634: int orig_length;
635:
636: if(inout == 1)
637: {
638: /* First check for the Signature */
639: if (length >= 10 && strncmp(buffer, "scsi_debug", 10) == 0) {
640: buffer += 11;
641: length -= 11;
642: /*
643: * OK, we are getting some kind of command. Figure out
644: * what we are supposed to do here. Simulate bus lockups
645: * to test our reset capability.
646: */
647: if( length == 6 && strncmp(buffer, "lockup", length) == 0 )
648: {
649: scsi_debug_lockup = 1;
650: return length;
651: }
652:
653: if( length == 6 && strncmp(buffer, "unlock", length) == 0 )
654: {
655: scsi_debug_lockup = 0;
656: return length;
657: }
658:
659: printk("Unknown command:%s\n", buffer);
660: } else
661: printk("Wrong Signature:%10s\n", (char *) ((ulong)buffer-11));
662:
663: return -EINVAL;
664:
665: }
666:
667: begin = 0;
668: pos = len = sprintf(buffer,
669: "This driver is not a real scsi driver, but it plays one on TV.\n"
670: "It is very handy for debugging specific problems because you\n"
671: "can simulate a variety of error conditions\n");
672: if(pos < offset)
673: {
674: len = 0;
675: begin = pos;
676: }
677:
678: *start = buffer + (offset - begin); /* Start of wanted data */
679: len -= (offset - begin);
680: if(len > length)
681: len = length;
682:
683: return(len);
684: }
685:
686: #ifdef MODULE
687: /* Eventually this will go into an include file, but this will be later */
688: Scsi_Host_Template driver_template = SCSI_DEBUG;
689:
690: #include "scsi_module.c"
691: #endif
692:
693: /*
694: * Overrides for Emacs so that we almost follow Linus's tabbing style.
695: * Emacs will notice this stuff at the end of the file and automatically
696: * adjust the settings for this buffer only. This must remain at the end
697: * of the file.
698: * ---------------------------------------------------------------------------
699: * Local variables:
700: * c-indent-level: 4
701: * c-brace-imaginary-offset: 0
702: * c-brace-offset: -4
703: * c-argdecl-indent: 4
704: * c-label-offset: -4
705: * c-continued-statement-offset: 4
706: * c-continued-brace-offset: 0
707: * indent-tabs-mode: nil
708: * tab-width: 8
709: * End:
710: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.