![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ds_routines.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / OSKit-Mach / oskit|
Return to ds_routines.c CVS log | Up to [GnuMach] / OSKit-Mach / oskit |
1.1 ! root 1: /* ! 2: * Mach device server routines (oskit version). ! 3: * ! 4: * Mach Operating System ! 5: * Copyright (c) 1993,1991,1990,1989 Carnegie Mellon University ! 6: * All Rights Reserved. ! 7: * ! 8: * Permission to use, copy, modify and distribute this software and its ! 9: * documentation is hereby granted, provided that both the copyright ! 10: * notice and this permission notice appear in all copies of the ! 11: * software, derivative works or modified versions, and any portions ! 12: * thereof, and that both notices appear in supporting documentation. ! 13: * ! 14: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 15: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR ! 16: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 17: * ! 18: * Carnegie Mellon requests users of this software to return to ! 19: * ! 20: * Software Distribution Coordinator or [email protected] ! 21: * School of Computer Science ! 22: * Carnegie Mellon University ! 23: * Pittsburgh PA 15213-3890 ! 24: * ! 25: * any improvements or extensions that they make and grant Carnegie Mellon ! 26: * the rights to redistribute these changes. ! 27: */ ! 28: ! 29: #include "ds_oskit.h" ! 30: #include "device_error_reply.h" ! 31: ! 32: #include <mach/boolean.h> ! 33: #include <mach/kern_return.h> ! 34: #include <mach/mig_errors.h> ! 35: #include <mach/port.h> ! 36: #include <mach/notify.h> ! 37: #include <mach/time_value.h> ! 38: ! 39: #include <vm/vm_map.h> ! 40: #include <vm/vm_kern.h> ! 41: #include <vm/vm_page.h> ! 42: #include "pmap.h" ! 43: ! 44: #include <ipc/ipc_port.h> ! 45: #include <ipc/ipc_space.h> ! 46: ! 47: #include <oskit/dev/dev.h> ! 48: #include <oskit/error.h> ! 49: #include <oskit/unsupp/bus_walk.h> ! 50: #include <oskit/dev/bus.h> ! 51: #include <oskit/dev/blk.h> ! 52: #ifdef HAVE_OSKIT_DEV_STREAM_H ! 53: # include <oskit/dev/stream.h> ! 54: #endif ! 55: #include <oskit/dev/net.h> ! 56: #include <oskit/dev/linux.h> ! 57: #include <oskit/com/stream.h> ! 58: #include <oskit/c/stdlib.h> ! 59: ! 60: #include <oskit/machine/pc/direct_cons.h> /* XXX direct_cons_set_flags */ ! 61: ! 62: #include <device/device_port.h> ! 63: ! 64: #include <string.h> ! 65: ! 66: ! 67: #define NDEVICES 256 ! 68: #define DEVICE_IO_MAP_SIZE (4 * 1024 * 1024) ! 69: ! 70: zone_t dev_hdr_zone; ! 71: zone_t io_inband_zone; /* for inband reads */ ! 72: ! 73: queue_head_t io_done_list; ! 74: decl_simple_lock_data(, io_done_list_lock) ! 75: ! 76: /* We maintain a hash table mapping COM oskit_device_t pointers to ! 77: open device ports (device_t). */ ! 78: ! 79: #define NDEVHASH 7 ! 80: #define DEV_PTR_HASH(com) ((natural_t) (com) % NDEVHASH) ! 81: queue_head_t dev_hash_table[NDEVHASH]; ! 82: ! 83: /* ! 84: * Lock for device-number to device lookup. ! 85: * Must be held before device-ref_count lock. ! 86: */ ! 87: decl_simple_lock_data(,dev_hash_lock) ! 88: ! 89: static void ! 90: dev_hash_enter (device_t device) ! 91: { ! 92: queue_enter (&dev_hash_table[DEV_PTR_HASH(device->com_device)], ! 93: device, device_t, hash_chain); ! 94: } ! 95: ! 96: static void ! 97: dev_hash_remove (device_t device) ! 98: { ! 99: queue_remove (&dev_hash_table[DEV_PTR_HASH(device->com_device)], ! 100: device, device_t, hash_chain); ! 101: } ! 102: ! 103: ! 104: static device_t ! 105: dev_hash_lookup (oskit_device_t *com_device, dev_mode_t mode) ! 106: { ! 107: queue_t q; ! 108: device_t device; ! 109: ! 110: q = &dev_hash_table[DEV_PTR_HASH (com_device)]; ! 111: queue_iterate (q, device, device_t, hash_chain) ! 112: if (device->com_device == com_device && (mode &~ device->mode) == 0) ! 113: return device; ! 114: ! 115: return DEVICE_NULL; ! 116: } ! 117: ! 118: /* ! 119: * Add a reference to the device. ! 120: */ ! 121: void ! 122: device_reference(device_t device) ! 123: { ! 124: simple_lock(&device->ref_lock); ! 125: device->ref_count++; ! 126: simple_unlock(&device->ref_lock); ! 127: } ! 128: ! 129: /* ! 130: * Remove a reference to the device, and deallocate the ! 131: * structure if no references are left. ! 132: */ ! 133: void ! 134: device_deallocate (device_t device) ! 135: { ! 136: if (device == DEVICE_NULL) ! 137: return; ! 138: ! 139: simple_lock (&device->ref_lock); ! 140: if (device->ref_count > 1) ! 141: { ! 142: --device->ref_count; ! 143: simple_unlock (&device->ref_lock); ! 144: return; ! 145: } ! 146: simple_unlock (&device->ref_lock); ! 147: ! 148: if (device->com_device) ! 149: { ! 150: simple_lock(&dev_hash_lock); ! 151: simple_lock(&device->ref_lock); ! 152: if (--device->ref_count > 0) ! 153: { ! 154: simple_unlock (&device->ref_lock); ! 155: simple_unlock (&dev_hash_lock); ! 156: return; ! 157: } ! 158: ! 159: dev_hash_remove (device); ! 160: simple_unlock(&device->ref_lock); ! 161: simple_unlock(&dev_hash_lock); ! 162: } ! 163: ! 164: /* Destroy the port. */ ! 165: ipc_kobject_set (device->port, IKO_NULL, IKOT_NONE); ! 166: ipc_port_dealloc_kernel (device->port); ! 167: device->port = IP_NULL; ! 168: ! 169: DEV_LOCK (device); ! 170: if (device->ops && device->ops->close) ! 171: (*device->ops->close) (device); ! 172: if (device->com_device) /* close hook might have cleared it */ ! 173: oskit_device_release (device->com_device); ! 174: DEV_UNLOCK (device); ! 175: ! 176: zfree(dev_hdr_zone, (vm_offset_t)device); ! 177: } ! 178: ! 179: const struct device_ops no_device_ops; ! 180: ! 181: void ds_init() ! 182: { ! 183: vm_offset_t device_io_min, device_io_max; ! 184: unsigned int i; ! 185: ! 186: queue_init(&io_done_list); ! 187: simple_lock_init(&io_done_list_lock); ! 188: ! 189: device_io_map = kmem_suballoc(kernel_map, ! 190: &device_io_min, ! 191: &device_io_max, ! 192: DEVICE_IO_MAP_SIZE, ! 193: FALSE); ! 194: /* ! 195: * If the kernel receives many device_write requests, the ! 196: * device_io_map might run out of space. To prevent ! 197: * device_write_get from failing in this case, we enable ! 198: * wait_for_space on the map. This causes kmem_io_map_copyout ! 199: * to block until there is sufficient space. ! 200: * (XXX Large writes may be starved by small writes.) ! 201: * ! 202: * There is a potential deadlock problem with this solution, ! 203: * if a device_write from the default pager has to wait ! 204: * for the completion of a device_write which needs to wait ! 205: * for memory allocation. Hence, once device_write_get ! 206: * allocates space in device_io_map, no blocking memory ! 207: * allocations should happen until device_write_dealloc ! 208: * frees the space. (XXX A large write might starve ! 209: * a small write from the default pager.) ! 210: */ ! 211: device_io_map->wait_for_space = TRUE; ! 212: ! 213: dev_hdr_zone = zinit(sizeof(struct device), ! 214: sizeof(struct device) * NDEVICES, ! 215: PAGE_SIZE, ! 216: FALSE, ! 217: "open device entry"); ! 218: ! 219: io_inband_zone = zinit(sizeof(io_buf_ptr_inband_t), ! 220: 1000 * sizeof(io_buf_ptr_inband_t), ! 221: 10 * sizeof(io_buf_ptr_inband_t), ! 222: FALSE, ! 223: "io inband read buffers"); ! 224: ! 225: simple_lock_init(&dev_hash_lock); ! 226: for (i = 0; i < NDEVHASH; i++) ! 227: queue_init(&dev_hash_table[i]); ! 228: ! 229: ds_osenv_init(); ! 230: ds_request_init(); ! 231: ! 232: DEV_LOCK_INIT; ! 233: } ! 234: ! 235: ! 236: boolean_t ! 237: ds_notify (mach_msg_header_t *msg) ! 238: { ! 239: if (msg->msgh_id == MACH_NOTIFY_NO_SENDERS) ! 240: { ! 241: device_t dev; ! 242: mach_no_senders_notification_t *ns; ! 243: ! 244: ns = (mach_no_senders_notification_t *) msg; ! 245: dev = dev_port_lookup ((ipc_port_t) ns->not_header.msgh_remote_port); ! 246: assert (dev); ! 247: ! 248: /* Extant send rights held one ref on the device object, ! 249: and we just got another one from dev_port_lookup. */ ! 250: device_deallocate (dev); ! 251: device_deallocate (dev); ! 252: ! 253: return TRUE; ! 254: } ! 255: ! 256: printf ("ds_notify: strange notification %d\n", msg->msgh_id); ! 257: return FALSE; ! 258: } ! 259: ! 260: ! 261: ipc_port_t ! 262: convert_device_to_port (device_t device) ! 263: { ! 264: ipc_port_t port; ! 265: ! 266: if (! device) ! 267: return IP_NULL; ! 268: device_lock(device); ! 269: port = ipc_port_make_send(device->port); ! 270: device_unlock(device); ! 271: device_deallocate(device); ! 272: return port; ! 273: } ! 274: ! 275: ! 276: /* ! 277: * Lookup a device by its port. ! 278: * Doesn't consume the naked send right; produces a device reference. ! 279: */ ! 280: device_t ! 281: dev_port_lookup(port) ! 282: ipc_port_t port; ! 283: { ! 284: register device_t device; ! 285: ! 286: if (!IP_VALID(port)) ! 287: return (DEVICE_NULL); ! 288: ! 289: ip_lock(port); ! 290: if (ip_active(port) && (ip_kotype(port) == IKOT_DEVICE)) { ! 291: device = (device_t) port->ip_kobject; ! 292: device_reference(device); ! 293: } ! 294: else ! 295: device = DEVICE_NULL; ! 296: ! 297: ip_unlock(port); ! 298: return (device); ! 299: } ! 300: ! 301: ! 302: /*** Opening devices. ***/ ! 303: ! 304: ! 305: device_t ! 306: dev_open_alloc (void) ! 307: { ! 308: device_t dev = (device_t) zalloc (dev_hdr_zone); ! 309: simple_lock_init(&dev->ref_lock); ! 310: dev->ref_count = 1; ! 311: simple_lock_init(&dev->lock); ! 312: ! 313: /* ! 314: * Allocate port, keeping a reference for it. ! 315: */ ! 316: dev->port = ipc_port_alloc_kernel (); ! 317: if (dev->port == IP_NULL) ! 318: { ! 319: zfree (dev_hdr_zone, (vm_offset_t) dev); ! 320: return DEVICE_NULL; ! 321: } ! 322: ! 323: /* Associate the port with the device. */ ! 324: ipc_kobject_set (dev->port, (ipc_kobject_t) dev, IKOT_DEVICE); ! 325: ! 326: return dev; ! 327: } ! 328: ! 329: ! 330: void ! 331: setup_no_senders (device_t dev) ! 332: { ! 333: ipc_port_t notify; ! 334: ! 335: /* ! 336: * Request no-senders notifications on device port. ! 337: * One ref in DEV->ref_count is held by the existence of send rights; ! 338: * the no-senders notification will release that ref. ! 339: */ ! 340: notify = ipc_port_make_sonce(dev->port); ! 341: ip_lock(dev->port); ! 342: ipc_port_nsrequest(dev->port, 1, notify, ¬ify); ! 343: assert(notify == IP_NULL); ! 344: ! 345: device_reference (dev); ! 346: } ! 347: ! 348: ! 349: /* Given a COM device object and an i/o mode, produce an open device. ! 350: Always consumes a ref on COM_DEVICE. */ ! 351: static io_return_t ! 352: dev_open_com (oskit_device_t *com_device, dev_mode_t mode, device_t *devp, ! 353: const char *diskpart) ! 354: { ! 355: device_t dev; ! 356: const struct device_ops *ops; ! 357: ! 358: /* First we look for an existing device port already open. */ ! 359: lookup: ! 360: simple_lock (&dev_hash_lock); ! 361: dev = dev_hash_lookup (com_device, mode); ! 362: if (dev != DEVICE_NULL) ! 363: { ! 364: /* Acquire a reference on the device, as by device_reference. ! 365: We don't just call that because of the locking here. */ ! 366: device_lock (dev); ! 367: ++dev->ref_count; ! 368: simple_unlock (&dev_hash_lock); ! 369: ! 370: DEV_LOCK (dev); ! 371: oskit_device_release (com_device); /* consume ref passed in */ ! 372: DEV_UNLOCK (dev); ! 373: if (dev->ops == 0) ! 374: { ! 375: /* Somebody else is blocked in the oskit getting this device open. ! 376: We will block until they wake us up. */ ! 377: dev->mode |= D_NODELAY; /* mark for opener */ ! 378: thread_sleep ((event_t) dev, simple_lock_addr (dev->lock), TRUE); ! 379: /* Repeat the lookup in case DEV got killed in a failed open. */ ! 380: goto lookup; ! 381: } ! 382: else ! 383: device_unlock (dev); ! 384: ! 385: goto got_device; ! 386: } ! 387: simple_unlock (&dev_hash_lock); ! 388: ! 389: /* Nope! We will need a new device port. */ ! 390: ! 391: dev = dev_open_alloc (); ! 392: if (!dev) ! 393: return KERN_RESOURCE_SHORTAGE; ! 394: ! 395: dev->com_device = com_device; ! 396: dev->mode = mode; ! 397: dev->ops = 0; ! 398: ! 399: /* Put the device in the hash table under its COM device. We hold the ! 400: only reference to the device, and releasing that reference will remove ! 401: it from the hash table. While it's live, someone else might come ! 402: along and find it in the hash table and get their own reference to ! 403: keep it there. After this point we need to use device_lock. */ ! 404: simple_lock (&dev_hash_lock); ! 405: dev_hash_enter (dev); ! 406: simple_unlock (&dev_hash_lock); ! 407: ! 408: /* Now we must open the oskit device, first determining which flavor it is. ! 409: */ ! 410: { ! 411: oskit_bus_t *bus; ! 412: oskit_blkdev_t *blkdev; ! 413: oskit_netdev_t *netdev; ! 414: #ifdef oskit_streamdev_open ! 415: oskit_streamdev_t *streamdev; ! 416: #endif ! 417: oskit_error_t rc; ! 418: inline void asyncio_init (device_t dev) ! 419: { ! 420: dev->com.stream.listening = 0; ! 421: queue_init (&dev->com.stream.read_queue); ! 422: queue_init (&dev->com.stream.write_queue); ! 423: dev->com.stream.ready_queue.next = 0; ! 424: } ! 425: ! 426: if (oskit_device_query (com_device, &oskit_stream_iid, ! 427: (void **) &dev->com.stream.io) == 0) ! 428: { ! 429: /* Special case for minimal console stream, not really a device. */ ! 430: if (oskit_stream_query (dev->com.stream.io, &oskit_asyncio_iid, ! 431: (void **) &dev->com.stream.aio) == 0) ! 432: { ! 433: asyncio_init (dev); ! 434: ops = &asyncio_device_ops; ! 435: } ! 436: else ! 437: ops = &stream_device_ops; ! 438: rc = 0; ! 439: ! 440: /* Kludge for kmsg. */ ! 441: if ((void *) com_device == kmsg_stream && (mode & D_READ)) ! 442: ++kmsg_readers; ! 443: } ! 444: else if (oskit_device_query (com_device, &oskit_bus_iid, ! 445: (void **) &bus) == 0) ! 446: { ! 447: if (mode & D_WRITE) ! 448: { ! 449: device_lock (dev); ! 450: mode = dev->mode & D_NODELAY; ! 451: device_unlock (dev); ! 452: if (mode & D_NODELAY) ! 453: /* Someone was waiting for us to finish opening. */ ! 454: thread_wakeup ((event_t)dev); ! 455: device_deallocate (dev); ! 456: return D_READ_ONLY; ! 457: } ! 458: ops = &bus_device_ops; ! 459: rc = populate_bus (dev, bus); ! 460: oskit_bus_release (bus); ! 461: } ! 462: else if (oskit_device_query (com_device, &oskit_blkdev_iid, ! 463: (void **) &blkdev) == 0) ! 464: { ! 465: ops = &block_device_ops; ! 466: rc = oskit_blkdev_open (blkdev, ! 467: ((mode & D_READ) ? OSKIT_DEV_OPEN_READ : 0) | ! 468: ((mode & D_WRITE) ? OSKIT_DEV_OPEN_WRITE : 0), ! 469: &dev->com.blk.io); ! 470: oskit_blkdev_release (blkdev); ! 471: if (OSKIT_SUCCEEDED (rc)) ! 472: dev->com.blk.size = oskit_blkio_getblocksize (dev->com.blk.io); ! 473: dev->com.blk.parts = 0; ! 474: } ! 475: else if (oskit_device_query (com_device, &oskit_netdev_iid, ! 476: (void **) &netdev) == 0) ! 477: { ! 478: ops = &net_device_ops; ! 479: rc = ds_netdev_open (dev, netdev); ! 480: } ! 481: #ifdef oskit_streamdev_open ! 482: else if (oskit_device_query (com_device, &oskit_streamdev_iid, ! 483: (void **) &streamdev) == 0) ! 484: { ! 485: rc = oskit_streamdev_open (streamdev, ! 486: ((mode & D_READ) ? OSKIT_DEV_OPEN_READ : 0) ! 487: | ((mode & D_WRITE) ! 488: ? OSKIT_DEV_OPEN_WRITE : 0), ! 489: &dev->com.stream.io); ! 490: oskit_streamdev_release (streamdev); ! 491: if (OSKIT_SUCCEEDED (rc)) ! 492: { ! 493: if (oskit_stream_query (dev->com.stream.io, &oskit_asyncio_iid, ! 494: (void **) &dev->com.stream.aio) == 0) ! 495: { ! 496: asyncio_init (dev); ! 497: ops = &asyncio_device_ops; ! 498: } ! 499: else ! 500: ops = &stream_device_ops; ! 501: } ! 502: } ! 503: #endif ! 504: ! 505: if (OSKIT_FAILED (rc)) ! 506: { ! 507: if (dev->mode & D_NODELAY) ! 508: /* Someone was waiting for us to finish opening. */ ! 509: thread_wakeup ((event_t)dev); ! 510: device_deallocate (dev); ! 511: return oskit_to_mach_error (rc); ! 512: } ! 513: } ! 514: ! 515: device_lock (dev); ! 516: dev->ops = ops; ! 517: mode = dev->mode & D_NODELAY; ! 518: dev->mode &= ~D_NODELAY; ! 519: device_unlock (dev); ! 520: if (mode) ! 521: /* Someone was waiting for us to finish opening. */ ! 522: thread_wakeup ((event_t)dev); ! 523: ! 524: setup_no_senders (dev); ! 525: ! 526: /* Return the open device. */ ! 527: ! 528: got_device: ! 529: ! 530: if (diskpart) ! 531: { ! 532: diskpart_t *part; ! 533: device_t subdev; ! 534: ! 535: /* Kludge for partitioning. */ ! 536: if (dev->ops != &block_device_ops) ! 537: { ! 538: device_deallocate (dev); ! 539: return D_NO_SUCH_DEVICE; ! 540: } ! 541: ! 542: device_lock (dev); ! 543: if (dev->com.blk.parts == 0) ! 544: { ! 545: diskpart_t *parts = (void *) kalloc (MAX_PARTS * sizeof *parts); ! 546: int n = diskpart_blkio_get_partition (dev->com.blk.io, ! 547: parts, MAX_PARTS); ! 548: if (n <= 0) ! 549: { ! 550: device_unlock (dev); ! 551: kfree ((vm_offset_t) parts, MAX_PARTS * sizeof *parts); ! 552: device_deallocate (dev); ! 553: return D_NO_SUCH_DEVICE; ! 554: } ! 555: dev->com.blk.parts = parts; ! 556: } ! 557: device_unlock (dev); ! 558: ! 559: part = diskpart_lookup_bsd_string (dev->com.blk.parts, diskpart); ! 560: if (part == 0) ! 561: { ! 562: device_deallocate (dev); ! 563: return D_NO_SUCH_DEVICE; ! 564: } ! 565: ! 566: /* Now we have the pointer to the partition we want. For partition ! 567: pseudo-devices, we use this pointer in lieu of the COM object ! 568: pointer as the key in the device hash table. */ ! 569: simple_lock (&dev_hash_lock); ! 570: subdev = dev_hash_lookup ((void *) part, mode); ! 571: if (subdev != DEVICE_NULL) ! 572: { ! 573: device_lock (subdev); ! 574: ++subdev->ref_count; ! 575: simple_unlock (&dev_hash_lock); ! 576: ! 577: device_deallocate (dev); ! 578: dev = subdev; ! 579: } ! 580: else ! 581: { ! 582: simple_unlock (&dev_hash_lock); ! 583: ! 584: subdev = dev_open_alloc (); ! 585: if (!subdev) ! 586: { ! 587: device_deallocate (dev); ! 588: return KERN_RESOURCE_SHORTAGE; ! 589: } ! 590: ! 591: mode = dev->mode; ! 592: subdev->com.blkpart.blk = dev; /* consumes our ref */ ! 593: subdev->com.blkpart.part = part; ! 594: dev = subdev; ! 595: ! 596: dev->com_device = (void *) part; ! 597: dev->mode = mode; ! 598: dev->ops = &block_partition_device_ops; ! 599: ! 600: simple_lock (&dev_hash_lock); ! 601: dev_hash_enter (dev); ! 602: simple_unlock (&dev_hash_lock); ! 603: ! 604: setup_no_senders (dev); ! 605: } ! 606: } ! 607: ! 608: *devp = dev; /* Caller consumes the reference. */ ! 609: return D_SUCCESS; ! 610: } ! 611: ! 612: /* Create a special pseudo-device that maps contiguous physical memory ! 613: starting with the physical memory backing the wired kernel virtual ! 614: address KVA. See ds_mem.c for the device ops. */ ! 615: static io_return_t ! 616: special_mem_device (device_t *loc, ! 617: dev_mode_t mode, ! 618: vm_offset_t kva, vm_size_t size, vm_size_t recsize, ! 619: device_t *out_dev) ! 620: { ! 621: if (*loc == DEVICE_NULL) ! 622: { ! 623: device_t dev = dev_open_alloc (); ! 624: if (dev == DEVICE_NULL) ! 625: return KERN_RESOURCE_SHORTAGE; ! 626: dev->mode = mode & (D_READ|D_WRITE); ! 627: dev->com_device = 0; ! 628: dev->com.mem.pa = pmap_extract (kernel_pmap, kva); ! 629: dev->com.mem.size = size; ! 630: dev->com.mem.recsize = recsize; ! 631: dev->ops = &mem_device_ops; ! 632: *loc = dev; ! 633: ! 634: /* The *LOC value (in a global variable) holds a reference that ! 635: is never released. */ ! 636: } ! 637: ! 638: device_reference (*loc); /* This reference is consumed by the caller. */ ! 639: *out_dev = *loc; ! 640: return D_SUCCESS; ! 641: } ! 642: ! 643: ! 644: io_return_t ! 645: ds_device_open (ipc_port_t open_port, ipc_port_t reply_port, ! 646: mach_msg_type_name_t reply_port_type, dev_mode_t mode, ! 647: char *name, device_t *devp) ! 648: { ! 649: char constructed[200]; ! 650: oskit_error_t rc; ! 651: oskit_device_t *com_device; ! 652: const char *subpart = 0; ! 653: ! 654: /* Open must be called on the master device port. */ ! 655: if (open_port != master_device_port) ! 656: INVALOP; ! 657: ! 658: /* There must be a reply port. */ ! 659: if (! IP_VALID (reply_port)) ! 660: return MIG_NO_REPLY; ! 661: ! 662: if (name[0] == '@') /* Bus tree location. */ ! 663: { ! 664: rc = oskit_bus_walk_lookup (name, &com_device, &subpart); ! 665: if (OSKIT_FAILED (rc)) ! 666: return oskit_to_mach_error (rc); ! 667: } ! 668: else if (!strcmp (name, "console")) /* Special case. */ ! 669: { ! 670: com_device = (oskit_device_t *) ds_console_stream; /* not a device */ ! 671: oskit_device_addref (com_device); ! 672: ! 673: /* Kludge. We don't do this at bootup so that the printing of any ! 674: kernel lossage or panics will be easier to read. But we need it ! 675: set for real use of the console device. It's harmless to call ! 676: this more than once, since it just sets a variable. */ ! 677: direct_cons_set_flags (DC_NO_ONLCR); ! 678: } ! 679: else if (!strcmp (name, "kmsg")) /* Special case. */ ! 680: { ! 681: com_device = (oskit_device_t *) kmsg_stream; /* not a device */ ! 682: oskit_device_addref (com_device); ! 683: } ! 684: else if (!strcmp (name, "time")) /* Special case. */ ! 685: { ! 686: extern time_value_t *mtime; ! 687: static device_t mapped_time_device; ! 688: if (mode & D_WRITE) /* No writing of "time" device allowed; */ ! 689: return D_READ_ONLY; /* users must do host_set_time instead. */ ! 690: return special_mem_device (&mapped_time_device, D_READ, ! 691: (vm_offset_t) mtime, ! 692: sizeof *mtime, sizeof mtime->seconds, ! 693: devp); ! 694: } ! 695: else if (!strcmp (name, "mem")) /* Special case. */ ! 696: { ! 697: static device_t phys_mem_device; ! 698: return special_mem_device (&phys_mem_device, mode, ! 699: phystokv (0), ~(vm_offset_t)0, 1, ! 700: devp); ! 701: } ! 702: else if (bus_walk_from_compat_string (name, constructed)) /* compat hack */ ! 703: { ! 704: /* The name was recognized as a compatibility syntax, and CONSTRUCTED ! 705: now contains a name in bus walk syntax (starting with an '@'). */ ! 706: rc = oskit_bus_walk_lookup (constructed, &com_device, &subpart); ! 707: if (OSKIT_FAILED (rc)) ! 708: return oskit_to_mach_error (rc); ! 709: } ! 710: else /* I got no clue. */ ! 711: return D_NO_SUCH_DEVICE; ! 712: ! 713: return dev_open_com (com_device, mode & (D_READ | D_WRITE), devp, subpart); ! 714: } ! 715: ! 716: io_return_t ! 717: ds_device_close (device_t dev) ! 718: { ! 719: if (dev == DEVICE_NULL) ! 720: return D_NO_SUCH_DEVICE; ! 721: ! 722: /* The device_close RPC never does anything. ! 723: The device gets closed when the last send right to its port dies. */ ! 724: ! 725: return D_SUCCESS; ! 726: } ! 727: ! 728: ! 729: ! 730: /* Server functions for RPCs to open devices. ! 731: ! 732: Note: These functions expect a migworthy return value from the dev->ops ! 733: functions, i.e. MIG_NO_REPLY and not D_IO_QUEUED. ! 734: */ ! 735: ! 736: io_return_t ! 737: ds_device_write (device_t dev, ipc_port_t reply_port, ! 738: mach_msg_type_name_t reply_port_type, dev_mode_t mode, ! 739: recnum_t recnum, io_buf_ptr_t data, ! 740: mach_msg_type_number_t count, ! 741: int *bytes_written) ! 742: { ! 743: if (dev == DEVICE_NULL) ! 744: return D_NO_SUCH_DEVICE; ! 745: if (!(dev->mode & D_WRITE)) ! 746: INVALOP; ! 747: if (! data) ! 748: INVALSZ; ! 749: if (! dev->ops->write) ! 750: { ! 751: if (!dev->ops->write_inband) ! 752: return D_READ_ONLY; ! 753: else ! 754: { ! 755: /* ! 756: * Copy out-of-line data into kernel address space. ! 757: * Since data is copied as page list, it will be ! 758: * accessible. ! 759: */ ! 760: vm_offset_t addr; ! 761: kern_return_t kr = vm_map_copyout (device_io_map, &addr, ! 762: (vm_map_copy_t) data); ! 763: if (kr != KERN_SUCCESS) ! 764: return kr; ! 765: ! 766: /* Note: we assume that write_inband can take a large count. */ ! 767: kr = (*dev->ops->write_inband) (dev, reply_port, ! 768: reply_port_type, mode, recnum, ! 769: (char *) addr, count, ! 770: bytes_written); ! 771: (void) vm_deallocate (device_io_map, addr, count); ! 772: if (kr == KERN_SUCCESS || kr == MIG_NO_REPLY) ! 773: return kr; ! 774: /* We don't want to return an error to our caller, because it ! 775: will respond to that by destroying the message body--but we ! 776: have already consumed DATA, and destroying it would be bad. */ ! 777: if (IP_VALID (reply_port)) ! 778: ds_device_write_error_reply (reply_port, reply_port_type, kr); ! 779: return MIG_NO_REPLY; ! 780: } ! 781: } ! 782: return (*dev->ops->write) (dev, reply_port, ! 783: reply_port_type, mode, recnum, ! 784: data, count, bytes_written); ! 785: } ! 786: ! 787: io_return_t ! 788: ds_device_write_inband (device_t dev, ipc_port_t reply_port, ! 789: mach_msg_type_name_t reply_port_type, ! 790: dev_mode_t mode, recnum_t recnum, ! 791: io_buf_ptr_inband_t data, unsigned count, ! 792: int *bytes_written) ! 793: { ! 794: if (dev == DEVICE_NULL) ! 795: return D_NO_SUCH_DEVICE; ! 796: if (!(dev->mode & D_WRITE)) ! 797: INVALOP; ! 798: if (! data) ! 799: INVALSZ; ! 800: assert (count <= IO_INBAND_MAX); ! 801: if (! dev->ops->write_inband) ! 802: { ! 803: if (! dev->ops->write) ! 804: INVALOP; ! 805: else ! 806: { ! 807: vm_offset_t addr; ! 808: kern_return_t kr; ! 809: vm_map_copy_t copy; ! 810: ! 811: assert (IO_INBAND_MAX <= PAGE_SIZE); ! 812: kr = kmem_alloc (kernel_map, &addr, PAGE_SIZE); ! 813: if (kr != KERN_SUCCESS) ! 814: return kr; ! 815: ! 816: memcpy ((char *) addr, data, count); ! 817: kr = vm_map_copyin_page_list (kernel_map, addr, PAGE_SIZE, ! 818: TRUE, TRUE, ©, FALSE); ! 819: assert (kr == KERN_SUCCESS); ! 820: ! 821: kr = (*dev->ops->write) (dev, reply_port, ! 822: reply_port_type, mode, recnum, ! 823: (char *) copy, count, bytes_written); ! 824: if (kr != D_SUCCESS) ! 825: vm_map_copy_discard (copy); ! 826: return kr; ! 827: } ! 828: } ! 829: return (*dev->ops->write_inband) (dev, reply_port, ! 830: reply_port_type, mode, recnum, ! 831: data, count, bytes_written); ! 832: } ! 833: ! 834: io_return_t ! 835: ds_device_read (device_t dev, ipc_port_t reply_port, ! 836: mach_msg_type_name_t reply_port_type, dev_mode_t mode, ! 837: recnum_t recnum, int count, io_buf_ptr_t *data, ! 838: unsigned *bytes_read) ! 839: { ! 840: io_return_t err; ! 841: ! 842: /* There must be a reply port. */ ! 843: if (! IP_VALID (reply_port)) ! 844: return MIG_NO_REPLY; ! 845: if (dev == DEVICE_NULL) ! 846: return D_NO_SUCH_DEVICE; ! 847: if (!(dev->mode & D_READ)) ! 848: INVALOP; ! 849: ! 850: err = (dev->ops->read ? (*dev->ops->read) (dev, reply_port, ! 851: reply_port_type, mode, recnum, ! 852: count, data, bytes_read) ! 853: : D_INVALID_OPERATION); ! 854: ! 855: /* The ops->read function can return D_INVALID_OPERATION to tell us that ! 856: it doesn't want to deal with making a copy object for this read. We ! 857: fall back to the generic code below using the inband read function. */ ! 858: if (err != D_INVALID_OPERATION) ! 859: return err; ! 860: ! 861: if (! dev->ops->read_inband) ! 862: INVALOP; ! 863: else ! 864: { ! 865: vm_offset_t addr; ! 866: vm_size_t size; ! 867: kern_return_t kr; ! 868: ! 869: size = round_page (count); ! 870: kr = kmem_alloc (kernel_map, &addr, size); ! 871: if (kr != KERN_SUCCESS) ! 872: return kr; ! 873: kr = (*dev->ops->read_inband) (dev, reply_port, ! 874: reply_port_type, mode, recnum, ! 875: count, (char *) addr, bytes_read); ! 876: if (kr == D_SUCCESS) ! 877: { ! 878: vm_size_t result_size = round_page (*bytes_read); ! 879: ! 880: /* Free any excess pages we allocated beyond what was used. */ ! 881: size -= result_size; ! 882: if (size > 0) ! 883: vm_deallocate (kernel_map, addr + result_size, size); ! 884: ! 885: /* Zero memory that the device did not fill. */ ! 886: memset ((char *) addr + *bytes_read, 0, ! 887: result_size - *bytes_read); ! 888: ! 889: kr = vm_map_copyin_page_list (kernel_map, addr, result_size, ! 890: TRUE, TRUE, (vm_map_copy_t *) data, ! 891: FALSE); ! 892: if (kr != KERN_SUCCESS) ! 893: panic ("vm_map_copyin_page_list failed"); ! 894: } ! 895: else ! 896: { ! 897: /* Deallocate the pages since the read failed completely. */ ! 898: vm_deallocate (kernel_map, addr, size); ! 899: } ! 900: return kr; ! 901: } ! 902: } ! 903: ! 904: io_return_t ! 905: ds_device_read_inband (device_t dev, ipc_port_t reply_port, ! 906: mach_msg_type_name_t reply_port_type, dev_mode_t mode, ! 907: recnum_t recnum, int count, char *data, ! 908: unsigned *bytes_read) ! 909: { ! 910: /* There must be a reply port. */ ! 911: if (! IP_VALID (reply_port)) ! 912: return MIG_NO_REPLY; ! 913: if (dev == DEVICE_NULL) ! 914: return D_NO_SUCH_DEVICE; ! 915: if (!(dev->mode & D_READ)) ! 916: INVALOP; ! 917: if (count > IO_INBAND_MAX) ! 918: count = IO_INBAND_MAX; ! 919: ! 920: if (dev->ops->read_inband) ! 921: return (*dev->ops->read_inband) (dev, reply_port, ! 922: reply_port_type, mode, recnum, ! 923: count, data, bytes_read); ! 924: if (dev->ops->read) ! 925: { ! 926: vm_map_copy_t copy; ! 927: io_return_t err = (*dev->ops->read) (dev, reply_port, ! 928: reply_port_type, mode, recnum, ! 929: count, ! 930: (io_buf_ptr_t *) ©, ! 931: bytes_read); ! 932: if (!err) ! 933: { ! 934: vm_offset_t addr; ! 935: err = vm_map_copyout (kernel_map, &addr, copy); ! 936: assert (!err); ! 937: memcpy (data, (char *) addr, *bytes_read); ! 938: vm_deallocate (kernel_map, addr, round_page (*bytes_read)); ! 939: } ! 940: return err; ! 941: } ! 942: ! 943: INVALOP; ! 944: } ! 945: ! 946: io_return_t ! 947: ds_device_set_status (device_t dev, dev_flavor_t flavor, ! 948: dev_status_t status, mach_msg_type_number_t status_count) ! 949: { ! 950: if (dev == DEVICE_NULL) ! 951: return D_NO_SUCH_DEVICE; ! 952: if (! dev->ops->set_status) ! 953: INVALOP; ! 954: ! 955: return (*dev->ops->set_status) (dev, flavor, status, ! 956: status_count); ! 957: } ! 958: ! 959: io_return_t ! 960: ds_device_get_status (device_t dev, dev_flavor_t flavor, dev_status_t status, ! 961: mach_msg_type_number_t *status_count) ! 962: { ! 963: if (dev == DEVICE_NULL) ! 964: return D_NO_SUCH_DEVICE; ! 965: if (! dev->ops->get_status) ! 966: INVALOP; ! 967: ! 968: return (*dev->ops->get_status) (dev, flavor, status, ! 969: status_count); ! 970: } ! 971: ! 972: io_return_t ! 973: ds_device_set_filter (device_t dev, ipc_port_t receive_port, int priority, ! 974: filter_t *filter, unsigned filter_count) ! 975: { ! 976: if (dev == DEVICE_NULL) ! 977: return D_NO_SUCH_DEVICE; ! 978: if (! dev->ops->set_filter) ! 979: INVALOP; ! 980: return (*dev->ops->set_filter) (dev, receive_port, ! 981: priority, filter, filter_count); ! 982: } ! 983: ! 984: io_return_t ! 985: ds_device_map (device_t dev, vm_prot_t prot, vm_offset_t offset, ! 986: vm_size_t size, ipc_port_t *pager, boolean_t unmap) ! 987: { ! 988: kern_return_t kr; ! 989: ! 990: if (dev == DEVICE_NULL) ! 991: return D_NO_SUCH_DEVICE; ! 992: if (! dev->ops->map) ! 993: INVALOP; ! 994: ! 995: if (dev->mode != (D_READ | ((prot & VM_PROT_WRITE) ? D_WRITE : 0))) ! 996: INVALOP; ! 997: ! 998: /* This call serves only to verify that this offset and size are valid. ! 999: It does not do any mapping! All the real work with the VM system ! 1000: is done by the device pager code (found in device/dev_pager.c). */ ! 1001: kr = (*dev->ops->map) (dev, prot, offset, size, 0); ! 1002: if (!kr) ! 1003: kr = device_pager_setup (dev, prot, offset, size, pager); ! 1004: return kr; ! 1005: } ! 1006: ! 1007: ! 1008: io_return_t ! 1009: ds_device_write_trap (device_t dev, dev_mode_t mode, ! 1010: recnum_t recnum, vm_offset_t data, vm_size_t count) ! 1011: { ! 1012: if (dev == DEVICE_NULL) ! 1013: return D_NO_SUCH_DEVICE; ! 1014: if (!(dev->mode & D_WRITE)) ! 1015: return D_INVALID_OPERATION; ! 1016: if (! dev->ops->write_trap) ! 1017: return D_INVALID_OPERATION; ! 1018: return (*dev->ops->write_trap) (dev, mode, recnum, data, count); ! 1019: } ! 1020: ! 1021: io_return_t ! 1022: ds_device_writev_trap (device_t dev, dev_mode_t mode, ! 1023: recnum_t recnum, io_buf_vec_t *iovec, vm_size_t count) ! 1024: { ! 1025: if (dev == DEVICE_NULL) ! 1026: return D_NO_SUCH_DEVICE; ! 1027: if (!(dev->mode & D_WRITE)) ! 1028: return D_INVALID_OPERATION; ! 1029: if (! dev->ops->writev_trap) ! 1030: return D_INVALID_OPERATION; ! 1031: return (*dev->ops->writev_trap) (dev, mode, recnum, iovec, count); ! 1032: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.