![[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] / Gnu-Mach / device|
Return to ds_routines.c CVS log | Up to [GnuMach] / Gnu-Mach / device |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1993,1991,1990,1989 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: * Author: David B. Golub, Carnegie Mellon University
28: * Date: 3/89
29: */
30:
31: #include <norma_device.h>
32:
33: #include <mach/boolean.h>
34: #include <mach/kern_return.h>
35: #include <mach/mig_errors.h>
36: #include <mach/port.h>
37: #include <mach/vm_param.h>
38: #include <mach/notify.h>
39: #include <machine/machspl.h> /* spl definitions */
40:
41: #include <ipc/ipc_port.h>
42: #include <ipc/ipc_space.h>
43:
44: #include <kern/ast.h>
45: #include <kern/counters.h>
46: #include <kern/queue.h>
47: #include <kern/zalloc.h>
48: #include <kern/thread.h>
49: #include <kern/task.h>
50: #include <kern/sched_prim.h>
51:
52: #include <vm/memory_object.h>
53: #include <vm/vm_map.h>
54: #include <vm/vm_kern.h>
55:
56: #include <device/device_types.h>
57: #include <device/dev_hdr.h>
58: #include <device/conf.h>
59: #include <device/io_req.h>
60: #include <device/ds_routines.h>
61: #include <device/net_status.h>
62: #include <device/device_port.h>
63: #include "device_reply.h"
64:
65: #include <machine/machspl.h>
66:
67: #ifdef i386
68: #include <i386at/device_emul.h>
69: #include <i386/device-drivers.h>
70: #endif
71:
72: #ifdef i386
73: ipc_port_t
74: mach_convert_device_to_port (void *d)
75: {
76: ipc_port_t port;
77: mach_device_t device = d;
78:
79: if (! device)
80: return IP_NULL;
81: device_lock(device);
82: if (device->state == DEV_STATE_OPEN)
83: port = ipc_port_make_send(device->port);
84: else
85: port = IP_NULL;
86: device_unlock(device);
87: mach_device_deallocate(device);
88: return port;
89: }
90: #endif /* i386 */
91:
92: #ifdef i386
93: static io_return_t
94: device_open(reply_port, reply_port_type, mode, name, device_p)
95: #else
96: io_return_t
97: ds_device_open(open_port, reply_port, reply_port_type,
98: mode, name, device_p)
99: ipc_port_t open_port;
100: #endif
101: ipc_port_t reply_port;
102: mach_msg_type_name_t reply_port_type;
103: dev_mode_t mode;
104: char * name;
105: device_t *device_p; /* out */
106: {
107: register mach_device_t device;
108: register kern_return_t result;
109: register io_req_t ior;
110: char namebuf[64];
111: ipc_port_t notify;
112:
113: #ifndef i386
114: /*
115: * Open must be called on the master device port.
116: */
117: if (open_port != master_device_port)
118: return (D_INVALID_OPERATION);
119:
120: /*
121: * There must be a reply port.
122: */
123: if (!IP_VALID(reply_port)) {
124: printf("ds_* invalid reply port\n");
125: Debugger("ds_* reply_port");
126: return (MIG_NO_REPLY); /* no sense in doing anything */
127: }
128:
129: #if NORMA_DEVICE
130: /*
131: * Map global device name to <node> + local device name.
132: */
133: if (name[0] != '<') {
134: extern char *dev_forward_name();
135:
136: name = dev_forward_name(name, namebuf, sizeof(namebuf));
137: }
138: /*
139: * Look for explicit node specifier, e.g., <2>sd0a.
140: * If found, then forward request to correct device server.
141: * If not found, then remove '<n>' and process locally.
142: *
143: * XXX should handle send-right reply_port as well as send-once XXX
144: */
145: if (name[0] == '<') {
146: char *n;
147: int node = 0;
148:
149: for (n = &name[1]; *n != '>'; n++) {
150: if (*n >= '0' && *n <= '9') {
151: node = 10 * node + (*n - '0');
152: } else {
153: return (D_NO_SUCH_DEVICE);
154: }
155: }
156: if (node == node_self()) {
157: name = &n[1]; /* skip trailing '>' */
158: } else {
159: forward_device_open_send(remote_device(node),
160: reply_port, mode, name);
161: return (MIG_NO_REPLY);
162: }
163: }
164: #endif NORMA_DEVICE
165: #endif /* ! i386 */
166:
167: /*
168: * Find the device.
169: */
170: device = device_lookup(name);
171: if (device == MACH_DEVICE_NULL)
172: return (D_NO_SUCH_DEVICE);
173:
174: /*
175: * If the device is being opened or closed,
176: * wait for that operation to finish.
177: */
178: device_lock(device);
179: while (device->state == DEV_STATE_OPENING ||
180: device->state == DEV_STATE_CLOSING) {
181: device->io_wait = TRUE;
182: thread_sleep((event_t)device, simple_lock_addr(device->lock), TRUE);
183: device_lock(device);
184: }
185:
186: /*
187: * If the device is already open, increment the open count
188: * and return.
189: */
190: if (device->state == DEV_STATE_OPEN) {
191:
192: if (device->flag & D_EXCL_OPEN) {
193: /*
194: * Cannot open a second time.
195: */
196: device_unlock(device);
197: mach_device_deallocate(device);
198: return (D_ALREADY_OPEN);
199: }
200:
201: device->open_count++;
202: device_unlock(device);
203: #ifdef i386
204: *device_p = &device->dev;
205: #else
206: *device_p = device;
207: #endif
208: return (D_SUCCESS);
209: /*
210: * Return deallocates device reference while acquiring
211: * port.
212: */
213: }
214:
215: /*
216: * Allocate the device port and register the device before
217: * opening it.
218: */
219: device->state = DEV_STATE_OPENING;
220: device_unlock(device);
221:
222: /*
223: * Allocate port, keeping a reference for it.
224: */
225: device->port = ipc_port_alloc_kernel();
226: if (device->port == IP_NULL) {
227: device_lock(device);
228: device->state = DEV_STATE_INIT;
229: device->port = IP_NULL;
230: if (device->io_wait) {
231: device->io_wait = FALSE;
232: thread_wakeup((event_t)device);
233: }
234: device_unlock(device);
235: mach_device_deallocate(device);
236: return (KERN_RESOURCE_SHORTAGE);
237: }
238:
239: dev_port_enter(device);
240:
241: /*
242: * Request no-senders notifications on device port.
243: */
244: notify = ipc_port_make_sonce(device->port);
245: ip_lock(device->port);
246: ipc_port_nsrequest(device->port, 1, notify, ¬ify);
247: assert(notify == IP_NULL);
248:
249: /*
250: * Open the device.
251: */
252: io_req_alloc(ior, 0);
253:
254: ior->io_device = device;
255: ior->io_unit = device->dev_number;
256: ior->io_op = IO_OPEN | IO_CALL;
257: ior->io_mode = mode;
258: ior->io_error = 0;
259: ior->io_done = ds_open_done;
260: ior->io_reply_port = reply_port;
261: ior->io_reply_port_type = reply_port_type;
262:
263: result = (*device->dev_ops->d_open)(device->dev_number, (int)mode, ior);
264: if (result == D_IO_QUEUED)
265: return (MIG_NO_REPLY);
266:
267: /*
268: * Return result via ds_open_done.
269: */
270: ior->io_error = result;
271: (void) ds_open_done(ior);
272:
273: io_req_free(ior);
274:
275: return (MIG_NO_REPLY); /* reply already sent */
276: }
277:
278: boolean_t
279: ds_open_done(ior)
280: register io_req_t ior;
281: {
282: kern_return_t result;
283: register mach_device_t device;
284:
285: device = ior->io_device;
286: result = ior->io_error;
287:
288: if (result != D_SUCCESS) {
289: /*
290: * Open failed. Deallocate port and device.
291: */
292: dev_port_remove(device);
293: ipc_port_dealloc_kernel(device->port);
294: device->port = IP_NULL;
295:
296: device_lock(device);
297: device->state = DEV_STATE_INIT;
298: if (device->io_wait) {
299: device->io_wait = FALSE;
300: thread_wakeup((event_t)device);
301: }
302: device_unlock(device);
303:
304: mach_device_deallocate(device);
305: device = MACH_DEVICE_NULL;
306: }
307: else {
308: /*
309: * Open succeeded.
310: */
311: device_lock(device);
312: device->state = DEV_STATE_OPEN;
313: device->open_count = 1;
314: if (device->io_wait) {
315: device->io_wait = FALSE;
316: thread_wakeup((event_t)device);
317: }
318: device_unlock(device);
319:
320: /* donate device reference to get port */
321: }
322: /*
323: * Must explicitly convert device to port, since
324: * device_reply interface is built as 'user' side
325: * (thus cannot get translation).
326: */
327: if (IP_VALID(ior->io_reply_port)) {
328: (void) ds_device_open_reply(ior->io_reply_port,
329: ior->io_reply_port_type,
330: result,
331: #ifdef i386
332: (mach_convert_device_to_port
333: (device)));
334: #else
335: convert_device_to_port(device));
336: #endif
337: } else
338: mach_device_deallocate(device);
339:
340: return (TRUE);
341: }
342:
343: #ifdef i386
344: static io_return_t
345: device_close(device)
346: #else
347: io_return_t
348: ds_device_close(device)
349: #endif
350: register mach_device_t device;
351: {
352: #ifndef i386
353: if (device == DEVICE_NULL)
354: return (D_NO_SUCH_DEVICE);
355: #endif
356:
357: device_lock(device);
358:
359: /*
360: * If device will remain open, do nothing.
361: */
362: if (--device->open_count > 0) {
363: device_unlock(device);
364: return (D_SUCCESS);
365: }
366:
367: /*
368: * If device is being closed, do nothing.
369: */
370: if (device->state == DEV_STATE_CLOSING) {
371: device_unlock(device);
372: return (D_SUCCESS);
373: }
374:
375: /*
376: * Mark device as closing, to prevent new IO.
377: * Outstanding IO will still be in progress.
378: */
379: device->state = DEV_STATE_CLOSING;
380: device_unlock(device);
381:
382: /*
383: * ? wait for IO to end ?
384: * only if device wants to
385: */
386:
387: /*
388: * Remove the device-port association.
389: */
390: dev_port_remove(device);
391: ipc_port_dealloc_kernel(device->port);
392:
393: /*
394: * Close the device
395: */
396: (*device->dev_ops->d_close)(device->dev_number);
397:
398: /*
399: * Finally mark it closed. If someone else is trying
400: * to open it, the open can now proceed.
401: */
402: device_lock(device);
403: device->state = DEV_STATE_INIT;
404: if (device->io_wait) {
405: device->io_wait = FALSE;
406: thread_wakeup((event_t)device);
407: }
408: device_unlock(device);
409:
410: return (D_SUCCESS);
411: }
412:
413: /*
414: * Write to a device.
415: */
416: #ifdef i386
417: static io_return_t
418: device_write(d, reply_port, reply_port_type, mode, recnum,
419: data, data_count, bytes_written)
420: void *d;
421: #else
422: io_return_t
423: ds_device_write(device, reply_port, reply_port_type, mode, recnum,
424: data, data_count, bytes_written)
425: register mach_device_t device;
426: #endif
427: ipc_port_t reply_port;
428: mach_msg_type_name_t reply_port_type;
429: dev_mode_t mode;
430: recnum_t recnum;
431: io_buf_ptr_t data;
432: unsigned int data_count;
433: int *bytes_written; /* out */
434: {
435: #ifdef i386
436: register mach_device_t device = d;
437: #endif
438: register io_req_t ior;
439: register io_return_t result;
440:
441: #ifndef i386
442: /*
443: * Refuse if device is dead or not completely open.
444: */
445: if (device == DEVICE_NULL)
446: return (D_NO_SUCH_DEVICE);
447: #endif
448:
449: if (device->state != DEV_STATE_OPEN)
450: return (D_NO_SUCH_DEVICE);
451:
452: #ifndef i386
453: if (data == 0)
454: return (D_INVALID_SIZE);
455: #endif
456:
457: /*
458: * XXX Need logic to reject ridiculously big requests.
459: */
460:
461: /* XXX note that a CLOSE may proceed at any point */
462:
463: /*
464: * Package the write request for the device driver
465: */
466: io_req_alloc(ior, data_count);
467:
468: ior->io_device = device;
469: ior->io_unit = device->dev_number;
470: ior->io_op = IO_WRITE | IO_CALL;
471: ior->io_mode = mode;
472: ior->io_recnum = recnum;
473: ior->io_data = data;
474: ior->io_count = data_count;
475: ior->io_total = data_count;
476: ior->io_alloc_size = 0;
477: ior->io_residual = 0;
478: ior->io_error = 0;
479: ior->io_done = ds_write_done;
480: ior->io_reply_port = reply_port;
481: ior->io_reply_port_type = reply_port_type;
482: ior->io_copy = VM_MAP_COPY_NULL;
483:
484: /*
485: * The ior keeps an extra reference for the device.
486: */
487: mach_device_reference(device);
488:
489: /*
490: * And do the write ...
491: *
492: * device_write_dealoc returns false if there's more
493: * to do; it has updated the ior appropriately and expects
494: * its caller to reinvoke it on the device.
495: */
496:
497: do {
498:
499: result = (*device->dev_ops->d_write)(device->dev_number, ior);
500:
501: /*
502: * If the IO was queued, delay reply until it is finished.
503: */
504: if (result == D_IO_QUEUED)
505: return (MIG_NO_REPLY);
506:
507: /*
508: * Discard the local mapping of the data.
509: */
510:
511: } while (!device_write_dealloc(ior));
512:
513: /*
514: * Return the number of bytes actually written.
515: */
516: *bytes_written = ior->io_total - ior->io_residual;
517:
518: /*
519: * Remove the extra reference.
520: */
521: mach_device_deallocate(device);
522:
523: io_req_free(ior);
524: return (result);
525: }
526:
527: /*
528: * Write to a device, but memory is in message.
529: */
530: #ifdef i386
531: static io_return_t
532: device_write_inband(d, reply_port, reply_port_type, mode, recnum,
533: data, data_count, bytes_written)
534: void *d;
535: #else
536: io_return_t
537: ds_device_write_inband(device, reply_port, reply_port_type, mode, recnum,
538: data, data_count, bytes_written)
539: register mach_device_t device;
540: #endif
541: ipc_port_t reply_port;
542: mach_msg_type_name_t reply_port_type;
543: dev_mode_t mode;
544: recnum_t recnum;
545: io_buf_ptr_inband_t data;
546: unsigned int data_count;
547: int *bytes_written; /* out */
548: {
549: #ifdef i386
550: register mach_device_t device = d;
551: #endif
552: register io_req_t ior;
553: register io_return_t result;
554:
555: #ifndef i386
556: /*
557: * Refuse if device is dead or not completely open.
558: */
559: if (device == DEVICE_NULL)
560: return (D_NO_SUCH_DEVICE);
561: #endif
562:
563: if (device->state != DEV_STATE_OPEN)
564: return (D_NO_SUCH_DEVICE);
565:
566: #ifndef i386
567: if (data == 0)
568: return (D_INVALID_SIZE);
569: #endif
570:
571: /* XXX note that a CLOSE may proceed at any point */
572:
573: /*
574: * Package the write request for the device driver.
575: */
576: io_req_alloc(ior, 0);
577:
578: ior->io_device = device;
579: ior->io_unit = device->dev_number;
580: ior->io_op = IO_WRITE | IO_CALL | IO_INBAND;
581: ior->io_mode = mode;
582: ior->io_recnum = recnum;
583: ior->io_data = data;
584: ior->io_count = data_count;
585: ior->io_total = data_count;
586: ior->io_alloc_size = 0;
587: ior->io_residual = 0;
588: ior->io_error = 0;
589: ior->io_done = ds_write_done;
590: ior->io_reply_port = reply_port;
591: ior->io_reply_port_type = reply_port_type;
592:
593: /*
594: * The ior keeps an extra reference for the device.
595: */
596: mach_device_reference(device);
597:
598: /*
599: * And do the write.
600: */
601: result = (*device->dev_ops->d_write)(device->dev_number, ior);
602:
603: /*
604: * If the IO was queued, delay reply until it is finished.
605: */
606: if (result == D_IO_QUEUED)
607: return (MIG_NO_REPLY);
608:
609: /*
610: * Return the number of bytes actually written.
611: */
612: *bytes_written = ior->io_total - ior->io_residual;
613:
614: /*
615: * Remove the extra reference.
616: */
617: mach_device_deallocate(device);
618:
619: io_req_free(ior);
620: return (result);
621: }
622:
623: /*
624: * Wire down incoming memory to give to device.
625: */
626: kern_return_t
627: device_write_get(ior, wait)
628: register io_req_t ior;
629: boolean_t *wait;
630: {
631: vm_map_copy_t io_copy;
632: vm_offset_t new_addr;
633: register kern_return_t result;
634: int bsize;
635: vm_size_t min_size;
636:
637: /*
638: * By default, caller does not have to wait.
639: */
640: *wait = FALSE;
641:
642: /*
643: * Nothing to do if no data.
644: */
645: if (ior->io_count == 0)
646: return (KERN_SUCCESS);
647:
648: /*
649: * Loaned iors already have valid data.
650: */
651: if (ior->io_op & IO_LOANED)
652: return (KERN_SUCCESS);
653:
654: /*
655: * Inband case.
656: */
657: if (ior->io_op & IO_INBAND) {
658: assert(ior->io_count <= sizeof (io_buf_ptr_inband_t));
659: new_addr = zalloc(io_inband_zone);
660: bcopy((void*)ior->io_data, (void*)new_addr, ior->io_count);
661: ior->io_data = (io_buf_ptr_t)new_addr;
662: ior->io_alloc_size = sizeof (io_buf_ptr_inband_t);
663:
664: return (KERN_SUCCESS);
665: }
666:
667: /*
668: * Figure out how much data to move this time. If the device
669: * won't return a block size, then we have to do the whole
670: * request in one shot (ditto if this is a block fragment),
671: * otherwise, move at least one block's worth.
672: */
673: result = (*ior->io_device->dev_ops->d_dev_info)(
674: ior->io_device->dev_number,
675: D_INFO_BLOCK_SIZE,
676: &bsize);
677:
678: if (result != KERN_SUCCESS || ior->io_count < (vm_size_t) bsize)
679: min_size = (vm_size_t) ior->io_count;
680: else
681: min_size = (vm_size_t) bsize;
682:
683: /*
684: * Map the pages from this page list into memory.
685: * io_data records location of data.
686: * io_alloc_size is the vm size of the region to deallocate.
687: */
688: io_copy = (vm_map_copy_t) ior->io_data;
689: result = kmem_io_map_copyout(device_io_map,
690: (vm_offset_t*)&ior->io_data, &new_addr,
691: &ior->io_alloc_size, io_copy, min_size);
692: if (result != KERN_SUCCESS)
693: return (result);
694:
695: if ((ior->io_data + ior->io_count) >
696: (((char *)new_addr) + ior->io_alloc_size)) {
697:
698: /*
699: * Operation has to be split. Reset io_count for how
700: * much we can do this time.
701: */
702: assert(vm_map_copy_has_cont(io_copy));
703: assert(ior->io_count == io_copy->size);
704: ior->io_count = ior->io_alloc_size -
705: (ior->io_data - ((char *)new_addr));
706:
707: /*
708: * Caller must wait synchronously.
709: */
710: ior->io_op &= ~IO_CALL;
711: *wait = TRUE;
712: }
713:
714: ior->io_copy = io_copy; /* vm_map_copy to discard */
715: return (KERN_SUCCESS);
716: }
717:
718: /*
719: * Clean up memory allocated for IO.
720: */
721: boolean_t
722: device_write_dealloc(ior)
723: register io_req_t ior;
724: {
725: vm_map_copy_t new_copy = VM_MAP_COPY_NULL;
726: register
727: vm_map_copy_t io_copy;
728: kern_return_t result;
729: vm_offset_t size_to_do;
730: int bsize;
731:
732: if (ior->io_alloc_size == 0)
733: return (TRUE);
734:
735: /*
736: * Inband case.
737: */
738: if (ior->io_op & IO_INBAND) {
739: zfree(io_inband_zone, (vm_offset_t)ior->io_data);
740:
741: return (TRUE);
742: }
743:
744: if ((io_copy = ior->io_copy) == VM_MAP_COPY_NULL)
745: return (TRUE);
746:
747: /*
748: * To prevent a possible deadlock with the default pager,
749: * we have to release space in the device_io_map before
750: * we allocate any memory. (Which vm_map_copy_invoke_cont
751: * might do.) See the discussion in ds_init.
752: */
753:
754: kmem_io_map_deallocate(device_io_map,
755: trunc_page(ior->io_data),
756: (vm_size_t) ior->io_alloc_size);
757:
758: if (vm_map_copy_has_cont(io_copy)) {
759:
760: /*
761: * Remember how much is left, then
762: * invoke or abort the continuation.
763: */
764: size_to_do = io_copy->size - ior->io_count;
765: if (ior->io_error == 0) {
766: vm_map_copy_invoke_cont(io_copy, &new_copy, &result);
767: }
768: else {
769: vm_map_copy_abort_cont(io_copy);
770: result = KERN_FAILURE;
771: }
772:
773: if (result == KERN_SUCCESS && new_copy != VM_MAP_COPY_NULL) {
774: register int res;
775:
776: /*
777: * We have a new continuation, reset the ior to
778: * represent the remainder of the request. Must
779: * adjust the recnum because drivers assume
780: * that the residual is zero.
781: */
782: ior->io_op &= ~IO_DONE;
783: ior->io_op |= IO_CALL;
784:
785: res = (*ior->io_device->dev_ops->d_dev_info)(
786: ior->io_device->dev_number,
787: D_INFO_BLOCK_SIZE,
788: &bsize);
789:
790: if (res != D_SUCCESS)
791: panic("device_write_dealloc: No block size");
792:
793: ior->io_recnum += ior->io_count/bsize;
794: ior->io_count = new_copy->size;
795: }
796: else {
797:
798: /*
799: * No continuation. Add amount we didn't get
800: * to into residual.
801: */
802: ior->io_residual += size_to_do;
803: }
804: }
805:
806: /*
807: * Clean up the state for the IO that just completed.
808: */
809: vm_map_copy_discard(ior->io_copy);
810: ior->io_copy = VM_MAP_COPY_NULL;
811: ior->io_data = (char *) new_copy;
812:
813: /*
814: * Return FALSE if there's more IO to do.
815: */
816:
817: return(new_copy == VM_MAP_COPY_NULL);
818: }
819:
820: /*
821: * Send write completion message to client, and discard the data.
822: */
823: boolean_t
824: ds_write_done(ior)
825: register io_req_t ior;
826: {
827: /*
828: * device_write_dealloc discards the data that has been
829: * written, but may decide that there is more to write.
830: */
831: while (!device_write_dealloc(ior)) {
832: register io_return_t result;
833: register mach_device_t device;
834:
835: /*
836: * More IO to do -- invoke it.
837: */
838: device = ior->io_device;
839: result = (*device->dev_ops->d_write)(device->dev_number, ior);
840:
841: /*
842: * If the IO was queued, return FALSE -- not done yet.
843: */
844: if (result == D_IO_QUEUED)
845: return (FALSE);
846: }
847:
848: /*
849: * Now the write is really complete. Send reply.
850: */
851:
852: if (IP_VALID(ior->io_reply_port)) {
853: (void) (*((ior->io_op & IO_INBAND) ?
854: ds_device_write_reply_inband :
855: ds_device_write_reply))(ior->io_reply_port,
856: ior->io_reply_port_type,
857: ior->io_error,
858: (int) (ior->io_total -
859: ior->io_residual));
860: }
861: mach_device_deallocate(ior->io_device);
862:
863: return (TRUE);
864: }
865:
866: /*
867: * Read from a device.
868: */
869: #ifdef i386
870: static io_return_t
871: device_read(d, reply_port, reply_port_type, mode, recnum,
872: bytes_wanted, data, data_count)
873: void *d;
874: #else
875: io_return_t
876: ds_device_read(device, reply_port, reply_port_type, mode, recnum,
877: bytes_wanted, data, data_count)
878: register mach_device_t device;
879: #endif
880: ipc_port_t reply_port;
881: mach_msg_type_name_t reply_port_type;
882: dev_mode_t mode;
883: recnum_t recnum;
884: int bytes_wanted;
885: io_buf_ptr_t *data; /* out */
886: unsigned int *data_count; /* out */
887: {
888: #ifdef i386
889: register mach_device_t device = d;
890: #endif
891: register io_req_t ior;
892: register io_return_t result;
893:
894: #ifdef lint
895: *data = *data;
896: *data_count = *data_count;
897: #endif lint
898:
899: #ifndef i386
900: /*
901: * Refuse if device is dead or not completely open.
902: */
903: if (device == DEVICE_NULL)
904: return (D_NO_SUCH_DEVICE);
905: #endif
906:
907: if (device->state != DEV_STATE_OPEN)
908: return (D_NO_SUCH_DEVICE);
909:
910: /* XXX note that a CLOSE may proceed at any point */
911:
912: /*
913: * There must be a reply port.
914: */
915: if (!IP_VALID(reply_port)) {
916: printf("ds_* invalid reply port\n");
917: Debugger("ds_* reply_port");
918: return (MIG_NO_REPLY); /* no sense in doing anything */
919: }
920:
921: /*
922: * Package the read request for the device driver
923: */
924: io_req_alloc(ior, 0);
925:
926: ior->io_device = device;
927: ior->io_unit = device->dev_number;
928: ior->io_op = IO_READ | IO_CALL;
929: ior->io_mode = mode;
930: ior->io_recnum = recnum;
931: ior->io_data = 0; /* driver must allocate data */
932: ior->io_count = bytes_wanted;
933: ior->io_alloc_size = 0; /* no data allocated yet */
934: ior->io_residual = 0;
935: ior->io_error = 0;
936: ior->io_done = ds_read_done;
937: ior->io_reply_port = reply_port;
938: ior->io_reply_port_type = reply_port_type;
939:
940: /*
941: * The ior keeps an extra reference for the device.
942: */
943: mach_device_reference(device);
944:
945: /*
946: * And do the read.
947: */
948: result = (*device->dev_ops->d_read)(device->dev_number, ior);
949:
950: /*
951: * If the IO was queued, delay reply until it is finished.
952: */
953: if (result == D_IO_QUEUED)
954: return (MIG_NO_REPLY);
955:
956: /*
957: * Return result via ds_read_done.
958: */
959: ior->io_error = result;
960: (void) ds_read_done(ior);
961: io_req_free(ior);
962:
963: return (MIG_NO_REPLY); /* reply has already been sent. */
964: }
965:
966: /*
967: * Read from a device, but return the data 'inband.'
968: */
969: #ifdef i386
970: static io_return_t
971: device_read_inband(d, reply_port, reply_port_type, mode, recnum,
972: bytes_wanted, data, data_count)
973: void *d;
974: #else
975: io_return_t
976: ds_device_read_inband(device, reply_port, reply_port_type, mode, recnum,
977: bytes_wanted, data, data_count)
978: register mach_device_t device;
979: #endif
980: ipc_port_t reply_port;
981: mach_msg_type_name_t reply_port_type;
982: dev_mode_t mode;
983: recnum_t recnum;
984: int bytes_wanted;
985: char *data; /* pointer to OUT array */
986: unsigned int *data_count; /* out */
987: {
988: #ifdef i386
989: register mach_device_t device = d;
990: #endif
991: register io_req_t ior;
992: register io_return_t result;
993:
994: #ifdef lint
995: *data = *data;
996: *data_count = *data_count;
997: #endif lint
998:
999: #ifndef i386
1000: /*
1001: * Refuse if device is dead or not completely open.
1002: */
1003: if (device == DEVICE_NULL)
1004: return (D_NO_SUCH_DEVICE);
1005: #endif
1006:
1007: if (device->state != DEV_STATE_OPEN)
1008: return (D_NO_SUCH_DEVICE);
1009:
1010: /* XXX note that a CLOSE may proceed at any point */
1011:
1012: /*
1013: * There must be a reply port.
1014: */
1015: if (!IP_VALID(reply_port)) {
1016: printf("ds_* invalid reply port\n");
1017: Debugger("ds_* reply_port");
1018: return (MIG_NO_REPLY); /* no sense in doing anything */
1019: }
1020:
1021: /*
1022: * Package the read for the device driver
1023: */
1024: io_req_alloc(ior, 0);
1025:
1026: ior->io_device = device;
1027: ior->io_unit = device->dev_number;
1028: ior->io_op = IO_READ | IO_CALL | IO_INBAND;
1029: ior->io_mode = mode;
1030: ior->io_recnum = recnum;
1031: ior->io_data = 0; /* driver must allocate data */
1032: ior->io_count =
1033: ((bytes_wanted < sizeof(io_buf_ptr_inband_t)) ?
1034: bytes_wanted : sizeof(io_buf_ptr_inband_t));
1035: ior->io_alloc_size = 0; /* no data allocated yet */
1036: ior->io_residual = 0;
1037: ior->io_error = 0;
1038: ior->io_done = ds_read_done;
1039: ior->io_reply_port = reply_port;
1040: ior->io_reply_port_type = reply_port_type;
1041:
1042: /*
1043: * The ior keeps an extra reference for the device.
1044: */
1045: mach_device_reference(device);
1046:
1047: /*
1048: * Do the read.
1049: */
1050: result = (*device->dev_ops->d_read)(device->dev_number, ior);
1051:
1052: /*
1053: * If the io was queued, delay reply until it is finished.
1054: */
1055: if (result == D_IO_QUEUED)
1056: return (MIG_NO_REPLY);
1057:
1058: /*
1059: * Return result, via ds_read_done.
1060: */
1061: ior->io_error = result;
1062: (void) ds_read_done(ior);
1063: io_req_free(ior);
1064:
1065: return (MIG_NO_REPLY); /* reply has already been sent. */
1066: }
1067:
1068:
1069: /*
1070: * Allocate wired-down memory for device read.
1071: */
1072: kern_return_t device_read_alloc(ior, size)
1073: register io_req_t ior;
1074: register vm_size_t size;
1075: {
1076: vm_offset_t addr;
1077: kern_return_t kr;
1078:
1079: /*
1080: * Nothing to do if no data.
1081: */
1082: if (ior->io_count == 0)
1083: return (KERN_SUCCESS);
1084:
1085: if (ior->io_op & IO_INBAND) {
1086: ior->io_data = (io_buf_ptr_t) zalloc(io_inband_zone);
1087: ior->io_alloc_size = sizeof(io_buf_ptr_inband_t);
1088: } else {
1089: size = round_page(size);
1090: kr = kmem_alloc(kernel_map, &addr, size);
1091: if (kr != KERN_SUCCESS)
1092: return (kr);
1093:
1094: ior->io_data = (io_buf_ptr_t) addr;
1095: ior->io_alloc_size = size;
1096: }
1097:
1098: return (KERN_SUCCESS);
1099: }
1100:
1101: boolean_t ds_read_done(ior)
1102: io_req_t ior;
1103: {
1104: vm_offset_t start_data, end_data;
1105: vm_offset_t start_sent, end_sent;
1106: register vm_size_t size_read;
1107:
1108: if (ior->io_error)
1109: size_read = 0;
1110: else
1111: size_read = ior->io_count - ior->io_residual;
1112:
1113: start_data = (vm_offset_t)ior->io_data;
1114: end_data = start_data + size_read;
1115:
1116: start_sent = (ior->io_op & IO_INBAND) ? start_data :
1117: trunc_page(start_data);
1118: end_sent = (ior->io_op & IO_INBAND) ?
1119: start_data + ior->io_alloc_size : round_page(end_data);
1120:
1121: /*
1122: * Zero memory that the device did not fill.
1123: */
1124: if (start_sent < start_data)
1125: bzero((char *)start_sent, start_data - start_sent);
1126: if (end_sent > end_data)
1127: bzero((char *)end_data, end_sent - end_data);
1128:
1129:
1130: /*
1131: * Touch the data being returned, to mark it dirty.
1132: * If the pages were filled by DMA, the pmap module
1133: * may think that they are clean.
1134: */
1135: {
1136: register vm_offset_t touch;
1137: register int c;
1138:
1139: for (touch = start_sent; touch < end_sent; touch += PAGE_SIZE) {
1140: c = *(char *)touch;
1141: *(char *)touch = c;
1142: }
1143: }
1144:
1145: /*
1146: * Send the data to the reply port - this
1147: * unwires and deallocates it.
1148: */
1149: if (ior->io_op & IO_INBAND) {
1150: (void)ds_device_read_reply_inband(ior->io_reply_port,
1151: ior->io_reply_port_type,
1152: ior->io_error,
1153: (char *) start_data,
1154: size_read);
1155: } else {
1156: vm_map_copy_t copy;
1157: kern_return_t kr;
1158:
1159: kr = vm_map_copyin_page_list(kernel_map, start_data,
1160: size_read, TRUE, TRUE,
1161: ©, FALSE);
1162:
1163: if (kr != KERN_SUCCESS)
1164: panic("read_done: vm_map_copyin_page_list failed");
1165:
1166: (void)ds_device_read_reply(ior->io_reply_port,
1167: ior->io_reply_port_type,
1168: ior->io_error,
1169: (char *) copy,
1170: size_read);
1171: }
1172:
1173: /*
1174: * Free any memory that was allocated but not sent.
1175: */
1176: if (ior->io_count != 0) {
1177: if (ior->io_op & IO_INBAND) {
1178: if (ior->io_alloc_size > 0)
1179: zfree(io_inband_zone, (vm_offset_t)ior->io_data);
1180: } else {
1181: register vm_offset_t end_alloc;
1182:
1183: end_alloc = start_sent + round_page(ior->io_alloc_size);
1184: if (end_alloc > end_sent)
1185: (void) vm_deallocate(kernel_map,
1186: end_sent,
1187: end_alloc - end_sent);
1188: }
1189: }
1190:
1191: mach_device_deallocate(ior->io_device);
1192:
1193: return (TRUE);
1194: }
1195:
1196: #ifdef i386
1197: static io_return_t
1198: device_set_status(d, flavor, status, status_count)
1199: void *d;
1200: #else
1201: io_return_t
1202: ds_device_set_status(device, flavor, status, status_count)
1203: register mach_device_t device;
1204: #endif
1205: dev_flavor_t flavor;
1206: dev_status_t status;
1207: mach_msg_type_number_t status_count;
1208: {
1209: #ifdef i386
1210: register mach_device_t device = d;
1211: #endif
1212:
1213: #ifndef i386
1214: /*
1215: * Refuse if device is dead or not completely open.
1216: */
1217: if (device == DEVICE_NULL)
1218: return (D_NO_SUCH_DEVICE);
1219: #endif
1220:
1221: if (device->state != DEV_STATE_OPEN)
1222: return (D_NO_SUCH_DEVICE);
1223:
1224: /* XXX note that a CLOSE may proceed at any point */
1225:
1226: return ((*device->dev_ops->d_setstat)(device->dev_number,
1227: flavor,
1228: status,
1229: status_count));
1230: }
1231:
1232: #ifdef i386
1233: io_return_t
1234: mach_device_get_status(d, flavor, status, status_count)
1235: void *d;
1236: #else
1237: io_return_t
1238: ds_device_get_status(device, flavor, status, status_count)
1239: register mach_device_t device;
1240: #endif
1241: dev_flavor_t flavor;
1242: dev_status_t status; /* pointer to OUT array */
1243: mach_msg_type_number_t *status_count; /* out */
1244: {
1245: #ifdef i386
1246: register mach_device_t device = d;
1247: #endif
1248:
1249: #ifndef i386
1250: /*
1251: * Refuse if device is dead or not completely open.
1252: */
1253: if (device == DEVICE_NULL)
1254: return (D_NO_SUCH_DEVICE);
1255: #endif
1256:
1257: if (device->state != DEV_STATE_OPEN)
1258: return (D_NO_SUCH_DEVICE);
1259:
1260: /* XXX note that a CLOSE may proceed at any point */
1261:
1262: return ((*device->dev_ops->d_getstat)(device->dev_number,
1263: flavor,
1264: status,
1265: status_count));
1266: }
1267:
1268: #ifdef i386
1269: static io_return_t
1270: device_set_filter(d, receive_port, priority, filter, filter_count)
1271: void *d;
1272: #else
1273: io_return_t
1274: ds_device_set_filter(device, receive_port, priority, filter, filter_count)
1275: register mach_device_t device;
1276: #endif
1277: ipc_port_t receive_port;
1278: int priority;
1279: filter_t filter[]; /* pointer to IN array */
1280: unsigned int filter_count;
1281: {
1282: #ifdef i386
1283: register mach_device_t device = d;
1284: #endif
1285:
1286: #ifndef i386
1287: /*
1288: * Refuse if device is dead or not completely open.
1289: */
1290: if (device == DEVICE_NULL)
1291: return (D_NO_SUCH_DEVICE);
1292: #endif
1293:
1294: if (device->state != DEV_STATE_OPEN)
1295: return (D_NO_SUCH_DEVICE);
1296:
1297: /* XXX note that a CLOSE may proceed at any point */
1298:
1299: /*
1300: * Request is absurd if no receive port is specified.
1301: */
1302: if (!IP_VALID(receive_port))
1303: return (D_INVALID_OPERATION);
1304:
1305: return ((*device->dev_ops->d_async_in)(device->dev_number,
1306: receive_port,
1307: priority,
1308: filter,
1309: filter_count));
1310: }
1311:
1312: #ifdef i386
1313: static io_return_t
1314: device_map(d, protection, offset, size, pager, unmap)
1315: void *d;
1316: #else
1317: io_return_t
1318: ds_device_map(device, protection, offset, size, pager, unmap)
1319: register mach_device_t device;
1320: #endif
1321: vm_prot_t protection;
1322: vm_offset_t offset;
1323: vm_size_t size;
1324: ipc_port_t *pager; /* out */
1325: boolean_t unmap; /* ? */
1326: {
1327: #ifdef i386
1328: register mach_device_t device = d;
1329: #endif
1330:
1331: #ifdef lint
1332: unmap = unmap;
1333: #endif lint
1334: if (protection & ~VM_PROT_ALL)
1335: return (KERN_INVALID_ARGUMENT);
1336:
1337: #ifndef i386
1338: /*
1339: * Refuse if device is dead or not completely open.
1340: */
1341: if (device == DEVICE_NULL)
1342: return (D_NO_SUCH_DEVICE);
1343: #endif
1344:
1345: if (device->state != DEV_STATE_OPEN)
1346: return (D_NO_SUCH_DEVICE);
1347:
1348: /* XXX note that a CLOSE may proceed at any point */
1349:
1350: return (device_pager_setup(device, protection, offset, size,
1351: (mach_port_t*)pager));
1352: }
1353:
1354: /*
1355: * Doesn't do anything (yet).
1356: */
1357: #ifdef i386
1358: static void
1359: #else
1360: void
1361: #endif
1362: ds_no_senders(notification)
1363: mach_no_senders_notification_t *notification;
1364: {
1365: printf("ds_no_senders called! device_port=0x%x count=%d\n",
1366: notification->not_header.msgh_remote_port,
1367: notification->not_count);
1368: }
1369:
1370: #ifndef i386
1371: boolean_t
1372: ds_notify(msg)
1373: mach_msg_header_t *msg;
1374: {
1375: switch (msg->msgh_id) {
1376: case MACH_NOTIFY_NO_SENDERS:
1377: ds_no_senders((mach_no_senders_notification_t *) msg);
1378: return TRUE;
1379:
1380: default:
1381: printf("ds_notify: strange notification %d\n", msg->msgh_id);
1382: return FALSE;
1383: }
1384: }
1385: #endif
1386:
1387: queue_head_t io_done_list;
1388: decl_simple_lock_data(, io_done_list_lock)
1389:
1390: #define splio splsched /* XXX must block ALL io devices */
1391:
1392: void iodone(ior)
1393: register io_req_t ior;
1394: {
1395: register spl_t s;
1396:
1397: /*
1398: * If this ior was loaned to us, return it directly.
1399: */
1400: if (ior->io_op & IO_LOANED) {
1401: (*ior->io_done)(ior);
1402: return;
1403: }
1404: /*
1405: * If !IO_CALL, some thread is waiting for this. Must lock
1406: * structure to interlock correctly with iowait(). Else can
1407: * toss on queue for io_done thread to call completion.
1408: */
1409: s = splio();
1410: if ((ior->io_op & IO_CALL) == 0) {
1411: ior_lock(ior);
1412: ior->io_op |= IO_DONE;
1413: ior->io_op &= ~IO_WANTED;
1414: ior_unlock(ior);
1415: thread_wakeup((event_t)ior);
1416: } else {
1417: ior->io_op |= IO_DONE;
1418: simple_lock(&io_done_list_lock);
1419: enqueue_tail(&io_done_list, (queue_entry_t)ior);
1420: thread_wakeup((event_t)&io_done_list);
1421: simple_unlock(&io_done_list_lock);
1422: }
1423: splx(s);
1424: }
1425:
1426: void io_done_thread_continue()
1427: {
1428: for (;;) {
1429: register spl_t s;
1430: register io_req_t ior;
1431:
1432: #if defined (i386) && defined (LINUX_DEV) && defined (CONFIG_INET)
1433: free_skbuffs ();
1434: #endif
1435: s = splio();
1436: simple_lock(&io_done_list_lock);
1437: while ((ior = (io_req_t)dequeue_head(&io_done_list)) != 0) {
1438: simple_unlock(&io_done_list_lock);
1439: (void) splx(s);
1440:
1441: if ((*ior->io_done)(ior)) {
1442: /*
1443: * IO done - free io_req_elt
1444: */
1445: io_req_free(ior);
1446: }
1447: /* else routine has re-queued it somewhere */
1448:
1449: s = splio();
1450: simple_lock(&io_done_list_lock);
1451: }
1452:
1453: assert_wait(&io_done_list, FALSE);
1454: simple_unlock(&io_done_list_lock);
1455: (void) splx(s);
1456: counter(c_io_done_thread_block++);
1457: thread_block(io_done_thread_continue);
1458: }
1459: }
1460:
1461: void io_done_thread()
1462: {
1463: /*
1464: * Set thread privileges and highest priority.
1465: */
1466: current_thread()->vm_privilege = TRUE;
1467: stack_privilege(current_thread());
1468: thread_set_own_priority(0);
1469:
1470: io_done_thread_continue();
1471: /*NOTREACHED*/
1472: }
1473:
1474: #define DEVICE_IO_MAP_SIZE (2 * 1024 * 1024)
1475:
1476: extern void ds_trap_init(void); /* forward */
1477:
1478: void ds_init()
1479: {
1480: vm_offset_t device_io_min, device_io_max;
1481:
1482: queue_init(&io_done_list);
1483: simple_lock_init(&io_done_list_lock);
1484:
1485: device_io_map = kmem_suballoc(kernel_map,
1486: &device_io_min,
1487: &device_io_max,
1488: DEVICE_IO_MAP_SIZE,
1489: FALSE);
1490: /*
1491: * If the kernel receives many device_write requests, the
1492: * device_io_map might run out of space. To prevent
1493: * device_write_get from failing in this case, we enable
1494: * wait_for_space on the map. This causes kmem_io_map_copyout
1495: * to block until there is sufficient space.
1496: * (XXX Large writes may be starved by small writes.)
1497: *
1498: * There is a potential deadlock problem with this solution,
1499: * if a device_write from the default pager has to wait
1500: * for the completion of a device_write which needs to wait
1501: * for memory allocation. Hence, once device_write_get
1502: * allocates space in device_io_map, no blocking memory
1503: * allocations should happen until device_write_dealloc
1504: * frees the space. (XXX A large write might starve
1505: * a small write from the default pager.)
1506: */
1507: device_io_map->wait_for_space = TRUE;
1508:
1509: io_inband_zone = zinit(sizeof(io_buf_ptr_inband_t),
1510: 1000 * sizeof(io_buf_ptr_inband_t),
1511: 10 * sizeof(io_buf_ptr_inband_t),
1512: FALSE,
1513: "io inband read buffers");
1514:
1515: ds_trap_init();
1516: }
1517:
1518: void iowait(ior)
1519: io_req_t ior;
1520: {
1521: spl_t s;
1522:
1523: s = splio();
1524: ior_lock(ior);
1525: while ((ior->io_op&IO_DONE)==0) {
1526: assert_wait((event_t)ior, FALSE);
1527: ior_unlock(ior);
1528: thread_block((void (*)()) 0);
1529: ior_lock(ior);
1530: }
1531: ior_unlock(ior);
1532: splx(s);
1533: }
1534:
1535:
1536: /*
1537: * Device trap support.
1538: */
1539:
1540: /*
1541: * Memory Management
1542: *
1543: * This currently has a single pool of 2k wired buffers
1544: * since we only handle writes to an ethernet device.
1545: * Should be more general.
1546: */
1547: #define IOTRAP_REQSIZE 2048
1548:
1549: zone_t io_trap_zone;
1550:
1551: /*
1552: * Initialization. Called from ds_init().
1553: */
1554: void
1555: ds_trap_init(void)
1556: {
1557: io_trap_zone = zinit(IOTRAP_REQSIZE,
1558: 256 * IOTRAP_REQSIZE,
1559: 16 * IOTRAP_REQSIZE,
1560: FALSE,
1561: "wired device trap buffers");
1562: }
1563:
1564: /*
1565: * Allocate an io_req_t.
1566: * Currently zalloc's from io_trap_zone.
1567: *
1568: * Could have lists of different size zones.
1569: * Could call a device-specific routine.
1570: */
1571: io_req_t
1572: ds_trap_req_alloc(mach_device_t device, vm_size_t data_size)
1573: {
1574: return (io_req_t) zalloc(io_trap_zone);
1575: }
1576:
1577: /*
1578: * Called by iodone to release ior.
1579: */
1580: boolean_t
1581: ds_trap_write_done(io_req_t ior)
1582: {
1583: register mach_device_t dev;
1584:
1585: dev = ior->io_device;
1586:
1587: /*
1588: * Should look at reply port and maybe send a message.
1589: */
1590: zfree(io_trap_zone, ior);
1591:
1592: /*
1593: * Give up device reference from ds_write_trap.
1594: */
1595: mach_device_deallocate(dev);
1596: return TRUE;
1597: }
1598:
1599: /*
1600: * Like device_write except that data is in user space.
1601: */
1602: #ifdef i386
1603: static io_return_t
1604: device_write_trap (void *d, dev_mode_t mode,
1605: recnum_t recnum, vm_offset_t data, vm_size_t data_count)
1606: #else
1607: io_return_t
1608: ds_device_write_trap(device_t device,
1609: dev_mode_t mode,
1610: recnum_t recnum,
1611: vm_offset_t data,
1612: vm_size_t data_count)
1613: #endif
1614: {
1615: #ifdef i386
1616: mach_device_t device = d;
1617: #endif
1618: io_req_t ior;
1619: io_return_t result;
1620:
1621: #ifndef i386
1622: /*
1623: * Refuse if device is dead or not completely open.
1624: */
1625: if (device == DEVICE_NULL)
1626: return (D_NO_SUCH_DEVICE);
1627: #endif
1628:
1629: if (device->state != DEV_STATE_OPEN)
1630: return (D_NO_SUCH_DEVICE);
1631:
1632: /* XXX note that a CLOSE may proceed at any point */
1633:
1634: /*
1635: * Get a buffer to hold the ioreq.
1636: */
1637: ior = ds_trap_req_alloc(device, data_count);
1638:
1639: /*
1640: * Package the write request for the device driver.
1641: */
1642:
1643: ior->io_device = device;
1644: ior->io_unit = device->dev_number;
1645: ior->io_op = IO_WRITE | IO_CALL | IO_LOANED;
1646: ior->io_mode = mode;
1647: ior->io_recnum = recnum;
1648: ior->io_data = (io_buf_ptr_t)
1649: (vm_offset_t)ior + sizeof(struct io_req);
1650: ior->io_count = data_count;
1651: ior->io_total = data_count;
1652: ior->io_alloc_size = 0;
1653: ior->io_residual = 0;
1654: ior->io_error = 0;
1655: ior->io_done = ds_trap_write_done;
1656: ior->io_reply_port = IP_NULL; /* XXX */
1657: ior->io_reply_port_type = 0; /* XXX */
1658:
1659: /*
1660: * Copy the data from user space.
1661: */
1662: if (data_count > 0)
1663: copyin((char *)data, (char *)ior->io_data, data_count);
1664:
1665: /*
1666: * The ior keeps an extra reference for the device.
1667: */
1668: mach_device_reference(device);
1669:
1670: /*
1671: * And do the write.
1672: */
1673: result = (*device->dev_ops->d_write)(device->dev_number, ior);
1674:
1675: /*
1676: * If the IO was queued, delay reply until it is finished.
1677: */
1678: if (result == D_IO_QUEUED)
1679: return (MIG_NO_REPLY);
1680:
1681: /*
1682: * Remove the extra reference.
1683: */
1684: mach_device_deallocate(device);
1685:
1686: zfree(io_trap_zone, ior);
1687: return (result);
1688: }
1689:
1690: #ifdef i386
1691: static io_return_t
1692: device_writev_trap (void *d, dev_mode_t mode,
1693: recnum_t recnum, io_buf_vec_t *iovec, vm_size_t iocount)
1694: #else
1695: io_return_t
1696: ds_device_writev_trap(device_t device,
1697: dev_mode_t mode,
1698: recnum_t recnum,
1699: io_buf_vec_t *iovec,
1700: vm_size_t iocount)
1701: #endif
1702: {
1703: #ifdef i386
1704: mach_device_t device = d;
1705: #endif
1706: io_req_t ior;
1707: io_return_t result;
1708: io_buf_vec_t stack_iovec[16]; /* XXX */
1709: vm_size_t data_count;
1710: int i;
1711:
1712: #ifndef i386
1713: /*
1714: * Refuse if device is dead or not completely open.
1715: */
1716: if (device == DEVICE_NULL)
1717: return (D_NO_SUCH_DEVICE);
1718: #endif
1719:
1720: if (device->state != DEV_STATE_OPEN)
1721: return (D_NO_SUCH_DEVICE);
1722:
1723: /* XXX note that a CLOSE may proceed at any point */
1724:
1725: /*
1726: * Copyin user addresses.
1727: */
1728: if (iocount > 16)
1729: return KERN_INVALID_VALUE; /* lame */
1730: copyin((char *)iovec,
1731: (char *)stack_iovec,
1732: iocount * sizeof(io_buf_vec_t));
1733: for (data_count = 0, i = 0; i < iocount; i++)
1734: data_count += stack_iovec[i].count;
1735:
1736: /*
1737: * Get a buffer to hold the ioreq.
1738: */
1739: ior = ds_trap_req_alloc(device, data_count);
1740:
1741: /*
1742: * Package the write request for the device driver.
1743: */
1744:
1745: ior->io_device = device;
1746: ior->io_unit = device->dev_number;
1747: ior->io_op = IO_WRITE | IO_CALL | IO_LOANED;
1748: ior->io_mode = mode;
1749: ior->io_recnum = recnum;
1750: ior->io_data = (io_buf_ptr_t)
1751: (vm_offset_t)ior + sizeof(struct io_req);
1752: ior->io_count = data_count;
1753: ior->io_total = data_count;
1754: ior->io_alloc_size = 0;
1755: ior->io_residual = 0;
1756: ior->io_error = 0;
1757: ior->io_done = ds_trap_write_done;
1758: ior->io_reply_port = IP_NULL; /* XXX */
1759: ior->io_reply_port_type = 0; /* XXX */
1760:
1761: /*
1762: * Copy the data from user space.
1763: */
1764: if (data_count > 0) {
1765: vm_offset_t p;
1766:
1767: p = (vm_offset_t) ior->io_data;
1768: for (i = 0; i < iocount; i++) {
1769: copyin((char *) stack_iovec[i].data,
1770: (char *) p,
1771: stack_iovec[i].count);
1772: p += stack_iovec[i].count;
1773: }
1774: }
1775:
1776: /*
1777: * The ior keeps an extra reference for the device.
1778: */
1779: mach_device_reference(device);
1780:
1781: /*
1782: * And do the write.
1783: */
1784: result = (*device->dev_ops->d_write)(device->dev_number, ior);
1785:
1786: /*
1787: * If the IO was queued, delay reply until it is finished.
1788: */
1789: if (result == D_IO_QUEUED)
1790: return (MIG_NO_REPLY);
1791:
1792: /*
1793: * Remove the extra reference.
1794: */
1795: mach_device_deallocate(device);
1796:
1797: zfree(io_trap_zone, ior);
1798: return (result);
1799: }
1800:
1801: #ifdef i386
1802: struct device_emulation_ops mach_device_emulation_ops =
1803: {
1804: mach_device_reference,
1805: mach_device_deallocate,
1806: mach_convert_device_to_port,
1807: device_open,
1808: device_close,
1809: device_write,
1810: device_write_inband,
1811: device_read,
1812: device_read_inband,
1813: device_set_status,
1814: mach_device_get_status,
1815: device_set_filter,
1816: device_map,
1817: ds_no_senders,
1818: device_write_trap,
1819: device_writev_trap
1820: };
1821: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.