![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rz_disk.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / scsi|
Return to rz_disk.c CVS log | Up to [GnuMach] / Gnu-Mach / scsi |
1.1 ! root 1: /* ! 2: * Mach Operating System ! 3: * Copyright (c) 1991,1990 Carnegie Mellon University ! 4: * All Rights Reserved. ! 5: * ! 6: * Permission to use, copy, modify and distribute this software and its ! 7: * documentation is hereby granted, provided that both the copyright ! 8: * notice and this permission notice appear in all copies of the ! 9: * software, derivative works or modified versions, and any portions ! 10: * thereof, and that both notices appear in supporting documentation. ! 11: * ! 12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR ! 14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 15: * ! 16: * Carnegie Mellon requests users of this software to return to ! 17: * ! 18: * Software Distribution Coordinator or [email protected] ! 19: * School of Computer Science ! 20: * Carnegie Mellon University ! 21: * Pittsburgh PA 15213-3890 ! 22: * ! 23: * any improvements or extensions that they make and grant Carnegie Mellon ! 24: * the rights to redistribute these changes. ! 25: */ ! 26: /* ! 27: * File: rz_disk.c ! 28: * Author: Alessandro Forin, Carnegie Mellon University ! 29: * Date: 10/90 ! 30: * ! 31: * Top layer of the SCSI driver: interface with the MI. ! 32: * This file contains operations specific to disk-like devices. ! 33: * ! 34: * Modified by Kevin T. Van Maren to use a common partition code ! 35: * with the ide driver, and support 'slices'. ! 36: */ ! 37: ! 38: ! 39: #include <scsi/scsi.h> ! 40: #if (NSCSI > 0) ! 41: ! 42: #include <device/buf.h> ! 43: #include <device/disk_status.h> ! 44: #include <device/device_types.h> ! 45: #include <device/param.h> ! 46: #include <device/errno.h> ! 47: ! 48: #include <kern/time_out.h> ! 49: #include <machine/machspl.h> /* spl definitions */ ! 50: #include <mach/std_types.h> ! 51: #include <platforms.h> ! 52: ! 53: #include <scsi/compat_30.h> ! 54: #include <scsi/scsi.h> ! 55: #include <scsi/scsi_defs.h> ! 56: #include <scsi/rz.h> ! 57: #include <scsi/rz_labels.h> ! 58: ! 59: #ifdef MACH_KERNEL ! 60: #else /*MACH_KERNEL*/ ! 61: #include <sys/kernel.h> /* for hz */ ! 62: #endif /*MACH_KERNEL*/ ! 63: ! 64: #include <sys/types.h> ! 65: #include <sys/ioctl.h> ! 66: #include "vm_param.h" ! 67: #include <vm/vm_kern.h> ! 68: #include <vm/pmap.h> ! 69: ! 70: extern void scdisk_read(), scdisk_write(), ! 71: scsi_long_read(), scsi_long_write(); ! 72: ! 73: void scdisk_start(); /* forwards */ ! 74: void scdisk_start_rw(); ! 75: unsigned dkcksum(); ! 76: ! 77: #if 0 ! 78: struct diskpart scsi_array[8*64]; ! 79: #endif 0 ! 80: ! 81: ! 82: /* THIS IS THE BOTTOM LAYER FOR THE SCSI PARTITION CODE */ ! 83: typedef struct scsi_driver_info { ! 84: target_info_t *tgt; ! 85: io_req_t ior; ! 86: void (*readfun)(); ! 87: int sectorsize; ! 88: } scsi_driver_info; ! 89: ! 90: int scsi_read_fun(scsi_driver_info *param, int sectornum, void *buff) ! 91: { ! 92: char *psave; ! 93: int result = TRUE; /* SUCCESS */ ! 94: psave=param->ior->io_data; /* is this necessary ? */ ! 95: ! 96: param->ior->io_data=buff; ! 97: param->ior->io_count = param->sectorsize; ! 98: param->ior->io_op = IO_READ; ! 99: param->ior->io_error = 0; ! 100: param->tgt->ior = param->ior; ! 101: ! 102: (*param->readfun)( param->tgt, sectornum, param->ior); ! 103: iowait(param->ior); ! 104: ! 105: param->ior->io_data=psave; /* restore the io_data pointer ?? */ ! 106: return(result); ! 107: } ! 108: ! 109: ! 110: ! 111: /* ! 112: * Specialized side of the open routine for disks ! 113: */ ! 114: scsi_ret_t scdisk_open(tgt, req) ! 115: target_info_t *tgt; ! 116: io_req_t req; ! 117: { ! 118: register int i, dev_bsize; ! 119: scsi_ret_t ret = /* SCSI_RET_SUCCESS; */ -1; ! 120: unsigned int disk_size, secs_per_cyl, sector_size; ! 121: scsi_rcap_data_t *cap; ! 122: struct disklabel *label; ! 123: io_req_t ior; ! 124: void (*readfun)() = scdisk_read; ! 125: char *data = (char *)0; ! 126: ! 127: int numpart; ! 128: ! 129: scsi_driver_info scsi_info; ! 130: char drive_name[10]; /* used for disklabel strings */ ! 131: ! 132: if (tgt->flags & TGT_ONLINE) ! 133: return SCSI_RET_SUCCESS; ! 134: ! 135: /* ! 136: * Dummy ior for proper sync purposes ! 137: */ ! 138: io_req_alloc(ior,0); ! 139: ior->io_next = 0; ! 140: ior->io_count = 0; ! 141: ! 142: /* ! 143: * Set the LBN to DEV_BSIZE with a MODE SELECT. ! 144: * If this fails we try a couple other tricks. ! 145: */ ! 146: dev_bsize = 0; ! 147: for (i = 0; i < 5; i++) { ! 148: ior->io_op = IO_INTERNAL; ! 149: ior->io_error = 0; ! 150: ret = scdisk_mode_select(tgt, DEV_BSIZE, ior, 0, 0, 0); ! 151: if (ret == SCSI_RET_SUCCESS) { ! 152: dev_bsize = DEV_BSIZE; ! 153: break; ! 154: } ! 155: if (ret == SCSI_RET_RETRY) { ! 156: timeout(wakeup, tgt, 2*hz); ! 157: await(tgt); ! 158: } ! 159: if (ret == SCSI_RET_DEVICE_DOWN) ! 160: goto done; ! 161: } ! 162: #if 0 ! 163: if (ret != SCSI_RET_SUCCESS) { ! 164: scsi_error( tgt, SCSI_ERR_MSEL, ret, 0); ! 165: ret = D_INVALID_SIZE; ! 166: goto done; ! 167: } ! 168: #endif ! 169: /* ! 170: * Do a READ CAPACITY to get max size. Check LBN too. ! 171: */ ! 172: for (i = 0; i < 5; i++) { ! 173: ior->io_op = IO_INTERNAL; ! 174: ior->io_error = 0; ! 175: ret = scsi_read_capacity(tgt, 0, ior); ! 176: if (ret == SCSI_RET_SUCCESS) ! 177: break; ! 178: } ! 179: if (ret == SCSI_RET_SUCCESS) { ! 180: int val; ! 181: ! 182: cap = (scsi_rcap_data_t*) tgt->cmd_ptr; ! 183: disk_size = (cap->lba1<<24) | ! 184: (cap->lba2<<16) | ! 185: (cap->lba3<< 8) | ! 186: cap->lba4; ! 187: if (scsi_debug) ! 188: printf("rz%d holds %d blocks\n", tgt->unit_no, disk_size); ! 189: val = (cap->blen1<<24) | ! 190: (cap->blen2<<16) | ! 191: (cap->blen3<<8 ) | ! 192: cap->blen4; ! 193: if (dev_bsize == 0) ! 194: dev_bsize = val; ! 195: else ! 196: if (val != dev_bsize) panic("read capacity bad"); ! 197: ! 198: if (disk_size > SCSI_CMD_READ_MAX_LBA) ! 199: tgt->flags |= TGT_BIG; ! 200: ! 201: } else { ! 202: printf("Unknown disk capacity??\n"); ! 203: disk_size = -1; ! 204: } ! 205: /* ! 206: * Mandatory long-form commands ? ! 207: */ ! 208: if (BGET(scsi_use_long_form,(unsigned char)tgt->masterno,tgt->target_id)) ! 209: tgt->flags |= TGT_BIG; ! 210: if (tgt->flags & TGT_BIG) ! 211: readfun = scsi_long_read; ! 212: ! 213: /* ! 214: * Some CDROMS truly dislike 512 as LBN. ! 215: * Use a MODE_SENSE to cover for this case. ! 216: */ ! 217: if (dev_bsize == 0) { ! 218: scsi_mode_sense_data_t *m; ! 219: ! 220: ior->io_op = IO_INTERNAL; ! 221: ior->io_error = 0; ! 222: ret = scsi_mode_sense(tgt, 0/*pagecode*/, 32/*?*/, ior); ! 223: if (ret == SCSI_RET_SUCCESS) { ! 224: m = (scsi_mode_sense_data_t *) tgt->cmd_ptr; ! 225: dev_bsize = ! 226: m->bdesc[0].blen_msb << 16 | ! 227: m->bdesc[0].blen << 8 | ! 228: m->bdesc[0].blen_lsb; ! 229: } ! 230: } ! 231: ! 232: /* ! 233: * Find out about the phys disk geometry -- scsi specific ! 234: */ ! 235: ! 236: ior->io_op = IO_INTERNAL; ! 237: ior->io_error = 0; ! 238: ret = scsi_read_capacity( tgt, 1, ior); ! 239: if (ret == SCSI_RET_SUCCESS) { ! 240: cap = (scsi_rcap_data_t*) tgt->cmd_ptr; ! 241: secs_per_cyl = (cap->lba1<<24) | (cap->lba2<<16) | ! 242: (cap->lba3<< 8) | cap->lba4; ! 243: secs_per_cyl += 1; ! 244: sector_size = (cap->blen1<<24) | (cap->blen2<<16) | ! 245: (cap->blen3<<8 ) | cap->blen4; ! 246: } else { ! 247: sector_size = dev_bsize ? dev_bsize : DEV_BSIZE; ! 248: secs_per_cyl = disk_size; ! 249: } ! 250: if (dev_bsize == 0) ! 251: dev_bsize = sector_size; ! 252: ! 253: if (scsi_debug) ! 254: printf("rz%d: %d sect/cyl %d bytes/sec\n", tgt->unit_no, ! 255: secs_per_cyl, sector_size); ! 256: ! 257: /* ! 258: * At this point, one way or other, we are committed to ! 259: * a given disk capacity and sector size. ! 260: */ ! 261: tgt->block_size = dev_bsize; ! 262: ! 263: /* ! 264: * Get partition table off pack ! 265: */ ! 266: ! 267: #ifdef MACH_KERNEL ! 268: ior->io_data = (char *)kalloc(sector_size); ! 269: #endif /*MACH_KERNEL*/ ! 270: ! 271: scsi_info.tgt=tgt; ! 272: scsi_info.ior=ior; ! 273: scsi_info.readfun=readfun; ! 274: scsi_info.sectorsize=sector_size; ! 275: ! 276: /* label has NOT been allocated space yet! set to the tgt disklabel */ ! 277: label=&scsi_info.tgt->dev_info.disk.l; ! 278: ! 279: sprintf(drive_name, "sd%d:", tgt->unit_no); ! 280: ! 281: if (scsi_debug) ! 282: printf("Using bogus geometry: 32 sectors/track, 64 heads\n"); ! 283: ! 284: fudge_bsd_label(label, DTYPE_SCSI, disk_size /* /(32*64)*/ , ! 285: 64, 32, sector_size, 8); ! 286: ! 287: numpart=get_only_partition(&scsi_info, (*scsi_read_fun), ! 288: tgt->dev_info.disk.scsi_array, MAX_SCSI_PARTS, disk_size, drive_name); ! 289: ! 290: printf("%s %d partitions found\n",drive_name,numpart); ! 291: ! 292: ret=SCSI_RET_SUCCESS; /* if 0, return SCSI_RET_SUCCESS */ ! 293: ! 294: ! 295: done: ! 296: io_req_free(ior); ! 297: ! 298: return(ret); ! 299: } ! 300: ! 301: ! 302: /* ! 303: * Disk strategy routine ! 304: */ ! 305: int scdisk_strategy(ior) ! 306: register io_req_t ior; ! 307: { ! 308: target_info_t *tgt; ! 309: register scsi_softc_t *sc; ! 310: register int i = ior->io_unit, part; ! 311: register unsigned rec, max; ! 312: spl_t s; ! 313: struct diskpart *label; ! 314: ! 315: sc = scsi_softc[rzcontroller(i)]; ! 316: tgt = sc->target[rzslave(i)]; ! 317: part = rzpartition(i); ! 318: ! 319: /* ! 320: * Validate request ! 321: */ ! 322: ! 323: /* readonly ? */ ! 324: if ((tgt->flags & TGT_READONLY) && ! 325: (ior->io_op & (IO_READ|IO_INTERNAL) == 0)) { ! 326: ior->io_error = D_READ_ONLY; ! 327: ior->io_op |= IO_ERROR; ! 328: ior->io_residual = ior->io_count; ! 329: iodone(ior); ! 330: return ior->io_error; ! 331: } ! 332: ! 333: rec = ior->io_recnum; ! 334: ! 335: label=lookup_part(tgt->dev_info.disk.scsi_array, part); ! 336: if (!label) { ! 337: if (scsi_debug) ! 338: printf("sc strategy -- bad partition\n"); ! 339: ior->io_error = D_INVALID_SIZE; ! 340: ior->io_op |= IO_ERROR; ! 341: ior->io_residual = ior->io_count; ! 342: iodone(ior); ! 343: return ior->io_error; ! 344: } ! 345: else max=label->size; ! 346: if (max == -1) /* what about 0? */ ! 347: max = tgt->dev_info.disk.l.d_secperunit - ! 348: ! 349: label->start; ! 350: ! 351: i = (ior->io_count + tgt->block_size - 1) / tgt->block_size; ! 352: if (((rec + i) > max) || (ior->io_count < 0) || ! 353: #if later ! 354: ((rec <= LABELSECTOR) && ((tgt->flags & TGT_WRITE_LABEL) == 0)) ! 355: #else ! 356: FALSE ! 357: #endif ! 358: ) { ! 359: ior->io_error = D_INVALID_SIZE; ! 360: ior->io_op |= IO_ERROR; ! 361: ior->io_residual = ior->io_count; ! 362: iodone(ior); ! 363: return ior->io_error; ! 364: } ! 365: /* ! 366: * Find location on disk: secno and cyl (for disksort) ! 367: */ ! 368: rec += label->start; ! 369: ior->io_residual = rec / tgt->dev_info.disk.l.d_secpercyl; ! 370: ! 371: /* ! 372: * Enqueue operation ! 373: */ ! 374: s = splbio(); ! 375: simple_lock(&tgt->target_lock); ! 376: if (tgt->ior) { ! 377: disksort(tgt->ior, ior); ! 378: simple_unlock(&tgt->target_lock); ! 379: splx(s); ! 380: } else { ! 381: ior->io_next = 0; ! 382: tgt->ior = ior; ! 383: simple_unlock(&tgt->target_lock); ! 384: splx(s); ! 385: ! 386: scdisk_start(tgt,FALSE); ! 387: } ! 388: ! 389: return D_SUCCESS; ! 390: } ! 391: ! 392: /*#define CHECKSUM*/ ! 393: #ifdef CHECKSUM ! 394: int max_checksum_size = 0x2000; ! 395: #endif CHECKSUM ! 396: ! 397: /* ! 398: * Start/completion routine for disks ! 399: */ ! 400: void scdisk_start(tgt, done) ! 401: target_info_t *tgt; ! 402: boolean_t done; ! 403: { ! 404: register io_req_t ior = tgt->ior; ! 405: register unsigned part; ! 406: #ifdef CHECKSUM ! 407: register unsigned secno; ! 408: #endif ! 409: struct diskpart *label; ! 410: ! 411: if (ior == 0) ! 412: return; ! 413: ! 414: if (tgt->flags & TGT_BBR_ACTIVE) ! 415: { ! 416: scdisk_bbr_start(tgt, done); ! 417: return; ! 418: } ! 419: ! 420: if (done) { ! 421: register unsigned int xferred; ! 422: unsigned int max_dma_data; ! 423: ! 424: max_dma_data = scsi_softc[(unsigned char)tgt->masterno]->max_dma_data; ! 425: /* see if we must retry */ ! 426: if ((tgt->done == SCSI_RET_RETRY) && ! 427: ((ior->io_op & IO_INTERNAL) == 0)) { ! 428: delay(1000000);/*XXX*/ ! 429: goto start; ! 430: } else ! 431: /* got a bus reset ? pifff.. */ ! 432: if ((tgt->done == (SCSI_RET_ABORTED|SCSI_RET_RETRY)) && ! 433: ((ior->io_op & IO_INTERNAL) == 0)) { ! 434: if (xferred = ior->io_residual) { ! 435: ior->io_data -= xferred; ! 436: ior->io_count += xferred; ! 437: ior->io_recnum -= xferred / tgt->block_size; ! 438: ior->io_residual = 0; ! 439: } ! 440: goto start; ! 441: } else ! 442: /* ! 443: * Quickly check for errors: if anything goes wrong ! 444: * we do a request sense, see if that is what we did. ! 445: */ ! 446: if (tgt->cur_cmd == SCSI_CMD_REQUEST_SENSE) { ! 447: scsi_sense_data_t *sns; ! 448: unsigned int blockno; ! 449: char *outcome; ! 450: ! 451: ior->io_op = ior->io_temporary; ! 452: ! 453: sns = (scsi_sense_data_t *)tgt->cmd_ptr; ! 454: if (sns->addr_valid) ! 455: blockno = sns->u.xtended.info0 << 24 | ! 456: sns->u.xtended.info1 << 16 | ! 457: sns->u.xtended.info2 << 8 | ! 458: sns->u.xtended.info3; ! 459: else { ! 460: part = rzpartition(ior->io_unit); ! 461: label = lookup_part(tgt->dev_info.disk.scsi_array, part); ! 462: blockno = label->start; ! 463: blockno += ior->io_recnum; ! 464: if (!label) blockno=-1; ! 465: } ! 466: ! 467: if (scsi_check_sense_data(tgt, sns)) { ! 468: ior->io_error = 0; ! 469: if ((tgt->done == SCSI_RET_RETRY) && ! 470: ((ior->io_op & IO_INTERNAL) == 0)) { ! 471: delay(1000000);/*XXX*/ ! 472: goto start; ! 473: } ! 474: outcome = "Recovered"; ! 475: } else { ! 476: outcome = "Unrecoverable"; ! 477: ior->io_error = D_IO_ERROR; ! 478: ior->io_op |= IO_ERROR; ! 479: } ! 480: if ((tgt->flags & TGT_OPTIONAL_CMD) == 0) { ! 481: printf("%s Error, rz%d: %s%s%d\n", outcome, ! 482: tgt->target_id + (tgt->masterno * 8), ! 483: (ior->io_op & IO_READ) ? "Read" : ! 484: ((ior->io_op & IO_INTERNAL) ? "(command)" : "Write"), ! 485: " disk error, phys block no. ", blockno); ! 486: ! 487: scsi_print_sense_data(sns); ! 488: ! 489: /* ! 490: * On fatal read/write errors try replacing the bad block ! 491: * The bbr routine will return TRUE iff it took control ! 492: * over the target for all subsequent operations. In this ! 493: * event, the queue of requests is effectively frozen. ! 494: */ ! 495: if (ior->io_error && ! 496: ((sns->error_class == SCSI_SNS_XTENDED_SENSE_DATA) && ! 497: ((sns->u.xtended.sense_key == SCSI_SNS_HW_ERR) || ! 498: (sns->u.xtended.sense_key == SCSI_SNS_MEDIUM_ERR))) && ! 499: scdisk_bad_block_repl(tgt, blockno)) ! 500: return; ! 501: } ! 502: } ! 503: ! 504: /* ! 505: * See if we had errors ! 506: */ ! 507: else if (tgt->done != SCSI_RET_SUCCESS) { ! 508: ! 509: if (tgt->done == SCSI_RET_NEED_SENSE) { ! 510: ! 511: ior->io_temporary = ior->io_op; ! 512: ior->io_op = IO_INTERNAL; ! 513: scsi_request_sense(tgt, ior, 0); ! 514: return; ! 515: ! 516: } else if (tgt->done == SCSI_RET_DEVICE_DOWN) { ! 517: ior->io_error = D_DEVICE_DOWN; ! 518: ior->io_op |= IO_ERROR; ! 519: } else { ! 520: printf("%s%x\n", "?rz_disk Disk error, ret=x", tgt->done); ! 521: ior->io_error = D_IO_ERROR; ! 522: ior->io_op |= IO_ERROR; ! 523: } ! 524: } ! 525: /* ! 526: * No errors. ! 527: * See if we requested more than the max ! 528: * (We use io_residual in a flip-side way here) ! 529: */ ! 530: else if (ior->io_count > (xferred = max_dma_data)) { ! 531: ior->io_residual += xferred; ! 532: ior->io_count -= xferred; ! 533: ior->io_data += xferred; ! 534: ior->io_recnum += xferred / tgt->block_size; ! 535: goto start; ! 536: } ! 537: else if (xferred = ior->io_residual) { ! 538: ior->io_data -= xferred; ! 539: ior->io_count += xferred; ! 540: ior->io_recnum -= xferred / tgt->block_size; ! 541: ior->io_residual = 0; ! 542: } /* that's it */ ! 543: ! 544: #ifdef CHECKSUM ! 545: if ((ior->io_op & IO_READ) && (ior->io_count < max_checksum_size)) { ! 546: part = rzpartition(ior->io_unit); ! 547: label=lookup_part(tgt->dev_info.disk.scsi_array, part); ! 548: if (!label) printf("NOT FOUND!\n"); ! 549: secno = ior->io_recnum + label->start; ! 550: scdisk_bcheck(secno, ior->io_data, ior->io_count); ! 551: } ! 552: #endif CHECKSUM ! 553: ! 554: /* dequeue next one */ ! 555: { ! 556: io_req_t next; ! 557: ! 558: simple_lock(&tgt->target_lock); ! 559: next = ior->io_next; ! 560: tgt->ior = next; ! 561: simple_unlock(&tgt->target_lock); ! 562: ! 563: iodone(ior); ! 564: if (next == 0) ! 565: return; ! 566: ! 567: ior = next; ! 568: } ! 569: ! 570: #ifdef CHECKSUM ! 571: if (((ior->io_op & IO_READ) == 0) && (ior->io_count < max_checksum_size)) { ! 572: part = rzpartition(ior->io_unit); ! 573: label=lookup_part(tgt->dev_info.disk.scsi_array, part); ! 574: secno = ior->io_recnum + label->start; ! 575: scdisk_checksum(secno, ior->io_data, ior->io_count); ! 576: } ! 577: #endif CHECKSUM ! 578: } ! 579: ior->io_residual = 0; ! 580: start: ! 581: scdisk_start_rw( tgt, ior); ! 582: } ! 583: ! 584: void scdisk_start_rw( tgt, ior) ! 585: target_info_t *tgt; ! 586: register io_req_t ior; ! 587: { ! 588: unsigned int part, secno; ! 589: register boolean_t long_form; ! 590: struct diskpart *label; ! 591: ! 592: part = rzpartition(ior->io_unit); ! 593: label=lookup_part(tgt->dev_info.disk.scsi_array, part); ! 594: if (!label) ! 595: printf("NOT FOUND!\n"); ! 596: secno = ior->io_recnum + label->start; ! 597: ! 598: /* Use long form if either big block addresses or ! 599: the size is more than we can fit in one byte */ ! 600: long_form = (tgt->flags & TGT_BIG) || ! 601: (ior->io_count > (256 * tgt->block_size)); ! 602: if (ior->io_op & IO_READ) ! 603: (long_form ? scsi_long_read : scdisk_read)(tgt, secno, ior); ! 604: else if ((ior->io_op & IO_INTERNAL) == 0) ! 605: (long_form ? scsi_long_write : scdisk_write)(tgt, secno, ior); ! 606: } ! 607: ! 608: #include <sys/ioctl.h> ! 609: #ifdef ULTRIX_COMPAT ! 610: #include <mips/PMAX/rzdisk.h> ! 611: #endif /*ULTRIX_COMPAT*/ ! 612: ! 613: io_return_t ! 614: scdisk_get_status(dev, tgt, flavor, status, status_count) ! 615: int dev; ! 616: target_info_t *tgt; ! 617: dev_flavor_t flavor; ! 618: dev_status_t status; ! 619: natural_t *status_count; ! 620: { ! 621: struct disklabel *lp; ! 622: struct diskpart *label; ! 623: ! 624: lp = &tgt->dev_info.disk.l; ! 625: ! 626: switch (flavor) { ! 627: #ifdef MACH_KERNEL ! 628: case DEV_GET_SIZE: ! 629: ! 630: label=lookup_part(tgt->dev_info.disk.scsi_array, rzpartition(dev)); ! 631: status[DEV_GET_SIZE_DEVICE_SIZE] = label->size * lp->d_secsize; ! 632: status[DEV_GET_SIZE_RECORD_SIZE] = tgt->block_size; ! 633: *status_count = DEV_GET_SIZE_COUNT; ! 634: break; ! 635: #endif ! 636: ! 637: case DIOCGDINFO: ! 638: *(struct disklabel *)status = *lp; ! 639: #ifdef MACH_KERNEL ! 640: *status_count = sizeof(struct disklabel)/sizeof(int); ! 641: #endif MACH_KERNEL ! 642: break; ! 643: ! 644: case DIOCGDINFO - (0x10<<16): ! 645: *(struct disklabel *)status = *lp; ! 646: #ifdef MACH_KERNEL ! 647: *status_count = sizeof(struct disklabel)/sizeof(int) - 4; ! 648: #endif MACH_KERNEL ! 649: break; ! 650: ! 651: #ifdef MACH_KERNEL ! 652: #else /*MACH_KERNEL*/ ! 653: #if ULTRIX_COMPAT ! 654: case SCSI_MODE_SENSE: /*_IOWR(p, 9, struct mode_sel_sns_params) */ ! 655: break; ! 656: case DIOCGETPT: /*_IOR(p, 1, struct pt) */ ! 657: case SCSI_GET_SENSE: /*_IOR(p, 10, struct extended_sense) */ ! 658: return ul_disk_ioctl(tgt, flavor, status, status_count); ! 659: #endif /*ULTRIX_COMPAT*/ ! 660: #endif /*!MACH_KERNEL*/ ! 661: ! 662: #if 0 ! 663: case DIOCRFORMAT: ! 664: break; ! 665: #endif ! 666: default: ! 667: #ifdef i386 ! 668: return(scsi_i386_get_status(dev, tgt, flavor, status, status_count)); ! 669: #else i386 ! 670: return(D_INVALID_OPERATION); ! 671: #endif i386 ! 672: } ! 673: return D_SUCCESS; ! 674: } ! 675: ! 676: io_return_t ! 677: scdisk_set_status(dev, tgt, flavor, status, status_count) ! 678: int dev; ! 679: target_info_t *tgt; ! 680: dev_flavor_t flavor; ! 681: dev_status_t status; ! 682: natural_t status_count; ! 683: { ! 684: io_return_t error = D_SUCCESS; ! 685: struct disklabel *lp; ! 686: ! 687: lp = &tgt->dev_info.disk.l; ! 688: ! 689: ! 690: switch (flavor) { ! 691: case DIOCSRETRIES: ! 692: #ifdef MACH_KERNEL ! 693: if (status_count != sizeof(int)) ! 694: return D_INVALID_SIZE; ! 695: #endif /* MACH_KERNEL */ ! 696: scsi_bbr_retries = *(int *)status; ! 697: break; ! 698: ! 699: case DIOCWLABEL: ! 700: case DIOCWLABEL - (0x10<<16): ! 701: if (*(int*)status) ! 702: tgt->flags |= TGT_WRITE_LABEL; ! 703: else ! 704: tgt->flags &= ~TGT_WRITE_LABEL; ! 705: break; ! 706: case DIOCSDINFO: ! 707: case DIOCSDINFO - (0x10<<16): ! 708: case DIOCWDINFO: ! 709: case DIOCWDINFO - (0x10<<16): ! 710: #ifdef MACH_KERNEL ! 711: if (status_count != sizeof(struct disklabel) / sizeof(int)) ! 712: return D_INVALID_SIZE; ! 713: #endif /* MACH_KERNEL */ ! 714: error = setdisklabel(lp, (struct disklabel*) status); ! 715: if (error || (flavor == DIOCSDINFO) || (flavor == DIOCSDINFO - (0x10<<16))) ! 716: return error; ! 717: error = scdisk_writelabel(tgt); ! 718: break; ! 719: ! 720: #ifdef MACH_KERNEL ! 721: #else /*MACH_KERNEL*/ ! 722: #if ULTRIX_COMPAT ! 723: case SCSI_FORMAT_UNIT: /*_IOW(p, 4, struct format_params) */ ! 724: case SCSI_REASSIGN_BLOCK: /*_IOW(p, 5, struct reassign_params) */ ! 725: case SCSI_READ_DEFECT_DATA: /*_IOW(p, 6, struct read_defect_params) */ ! 726: case SCSI_VERIFY_DATA: /*_IOW(p, 7, struct verify_params) */ ! 727: case SCSI_MODE_SELECT: /*_IOW(p, 8, struct mode_sel_sns_params) */ ! 728: case SCSI_MODE_SENSE: /*_IOW(p, 9, struct mode_sel_sns_params) */ ! 729: case SCSI_GET_INQUIRY_DATA: /*_IOW(p, 11, struct inquiry_info) */ ! 730: return ul_disk_ioctl(tgt, flavor, status, status_count); ! 731: #endif /*ULTRIX_COMPAT*/ ! 732: #endif /*!MACH_KERNEL*/ ! 733: ! 734: #if notyet ! 735: case DIOCWFORMAT: ! 736: case DIOCSBAD: /* ?? how ? */ ! 737: #endif ! 738: default: ! 739: #ifdef i386 ! 740: error = scsi_i386_set_status(dev, tgt, flavor, status, status_count); ! 741: #else i386 ! 742: error = D_INVALID_OPERATION; ! 743: #endif i386 ! 744: } ! 745: return error; ! 746: } ! 747: ! 748: static int grab_it(tgt, ior) ! 749: target_info_t *tgt; ! 750: io_req_t ior; ! 751: { ! 752: spl_t s; ! 753: ! 754: s = splbio(); ! 755: simple_lock(&tgt->target_lock); ! 756: if (!tgt->ior) ! 757: tgt->ior = ior; ! 758: simple_unlock(&tgt->target_lock); ! 759: splx(s); ! 760: ! 761: if (tgt->ior != ior) ! 762: return D_ALREADY_OPEN; ! 763: return D_SUCCESS; ! 764: } ! 765: ! 766: /* Write back a label to the disk */ ! 767: io_return_t scdisk_writelabel(tgt) ! 768: target_info_t *tgt; ! 769: { ! 770: ! 771: printf("scdisk_writelabel: NO LONGER IMPLEMENTED\n"); ! 772: #if 0 ! 773: /* Taken out at Bryan's suggestion until 'fixed' for slices */ ! 774: ! 775: io_req_t ior; ! 776: char *data = (char *)0; ! 777: struct disklabel *label; ! 778: io_return_t error; ! 779: int dev_bsize = tgt->block_size; ! 780: ! 781: io_req_alloc(ior,0); ! 782: #ifdef MACH_KERNEL ! 783: data = (char *)kalloc(dev_bsize); ! 784: #else /*MACH_KERNEL*/ ! 785: data = (char *)ior->io_data; ! 786: #endif /*MACH_KERNEL*/ ! 787: ior->io_next = 0; ! 788: ior->io_prev = 0; ! 789: ior->io_data = data; ! 790: ior->io_count = dev_bsize; ! 791: ior->io_op = IO_READ; ! 792: ior->io_error = 0; ! 793: ! 794: if (grab_it(tgt, ior) != D_SUCCESS) { ! 795: error = D_ALREADY_OPEN; ! 796: goto ret; ! 797: } ! 798: ! 799: scdisk_read( tgt, tgt->dev_info.disk.labelsector, ior); ! 800: iowait(ior); ! 801: if (error = ior->io_error) ! 802: goto ret; ! 803: ! 804: label = (struct disklabel *) &data[tgt->dev_info.disk.labeloffset]; ! 805: *label = tgt->dev_info.disk.l; ! 806: ! 807: ior->io_next = 0; ! 808: ior->io_prev = 0; ! 809: ior->io_data = data; ! 810: ior->io_count = dev_bsize; ! 811: ior->io_op = IO_WRITE; ! 812: ! 813: while (grab_it(tgt, ior) != D_SUCCESS) ; /* ahem */ ! 814: ! 815: scdisk_write( tgt, tgt->dev_info.disk.labelsector, ior); ! 816: iowait(ior); ! 817: ! 818: error = ior->io_error; ! 819: ret: ! 820: #ifdef MACH_KERNEL ! 821: if (data) kfree((int)data, dev_bsize); ! 822: #endif /*MACH_KERNEL*/ ! 823: io_req_free(ior); ! 824: return error; ! 825: ! 826: #endif 0 scdisk_writelabel ! 827: return -1; /* FAILURE ? */ ! 828: } ! 829: ! 830: #ifdef MACH_KERNEL ! 831: #else /*MACH_KERNEL*/ ! 832: #if ULTRIX_COMPAT ! 833: ! 834: io_return_t ul_disk_ioctl(tgt, flavor, status, status_count) ! 835: target_info_t *tgt; ! 836: dev_flavor_t flavor; ! 837: dev_status_t status; ! 838: natural_t status_count; ! 839: { ! 840: io_return_t ret; ! 841: scsi_ret_t err = SCSI_RET_ABORTED;/*xxx*/ ! 842: io_req_t ior; ! 843: ! 844: if (!suser()) ! 845: return EACCES; ! 846: ! 847: ior = geteblk(sizeof(struct defect_descriptors)); ! 848: ior->io_next = 0; ! 849: ior->io_count = 0; ! 850: ior->io_op = IO_INTERNAL; ! 851: ior->io_error = 0; ! 852: ior->io_recnum = 0; ! 853: ior->io_residual = 0; ! 854: ! 855: switch (flavor) { ! 856: ! 857: case DIOCGETPT: { /*_IOR(p, 1, struct pt) */ ! 858: scsi_dec_label_t *p; ! 859: struct disklabel *lp; ! 860: int i; ! 861: ! 862: lp = &tgt->dev_info.disk.l; ! 863: p = (scsi_dec_label_t *)status; ! 864: ! 865: p->magic = DEC_PARTITION_MAGIC; ! 866: p->in_use = 1; ! 867: for (i = 0; i < 8; i++) { ! 868: label=lookup_part(tgt->dev_info.disk.scsi_array, part); ! 869: p->partitions[i].n_sectors = label->size; ! 870: p->partitions[i].offset = label->start; ! 871: } ! 872: err = SCSI_RET_SUCCESS; ! 873: } ! 874: break; ! 875: ! 876: case SCSI_GET_SENSE: { /*_IOR(p, 10, struct extended_sense) */ ! 877: scsi_sense_data_t *s; ! 878: ! 879: s = (scsi_sense_data_t*)tgt->cmd_ptr; ! 880: bcopy(s, status, sizeof(*s) + s->u.xtended.add_len - 1); ! 881: err = SCSI_RET_SUCCESS; ! 882: /* only once */ ! 883: bzero(tgt->cmd_ptr, sizeof(scsi_sense_data_t)); ! 884: } ! 885: break; ! 886: ! 887: case SCSI_GET_INQUIRY_DATA: { /*_IOR(p, 11, struct inquiry_info) */ ! 888: struct mode_sel_sns_params *ms; ! 889: ! 890: ms = (struct mode_sel_sns_params*)status; ! 891: err = scsi_inquiry( tgt, SCSI_INQ_STD_DATA); ! 892: if (copyout(tgt->cmd_ptr, ms->msp_addr, sizeof(struct inquiry_info))){ ! 893: ret = EFAULT; ! 894: goto out; ! 895: } ! 896: } ! 897: break; ! 898: ! 899: case SCSI_FORMAT_UNIT: { /*_IOW(p, 4, struct format_params) */ ! 900: struct format_params *fp; ! 901: struct defect_descriptors *df; ! 902: unsigned char mode; ! 903: unsigned int old_timeout; ! 904: ! 905: fp = (struct format_params *)status; ! 906: df = (struct defect_descriptors*)ior->io_data; ! 907: if (fp->fp_length != 0) { ! 908: if (copyin(fp->fp_addr, df, sizeof(*df))) { ! 909: ret = EFAULT; ! 910: goto out; ! 911: } ! 912: ior->io_count = sizeof(*df); ! 913: } else ! 914: ior->io_count = 0; ! 915: mode = fp->fp_format & SCSI_CMD_FMT_LIST_TYPE; ! 916: switch (fp->fp_defects) { ! 917: case VENDOR_DEFECTS: ! 918: mode |= SCSI_CMD_FMT_FMTDATA|SCSI_CMD_FMT_CMPLIST; ! 919: break; ! 920: case KNOWN_DEFECTS: ! 921: mode |= SCSI_CMD_FMT_FMTDATA; ! 922: break; ! 923: case NO_DEFECTS: ! 924: default: ! 925: break; ! 926: } ! 927: old_timeout = scsi_watchdog_period; ! 928: scsi_watchdog_period = 60*60; /* 1 hour should be enough, I hope */ ! 929: err = scsi_format_unit( tgt, mode, fp->fp_pattern, ! 930: fp->fp_interleave, ior); ! 931: scsi_watchdog_period = old_timeout; ! 932: /* Make sure we re-read all info afresh */ ! 933: tgt->flags = TGT_ALIVE | ! 934: (tgt->flags & (TGT_REMOVABLE_MEDIA|TGT_FULLY_PROBED)); ! 935: } ! 936: break; ! 937: ! 938: case SCSI_REASSIGN_BLOCK: { /*_IOW(p, 5, struct reassign_params) */ ! 939: struct reassign_params *r; ! 940: int ndef; ! 941: ! 942: r = (struct reassign_params*) status; ! 943: ndef = r->rp_header.defect_len0 | (r->rp_header.defect_len1 >> 8); ! 944: ndef >>= 2; ! 945: tgt->ior = ior; ! 946: (void) scsi_reassign_blocks( tgt, &r->rp_lbn3, ndef, ior); ! 947: iowait(ior); ! 948: err = tgt->done; ! 949: } ! 950: break; ! 951: ! 952: case SCSI_READ_DEFECT_DATA: { /*_IOW(p, 6, struct read_defect_params) */ ! 953: struct read_defect_params *dp; ! 954: ! 955: dp = (struct read_defect_params *)status; ! 956: ior->io_count = ior->io_alloc_size; ! 957: if (dp->rdp_alclen > ior->io_count) ! 958: dp->rdp_alclen = ior->io_count; ! 959: else ! 960: ior->io_count = dp->rdp_alclen; ! 961: ior->io_op |= IO_READ; ! 962: tgt->ior = ior; ! 963: err = scsi_read_defect(tgt, dp->rdp_format|0x18, ior); ! 964: if (copyout(ior->io_data, dp->rdp_addr, dp->rdp_alclen)) { ! 965: ret = EFAULT; ! 966: goto out; ! 967: } ! 968: } ! 969: break; ! 970: ! 971: case SCSI_VERIFY_DATA: { /*_IOW(p, 7, struct verify_params) */ ! 972: struct verify_params *v; ! 973: unsigned int old_timeout; ! 974: ! 975: old_timeout = scsi_watchdog_period; ! 976: scsi_watchdog_period = 5*60; /* 5 mins enough, I hope */ ! 977: v = (struct verify_params *)status; ! 978: ior->io_count = 0; ! 979: err = scdisk_verify( tgt, v->vp_lbn, v->vp_length, ior); ! 980: scsi_watchdog_period = old_timeout; ! 981: } ! 982: break; ! 983: ! 984: case SCSI_MODE_SELECT: { /*_IOW(p, 8, struct mode_sel_sns_params) */ ! 985: struct mode_sel_sns_params *ms; ! 986: ! 987: ms = (struct mode_sel_sns_params*)status; ! 988: if(copyin(ms->msp_addr, ior->io_data, ms->msp_length)) { ! 989: ret = EFAULT; ! 990: goto out; ! 991: } ! 992: err = scdisk_mode_select( tgt, DEV_BSIZE, ior, ior->io_data, ! 993: ms->msp_length, ms->msp_setps); ! 994: } ! 995: break; ! 996: ! 997: case SCSI_MODE_SENSE: { /*_IOWR(p, 9, struct mode_sel_sns_params) */ ! 998: struct mode_sel_sns_params *ms; ! 999: unsigned char pagecode; ! 1000: ! 1001: ms = (struct mode_sel_sns_params*)status; ! 1002: pagecode = (ms->msp_pgcode & 0x3f) | (ms->msp_pgctrl << 6); ! 1003: err = scsi_mode_sense( tgt, pagecode, ms->msp_length, ior); ! 1004: if (copyout(tgt->cmd_ptr, ms->msp_addr, ms->msp_length)){ ! 1005: ret = EFAULT; ! 1006: goto out; ! 1007: } ! 1008: } ! 1009: break; ! 1010: } ! 1011: ! 1012: ret = (err == SCSI_RET_SUCCESS) ? D_SUCCESS : D_IO_ERROR; ! 1013: if (ior->io_op & IO_ERROR) ! 1014: ret = D_IO_ERROR; ! 1015: out: ! 1016: brelse(ior); ! 1017: return ret; ! 1018: } ! 1019: #endif /*ULTRIX_COMPAT*/ ! 1020: #endif /*!MACH_KERNEL*/ ! 1021: ! 1022: #ifdef CHECKSUM ! 1023: ! 1024: #define SUMSIZE 0x10000 ! 1025: #define SUMHASH(b) (((b)>>1) & (SUMSIZE - 1)) ! 1026: struct { ! 1027: long blockno; ! 1028: long sum; ! 1029: } scdisk_checksums[SUMSIZE]; ! 1030: ! 1031: void scdisk_checksum(bno, addr, size) ! 1032: long bno; ! 1033: register unsigned int *addr; ! 1034: { ! 1035: register int i = size/sizeof(int); ! 1036: register unsigned int sum = -1; ! 1037: ! 1038: while (i-- > 0) ! 1039: sum ^= *addr++; ! 1040: scdisk_checksums[SUMHASH(bno)].blockno = bno; ! 1041: scdisk_checksums[SUMHASH(bno)].sum = sum; ! 1042: } ! 1043: ! 1044: void scdisk_bcheck(bno, addr, size) ! 1045: long bno; ! 1046: register unsigned int *addr; ! 1047: { ! 1048: register int i = size/sizeof(int); ! 1049: register unsigned int sum = -1; ! 1050: unsigned int *start = addr; ! 1051: ! 1052: if (scdisk_checksums[SUMHASH(bno)].blockno != bno) { ! 1053: if (scsi_debug) printf("No checksum for block x%x\n", bno); ! 1054: return; ! 1055: } ! 1056: ! 1057: while (i-- > 0) ! 1058: sum ^= *addr++; ! 1059: ! 1060: if (scdisk_checksums[SUMHASH(bno)].sum != sum) { ! 1061: printf("Bad checksum (x%x != x%x), bno x%x size x%x at x%x\n", ! 1062: sum, ! 1063: scdisk_checksums[bno & (SUMSIZE - 1)].sum, ! 1064: bno, size, start); ! 1065: gimmeabreak(); ! 1066: scdisk_checksums[SUMHASH(bno)].sum = sum; ! 1067: } ! 1068: } ! 1069: ! 1070: ! 1071: #endif CHECKSUM ! 1072: ! 1073: /*#define PERF */ ! 1074: #ifdef PERF ! 1075: int test_read_size = 512; ! 1076: int test_read_skew = 12; ! 1077: int test_read_skew_min = 0; ! 1078: int test_read_nreads = 1000; ! 1079: int test_read_bdev = 0; ! 1080: ! 1081: #include <sys/time.h> ! 1082: ! 1083: void test_read(max) ! 1084: { ! 1085: int i, ssk, usecs; ! 1086: struct timeval start, stop; ! 1087: ! 1088: if (max == 0) ! 1089: max = test_read_skew + 1; ! 1090: ssk = test_read_skew; ! 1091: for (i = test_read_skew_min; i < max; i++){ ! 1092: test_read_skew = i; ! 1093: ! 1094: start = time; ! 1095: read_test(); ! 1096: stop = time; ! 1097: ! 1098: usecs = stop.tv_usec - start.tv_usec; ! 1099: if (usecs < 0) { ! 1100: stop.tv_sec -= 1; ! 1101: usecs += 1000000; ! 1102: } ! 1103: printf("Skew %3d size %d count %d time %3d sec %d us\n", ! 1104: i, test_read_size, test_read_nreads, ! 1105: stop.tv_sec - start.tv_sec, usecs); ! 1106: } ! 1107: test_read_skew = ssk; ! 1108: } ! 1109: ! 1110: void read_test() ! 1111: { ! 1112: static int buffer[(8192*2)/sizeof(int)]; ! 1113: struct io_req io; ! 1114: register int i, rec; ! 1115: ! 1116: bzero(&io, sizeof(io)); ! 1117: io.io_unit = test_read_bdev; ! 1118: io.io_op = IO_READ; ! 1119: io.io_count = test_read_size; ! 1120: io.io_data = (char*) buffer; ! 1121: ! 1122: for (rec = 0, i = 0; i < test_read_nreads; i++) { ! 1123: io.io_op = IO_READ; ! 1124: io.io_recnum = rec; ! 1125: scdisk_strategy(&io); ! 1126: rec += test_read_skew; ! 1127: iowait(&io); ! 1128: } ! 1129: } ! 1130: ! 1131: void tur_test() ! 1132: { ! 1133: struct io_req io; ! 1134: register int i; ! 1135: char *a, *b; ! 1136: struct timeval start, stop; ! 1137: ! 1138: bzero(&io, sizeof(io)); ! 1139: io.io_unit = test_read_bdev; ! 1140: io.io_data = (char*)&io;/*unused but kernel space*/ ! 1141: ! 1142: start = time; ! 1143: for (i = 0; i < test_read_nreads; i++) { ! 1144: io.io_op = IO_INTERNAL; ! 1145: rz_check(io.io_unit, &a, &b); ! 1146: scsi_test_unit_ready(b,&io); ! 1147: } ! 1148: stop = time; ! 1149: i = stop.tv_usec - start.tv_usec; ! 1150: if (i < 0) { ! 1151: stop.tv_sec -= 1; ! 1152: i += 1000000; ! 1153: } ! 1154: printf("%d test-unit-ready took %3d sec %d us\n", ! 1155: test_read_nreads, ! 1156: stop.tv_sec - start.tv_sec, i); ! 1157: } ! 1158: ! 1159: #endif PERF ! 1160: ! 1161: /*#define WDEBUG*/ ! 1162: #ifdef WDEBUG ! 1163: ! 1164: int buggo_write_size = 8192; ! 1165: int buggo_dev = 2; /* rz0b */ /* changed by KTVM from 1 (still b) */ ! 1166: int buggo_out_buffer[8192/2]; ! 1167: int buggo_in_buffer[8192/2]; ! 1168: int buggotest(n, pattern, verbose) ! 1169: { ! 1170: struct io_req io; ! 1171: register int i, rec; ! 1172: ! 1173: if (n <= 0) ! 1174: n = 1; ! 1175: ! 1176: if(pattern) ! 1177: for (i = 0; i < buggo_write_size/4; i++) ! 1178: buggo_out_buffer[i] = i + pattern; ! 1179: ! 1180: for (i = 0; i < n; i++) { ! 1181: register int j; ! 1182: ! 1183: buggo_out_buffer[0] = i + pattern; ! 1184: buggo_out_buffer[(buggo_write_size/4)-1] = i + pattern; ! 1185: bzero(&io, sizeof(io)); ! 1186: io.io_unit = buggo_dev; ! 1187: io.io_data = (char*)buggo_out_buffer; ! 1188: io.io_op = IO_WRITE; ! 1189: io.io_count = buggo_write_size; ! 1190: io.io_recnum = i % 1024; ! 1191: scdisk_strategy(&io); ! 1192: ! 1193: bzero(buggo_in_buffer, sizeof(buggo_in_buffer)); ! 1194: iowait(&io); ! 1195: ! 1196: if (verbose) ! 1197: printf("Done write with %x", io.io_error); ! 1198: ! 1199: bzero(&io, sizeof(io)); ! 1200: io.io_unit = buggo_dev; ! 1201: io.io_data = (char*)buggo_in_buffer; ! 1202: io.io_op = IO_READ; ! 1203: io.io_count = buggo_write_size; ! 1204: io.io_recnum = i % 1024; ! 1205: scdisk_strategy(&io); ! 1206: iowait(&io); ! 1207: ! 1208: if (verbose) ! 1209: printf("Done read with %x", io.io_error); ! 1210: ! 1211: for (j = 0; j < buggo_write_size/4; j++) ! 1212: if (buggo_out_buffer[j] != buggo_in_buffer[j]){ ! 1213: printf("Difference at %d-th word: %x %x\n", ! 1214: buggo_out_buffer[j], buggo_in_buffer[j]); ! 1215: return i; ! 1216: } ! 1217: } ! 1218: printf("Test ok\n"); ! 1219: return n; ! 1220: } ! 1221: #endif WDEBUG ! 1222: #endif /* NSCSI > 0 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.