![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to SCSIDiskKern.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / dev|
Return to SCSIDiskKern.m CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* Copyright (c) 1991 NeXT Computer, Inc. All rights reserved. ! 26: * ! 27: * SCSIDiskKern.m - UNIX front end for kernel SCSIDisk device. ! 28: * ! 29: * HISTORY ! 30: * 30-Apr-91 Doug Mitchell at NeXT ! 31: * Created. ! 32: */ ! 33: ! 34: /* ! 35: * Note that this file builds with KERNEL_PRIVATE and !MACH_USER_API. ! 36: */ ! 37: #import <sys/systm.h> /* for nblkdev and nchrdev */ ! 38: #import <driverkit/SCSIDisk.h> ! 39: #import <driverkit/kernelDiskMethods.h> ! 40: #import <driverkit/SCSIDiskKern.h> ! 41: #import <driverkit/SCSIDiskPrivate.h> ! 42: #import <driverkit/SCSIDiskTypes.h> ! 43: #import <driverkit/scsiTypes.h> ! 44: #import <driverkit/SCSIStructInlines.h> ! 45: #import <bsd/dev/scsireg.h> ! 46: #import <driverkit/IODiskPartition.h> ! 47: #import <driverkit/xpr_mi.h> ! 48: #import <sys/buf.h> ! 49: #import <sys/conf.h> ! 50: #import <sys/uio.h> ! 51: #import <bsd/dev/ldd.h> ! 52: #import <sys/errno.h> ! 53: #import <sys/proc.h> ! 54: #import <vm/vm_kern.h> ! 55: #import <sys/fcntl.h> ! 56: #import <bsd/dev/disk.h> ! 57: #import <driverkit/align.h> ! 58: ! 59: #import <kern/assert.h> ! 60: ! 61: ! 62: #ifdef ppc //bknight - 12/3/97 - Radar #2004660 ! 63: #define GROK_APPLE 1 ! 64: #endif //bknight - 12/3/97 - Radar #2004660 ! 65: ! 66: // wait until 20 seconds after probe non-ready disks ! 67: #define MAX_DISK_PROBE_TIME 20 ! 68: ! 69: ! 70: int sdopen(dev_t dev, int flag, int devtype, struct proc * pp); ! 71: int sdclose(dev_t dev, int flag, int devtype, struct proc * pp); ! 72: int sdread(dev_t dev, struct uio *uiop, int ioflag); ! 73: int sdwrite(dev_t dev, struct uio *uiop, int ioflag); ! 74: int sdstrategy(register struct buf *bp); ! 75: int sdioctl(dev_t dev, ! 76: u_long cmd, ! 77: caddr_t data, ! 78: int flag, struct proc *pp); ! 79: int sdsize(dev_t dev); ! 80: ! 81: /* ! 82: * dev-to-id map array. Instances of DiskObject register their IDs in ! 83: * this array via registerUnixDisk:. ! 84: */ ! 85: static IODevAndIdInfo SCSIDiskIdMap[NUM_SD_DEV]; ! 86: ! 87: /* ! 88: * Private per-unit data. ! 89: */ ! 90: typedef struct _SCSIDisk_DataTag { ! 91: struct buf physbuf; ! 92: unsigned int maxTransfer; ! 93: } SCSIDisk_Data_t; ! 94: ! 95: static SCSIDisk_Data_t *SCSIDisk_dev[NUM_SD_DEV]; ! 96: ! 97: /* ! 98: * Indices of our entries in devsw's. ! 99: */ ! 100: static int sd_block_major; ! 101: static int sd_raw_major; ! 102: ! 103: /* ! 104: * prototypes for internal functions ! 105: */ ! 106: static unsigned sdminphys(struct buf *bp); ! 107: static id sd_dev_to_id(dev_t dev); ! 108: static id sd_phys_dev_id(dev_t dev); ! 109: ! 110: static void sd_prevent_eject(id physicalDisk, BOOL prevent); ! 111: ! 112: ! 113: #ifdef DDM_DEBUG ! 114: static IONamedValue sdIoctlValues[] = { ! 115: {DKIOCSFORMAT, "DKIOCSFORMAT" }, ! 116: {DKIOCGFORMAT, "DKIOCGFORMAT" }, ! 117: {DKIOCGLABEL, "DKIOCGLABEL" }, ! 118: {DKIOCSLABEL, "DKIOCSLABEL" }, ! 119: {DKIOCEJECT, "DKIOCEJECT" }, ! 120: {SDIOCSRQ, "SDIOCSRQ" }, ! 121: {SDIOCGETCAP, "SDIOCGETCAP" }, ! 122: {DKIOCINFO, "DKIOCINFO" }, ! 123: {0, NULL } ! 124: }; ! 125: ! 126: #endif DDM_DEBUG ! 127: ! 128: /* ! 129: * Initialize id map and SCSIDisk_dev. Currently invoked by SCSIDisk probe:. ! 130: */ ! 131: void sd_init_idmap() ! 132: { ! 133: IODevAndIdInfo *idMap = SCSIDiskIdMap; ! 134: int unit; ! 135: struct bdevsw *bd; ! 136: struct cdevsw *cd; ! 137: ! 138: /* ! 139: * figure out our major device numbers. ! 140: */ ! 141: for (bd = bdevsw; bd < &bdevsw[nblkdev]; bd++) { ! 142: if (bd->d_open == (int (*)())sdopen) { ! 143: sd_block_major = bd - bdevsw; ! 144: break; ! 145: } ! 146: } ! 147: for (cd = cdevsw; cd < &cdevsw[nchrdev]; cd++) { ! 148: if (cd->d_open == (int (*)())sdopen) { ! 149: sd_raw_major = cd - cdevsw; ! 150: break; ! 151: } ! 152: } ! 153: ! 154: bzero(idMap, sizeof(*idMap) * NUM_SD_DEV); ! 155: for(unit=0; unit<NUM_SD_DEV; unit++) { ! 156: idMap->rawDev = makedev(sd_raw_major, (unit << 3)); ! 157: idMap->blockDev = makedev(sd_block_major, (unit << 3)); ! 158: idMap++; ! 159: SCSIDisk_dev[unit] = IOMalloc(sizeof(SCSIDisk_Data_t)); ! 160: SCSIDisk_dev[unit]->physbuf.b_flags = 0; ! 161: } ! 162: } ! 163: ! 164: IODevAndIdInfo *sd_idmap() ! 165: { ! 166: return SCSIDiskIdMap; ! 167: } ! 168: ! 169: int sdopen(dev_t dev, int flag, int devtype, struct proc *pp) ! 170: { ! 171: id diskObj; ! 172: BOOL prompt; ! 173: int err; ! 174: int unit; ! 175: ! 176: // UFS partition a ! 177: diskObj = sd_dev_to_id(dev & 0x78); ! 178: if( diskObj) ! 179: [diskObj waitForProbe:MAX_DISK_PROBE_TIME]; ! 180: ! 181: diskObj = sd_dev_to_id(dev); ! 182: if(diskObj == nil) { ! 183: return(ENXIO); ! 184: } ! 185: xpr_sd("%s: sdopen\n", [diskObj name], 2,3,4,5); ! 186: if(flag & O_NDELAY) { ! 187: prompt = NO; ! 188: } ! 189: else { ! 190: prompt = YES; ! 191: } ! 192: if([diskObj isDiskReady:prompt]) { ! 193: return(ENXIO); ! 194: } ! 195: ! 196: /* ! 197: * Register this 'Unix-level open' event for IODiskPartitions. ! 198: */ ! 199: if(IO_DISK_PART(dev) != SD_LIVE_PART) { ! 200: // If this is the first open() on a removable disk, ! 201: // whether block or raw, on any of the partitions, ! 202: // send a TEST UNIT READY to guarantee the disk is ! 203: // still present (isDiskReady doesn't do this). If ! 204: // it is, we send a PREVENT MEDIUM REMOVAL to lock ! 205: // down the removable disk while it is open. ! 206: // ! 207: // Note that we don't keep track of live open()'s, ! 208: // so we don't send TEST UNIT READY and/or PREVENT ! 209: // MEDIUM REMOVAL on live opens. Should not be an ! 210: // issue (for now). ! 211: ! 212: if ( [diskObj isRemovable] == YES && ! 213: [diskObj isInstanceOpen] == NO && ! 214: [diskObj isAnyOtherOpen] == NO ) ! 215: { ! 216: id physDisk = sd_phys_dev_id(dev); ! 217: ASSERT(physDisk); ! 218: ! 219: if ( [physDisk updateReadyState] != IO_Ready ) ! 220: { ! 221: [physDisk diskNotReady]; // not ready state ! 222: return ENXIO; ! 223: } ! 224: ! 225: sd_prevent_eject(physDisk, YES); ! 226: } ! 227: if(major(dev) == sd_block_major) { ! 228: [diskObj setBlockDeviceOpen:YES]; ! 229: } ! 230: else { ! 231: [diskObj setRawDeviceOpen:YES]; ! 232: } ! 233: } ! 234: ! 235: unit = IO_DISK_UNIT(dev); ! 236: #ifdef GROK_APPLE ! 237: if (unit >= NUM_SD_DEV) ! 238: unit -= NUM_SD_DEV; ! 239: #endif /* GROK_APPLE */ ! 240: ! 241: /* We have the physical disk now so grab a maxTransfer if necessary */ ! 242: if ( !SCSIDisk_dev[unit]->maxTransfer ) { ! 243: diskObj = sd_phys_dev_id(dev); /* Get the physical disk */ ! 244: SCSIDisk_dev[unit]->maxTransfer = [[diskObj controller] maxTransfer]; ! 245: } ! 246: ! 247: return(0); ! 248: } /* sdopen() */ ! 249: ! 250: int sdclose(dev_t dev, int flag, int devtype, struct proc *pp) ! 251: { ! 252: id diskObj = sd_dev_to_id(dev); ! 253: id physDisk = sd_phys_dev_id(dev); ! 254: ! 255: if(diskObj == nil) { ! 256: return(ENXIO); ! 257: } ! 258: kprintf("%s: sdclose major %d minor %d\n", [diskObj name], ! 259: major(dev),minor(dev)); ! 260: xpr_sd("%s: sdclose\n", [diskObj name], 2,3,4,5); ! 261: ! 262: /* Issue a Synchronize-cache operation, which will force ! 263: * the device to flush its cached blocks. ! 264: */ ! 265: if (physDisk != nil) { ! 266: [physDisk synchronizeCache]; ! 267: } ! 268: ! 269: /* ! 270: * bknight - 12/3/97 - 2004660 ! 271: * This test is safe, even when IO_DISK_PART denotes an HFS partition. ! 272: */ ! 273: ! 274: if(IO_DISK_PART(dev) == SD_LIVE_PART) { ! 275: return 0; ! 276: } else if(![diskObj isInstanceOpen]) { ! 277: return(ENXIO); ! 278: } ! 279: ! 280: /* ! 281: * Register this 'Unix-level close' event. We won't be called unless ! 282: * this is the last close. ! 283: */ ! 284: if(major(dev) == sd_block_major) { ! 285: [diskObj setBlockDeviceOpen:NO]; ! 286: } ! 287: else { ! 288: [diskObj setRawDeviceOpen:NO]; ! 289: } ! 290: ! 291: // If this is the last close() on a removable disk, ! 292: // whether block or raw, for all of the partitions, ! 293: // send an ALLOW MEDIUM REMOVAL to the SCSI drive. ! 294: // ! 295: // Note that we don't keep track of live open()'s, ! 296: // so we don't send PREVENT/ALLOW MEDIUM REMOVAL ! 297: // on live opens/closes either. ! 298: // ! 299: // Note that diskObj is an IOLogicalDisk here. ! 300: ! 301: if ( [diskObj isRemovable] == YES && ! 302: [diskObj isInstanceOpen] == NO && // (raw and block) ! 303: [diskObj isAnyOtherOpen] == NO) // (raw and block) ! 304: { ! 305: sd_prevent_eject(physDisk, NO); ! 306: } ! 307: ! 308: return(0); ! 309: } /* sdclose() */ ! 310: ! 311: /* ! 312: * Raw I/O uses standard UNIX physio routine, resulting in async I/O requests ! 313: * via sdstrategy(). ! 314: * ! 315: * For now, we do DMA alignment in both disk driver's phys read and ! 316: * physwrite as well as in the ioctl ops which do DMA. Ugh. ! 317: */ ! 318: #define SD_PHYS_ALIGN 1 ! 319: #if SD_PHYS_ALIGN ! 320: ! 321: #define FORCE_PAGE_ALIGN 1 ! 322: #if FORCE_PAGE_ALIGN ! 323: int forceSdPageAlign = 0; ! 324: #endif FORCE_PAGE_ALIGN ! 325: #endif SD_PHYS_ALIGN ! 326: ! 327: int sdread(dev_t dev, struct uio *uiop, int ioflag) ! 328: { ! 329: id diskObj = sd_dev_to_id(dev); ! 330: int unit = IO_DISK_UNIT(dev); ! 331: int rtn; ! 332: #if SD_PHYS_ALIGN ! 333: void *freePtr = NULL; // memory to free ! 334: void *alignedPtr = NULL; // DMA target ! 335: int freeCnt = 0; // size to free ! 336: void *userPtr = NULL; // user spec'd pointer ! 337: BOOL didAlign = NO; ! 338: struct iovec *iov; ! 339: int userCnt = 0; ! 340: int userSegflg = 0; ! 341: IODMAAlignment dmaAlign; ! 342: id liveId = sd_phys_dev_id(dev); ! 343: #endif SD_PHYS_ALIGN ! 344: ! 345: if(diskObj == nil) { ! 346: return(ENXIO); ! 347: } ! 348: xpr_sd("sdread %s\n", [diskObj name], 2,3,4,5); ! 349: ! 350: /* ! 351: * Catch unformatted disks right now, since blockSize is zero in ! 352: * that case. ! 353: */ ! 354: if(![diskObj isFormatted]) { ! 355: return EINVAL; ! 356: } ! 357: ! 358: #if SD_PHYS_ALIGN ! 359: ! 360: /* ! 361: * Note - this is temporary. We assume one vector and a well aligned ! 362: * byte count. ! 363: */ ! 364: ASSERT(uiop->uio_iovcnt == 1); ! 365: iov = uiop->uio_iov; ! 366: [[liveId controller] getDMAAlignment:&dmaAlign]; ! 367: #if FORCE_PAGE_ALIGN ! 368: if(forceSdPageAlign) { ! 369: dmaAlign.readStart = PAGE_SIZE; ! 370: } ! 371: #endif FORCE_PAGE_ALIGN ! 372: if( ( (dmaAlign.readStart > 1) && ! 373: !IOIsAligned(iov->iov_base, dmaAlign.readStart) ! 374: ) || ! 375: ( (dmaAlign.readLength > 1) && ! 376: !IOIsAligned(iov->iov_len, dmaAlign.readLength) ! 377: ) ! 378: #if sparc ! 379: || 1 ! 380: #endif ! 381: ) { ! 382: didAlign = YES; ! 383: alignedPtr = [[liveId controller] allocateBufferOfLength: ! 384: iov->iov_len ! 385: actualStart:&freePtr ! 386: actualLength:&freeCnt]; ! 387: userPtr = (void *)iov->iov_base; ! 388: iov->iov_base = (caddr_t)alignedPtr; ! 389: userCnt = iov->iov_len; ! 390: ! 391: /* ! 392: * DMA to kernel space now... ! 393: */ ! 394: userSegflg = uiop->uio_segflg; ! 395: uiop->uio_segflg = UIO_SYSSPACE; ! 396: } ! 397: #endif SD_PHYS_ALIGN ! 398: ! 399: #ifdef GROK_APPLE ! 400: if (unit >= NUM_SD_DEV) ! 401: unit -= NUM_SD_DEV; ! 402: #endif /* GROK_APPLE */ ! 403: ! 404: rtn = physio(sdstrategy, ! 405: (struct buf *) SCSIDisk_dev[unit], ! 406: dev, ! 407: B_READ, ! 408: sdminphys, ! 409: uiop, ! 410: [diskObj blockSize]); ! 411: ! 412: #if SD_PHYS_ALIGN ! 413: if(didAlign) { ! 414: if(userSegflg == UIO_SYSSPACE) { ! 415: bcopy(alignedPtr, userPtr, userCnt); ! 416: } ! 417: else { ! 418: copyout(alignedPtr, userPtr, userCnt); ! 419: } ! 420: IOFree(freePtr, freeCnt); ! 421: } ! 422: #endif SD_PHYS_ALIGN ! 423: ! 424: return rtn; ! 425: ! 426: } /* sdread() */ ! 427: ! 428: int sdwrite(dev_t dev, struct uio *uiop, int ioflag) ! 429: { ! 430: id diskObj = sd_dev_to_id(dev); ! 431: int unit = IO_DISK_UNIT(dev); ! 432: int rtn; ! 433: #if SD_PHYS_ALIGN ! 434: void *freePtr = NULL; // memory to free ! 435: void *alignedPtr = NULL; // DMA target ! 436: int freeCnt = 0; // size to free ! 437: void *userPtr = NULL; // user spec'd pointer ! 438: BOOL didAlign = NO; ! 439: struct iovec *iov; ! 440: IODMAAlignment dmaAlign; ! 441: id liveId = sd_phys_dev_id(dev); ! 442: #endif SD_PHYS_ALIGN ! 443: ! 444: if(diskObj == nil) ! 445: return(ENXIO); ! 446: xpr_sd("sd_write %s\n", [diskObj name], 2,3,4,5); ! 447: ! 448: /* ! 449: * Catch unformatted disks right now, since blockSize is zero in ! 450: * that case. ! 451: */ ! 452: if(![diskObj isFormatted]) { ! 453: return EINVAL; ! 454: } ! 455: ! 456: #if SD_PHYS_ALIGN ! 457: ! 458: /* ! 459: * Note - this is temporary. We assume one vector and a well aligned ! 460: * byte count. ! 461: * We force a copyin to kernel space for raw user-level I/O to ! 462: * ensure that rawVerify can work. ! 463: */ ! 464: ASSERT(uiop->uio_iovcnt == 1); ! 465: iov = uiop->uio_iov; ! 466: [[liveId controller] getDMAAlignment:&dmaAlign]; ! 467: #if FORCE_PAGE_ALIGN ! 468: if(forceSdPageAlign) { ! 469: dmaAlign.writeStart = PAGE_SIZE; ! 470: } ! 471: #endif FORCE_PAGE_ALIGN ! 472: if( ( (dmaAlign.writeStart > 1) && ! 473: !IOIsAligned(iov->iov_base, dmaAlign.writeStart) ! 474: ) || ! 475: ( (dmaAlign.writeLength > 1) && ! 476: !IOIsAligned(iov->iov_len, dmaAlign.writeLength) ! 477: ) ! 478: #if sparc ! 479: || 1 ! 480: #endif ! 481: ) { ! 482: ! 483: didAlign = YES; ! 484: alignedPtr = [[liveId controller] allocateBufferOfLength: ! 485: iov->iov_len ! 486: actualStart:&freePtr ! 487: actualLength:&freeCnt]; ! 488: userPtr = (void *)iov->iov_base; ! 489: iov->iov_base = (caddr_t)alignedPtr; ! 490: if(uiop->uio_segflg == UIO_SYSSPACE) { ! 491: bcopy(userPtr, alignedPtr, iov->iov_len); ! 492: } ! 493: else { ! 494: copyin(userPtr, alignedPtr, iov->iov_len); ! 495: uiop->uio_segflg = UIO_SYSSPACE; ! 496: } ! 497: ! 498: } ! 499: #endif SD_PHYS_ALIGN ! 500: ! 501: #ifdef GROK_APPLE ! 502: if (unit >= NUM_SD_DEV) ! 503: unit -= NUM_SD_DEV; ! 504: #endif /* GROK_APPLE */ ! 505: ! 506: rtn = physio(sdstrategy, ! 507: (struct buf *) SCSIDisk_dev[unit], ! 508: dev, ! 509: B_WRITE, ! 510: sdminphys, ! 511: uiop, ! 512: [diskObj blockSize]); ! 513: ! 514: #if SD_PHYS_ALIGN ! 515: if(didAlign) { ! 516: IOFree(freePtr, freeCnt); ! 517: } ! 518: #endif SD_PHYS_ALIGN ! 519: ! 520: return rtn; ! 521: ! 522: } /* sdwrite() */ ! 523: ! 524: int sdstrategy(struct buf *bp) ! 525: { ! 526: id diskObj = sd_dev_to_id(bp->b_dev); ! 527: u_int offset; ! 528: u_int bytes_req; ! 529: void *bufp; ! 530: u_int block_size; ! 531: IOReturn rtn; ! 532: vm_task_t client; ! 533: ! 534: xpr_sd("%s: sdstrategy\n", [diskObj name], 2,3,4,5); ! 535: if(diskObj == nil) { ! 536: xpr_sd("sdstrategy: bad unit\n", 1,2,3,4,5); ! 537: bp->b_error = ENXIO; ! 538: goto bad; ! 539: } ! 540: if((bp->b_flags & (B_PHYS|B_KERNSPACE)) == B_PHYS) { ! 541: /* ! 542: * Physical I/O to user space. ! 543: */ ! 544: client = ((task_t)bp->b_proc->task)->map; ! 545: } ! 546: else { ! 547: /* ! 548: * Either block I/O (always kernel space) or physical I/O ! 549: * to kernel space (e.g., loadable file system). ! 550: */ ! 551: client = kernel_map; ! 552: } ! 553: block_size = [diskObj blockSize]; ! 554: if(block_size == 0) { ! 555: xpr_sd("sdstrategy %s: zero block_size\n", ! 556: [diskObj name], 2,3,4,5); ! 557: bp->b_error = ENXIO; ! 558: goto bad; ! 559: } ! 560: offset = bp->b_blkno; ! 561: bytes_req = bp->b_bcount; ! 562: bufp = bp->b_un.b_addr; ! 563: if(bp->b_flags & B_READ) { ! 564: rtn = [diskObj readAsyncAt:offset ! 565: length:bytes_req ! 566: buffer:bufp ! 567: pending:bp ! 568: client:client]; ! 569: } ! 570: else { ! 571: rtn = [diskObj writeAsyncAt:offset ! 572: length:bytes_req ! 573: buffer:bufp ! 574: pending:bp ! 575: client:client]; ! 576: } ! 577: if(rtn) { ! 578: /* ! 579: * Check to see if 'IODisk' object has called completeTransfer. ! 580: * if so then don't try to repair the bp structure just return. ! 581: */ ! 582: if (bp->b_flags & B_DONE) { ! 583: xpr_sd("sdstrategy: COMMAND REJECT\n", 1,2,3,4,5); ! 584: return -1; ! 585: } ! 586: bp->b_error = [diskObj errnoFromReturn:rtn]; ! 587: goto bad; ! 588: } ! 589: xpr_sd("sdstrategy: SUCCESS\n", 1,2,3,4,5); ! 590: return(0); ! 591: ! 592: bad: ! 593: bp->b_flags |= B_ERROR; ! 594: rtn = -1; ! 595: biodone(bp); ! 596: xpr_sd("sdstrategy: COMMAND REJECT\n", 1,2,3,4,5); ! 597: return(rtn); ! 598: ! 599: } /* sdstrategy() */ ! 600: ! 601: /* ! 602: * Ops which are common to all IODiskPartitions are done on the raw device; ! 603: * SCSI-specific ioctls are done directly to the live SCSIDisk object. ! 604: */ ! 605: int sdioctl(dev_t dev, ! 606: u_long cmd, ! 607: caddr_t data, ! 608: int flag, ! 609: struct proc *pp) ! 610: { ! 611: int unit = IO_DISK_UNIT(dev); ! 612: int part = IO_DISK_PART(dev); ! 613: id diskObj; ! 614: IODevAndIdInfo *idmap; ! 615: int rtn = 0; ! 616: IOReturn irtn = IO_R_SUCCESS; ! 617: char *userData = *(char **)data; // user src/dest ! 618: void *alignedPtr = NULL; // kernel src/des ! 619: unsigned alignedLength; ! 620: int i; ! 621: IOSCSIRequest scsiReq; // new style - to controller ! 622: struct scsi_req *srp; // old style - from caller ! 623: int nblk; ! 624: void *freeBuf; ! 625: int freeLength; ! 626: ! 627: xpr_sd("sdioctl: unit %d cmd %s\n", unit, ! 628: IOFindNameForValue(cmd, sdIoctlValues), 3,4,5); ! 629: ! 630: #ifdef GROK_APPLE //bknight - 12/3/97 - Radar #2004660 ! 631: ! 632: /* Compensate for an HFS partition. */ ! 633: ! 634: if ( ! ( unit < NUM_SD_DEV ) ) { ! 635: unit -= NUM_SD_DEV; ! 636: part += NUM_SD_PART; ! 637: } ! 638: ! 639: #endif GROK_APPLE //bknight - 12/3/97 - Radar #2004660 ! 640: ! 641: if(!(unit < NUM_SD_DEV)) ! 642: return (ENXIO); ! 643: ! 644: #if 0 ! 645: if(major(dev) != sd_raw_major) { ! 646: xpr_sd("sdioctl: not raw device\n", 1,2,3,4,5); ! 647: return(ENXIO); ! 648: } ! 649: #endif ! 650: idmap = &SCSIDiskIdMap[unit]; ! 651: ! 652: #ifdef GROK_APPLE //bknight - 12/3/97 - Radar #2004660 ! 653: ! 654: /* ! 655: * Special cases for HFS partitions. ! 656: * DKIOCNUMBLKS - return # blocks on partition, not the whole device ! 657: * DKIOCSFORMAT - not permitted ! 658: * DKIOCGFORMAT - not permitted ! 659: * DKIOCGLABEL - not permitted ! 660: * DKIOCSLABEL - not permitted ! 661: */ ! 662: ! 663: /* Is it an HFS partition ? */ ! 664: ! 665: if ( ! ( part < NPART ) ) ! 666: { ! 667: /* ! 668: * For an HFS partition, return the # of blocks and block ! 669: * size in the partition, rather than on the whole device. ! 670: */ ! 671: diskObj = idmap->partitionId[part]; ! 672: switch ( cmd ) ! 673: { ! 674: case DKIOCBLKSIZE: ! 675: *(int *)data = [diskObj blockSize]; ! 676: return (0); ! 677: break; ! 678: ! 679: case DKIOCNUMBLKS: ! 680: *(int *)data = [diskObj diskSize]; ! 681: return (0); ! 682: break; ! 683: ! 684: case DKIOCSFORMAT: ! 685: case DKIOCGFORMAT: ! 686: case DKIOCGLABEL: ! 687: case DKIOCSLABEL: ! 688: return(EINVAL); ! 689: break; ! 690: } ! 691: } ! 692: ! 693: #endif GROK_APPLE //bknight - 12/3/97 - Radar #2004660 ! 694: ! 695: /* ! 696: * Get appropriate device. Note we sometimes use the live ! 697: * device partition (partition 7) here even if another partition ! 698: * was opened; we're just directing the I/O request to the correct ! 699: * object. ! 700: * ! 701: * Also note that several of these ioctls can fail if not invoked ! 702: * upon partition0, or if any block devices are open, or if any ! 703: * other partitions are open. That's handled elsewhere. ! 704: */ ! 705: switch (cmd) { ! 706: case DKIOCSFORMAT: ! 707: case DKIOCGFORMAT: ! 708: case DKIOCGLABEL: ! 709: case DKIOCSLABEL: ! 710: case DKIOCEJECT: ! 711: /* ! 712: * These must be performed on a valid raw device, ! 713: * but if caller asked for live device (as some disk ! 714: * diags are liable to do), we'll given them raw ! 715: * partition a. ! 716: */ ! 717: { ! 718: ! 719: #ifdef GROK_APPLE //bknight - 12/3/97 - Radar #2004660 ! 720: ! 721: /* Treat HFS partitions like the live partition, too. */ ! 722: ! 723: if ( part >= SD_LIVE_PART ) { ! 724: part = 0; ! 725: } ! 726: ! 727: #else GROK_APPLE //bknight - 12/3/97 - Radar #2004660 ! 728: ! 729: if(part == SD_LIVE_PART) { ! 730: part = 0; ! 731: } ! 732: ! 733: #endif GROK_APPLE //bknight - 12/3/97 - Radar #2004660 ! 734: ! 735: diskObj = idmap->partitionId[part]; ! 736: } ! 737: break; ! 738: ! 739: case DKIOCGLOCATION: ! 740: diskObj = idmap->partitionId[part]; ! 741: break; ! 742: ! 743: case SDIOCSRQ: ! 744: case SDIOCGETCAP: ! 745: case DKIOCINFO: ! 746: case DKIOCBLKSIZE: ! 747: case DKIOCNUMBLKS: ! 748: diskObj = idmap->liveId; ! 749: break; ! 750: default: ! 751: xpr_sd("sdioctl: BAD cmd (0x%x)\n", cmd,2,3,4,5); ! 752: return(EINVAL); ! 753: } ! 754: if(diskObj == nil) ! 755: goto nodev; ! 756: ! 757: switch (cmd) { ! 758: case DKIOCSFORMAT: ! 759: /* ! 760: * This can fail if block devices attached to this disk are ! 761: * open. ! 762: */ ! 763: irtn = [diskObj setFormatted:(*(u_int *)data)]; ! 764: break; ! 765: ! 766: case DKIOCGFORMAT: ! 767: { ! 768: *(int *)data = [diskObj isFormatted]; ! 769: break; ! 770: } ! 771: ! 772: case DKIOCGLABEL: ! 773: { ! 774: struct disk_label *labelp; ! 775: ! 776: labelp = IOMalloc(sizeof(*labelp)); ! 777: irtn = [diskObj readLabel:labelp]; ! 778: if(irtn == IO_R_SUCCESS) { ! 779: *(struct disk_label *)data = *labelp; ! 780: } ! 781: IOFree(labelp, sizeof(*labelp)); ! 782: break; ! 783: } ! 784: ! 785: case DKIOCSLABEL: ! 786: { ! 787: struct disk_label *labelp; ! 788: ! 789: labelp = IOMalloc(sizeof(*labelp)); ! 790: *labelp = *(struct disk_label *)data; ! 791: irtn = [diskObj writeLabel:labelp]; ! 792: IOFree(labelp, sizeof(*labelp)); ! 793: break; ! 794: } ! 795: ! 796: case DKIOCINFO: ! 797: { ! 798: struct drive_info info; ! 799: ! 800: bzero(&info, sizeof(info)); ! 801: strcpy(info.di_name, [diskObj driveName]); ! 802: info.di_devblklen = [diskObj blockSize]; ! 803: info.di_maxbcount = SCSIDisk_dev[unit]->maxTransfer; ! 804: if(info.di_devblklen) { ! 805: /* ! 806: * Careful, blockSize might be 0 for an ! 807: * unformatted disk. ! 808: */ ! 809: nblk = howmany(sizeof(struct disk_label), ! 810: info.di_devblklen); ! 811: for (i = 0; i < NLABELS; i++) ! 812: info.di_label_blkno[i] = nblk * i; ! 813: } ! 814: *(struct drive_info *)data = info; ! 815: break; ! 816: } ! 817: ! 818: case DKIOCEJECT: ! 819: /* ! 820: * This is a (legal) nop for non-removable drives. This ! 821: * merely accomodates a WSM quirk left over from ! 822: * m68k develolpment; it's handled here instead of ! 823: * in IODiskPartition to avoid propagating further... ! 824: */ ! 825: if(![diskObj isRemovable]) { ! 826: break; ! 827: } ! 828: // Send an ALLOW MEDIUM REMOVAL to the SCSI drive ! 829: // to permit the ejection of the disk, unless we ! 830: // detect another active open on this disk (aside ! 831: // from the one issuing this eject). The [eject] ! 832: // method also does this check, don't worry. We ! 833: // just don't want to send spurious PREVENT/ALLOW ! 834: // commands while other folks are doing I/O. ! 835: // ! 836: // Note that on successful ejection, a 2nd ALLOW ! 837: // MEDIUM REMOVAL will be sent after this on the ! 838: // close() of this device. This is not an issue. ! 839: ! 840: if ( [diskObj isAnyOtherOpen] == NO && ! 841: [diskObj isBlockDeviceOpen] == NO ) ! 842: { ! 843: // Note that eject ioctls arrive on raw opens, ! 844: // so we only check for outstanding block opens ! 845: // on our device. ! 846: sd_prevent_eject(idmap->liveId, NO); ! 847: ! 848: // Eject the disk now. ! 849: irtn = [diskObj eject]; ! 850: ! 851: // Send a PREVENT MEDIUM REMOVAL to the SCSI drive ! 852: // to re-prevent the ejection of the disk if the ! 853: // eject has failed for any reason. ! 854: if (irtn) sd_prevent_eject(idmap->liveId, YES); ! 855: } else { ! 856: irtn = [diskObj eject]; ! 857: } ! 858: break; ! 859: ! 860: case DKIOCBLKSIZE: ! 861: *(int *)data = [diskObj blockSize]; ! 862: break; ! 863: ! 864: case DKIOCNUMBLKS: ! 865: *(int *)data = [diskObj diskSize]; ! 866: break; ! 867: ! 868: case DKIOCGLOCATION: ! 869: if( nil == [diskObj getDevicePath:((struct drive_location *)data)->location ! 870: maxLength:sizeof(((struct drive_location *)data)->location) ! 871: useAlias:YES] ) ! 872: irtn = IO_R_UNSUPPORTED; ! 873: break; ! 874: ! 875: case SDIOCSRQ: ! 876: ! 877: srp = (struct scsi_req *)data; ! 878: ! 879: /* if user expects to do some DMA, get some well-aligned ! 880: * memory. Copy in the user's data if a DMA write is ! 881: * expected. By using allocateBufferOfLength we guarantee ! 882: * that there is enough space in the buffer we pass to the ! 883: * controller to handle end-of-buffer alignment, although ! 884: * we won't copy more than sr_dma_max to or from the ! 885: * caller. ! 886: */ ! 887: if(srp->sr_dma_max != 0) { ! 888: IODMAAlignment dmaAlign; ! 889: id controller = [idmap->liveId controller]; ! 890: unsigned alignment; ! 891: ! 892: [controller getDMAAlignment:&dmaAlign]; ! 893: if(srp->sr_dma_dir == SR_DMA_WR) { ! 894: alignment = dmaAlign.writeLength; ! 895: } ! 896: else { ! 897: alignment = dmaAlign.readLength; ! 898: } ! 899: if(alignment > 1) { ! 900: alignedLength = IOAlign(unsigned, ! 901: srp->sr_dma_max, ! 902: alignment); ! 903: } ! 904: else { ! 905: alignedLength = srp->sr_dma_max; ! 906: } ! 907: alignedPtr = [controller ! 908: allocateBufferOfLength:alignedLength ! 909: actualStart:&freeBuf ! 910: actualLength:&freeLength]; ! 911: if(srp->sr_dma_dir == SR_DMA_WR) { ! 912: rtn = copyin(srp->sr_addr, alignedPtr, ! 913: srp->sr_dma_max); ! 914: if(rtn) { ! 915: xpr_sd(" ...copyin() returned %d\n", ! 916: rtn, 2,3,4,5); ! 917: srp->sr_io_status = SR_IOST_MEMF; ! 918: goto err_exit; ! 919: } ! 920: } ! 921: } else { ! 922: alignedLength = 0; ! 923: alignedPtr = 0; ! 924: } ! 925: ! 926: /* ! 927: * Generate a contemporary version of scsi_req. ! 928: */ ! 929: bzero(&scsiReq, sizeof(scsiReq)); ! 930: scsiReq.target = [diskObj target]; ! 931: scsiReq.lun = [diskObj lun]; ! 932: /* ! 933: * Careful. this assumes that the old and new cdb structs are ! 934: * equivalent... ! 935: */ ! 936: scsiReq.cdb = srp->sr_cdb; ! 937: scsiReq.read = (srp->sr_dma_dir == SR_DMA_RD) ? ! 938: YES : NO; ! 939: scsiReq.maxTransfer = alignedLength; ! 940: scsiReq.timeoutLength = srp->sr_ioto; ! 941: scsiReq.disconnect = srp->sr_discon_disable ? 0 : 1; ! 942: scsiReq.cmdQueueDisable = srp->sr_cmd_queue_disable; ! 943: scsiReq.syncDisable = srp->sr_sync_disable; ! 944: scsiReq.cdbLength = srp->sr_cdb_length; ! 945: ! 946: /* ! 947: * Go for it. ! 948: */ ! 949: if(srp->sr_dma_dir == SR_DMA_WR) { ! 950: irtn = [diskObj sdCdbWrite:&scsiReq ! 951: buffer : alignedPtr ! 952: client : kernel_map]; ! 953: } ! 954: else { ! 955: irtn = [diskObj sdCdbRead:&scsiReq ! 956: buffer : alignedPtr ! 957: client : kernel_map]; ! 958: } ! 959: ! 960: /* ! 961: * Copy status back to user. ! 962: */ ! 963: srp->sr_io_status = scsiReq.driverStatus; ! 964: if(srp->sr_io_status == SR_IOST_BADST) { ! 965: /* ! 966: * dmitch 9 Jun 94: Warning: this code is ! 967: * bogus, though benign. Lower levels will give us ! 968: * SR_IOST_CHKSNV or SR_IOST_CHKSV in case of ! 969: * STAT_CHECK. ! 970: */ ! 971: if(scsiReq.scsiStatus == STAT_CHECK) ! 972: srp->sr_io_status = SR_IOST_CHKSNV; ! 973: } ! 974: srp->sr_scsi_status = scsiReq.scsiStatus; ! 975: srp->sr_dma_xfr = scsiReq.bytesTransferred; ! 976: if(srp->sr_dma_xfr > srp->sr_dma_max) { ! 977: srp->sr_dma_xfr = srp->sr_dma_max; ! 978: } ! 979: srp->sr_exec_time.tv_sec = srp->sr_exec_time.tv_usec = 0; ! 980: ! 981: /* ! 982: * Copy read data back to user if appropriate. ! 983: */ ! 984: if((srp->sr_dma_dir == SR_DMA_RD) && ! 985: (scsiReq.bytesTransferred != 0)) { ! 986: rtn = copyout(alignedPtr, ! 987: srp->sr_addr, ! 988: srp->sr_dma_xfr); ! 989: } ! 990: /* ! 991: * Copy sense data back to user if appropriate. ! 992: */ ! 993: if(srp->sr_io_status == SR_IOST_CHKSV) { ! 994: srp->sr_esense = scsiReq.senseData; ! 995: } ! 996: err_exit: ! 997: if (srp->sr_dma_max != 0) { ! 998: IOFree(freeBuf, freeLength); ! 999: } ! 1000: break; ! 1001: ! 1002: case SDIOCGETCAP: ! 1003: { ! 1004: irtn = [diskObj updatePhysicalParameters]; ! 1005: if(irtn) ! 1006: break; ! 1007: scsi_crp_setup((struct capacity_reply *) data, ! 1008: [diskObj blockSize], [diskObj diskSize] - 1); ! 1009: } ! 1010: break; ! 1011: ! 1012: default: ! 1013: xpr_sd("sdioctl: BAD cmd (0x%x)\n", cmd,2,3,4,5); ! 1014: return(EINVAL); ! 1015: } ! 1016: ! 1017: if(irtn) ! 1018: rtn = [diskObj errnoFromReturn:irtn]; ! 1019: xpr_sd("%s sdioctl: returning %s (errno %d)\n", ! 1020: [diskObj name], [diskObj stringFromReturn:irtn], ! 1021: rtn, 4,5); ! 1022: return(rtn); ! 1023: ! 1024: nodev: ! 1025: xpr_sd("sdioctl: no such device (dev = 0x%x)\n", ! 1026: dev, 2,3,4,5); ! 1027: return(ENXIO); ! 1028: ! 1029: } /* sdioctl() */ ! 1030: ! 1031: /* ! 1032: * Obtain physical block size. ! 1033: */ ! 1034: int sdsize(dev_t dev) ! 1035: { ! 1036: id diskObj = sd_dev_to_id(dev); ! 1037: ! 1038: if(diskObj == nil) { ! 1039: xpr_sd("sdsize: bad unit\n", 1,2,3,4,5); ! 1040: return -1; ! 1041: } ! 1042: return [diskObj blockSize]; ! 1043: ! 1044: } ! 1045: ! 1046: static unsigned sdminphys(struct buf *bp) ! 1047: { ! 1048: SCSIDisk_Data_t *dataBP = (SCSIDisk_Data_t *) bp; ! 1049: ! 1050: if (bp->b_bcount > dataBP->maxTransfer) ! 1051: bp->b_bcount = dataBP->maxTransfer; ! 1052: return bp->b_bcount; ! 1053: } ! 1054: ! 1055: /* ! 1056: * Map dev_t to id. A nil return indicates ENXIO. ! 1057: */ ! 1058: ! 1059: static id sd_dev_to_id(dev_t dev) ! 1060: { ! 1061: id rtn; ! 1062: int unit = IO_DISK_UNIT(dev); ! 1063: int part = IO_DISK_PART(dev); ! 1064: IODevAndIdInfo * idmap; ! 1065: ! 1066: #ifdef GROK_APPLE //bknight - 12/3/97 - Radar #2004660 ! 1067: ! 1068: if ( ! ( unit < NUM_SD_DEV ) ) { ! 1069: /* Modify the unit # under the assumption that it is an HFS device. */ ! 1070: ! 1071: unit -= NUM_SD_DEV; ! 1072: ! 1073: /* Is it an HFS device? */ ! 1074: ! 1075: if ( ! ( unit < NUM_SD_DEV ) ) { ! 1076: rtn = nil; ! 1077: goto Return; ! 1078: } ! 1079: ! 1080: /* Yes, it is an HFS device. */ ! 1081: ! 1082: /* But it doesn't have a raw variant. */ ! 1083: ! 1084: if ( major(dev) == sd_raw_major ) { ! 1085: rtn = nil; ! 1086: goto Return; ! 1087: } ! 1088: ! 1089: /* Modify the partition # to indicate an HFS partition and then proceed. */ ! 1090: ! 1091: part += NUM_SD_PART; ! 1092: ! 1093: } ! 1094: ! 1095: #else GROK_APPLE //bknight - 12/3/97 - Radar #2004660 ! 1096: ! 1097: if((unit >= NUM_SD_DEV) || (part >= NUM_SD_PART)) { ! 1098: return nil; ! 1099: } ! 1100: ! 1101: #endif GROK_APPLE //bknight - 12/3/97 - Radar #2004660 ! 1102: ! 1103: idmap = &SCSIDiskIdMap[unit]; ! 1104: ! 1105: if(part == SD_LIVE_PART) { ! 1106: if(major(dev) == sd_block_major) { ! 1107: /* ! 1108: * Live partition on the block device not permitted. ! 1109: */ ! 1110: rtn = nil; ! 1111: } ! 1112: else { ! 1113: rtn = idmap->liveId; ! 1114: } ! 1115: } ! 1116: else { ! 1117: rtn = idmap->partitionId[part]; ! 1118: } ! 1119: ! 1120: Return: ! 1121: ! 1122: return rtn; ! 1123: } ! 1124: ! 1125: /* ! 1126: * Obtain the id of the physical disk assiociated with specified dev. ! 1127: */ ! 1128: ! 1129: static id sd_phys_dev_id(dev_t dev) ! 1130: { ! 1131: int unit = IO_DISK_UNIT(dev); ! 1132: #ifdef GROK_APPLE //bknight - 12/3/97 - Radar #2004660 ! 1133: id rtn; ! 1134: ! 1135: if ( ! ( unit < NUM_SD_DEV ) ) { ! 1136: /* Could it be an HFS partition? */ ! 1137: ! 1138: unit -= NUM_SD_DEV; ! 1139: ! 1140: if ( ! (unit < NUM_SD_DEV) ) { ! 1141: rtn = nil; ! 1142: goto Return; ! 1143: } ! 1144: ! 1145: /* Yes, it is an HFS partition. Use adjusted <unit>. */ ! 1146: ! 1147: } ! 1148: ! 1149: rtn = SCSIDiskIdMap[unit].liveId; ! 1150: ! 1151: Return: ! 1152: ! 1153: return rtn; ! 1154: ! 1155: #else GROK_APPLE //bknight - 12/3/97 - Radar #2004660 ! 1156: if(unit > NUM_SD_DEV) { ! 1157: return nil; ! 1158: } ! 1159: return SCSIDiskIdMap[unit].liveId; ! 1160: #endif GROK_APPLE //bknight - 12/3/97 - Radar #2004660 ! 1161: } ! 1162: ! 1163: void sd_prevent_eject(id physicalDisk, BOOL prevent) ! 1164: { ! 1165: // ! 1166: // Sends a SCSI PREVENT/ALLOW MEDIUM REMOVAL command to the given ! 1167: // disk (target and lun) in order to prevent or permit the manual ! 1168: // ejection of removable disk(s) inside the SCSI drive. ! 1169: // ! 1170: ! 1171: IOSCSIRequest scsiReq; ! 1172: ! 1173: // ! 1174: // Set up the SCSI REQUEST structure. Note that cdbLength is an ! 1175: // optional field and is left as zero. ! 1176: // ! 1177: ! 1178: bzero(&scsiReq, sizeof(scsiReq)); ! 1179: ! 1180: scsiReq.cdb.cdb_c6.c6_opcode = C60P_PREVENTALLOW; ! 1181: scsiReq.cdb.cdb_c6.c6_len = (prevent ? 0x01 : 0x00); ! 1182: scsiReq.target = [physicalDisk target]; ! 1183: scsiReq.lun = [physicalDisk lun]; ! 1184: scsiReq.read = YES; ! 1185: scsiReq.timeoutLength = SD_TIMEOUT_SIMPLE; ! 1186: ! 1187: // ! 1188: // Execute the request. ! 1189: // ! 1190: ! 1191: [physicalDisk sdCdbRead : &scsiReq ! 1192: buffer : NULL ! 1193: client : kernel_map]; ! 1194: } ! 1195: ! 1196: /* end of SCSIDiskKern.m */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.