![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nw_mk.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / chips|
Return to nw_mk.c CVS log | Up to [GnuMach] / Gnu-Mach / chips |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1991,1990,1989,1988,1987 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 Scienctxe
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: /*** MACH KERNEL WRAPPER ***/
28:
29: #ifndef STUB
30: #include <kern/task.h>
31: #include <kern/thread.h>
32: #include <kern/sched_prim.h>
33: #include <kern/eventcount.h>
34: #include <kern/time_out.h>
35: #include <machine/machspl.h> /* spl definitions */
36: #include <vm/vm_kern.h>
37: #include <chips/nc.h>
38: #include <chips/nw_mk.h>
39:
40: decl_simple_lock_data(, nw_simple_lock);
41: u_int previous_spl;
42:
43: #define nw_lock() \
44: previous_spl = splimp(); \
45: simple_lock(&nw_simple_lock)
46:
47: #define nw_unlock() \
48: simple_unlock(&nw_simple_lock); \
49: splx(previous_spl)
50:
51: typedef struct nw_pvs {
52: task_t owner;
53: char *buf_start;
54: char *buf_end;
55: struct nw_pvs *next;
56: } nw_pv_s, *nw_pv_t;
57:
58: typedef struct nw_waiters {
59: thread_t waiter;
60: struct nw_waiters *next;
61: } nw_waiter_s, *nw_waiter_t;
62:
63: typedef struct {
64: nw_pv_t pv;
65: thread_t sig_waiter;
66: nw_waiter_t rx_first;
67: nw_waiter_t rx_last;
68: nw_waiter_t tx_first;
69: nw_waiter_t tx_last;
70: } nw_hecb, *nw_hecb_t;
71:
72: #else
73: #include "nc.h"
74: #include "nw_mk.h"
75: #endif
76:
77: /*** Types and data structures ***/
78:
79: int h_initialized = FALSE;
80: nw_pv_s nw_pv[2*MAX_EP];
81: nw_pv_t nw_free_pv;
82: nw_waiter_s nw_waiter[2*MAX_EP];
83: nw_waiter_t nw_free_waiter;
84: nw_ep_owned_s nw_waited[3*MAX_EP];
85: nw_ep_owned_t nw_free_waited;
86: nw_hecb hect[MAX_EP];
87: timer_elt_data_t nw_fast_timer, nw_slow_timer;
88:
89: /*** Initialization ***/
90:
91: void h_initialize() {
92: int ep, last_ep;
93:
94: if (!h_initialized) {
95: last_ep = sizeof(nw_pv)/sizeof(nw_pv_s) - 1;
96: for (ep = 0; ep < last_ep; ep++) {
97: nw_pv[ep].next = &nw_pv[ep+1];
98: }
99: nw_pv[last_ep].next = NULL;
100: nw_free_pv = &nw_pv[0];
101: last_ep = sizeof(nw_waiter)/sizeof(nw_waiter_s) - 1;
102: for (ep = 0; ep < last_ep; ep++) {
103: nw_waiter[ep].next = &nw_waiter[ep+1];
104: }
105: nw_waiter[last_ep].next = NULL;
106: nw_free_waiter = &nw_waiter[0];
107: last_ep = sizeof(nw_waited)/sizeof(nw_ep_owned_s) - 1;
108: for (ep = 0; ep < last_ep; ep++) {
109: nw_waited[ep].next = &nw_waited[ep+1];
110: }
111: nw_waited[last_ep].next = NULL;
112: nw_free_waited = &nw_waited[0];
113: last_ep = sizeof(hect)/sizeof(nw_hecb);
114: for (ep = 0; ep < last_ep; ep++) {
115: hect[ep].pv = NULL;
116: hect[ep].sig_waiter = NULL;
117: hect[ep].rx_first = NULL;
118: hect[ep].rx_last = NULL;
119: hect[ep].tx_first = NULL;
120: hect[ep].tx_last = NULL;
121: }
122: nw_fast_timer.fcn = mk_fast_sweep;
123: nw_fast_timer.param = NULL;
124: nw_fast_timer.set = TELT_UNSET;
125: nw_slow_timer.fcn = mk_slow_sweep;
126: nw_slow_timer.param = NULL;
127: #if PRODUCTION
128: set_timeout(&nw_slow_timer, 2*hz);
129: #endif
130: h_initialized = TRUE;
131: }
132: }
133:
134: /*** User-trappable functions ***/
135:
136: nw_result mk_update(mach_port_t master_port, nw_update_type up_type,
137: int *up_info) {
138: nw_result rc;
139:
140: if (master_port == 0) { /* XXX */
141: rc = NW_FAILURE;
142: } else {
143: nw_lock();
144: switch (up_type) {
145: case NW_HOST_ADDRESS_REGISTER:
146: case NW_HOST_ADDRESS_UNREGISTER:
147: if (invalid_user_access(current_task()->map, (vm_offset_t) up_info,
148: (vm_offset_t) up_info + sizeof(nw_address_s) - 1,
149: VM_PROT_READ | VM_PROT_WRITE)) {
150: rc = NW_INVALID_ARGUMENT;
151: } else {
152: rc = nc_update(up_type, up_info);
153: }
154: break;
155: case NW_INITIALIZE:
156: nc_initialize();
157: rc = NW_SUCCESS;
158: break;
159: default:
160: rc = NW_INVALID_ARGUMENT;
161: }
162: nw_unlock();
163: }
164: return rc;
165: }
166:
167:
168:
169: nw_result mk_lookup(nw_lookup_type lt, int *look_info) {
170: nw_result rc;
171: int max_size, dev;
172:
173: nw_lock();
174: switch (lt) {
175: case NW_HOST_ADDRESS_LOOKUP:
176: if (invalid_user_access(current_task()->map, (vm_offset_t) look_info,
177: (vm_offset_t) look_info + sizeof(nw_address_s) - 1,
178: VM_PROT_READ | VM_PROT_WRITE)) {
179: rc = NW_INVALID_ARGUMENT;
180: } else {
181: rc = nc_lookup(lt, look_info);
182: }
183: break;
184: case NW_STATUS:
185: max_size = sizeof(nw_device);
186: if (max_size < sizeof(nw_result))
187: max_size = sizeof(nw_result);
188: if (invalid_user_access(current_task()->map, (vm_offset_t) look_info,
189: (vm_offset_t) look_info + max_size - 1,
190: VM_PROT_READ | VM_PROT_WRITE) ||
191: (dev = look_info[0]) >= MAX_DEV || dev < 0) {
192: rc = NW_INVALID_ARGUMENT;
193: } else {
194: if (devct[dev].status != NW_SUCCESS) {
195: look_info[0] = (int) devct[dev].status;
196: rc = NW_SUCCESS;
197: } else {
198: rc = (*(devct[dev].entry->status)) (dev);
199: }
200: }
201: break;
202: default:
203: rc = NW_INVALID_ARGUMENT;
204: }
205: nw_unlock();
206: return rc;
207: }
208:
209:
210: nw_result mk_endpoint_allocate_internal(nw_ep_t epp, nw_protocol protocol,
211: nw_acceptance accept,
212: u_int buffer_size, boolean_t system) {
213: nw_result rc;
214: u_int ep;
215: vm_offset_t kernel_addr, user_addr;
216: nw_pv_t pv;
217: nw_ep_owned_t owned;
218:
219: ep = *epp;
220: if (buffer_size == 0)
221: buffer_size = 0x1000;
222: else
223: buffer_size = (buffer_size + 0xfff) & ~0xfff;
224: nw_lock();
225: if (ep >= MAX_EP || (pv = hect[ep].pv) != NULL) {
226: rc = NW_BAD_EP;
227: } else if (nw_free_pv == NULL || nw_free_waited == NULL) {
228: rc = NW_NO_EP;
229: } else if (projected_buffer_allocate(current_task()->map, buffer_size, 0,
230: &kernel_addr, &user_addr,
231: VM_PROT_READ | VM_PROT_WRITE,
232: VM_INHERIT_NONE) != KERN_SUCCESS) {
233: rc = NW_NO_RESOURCES;
234: } else {
235: rc = nc_endpoint_allocate(epp, protocol, accept,
236: (char *) kernel_addr, buffer_size);
237: if (rc == NW_NO_EP && (ep = *epp) != 0) {
238: rc = (*(devct[NW_DEVICE(ect[ep].conn->peer.rem_addr_1)].entry->
239: close)) (ep);
240: if (rc == NW_SYNCH) {
241: hect[ep].sig_waiter = current_thread();
242: assert_wait(0, TRUE);
243: simple_unlock(&nw_simple_lock);
244: thread_block((void (*)()) 0);
245: }
246: rc = nc_endpoint_deallocate(ep);
247: if (rc == NW_SUCCESS) {
248: nc_line_update(&ect[ep].conn->peer, 0);
249: rc = nc_endpoint_allocate(epp, protocol, accept,
250: (char *) kernel_addr, buffer_size);
251: }
252: }
253: if (rc == NW_SUCCESS) {
254: ep = *epp;
255: if (system) {
256: hect[ep].pv = NULL;
257: } else {
258: hect[ep].pv = nw_free_pv;
259: nw_free_pv = nw_free_pv->next;
260: hect[ep].pv->owner = current_task();
261: hect[ep].pv->buf_start = (char *) user_addr;
262: hect[ep].pv->buf_end = (char *) user_addr + buffer_size;
263: hect[ep].pv->next = NULL;
264: }
265: hect[ep].sig_waiter = NULL;
266: hect[ep].rx_first = NULL;
267: hect[ep].rx_last = NULL;
268: hect[ep].tx_first = NULL;
269: hect[ep].tx_last = NULL;
270: owned = nw_free_waited;
271: nw_free_waited = nw_free_waited->next;
272: owned->ep = ep;
273: owned->next = current_task()->nw_ep_owned;
274: current_task()->nw_ep_owned = owned;
275: } else {
276: projected_buffer_deallocate(current_task()->map, user_addr,
277: user_addr + buffer_size);
278: }
279: }
280: nw_unlock();
281: return rc;
282: }
283:
284:
285: nw_result mk_endpoint_allocate(nw_ep_t epp, nw_protocol protocol,
286: nw_acceptance accept, u_int buffer_size) {
287: nw_result rc;
288:
289: if (invalid_user_access(current_task()->map, (vm_offset_t) epp,
290: (vm_offset_t) epp + sizeof(nw_ep) - 1,
291: VM_PROT_READ | VM_PROT_WRITE) ||
292: (protocol != NW_RAW && protocol != NW_DATAGRAM &&
293: protocol != NW_SEQ_PACKET) || (accept != NW_NO_ACCEPT &&
294: accept != NW_APPL_ACCEPT && accept != NW_AUTO_ACCEPT)) {
295: rc = NW_INVALID_ARGUMENT;
296: } else {
297: rc = mk_endpoint_allocate_internal(epp, protocol, accept,
298: buffer_size, FALSE);
299: }
300: return rc;
301: }
302:
303: nw_result mk_endpoint_deallocate_internal(nw_ep ep, task_t task,
304: boolean_t shutdown) {
305: nw_result rc;
306: nw_pv_t pv, pv_previous;
307: nw_ep_owned_t owned, owned_previous;
308: nw_waiter_t w, w_previous, w_next;
309:
310: nw_lock();
311: if (ep >= MAX_EP || (pv = hect[ep].pv) == NULL) {
312: rc = NW_BAD_EP;
313: } else {
314: pv_previous = NULL;
315: while (pv != NULL && pv->owner != task) {
316: pv_previous = pv;
317: pv = pv->next;
318: }
319: if (pv == NULL) {
320: rc = NW_PROT_VIOLATION;
321: } else {
322: if (projected_buffer_deallocate(task->map, pv->buf_start,
323: pv->buf_end) != KERN_SUCCESS) {
324: rc = NW_INCONSISTENCY;
325: printf("Endpoint deallocate: inconsistency p. buffer\n");
326: } else {
327: if (pv_previous == NULL)
328: hect[ep].pv = pv->next;
329: else
330: pv_previous->next = pv->next;
331: pv->next = nw_free_pv;
332: nw_free_pv = pv;
333: owned = task->nw_ep_owned;
334: owned_previous = NULL;
335: while (owned != NULL && owned->ep != ep) {
336: owned_previous = owned;
337: owned = owned->next;
338: }
339: if (owned == NULL) {
340: rc = NW_INCONSISTENCY;
341: printf("Endpoint deallocate: inconsistency owned\n");
342: } else {
343: if (owned_previous == NULL)
344: task->nw_ep_owned = owned->next;
345: else
346: owned_previous->next = owned->next;
347: owned->next = nw_free_waited;
348: nw_free_waited = owned;
349: if (hect[ep].sig_waiter != NULL &&
350: hect[ep].sig_waiter->task == task) {
351: /* if (!shutdown)*/
352: mk_deliver_result(hect[ep].sig_waiter, NW_ABORTED);
353: hect[ep].sig_waiter = NULL;
354: }
355: w = hect[ep].rx_first;
356: w_previous = NULL;
357: while (w != NULL) {
358: if (w->waiter->task == task) {
359: /* if (!shutdown)*/
360: mk_deliver_result(w->waiter, NULL);
361: w_next = w->next;
362: if (w_previous == NULL)
363: hect[ep].rx_first = w_next;
364: else
365: w_previous->next = w_next;
366: w->next = nw_free_waiter;
367: nw_free_waiter = w;
368: w = w_next;
369: } else {
370: w_previous = w;
371: w = w->next;
372: }
373: }
374: if (hect[ep].rx_first == NULL)
375: hect[ep].rx_last = NULL;
376: w = hect[ep].tx_first;
377: w_previous = NULL;
378: while (w != NULL) {
379: if (w->waiter->task == task) {
380: /* if (!shutdown)*/
381: mk_deliver_result(w->waiter, NW_ABORTED);
382: w_next = w->next;
383: if (w_previous == NULL)
384: hect[ep].tx_first = w_next;
385: else
386: w_previous->next = w_next;
387: w->next = nw_free_waiter;
388: nw_free_waiter = w;
389: w = w_next;
390: } else {
391: w_previous = w;
392: w = w->next;
393: }
394: }
395: if (hect[ep].tx_first == NULL)
396: hect[ep].tx_last = NULL;
397: if (hect[ep].pv == NULL) {
398: if (ect[ep].state != NW_UNCONNECTED) {
399: rc = (*(devct[NW_DEVICE(ect[ep].conn->peer.rem_addr_1)].entry->
400: close)) (ep);
401: if (rc == NW_SYNCH) {
402: hect[ep].sig_waiter = current_thread();
403: assert_wait(0, TRUE);
404: simple_unlock(&nw_simple_lock);
405: thread_block((void (*)()) 0);
406: }
407: }
408: rc = nc_endpoint_deallocate(ep);
409: }
410: }
411: }
412: }
413: }
414: nw_unlock();
415: return rc;
416: }
417:
418: nw_result mk_endpoint_deallocate(nw_ep ep) {
419:
420: mk_endpoint_deallocate_internal(ep, current_task(), FALSE);
421: }
422:
423:
424: nw_buffer_t mk_buffer_allocate(nw_ep ep, u_int size) {
425: nw_buffer_t buf;
426: nw_pv_t pv;
427:
428: nw_lock();
429: if (ep >= MAX_EP || (pv = hect[ep].pv) == NULL) {
430: buf = NW_BUFFER_ERROR;
431: } else {
432: while (pv != NULL && pv->owner != current_task())
433: pv = pv->next;
434: if (pv == NULL) {
435: buf = NW_BUFFER_ERROR;
436: } else {
437: buf = nc_buffer_allocate(ep, size);
438: if (buf != NULL) {
439: buf = (nw_buffer_t) ((char *) buf - ect[ep].buf_start + pv->buf_start);
440: }
441: }
442: }
443: nw_unlock();
444: return buf;
445: }
446:
447:
448:
449: nw_result mk_buffer_deallocate(nw_ep ep, nw_buffer_t buffer) {
450: nw_result rc;
451: nw_pv_t pv;
452:
453: nw_lock();
454: if (ep >= MAX_EP || (pv = hect[ep].pv) == NULL) {
455: rc = NW_BAD_EP;
456: } else {
457: while (pv != NULL && pv->owner != current_task())
458: pv = pv->next;
459: if (pv == NULL) {
460: rc = NW_PROT_VIOLATION;
461: } else {
462: if ((char *) buffer < pv->buf_start ||
463: (char *) buffer + sizeof(nw_buffer_s) > pv->buf_end ||
464: !buffer->buf_used ||
465: (char *) buffer + buffer->buf_length > pv->buf_end) {
466: rc = NW_BAD_BUFFER;
467: } else {
468: buffer = (nw_buffer_t) ((char *) buffer - pv->buf_start +
469: ect[ep].buf_start);
470: rc = nc_buffer_deallocate(ep, buffer);
471: }
472: }
473: }
474: nw_unlock();
475: return rc;
476: }
477:
478:
479: nw_result mk_connection_open_internal(nw_ep local_ep, nw_address_1 rem_addr_1,
480: nw_address_2 rem_addr_2, nw_ep remote_ep) {
481: nw_result rc;
482:
483: rc = (*devct[NW_DEVICE(rem_addr_1)].entry->open) (local_ep,
484: rem_addr_1, rem_addr_2,
485: remote_ep);
486: if (rc == NW_SYNCH) {
487: hect[local_ep].sig_waiter = current_thread();
488: assert_wait(0, TRUE);
489: simple_unlock(&nw_simple_lock);
490: thread_block((void (*)()) 0);
491: }
492: return rc;
493: }
494:
495: nw_result mk_connection_open(nw_ep local_ep, nw_address_1 rem_addr_1,
496: nw_address_2 rem_addr_2, nw_ep remote_ep) {
497: nw_result rc;
498: nw_pv_t pv;
499:
500: nw_lock();
501: if (local_ep >= MAX_EP || (pv = hect[local_ep].pv) == NULL) {
502: rc = NW_BAD_EP;
503: } else {
504: while (pv != NULL && pv->owner != current_task())
505: pv = pv->next;
506: if (pv == NULL) {
507: rc = NW_PROT_VIOLATION;
508: } else {
509: rc = (*(devct[NW_DEVICE(rem_addr_1)].entry->open))
510: (local_ep, rem_addr_1, rem_addr_2, remote_ep);
511: if (rc == NW_SYNCH) {
512: hect[local_ep].sig_waiter = current_thread();
513: assert_wait(0, TRUE);
514: current_thread()->nw_ep_waited = NULL;
515: simple_unlock(&nw_simple_lock);
516: thread_block(mk_return);
517: }
518: }
519: }
520: nw_unlock();
521: return rc;
522: }
523:
524:
525: nw_result mk_connection_accept(nw_ep ep, nw_buffer_t msg,
526: nw_ep_t new_epp) {
527: nw_result rc;
528: nw_pv_t pv;
529:
530: nw_lock();
531: if (ep >= MAX_EP || (pv = hect[ep].pv) == NULL) {
532: rc = NW_BAD_EP;
533: } else {
534: while (pv != NULL && pv->owner != current_task())
535: pv = pv->next;
536: if (pv == NULL) {
537: rc = NW_PROT_VIOLATION;
538: } else if ((char *) msg < pv->buf_start ||
539: (char *) msg + sizeof(nw_buffer_s) > pv->buf_end ||
540: !msg->buf_used ||
541: (char *) msg + msg->buf_length > pv->buf_end) {
542: rc = NW_BAD_BUFFER;
543: } else if (new_epp != NULL &&
544: (invalid_user_access(current_task()->map, (vm_offset_t) new_epp,
545: (vm_offset_t) new_epp + sizeof(nw_ep) - 1,
546: VM_PROT_READ | VM_PROT_WRITE) ||
547: (*new_epp != 0 && *new_epp != ep))) {
548: rc = NW_INVALID_ARGUMENT;
549: } else {
550: rc = (*(devct[NW_DEVICE(ect[ep].conn->peer.rem_addr_1)].entry->accept))
551: (ep, msg, new_epp);
552: if (rc == NW_SYNCH) {
553: hect[ep].sig_waiter = current_thread();
554: assert_wait(0, TRUE);
555: current_thread()->nw_ep_waited = NULL;
556: simple_unlock(&nw_simple_lock);
557: thread_block(mk_return);
558: }
559: }
560: }
561: nw_unlock();
562: return rc;
563: }
564:
565: nw_result mk_connection_close(nw_ep ep) {
566: nw_result rc;
567: nw_pv_t pv;
568:
569: nw_lock();
570: if (ep >= MAX_EP || (pv = hect[ep].pv) == NULL) {
571: rc = NW_BAD_EP;
572: } else {
573: while (pv != NULL && pv->owner != current_task())
574: pv = pv->next;
575: if (pv == NULL) {
576: rc = NW_PROT_VIOLATION;
577: } else {
578: rc = (*devct[NW_DEVICE(ect[ep].conn->peer.rem_addr_1)].entry->close)
579: (ep);
580: if (rc == NW_SYNCH) {
581: hect[ep].sig_waiter = current_thread();
582: assert_wait(0, TRUE);
583: current_thread()->nw_ep_waited = NULL;
584: simple_unlock(&nw_simple_lock);
585: thread_block(mk_return);
586: }
587: }
588: }
589: nw_unlock();
590: return rc;
591: }
592:
593:
594: nw_result mk_multicast_add(nw_ep local_ep, nw_address_1 rem_addr_1,
595: nw_address_2 rem_addr_2, nw_ep remote_ep) {
596: nw_result rc;
597: nw_pv_t pv;
598:
599: nw_lock();
600: if (local_ep >= MAX_EP || (pv = hect[local_ep].pv) == NULL) {
601: rc = NW_BAD_EP;
602: } else {
603: while (pv != NULL && pv->owner != current_task())
604: pv = pv->next;
605: if (pv == NULL) {
606: rc = NW_PROT_VIOLATION;
607: } else {
608: rc = (*(devct[NW_DEVICE(rem_addr_1)].entry->add))
609: (local_ep, rem_addr_1, rem_addr_2, remote_ep);
610: if (rc == NW_SYNCH) {
611: hect[local_ep].sig_waiter = current_thread();
612: assert_wait(0, TRUE);
613: current_thread()->nw_ep_waited = NULL;
614: simple_unlock(&nw_simple_lock);
615: thread_block(mk_return);
616: }
617: }
618: }
619: nw_unlock();
620: return rc;
621: }
622:
623:
624: nw_result mk_multicast_drop(nw_ep local_ep, nw_address_1 rem_addr_1,
625: nw_address_2 rem_addr_2, nw_ep remote_ep) {
626: nw_result rc;
627: nw_pv_t pv;
628:
629: nw_lock();
630: if (local_ep >= MAX_EP || (pv = hect[local_ep].pv) == NULL) {
631: rc = NW_BAD_EP;
632: } else {
633: while (pv != NULL && pv->owner != current_task())
634: pv = pv->next;
635: if (pv == NULL) {
636: rc = NW_PROT_VIOLATION;
637: } else {
638: rc = (*(devct[NW_DEVICE(rem_addr_1)].entry->drop))
639: (local_ep, rem_addr_1, rem_addr_2, remote_ep);
640: if (rc == NW_SYNCH) {
641: hect[local_ep].sig_waiter = current_thread();
642: assert_wait(0, TRUE);
643: current_thread()->nw_ep_waited = NULL;
644: simple_unlock(&nw_simple_lock);
645: thread_block(mk_return);
646: }
647: }
648: }
649: nw_unlock();
650: return rc;
651: }
652:
653:
654: nw_result mk_endpoint_status(nw_ep ep, nw_state_t state,
655: nw_peer_t peer) {
656: nw_result rc;
657: nw_pv_t pv;
658:
659: nw_lock();
660: if (ep >= MAX_EP || (pv = hect[ep].pv) == NULL) {
661: rc = NW_BAD_EP;
662: } else {
663: while (pv != NULL && pv->owner != current_task())
664: pv = pv->next;
665: if (pv == NULL) {
666: rc = NW_PROT_VIOLATION;
667: } else {
668: if (invalid_user_access(current_task()->map, (vm_offset_t) state,
669: (vm_offset_t) state + sizeof(nw_state) - 1,
670: VM_PROT_WRITE) ||
671: invalid_user_access(current_task()->map, (vm_offset_t) peer,
672: (vm_offset_t) peer + sizeof(nw_peer_s) - 1,
673: VM_PROT_WRITE)) {
674: rc = NW_INVALID_ARGUMENT;
675: } else {
676: rc = nc_endpoint_status(ep, state, peer);
677: }
678: }
679: }
680: nw_unlock();
681: return rc;
682: }
683:
684:
685: nw_result mk_send(nw_ep ep, nw_buffer_t msg, nw_options options) {
686: nw_result rc;
687: nw_pv_t pv;
688: nw_ep sender;
689: int dev;
690: nw_ecb_t ecb;
691: nw_tx_header_t header, first_header, previous_header;
692: nw_hecb_t hecb;
693: nw_waiter_t w;
694:
695: nw_lock();
696: if (ep >= MAX_EP || (pv = hect[ep].pv) == NULL) {
697: rc = NW_BAD_EP;
698: } else {
699: while (pv != NULL && pv->owner != current_task())
700: pv = pv->next;
701: if (pv == NULL) {
702: rc = NW_PROT_VIOLATION;
703: } else {
704: ecb = &ect[ep];
705: if (ecb->state == NW_INEXISTENT ||
706: (ecb->protocol == NW_SEQ_PACKET && ecb->conn == NULL)) {
707: rc = NW_BAD_EP;
708: } else {
709: first_header = header = nc_tx_header_allocate();
710: previous_header = NULL;
711: rc = NW_SUCCESS;
712: while (header != NULL) {
713: if ((char *) msg < pv->buf_start ||
714: (char *) msg + sizeof(nw_buffer_s) > pv->buf_end ||
715: ((int) msg & 0x3) || (msg->block_offset & 0x3) ||
716: (msg->block_length & 0x3) || !msg->buf_used ||
717: (char *) msg + msg->buf_length > pv->buf_end ||
718: msg->block_offset + msg->block_length > msg->buf_length) {
719: rc = NW_BAD_BUFFER;
720: break;
721: } else {
722: if (previous_header == NULL) {
723: if (ecb->protocol == NW_SEQ_PACKET)
724: header->peer = ecb->conn->peer;
725: else
726: header->peer = msg->peer;
727: } else {
728: previous_header->next = header;
729: }
730: header->buffer = (nw_buffer_t) ((char *) msg - pv->buf_start +
731: ecb->buf_start);
732: header->block = (char *) header->buffer + msg->block_offset;
733: if (!msg->block_deallocate)
734: header->buffer = NULL;
735: header->msg_length = 0;
736: header->block_length = msg->block_length;
737: first_header->msg_length += header->block_length;
738: header->next = NULL;
739: if (msg->buf_next == NULL)
740: break;
741: msg = msg->buf_next;
742: previous_header = header;
743: header = nc_tx_header_allocate();
744: }
745: }
746: if (header == NULL) {
747: nc_tx_header_deallocate(first_header);
748: rc = NW_NO_RESOURCES;
749: } else if (rc == NW_SUCCESS) {
750: dev = NW_DEVICE(first_header->peer.rem_addr_1);
751: if (ecb->protocol != NW_DATAGRAM ||
752: devct[dev].type != NW_CONNECTION_ORIENTED) {
753: sender = first_header->peer.local_ep;
754: rc = NW_SUCCESS;
755: } else {
756: sender = nc_line_lookup(&first_header->peer);
757: if (sender == -1) {
758: rc = NW_BAD_ADDRESS;
759: } else if (sender > 0) {
760: rc = NW_SUCCESS;
761: } else {
762: rc = mk_endpoint_allocate_internal(&sender, NW_LINE,
763: NW_AUTO_ACCEPT, 0, TRUE);
764: if (rc == NW_SUCCESS) {
765: rc = mk_connection_open_internal(sender,
766: first_header->peer.rem_addr_1,
767: first_header->peer.rem_addr_2,
768: MASTER_LINE_EP);
769: if (rc == NW_SUCCESS)
770: nc_line_update(&first_header->peer, sender);
771: }
772: }
773: }
774: if (rc == NW_SUCCESS) {
775: first_header->sender = sender;
776: first_header->options = options;
777: rc = (*(devct[dev].entry->send)) (sender, first_header, options);
778: if ((rc == NW_SYNCH || rc == NW_QUEUED) &&
779: nw_free_waiter != NULL) {
780: w = nw_free_waiter;
781: nw_free_waiter = w->next;
782: w->waiter = current_thread();
783: w->next = NULL;
784: hecb = &hect[sender];
785: if (hecb->tx_last == NULL) {
786: hecb->tx_first = hecb->tx_last = w;
787: } else {
788: hecb->tx_last = hecb->tx_last->next = w;
789: }
790: assert_wait(0, TRUE);
791: current_thread()->nw_ep_waited = NULL;
792: simple_unlock(&nw_simple_lock);
793: thread_block(mk_return);
794: }
795: }
796: }
797: }
798: }
799: }
800: nw_unlock();
801: return rc;
802: }
803:
804:
805: nw_buffer_t mk_receive(nw_ep ep, int time_out) {
806: nw_buffer_t rc;
807: nw_pv_t pv;
808: nw_ecb_t ecb;
809: nw_rx_header_t header;
810: nw_hecb_t hecb;
811: nw_waiter_t w;
812: nw_ep_owned_t waited;
813:
814: nw_lock();
815: if (ep >= MAX_EP || (pv = hect[ep].pv) == NULL) {
816: rc = NW_BUFFER_ERROR;
817: } else {
818: while (pv != NULL && pv->owner != current_task())
819: pv = pv->next;
820: if (pv == NULL) {
821: rc = NW_BUFFER_ERROR;
822: } else {
823: ecb = &ect[ep];
824: header = ecb->rx_first;
825: if (header != NULL) {
826: rc = (nw_buffer_t) ((char *) header->buffer - ecb->buf_start +
827: pv->buf_start);
828: ecb->rx_first = header->next;
829: if (ecb->rx_first == NULL)
830: ecb->rx_last = NULL;
831: nc_rx_header_deallocate(header);
832: } else if (time_out != 0 && nw_free_waiter != NULL &&
833: (time_out == -1 || nw_free_waited != NULL)) {
834: w = nw_free_waiter;
835: nw_free_waiter = w->next;
836: w->waiter = current_thread();
837: w->next = NULL;
838: hecb = &hect[ep];
839: if (hecb->rx_last == NULL)
840: hecb->rx_first = hecb->rx_last = w;
841: else
842: hecb->rx_last = hecb->rx_last->next = w;
843: assert_wait(0, TRUE);
844: if (time_out != -1) {
845: waited = nw_free_waited;
846: nw_free_waited = waited->next;
847: waited->ep = ep;
848: waited->next = NULL;
849: current_thread()->nw_ep_waited = waited;
850: current_thread()->wait_result = NULL;
851: if (!current_thread()->timer.set)
852: thread_set_timeout(time_out);
853: } else {
854: current_thread()->nw_ep_waited = NULL;
855: }
856: simple_unlock(&nw_simple_lock);
857: thread_block(mk_return);
858: } else {
859: rc = NULL;
860: }
861: }
862: }
863: nw_unlock();
864: return rc;
865: }
866:
867:
868: nw_buffer_t mk_rpc(nw_ep ep, nw_buffer_t msg, nw_options options,
869: int time_out) {
870: nw_buffer_t rc;
871: nw_result nrc;
872: nw_ep sender;
873: int dev;
874: nw_pv_t pv;
875: nw_ecb_t ecb;
876: nw_tx_header_t header, first_header, previous_header;
877: nw_hecb_t hecb;
878: nw_waiter_t w;
879: nw_ep_owned_t waited;
880:
881: nw_lock();
882: if (ep >= MAX_EP || (pv = hect[ep].pv) == NULL) {
883: rc = NW_BUFFER_ERROR;
884: } else {
885: while (pv != NULL && pv->owner != current_task())
886: pv = pv->next;
887: if (pv == NULL) {
888: rc = NW_BUFFER_ERROR;
889: } else {
890: ecb = &ect[ep];
891: if (ecb->state == NW_INEXISTENT ||
892: (ecb->protocol == NW_SEQ_PACKET && ecb->conn == NULL)) {
893: rc = NW_BUFFER_ERROR;
894: } else {
895: first_header = header = nc_tx_header_allocate();
896: previous_header = NULL;
897: rc = NULL;
898: while (header != NULL) {
899: if ((char *) msg < pv->buf_start ||
900: (char *) msg + sizeof(nw_buffer_s) > pv->buf_end ||
901: ((int) msg & 0x3) || (msg->block_offset & 0x3) ||
902: (msg->block_length & 0x3) || !msg->buf_used ||
903: (char *) msg + msg->buf_length > pv->buf_end ||
904: msg->block_offset + msg->block_length > msg->buf_length) {
905: rc = NW_BUFFER_ERROR;
906: break;
907: } else {
908: if (previous_header == NULL) {
909: if (ecb->protocol == NW_SEQ_PACKET)
910: header->peer = ecb->conn->peer;
911: else
912: header->peer = msg->peer;
913: } else {
914: previous_header->next = header;
915: }
916: header->buffer = (nw_buffer_t) ((char *) msg - pv->buf_start +
917: ecb->buf_start);
918: header->block = (char *) header->buffer + msg->block_offset;
919: if (!msg->block_deallocate)
920: header->buffer = NULL;
921: header->msg_length = 0;
922: header->block_length = msg->block_length;
923: first_header->msg_length += header->block_length;
924: header->next = NULL;
925: if (msg->buf_next == NULL)
926: break;
927: msg = msg->buf_next;
928: previous_header = header;
929: header = nc_tx_header_allocate();
930: }
931: }
932: if (header == NULL) {
933: nc_tx_header_deallocate(first_header);
934: rc = NW_BUFFER_ERROR;
935: } else if (rc != NW_BUFFER_ERROR) {
936: dev = NW_DEVICE(first_header->peer.rem_addr_1);
937: if (ecb->protocol != NW_DATAGRAM ||
938: devct[dev].type != NW_CONNECTION_ORIENTED) {
939: sender = first_header->peer.local_ep;
940: nrc = NW_SUCCESS;
941: } else {
942: sender = nc_line_lookup(&first_header->peer);
943: if (sender == -1) {
944: nrc = NW_BAD_ADDRESS;
945: } else if (sender > 0) {
946: nrc = NW_SUCCESS;
947: } else {
948: nrc = mk_endpoint_allocate_internal(&sender, NW_LINE,
949: NW_AUTO_ACCEPT, 0, TRUE);
950: if (nrc == NW_SUCCESS) {
951: nrc = mk_connection_open_internal(sender,
952: first_header->peer.rem_addr_1,
953: first_header->peer.rem_addr_2,
954: MASTER_LINE_EP);
955: if (nrc == NW_SUCCESS)
956: nc_line_update(&first_header->peer, sender);
957: }
958: }
959: }
960: if (nrc == NW_SUCCESS) {
961: first_header->sender = sender;
962: first_header->options = options;
963: rc = (*(devct[dev].entry->rpc)) (sender, first_header, options);
964: if (rc != NULL && rc != NW_BUFFER_ERROR) {
965: rc = (nw_buffer_t) ((char *) rc - ecb->buf_start +
966: pv->buf_start);
967: } else if (rc == NULL && time_out != 0 && nw_free_waiter != NULL &&
968: (time_out == -1 || nw_free_waited != NULL)) {
969: w = nw_free_waiter;
970: nw_free_waiter = w->next;
971: w->waiter = current_thread();
972: w->next = NULL;
973: hecb = &hect[ep];
974: if (hecb->rx_last == NULL)
975: hecb->rx_first = hecb->rx_last = w;
976: else
977: hecb->rx_last = hecb->rx_last->next = w;
978: assert_wait(0, TRUE);
979: if (time_out != -1) {
980: waited = nw_free_waited;
981: nw_free_waited = waited->next;
982: waited->ep = ep;
983: waited->next = NULL;
984: current_thread()->nw_ep_waited = waited;
985: current_thread()->wait_result = NULL;
986: if (!current_thread()->timer.set)
987: thread_set_timeout(time_out);
988: } else {
989: current_thread()->nw_ep_waited = NULL;
990: }
991: simple_unlock(&nw_simple_lock);
992: thread_block(mk_return);
993: }
994: }
995: }
996: }
997: }
998: }
999: nw_unlock();
1000: return rc;
1001: }
1002:
1003: nw_buffer_t mk_select(u_int nep, nw_ep_t epp, int time_out) {
1004: nw_buffer_t rc;
1005: nw_pv_t pv;
1006: int i;
1007: nw_ep ep;
1008: nw_ecb_t ecb;
1009: nw_rx_header_t header;
1010: nw_hecb_t hecb;
1011: nw_waiter_t w, w_next;
1012: nw_ep_owned_t waited;
1013:
1014: if (invalid_user_access(current_task()->map, (vm_offset_t) epp,
1015: (vm_offset_t) epp + nep*sizeof(nw_ep) - 1,
1016: VM_PROT_READ)) {
1017: rc = NW_BUFFER_ERROR;
1018: } else {
1019: nw_lock();
1020: for (i = 0; i < nep; i++) {
1021: ep = epp[i];
1022: if (ep >= MAX_EP || (pv = hect[ep].pv) == NULL) {
1023: rc = NW_BUFFER_ERROR;
1024: break;
1025: } else {
1026: while (pv != NULL && pv->owner != current_task())
1027: pv = pv->next;
1028: if (pv == NULL) {
1029: rc = NW_BUFFER_ERROR;
1030: break;
1031: } else {
1032: ecb = &ect[ep];
1033: header = ecb->rx_first;
1034: if (header != NULL) {
1035: rc = (nw_buffer_t) ((char *) header->buffer - ecb->buf_start +
1036: pv->buf_start);
1037: ecb->rx_first = header->next;
1038: if (ecb->rx_first == NULL)
1039: ecb->rx_last = NULL;
1040: nc_rx_header_deallocate(header);
1041: break;
1042: }
1043: }
1044: }
1045: }
1046: if (i == nep) {
1047: if (time_out == 0) {
1048: rc = NULL;
1049: } else {
1050: w = nw_free_waiter;
1051: waited = nw_free_waited;
1052: i = 0;
1053: while (i < nep &&
1054: nw_free_waiter != NULL && nw_free_waited != NULL) {
1055: nw_free_waiter = nw_free_waiter->next;
1056: nw_free_waited = nw_free_waited->next;
1057: i++;
1058: }
1059: if (i < nep) {
1060: nw_free_waiter = w;
1061: nw_free_waited = waited;
1062: rc = NW_BUFFER_ERROR;
1063: } else {
1064: current_thread()->nw_ep_waited = waited;
1065: for (i = 0; i < nep; i++) {
1066: ep = epp[i];
1067: waited->ep = ep;
1068: if (i < nep-1)
1069: waited = waited->next;
1070: else
1071: waited->next = NULL;
1072: w->waiter = current_thread();
1073: w_next = w->next;
1074: w->next = NULL;
1075: hecb = &hect[ep];
1076: if (hecb->rx_last == NULL)
1077: hecb->rx_first = hecb->rx_last = w;
1078: else
1079: hecb->rx_last = hecb->rx_last->next = w;
1080: w = w_next;
1081: }
1082: assert_wait(0, TRUE);
1083: if (time_out != -1) {
1084: current_thread()->wait_result = NULL;
1085: if (!current_thread()->timer.set)
1086: thread_set_timeout(time_out);
1087: }
1088: simple_unlock(&nw_simple_lock);
1089: thread_block(mk_return);
1090: }
1091: }
1092: }
1093: nw_unlock();
1094: }
1095: return rc;
1096: }
1097:
1098:
1099: /*** System-dependent support ***/
1100:
1101: void mk_endpoint_collect(task_t task) {
1102:
1103: while (task->nw_ep_owned != NULL) {
1104: mk_endpoint_deallocate_internal(task->nw_ep_owned->ep, task, TRUE);
1105: }
1106: }
1107:
1108: void mk_waited_collect(thread_t thread) {
1109: nw_hecb_t hecb;
1110: nw_waiter_t w, w_previous;
1111: nw_ep_owned_t waited, waited_previous;
1112:
1113: waited = thread->nw_ep_waited;
1114: if (waited != NULL) {
1115: while (waited != NULL) {
1116: hecb = &hect[waited->ep];
1117: w = hecb->rx_first;
1118: w_previous = NULL;
1119: while (w != NULL && w->waiter != thread) {
1120: w_previous = w;
1121: w = w->next;
1122: }
1123: if (w != NULL) {
1124: if (w_previous == NULL)
1125: hecb->rx_first = w->next;
1126: else
1127: w_previous->next = w->next;
1128: if (w->next == NULL)
1129: hecb->rx_last = w_previous;
1130: w->next = nw_free_waiter;
1131: nw_free_waiter = w;
1132: }
1133: waited_previous = waited;
1134: waited = waited->next;
1135: }
1136: waited_previous->next = nw_free_waited;
1137: nw_free_waited = thread->nw_ep_waited;
1138: thread->nw_ep_waited = NULL;
1139: }
1140: }
1141:
1142: void mk_return() {
1143:
1144: thread_syscall_return(current_thread()->wait_result);
1145: }
1146:
1147:
1148: boolean_t mk_deliver_result(thread_t thread, int result) {
1149: boolean_t rc;
1150: int state, s;
1151:
1152: s = splsched();
1153: thread_lock(thread);
1154: state = thread->state;
1155:
1156: reset_timeout_check(&thread->timer);
1157:
1158: switch (state & TH_SCHED_STATE) {
1159: case TH_WAIT | TH_SUSP | TH_UNINT:
1160: case TH_WAIT | TH_UNINT:
1161: case TH_WAIT:
1162: /*
1163: * Sleeping and not suspendable - put on run queue.
1164: */
1165: thread->state = (state &~ TH_WAIT) | TH_RUN;
1166: thread->wait_result = (kern_return_t) result;
1167: simpler_thread_setrun(thread, TRUE);
1168: rc = TRUE;
1169: break;
1170:
1171: case TH_WAIT | TH_SUSP:
1172: case TH_RUN | TH_WAIT:
1173: case TH_RUN | TH_WAIT | TH_SUSP:
1174: case TH_RUN | TH_WAIT | TH_UNINT:
1175: case TH_RUN | TH_WAIT | TH_SUSP | TH_UNINT:
1176: /*
1177: * Either already running, or suspended.
1178: */
1179: thread->state = state &~ TH_WAIT;
1180: thread->wait_result = (kern_return_t) result;
1181: rc = FALSE;
1182: break;
1183:
1184: default:
1185: /*
1186: * Not waiting.
1187: */
1188: rc = FALSE;
1189: break;
1190: }
1191: thread_unlock(thread);
1192: splx(s);
1193: return rc;
1194: }
1195:
1196:
1197: boolean_t nc_deliver_result(nw_ep ep, nw_delivery type, int result) {
1198: boolean_t rc;
1199: nw_hecb_t hecb;
1200: nw_ecb_t ecb;
1201: nw_waiter_t w;
1202: thread_t thread;
1203: task_t task;
1204: nw_pv_t pv;
1205: nw_buffer_t buf;
1206: nw_rx_header_t rx_header;
1207: nw_tx_header_t tx_header;
1208: nw_ep lep;
1209:
1210: hecb = &hect[ep];
1211: ecb = &ect[ep];
1212:
1213: thread = NULL;
1214: if (type == NW_RECEIVE || type == NW_RECEIVE_URGENT) {
1215: w = hecb->rx_first;
1216: if (w != NULL) {
1217: thread = w->waiter;
1218: hecb->rx_first = w->next;
1219: if (hecb->rx_first == NULL)
1220: hecb->rx_last = NULL;
1221: w->next = nw_free_waiter;
1222: nw_free_waiter = w;
1223: task = thread->task;
1224: pv = hecb->pv;
1225: while (pv != NULL && pv->owner != task)
1226: pv = pv->next;
1227: if (pv == NULL) {
1228: rc = FALSE;
1229: } else {
1230: buf = (nw_buffer_t) ((char *) result - ecb->buf_start + pv->buf_start);
1231: rc = mk_deliver_result(thread, (int) buf);
1232: }
1233: } else {
1234: rx_header = nc_rx_header_allocate();
1235: if (rx_header == NULL) {
1236: rc = FALSE;
1237: } else {
1238: rx_header->buffer = (nw_buffer_t) result;
1239: if (type == NW_RECEIVE) {
1240: rx_header->next = NULL;
1241: if (ecb->rx_last == NULL)
1242: ecb->rx_first = rx_header;
1243: else
1244: ecb->rx_last->next = rx_header;
1245: ecb->rx_last = rx_header;
1246: } else {
1247: rx_header->next = ecb->rx_first;
1248: if (ecb->rx_first == NULL)
1249: ecb->rx_last = rx_header;
1250: ecb->rx_first = rx_header;
1251: }
1252: rc = TRUE;
1253: }
1254: }
1255: } else if (type == NW_SEND) {
1256: w = hecb->tx_first;
1257: if (w == NULL) {
1258: rc = FALSE;
1259: } else {
1260: thread = w->waiter;
1261: hecb->tx_first = w->next;
1262: if (hecb->tx_first == NULL)
1263: hecb->tx_last = NULL;
1264: w->next = nw_free_waiter;
1265: nw_free_waiter = w;
1266: rc = mk_deliver_result(thread, result);
1267: }
1268: tx_header = ect[ep].tx_initial;
1269: if (result == NW_SUCCESS) {
1270: lep = tx_header->peer.local_ep;
1271: while (tx_header != NULL) {
1272: if (tx_header->buffer != NULL)
1273: nc_buffer_deallocate(lep, tx_header->buffer);
1274: tx_header = tx_header->next;
1275: }
1276: }
1277: nc_tx_header_deallocate(ect[ep].tx_initial);
1278: ect[ep].tx_initial = ect[ep].tx_current = NULL;
1279: } else if (type == NW_SIGNAL) {
1280: thread = hecb->sig_waiter;
1281: hecb->sig_waiter = NULL;
1282: if (thread == NULL) {
1283: rc = FALSE;
1284: } else {
1285: rc = mk_deliver_result(thread, result);
1286: }
1287: }
1288: return rc;
1289: }
1290:
1291: int mk_fast_sweep() {
1292:
1293: nw_lock();
1294: nc_fast_sweep();
1295: nw_unlock();
1296: return 0;
1297: }
1298:
1299: void h_fast_timer_set() {
1300:
1301: #ifdef PRODUCTION
1302: if (!nw_fast_timer.set)
1303: set_timeout(&nw_fast_timer, 1);
1304: #endif
1305: }
1306:
1307: void h_fast_timer_reset() {
1308:
1309: if (nw_fast_timer.set)
1310: reset_timeout(&nw_fast_timer);
1311: }
1312:
1313: int mk_slow_sweep() {
1314:
1315: #ifdef PRODUCTION
1316: nw_lock();
1317: nc_slow_sweep();
1318: nw_unlock();
1319: set_timeout(&nw_slow_timer, 2*hz);
1320: return 0;
1321: #endif
1322: }
1323:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.