![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fipc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / OSKit-Mach / ipc|
Return to fipc.c CVS log | Up to [GnuMach] / OSKit-Mach / ipc |
1.1 root 1: /*
2: * Copyright (c) 1996-1994 The University of Utah and
3: * the Computer Systems Laboratory (CSL). All rights reserved.
4: *
5: * Permission to use, copy, modify and distribute this software is hereby
6: * granted provided that (1) source code retains these copyright, permission,
7: * and disclaimer notices, and (2) redistributions including binaries
8: * reproduce the notices in supporting documentation, and (3) all advertising
9: * materials mentioning features or use of this software display the following
10: * acknowledgement: ``This product includes software developed by the
11: * Computer Systems Laboratory at the University of Utah.''
12: *
13: * THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
14: * IS" CONDITION. THE UNIVERSITY OF UTAH AND CSL DISCLAIM ANY LIABILITY OF
15: * ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
16: *
17: * CSL requests users of this software to return to [email protected] any
18: * improvements that they make and grant CSL redistribution rights.
19: *
20: * Utah $Hdr: fipc.c 1.1 96/2/29$
21: * Author: Linus Kamb
22: */
23:
24: #ifdef FIPC
25:
26: #include <mach/kern_return.h>
27:
28: #include <device/device_types.h>
29: #include <device/device.h>
30: #include <device/dev_hdr.h>
31: #include <device/device_port.h>
32: #include <device/io_req.h>
33: #include <device/if_ether.h>
34: #include <net_io.h>
35: #include <spl.h>
36: #include <kern/lock.h>
37:
38: #include "fipc.h"
39:
40: void fipc_packet();
41: void allocate_fipc_buffers(boolean_t);
42: int fipc_lookup(unsigned short port);
43: int fipc_lookup_table_enter(unsigned short port);
44: int fipc_lookup_table_remove(unsigned short port);
45: int f_lookup_hash(unsigned short port);
46: int fipc_done(io_req_t ior);
47:
48:
49: /********************************************************************
50: * fipc variables
51: ********************************************************************/
52:
53: fipc_port_t fports[N_MAX_OPEN_FIPC_PORTS];
54: fipc_lookup_table_ent fipc_lookup_table[N_MAX_OPEN_FIPC_PORTS];
55:
56: int n_free_recv_bufs = 0;
57: int n_free_send_bufs = 0;
58: int n_fipc_recv_ports_used = 0;
59:
60: int fipc_sends = 0;
61: int fipc_recvs =0;
62:
63: fipc_stat_t fipc_stats;
64:
65: char *fipc_recv_free_list = NULL;
66: char *fipc_recv_free_list_tail = NULL;
67: char *fipc_send_free_list = NULL;
68: char *fipc_send_free_list_tail = NULL;
69:
70: /* fipc locks */
71: decl_simple_lock_data(, fipc_lock);
72: decl_simple_lock_data(, fipc_buf_q_lock);
73:
74:
75: /*
76: * Routine: fipc_init(): initializes the fipc data structures.
77: */
78:
79: void fipc_init(void)
80: {
81: int i;
82:
83: allocate_fipc_buffers(TRUE); /* recv buffers */
84: allocate_fipc_buffers(FALSE); /* send buffers */
85:
86: fipc_stats.dropped_msgs = 0;
87:
88: bzero (&fports, sizeof(fports));
89: for (i=0; i<N_MAX_OPEN_FIPC_PORTS; i++)
90: {
91: simple_lock_init(&(fports[i].lock));
92: fipc_lookup_table[i].fpt_num = INVALID;
93: fipc_lookup_table[i].fipc_port = INVALID;
94: }
95: }
96:
97:
98: /*
99: * Routine: allocate_fipc_buffers(): allocate more buffers
100: * Currently we are only allocating 1500 byte (ETHERMTU) buffers.
101: * We use the first word in the buffer as the pointer to the next.
102: */
103:
104: void allocate_fipc_buffers(boolean_t r_buf)
105: {
106: char *new_pg;
107: char **free_list, **free_list_tail;
108: int *free_count, min_count, max_count;
109: int total_buffer_size;
110:
111: if (r_buf)
112: {
113: free_count = &n_free_recv_bufs;
114: min_count = N_MIN_RECV_BUFS;
115: max_count = N_MAX_RECV_BUFS;
116: free_list = &fipc_recv_free_list;
117: free_list_tail = &fipc_recv_free_list_tail;
118: total_buffer_size = (N_MAX_RECV_BUFS * FIPC_BUFFER_SIZE);
119: total_buffer_size = round_page(total_buffer_size);
120: }
121: else
122: {
123: free_count = &n_free_send_bufs;
124: min_count = N_MIN_SEND_BUFS;
125: max_count = N_MAX_SEND_BUFS;
126: free_list = &fipc_send_free_list;
127: free_list_tail = &fipc_send_free_list_tail;
128: total_buffer_size = (N_MAX_SEND_BUFS * FIPC_BUFFER_SIZE);
129: total_buffer_size = round_page(total_buffer_size);
130: }
131:
132: if (!(*free_count)) /* empty buffer pool */
133: {
134: #ifdef FI_DEBUG
135: printf ("Allocating new fipc ");
136: if (r_buf)
137: printf ("recv buffer pool.\n");
138: else
139: printf ("send buffer pool.\n");
140: #endif
141: *free_list = (char*)kalloc (total_buffer_size);
142: if (!*free_list) /* bummer */
143: panic("allocate_fipc_buffers: no memory");
144: *free_list_tail = *free_list;
145: for (*free_count=1; *free_count<max_count; (*free_count)++)
146: {
147: *(char**)*free_list_tail = *free_list_tail + FIPC_BUFFER_SIZE;
148: *free_list_tail += FIPC_BUFFER_SIZE;
149: }
150: *(char**)*free_list_tail = NULL;
151: }
152: else /* Request to grow the buffer pool. */
153: {
154: #ifdef FI_DEBUG
155: printf ("Growing fipc ");
156: if (r_buf)
157: printf ("recv buffer pool.\n");
158: else
159: printf ("send buffer pool.\n");
160: #endif
161:
162: #define GROW_SIZE 8192
163: new_pg = (char*)kalloc (round_page(GROW_SIZE));
164: if (new_pg)
165: {
166: int new_cnt, n_new = GROW_SIZE / FIPC_BUFFER_SIZE;
167:
168: if (*free_list_tail != NULL)
169: *(char**)*free_list_tail = new_pg;
170: for ( new_cnt =0; new_cnt<n_new; new_cnt++)
171: {
172: *(char**)*free_list_tail = *free_list_tail + FIPC_BUFFER_SIZE;
173: *free_list_tail += FIPC_BUFFER_SIZE;
174: }
175: *(char**)*free_list_tail = NULL;
176: *free_count +=new_cnt;
177: }
178: #ifdef FI_DEBUG
179: else
180: printf ("### kalloc failed in allocate_fipc_buffers()\n");
181: #endif
182:
183: }
184: }
185:
186:
187: /*
188: * Routine: get_fipc_buffer (): returns a free buffer
189: * Takes a size (currently not used), a boolean flag to tell if it is a
190: * receive buffer, and a boolean flag if the request is coming at interrupt
191: * level.
192: */
193:
194: inline
195: char* get_fipc_buffer(int size, boolean_t r_buf, boolean_t at_int_lvl)
196: {
197: /* we currently don't care about size, since there is only one
198: * buffer pool. */
199:
200: char* head;
201: char **free_list;
202: int *free_count, min_count;
203:
204: if (r_buf)
205: {
206: free_count = &n_free_recv_bufs;
207: free_list = &fipc_recv_free_list;
208: min_count = N_MIN_RECV_BUFS;
209: }
210: else
211: {
212: free_count = &n_free_send_bufs;
213: free_list = &fipc_send_free_list;
214: min_count = N_MIN_SEND_BUFS;
215: }
216:
217: /*
218: * Since we currently allocate a full complement of receive buffers,
219: * there is no need to allocate more receive buffers. But that is likely
220: * to change, I'm sure.
221: */
222:
223: if (*free_count < min_count)
224: {
225: if (!at_int_lvl)
226: allocate_fipc_buffers(r_buf);
227: }
228:
229: if (*free_count)
230: {
231: head = *free_list;
232: *free_list = *(char**)*free_list;
233: (*free_count)--;
234: return head;
235: }
236: else
237: return NULL;
238: }
239:
240:
241: /*
242: * Routine: return_fipc_buffer (): puts a used buffer back in the pool.
243: */
244:
245: inline
246: void return_fipc_buffer(char* buf, int size,
247: boolean_t r_buf, boolean_t at_int_lvl)
248: {
249: /* return the buffer to the free pool */
250: char **free_list, **free_list_tail;
251: int *free_count, min_count;
252:
253: if (r_buf)
254: {
255: free_count = &n_free_recv_bufs;
256: free_list = &fipc_recv_free_list;
257: free_list_tail = &fipc_recv_free_list_tail;
258: min_count = N_MIN_RECV_BUFS;
259: }
260: else
261: {
262: free_count = &n_free_send_bufs;
263: free_list = &fipc_send_free_list;
264: free_list_tail = &fipc_send_free_list_tail;
265: min_count = N_MIN_SEND_BUFS;
266: }
267:
268: #ifdef FI_SECURE
269: bzero(buf, FIPC_BUFFER_SIZE);
270: #endif
271:
272: if (*free_list_tail != NULL)
273: *(char**)*free_list_tail = buf;
274: *free_list_tail = buf;
275: (*free_count)++;
276: *(char**)buf = NULL;
277:
278: if (!at_int_lvl)
279: if (*free_count < min_count)
280: allocate_fipc_buffers(r_buf);
281:
282: return;
283: }
284:
285: inline
286: int f_lookup_hash(unsigned short port)
287: {
288: /* Ok, so it's not really a hash function */
289: int bail=0;
290: int chk=0;
291:
292: if (n_fipc_recv_ports_used == N_MAX_OPEN_FIPC_PORTS ||
293: port > MAX_FIPC_PORT_NUM)
294: return INVALID;
295:
296: while (fipc_lookup_table[chk].fipc_port != port &&
297: fipc_lookup_table[chk].fpt_num != INVALID &&
298: bail < N_MAX_OPEN_FIPC_PORTS)
299: {
300: chk = (chk+1) % N_MAX_OPEN_FIPC_PORTS;
301: bail++;
302: }
303:
304: /* This is redundent, but better safe then sorry */
305: if (bail<N_MAX_OPEN_FIPC_PORTS)
306: return chk;
307: else
308: return INVALID;
309: }
310:
311: inline
312: int fipc_lookup_table_enter(unsigned short port)
313: {
314: int cfpn = n_fipc_recv_ports_used;
315: int lu_tbl_num = f_lookup_hash(port);
316:
317: if (lu_tbl_num == INVALID)
318: return INVALID;
319:
320: fipc_lookup_table[lu_tbl_num].fipc_port = port;
321: fipc_lookup_table[lu_tbl_num].fpt_num = cfpn;
322: n_fipc_recv_ports_used += 1;
323: return cfpn;
324: }
325:
326: inline
327: int fipc_lookup(unsigned short port)
328: {
329: int chk = f_lookup_hash(port);
330:
331: if (chk == INVALID)
332: return INVALID;
333:
334: if (fipc_lookup_table[chk].fpt_num == INVALID)
335: return fipc_lookup_table_enter(port);
336: else
337: return fipc_lookup_table[chk].fpt_num;
338: }
339:
340: inline
341: int fipc_lookup_table_remove(unsigned short port)
342: {
343: int chk = f_lookup_hash(port);
344:
345: if (chk == INVALID)
346: return 0;
347:
348: if (fipc_lookup_table[chk].fipc_port == port)
349: {
350: fports[fipc_lookup_table[chk].fpt_num].valid_msg = 0;
351: fports[fipc_lookup_table[chk].fpt_num].bound = FALSE;
352: fipc_lookup_table[chk].fpt_num = INVALID;
353: fipc_lookup_table[chk].fipc_port = INVALID;
354: n_fipc_recv_ports_used -=1;
355: return 1;
356: }
357: return 0;
358: }
359:
360: /*
361: * Routine: fipc_packet(): handles incoming fipc packets.
362: * does some simple packet handling and wakes up receiving thread, if any.
363: * called by device controller (currently, nerecv only.)
364: * called at interrupt level and splimp.
365: * Messages are dropped if the recv queue is full.
366: */
367:
368: void fipc_packet( char* msg_buf, struct ether_header sender)
369: {
370: int to_port = ((fipc_header_t*)msg_buf)->dest_port;
371: int from_port = ((fipc_header_t*)msg_buf)->send_port;
372: int f_tbl_num;
373: fipc_port_t *cfp;
374: fipc_buffer_q_ent *crqe;
375: int *tail;
376:
377: #ifdef FI_DEBUG
378: printf ("fipc_packet :(0x%x) %s", msg_buf,
379: msg_buf+sizeof(fipc_header_t));
380: #endif
381:
382: f_tbl_num = fipc_lookup(to_port);
383: if (f_tbl_num == INVALID)
384: {
385: #ifdef FI_DEBUG
386: printf ("Lookup failed.\n");
387: #endif
388: fipc_stats.dropped_msgs += 1;
389: return_fipc_buffer (msg_buf, FIPC_BUFFER_SIZE, TRUE, TRUE);
390: return;
391: }
392:
393: cfp = &fports[f_tbl_num];
394: tail = &cfp->rq_tail;
395: crqe = &cfp->recv_q[*tail];
396:
397: if (cfp->valid_msg == FIPC_RECV_Q_SIZE)
398: {
399: /* Queue full.
400: * Drop packet, return buffer, and return. */
401: #ifdef FI_DEBUG
402: printf ("Port %d queue is full: valid_msg count: %d\n",
403: to_port, cfp->valid_msg);
404: #endif
405: fipc_stats.dropped_msgs += 1;
406: return_fipc_buffer (msg_buf, FIPC_BUFFER_SIZE, TRUE, TRUE);
407: return;
408: }
409:
410: /* "enqueue" at "tail" */
411: crqe->buffer = msg_buf;
412: crqe->size = ((fipc_header_t*)msg_buf)->msg_size;
413: /* This could certainly be done faster... */
414: bcopy(&(sender.ether_shost), &(crqe->sender.hwaddr), ETHER_HWADDR_SIZE);
415: /* This is actually useless, since there _is_ no sender port.. duh. */
416: crqe->sender.port = from_port;
417:
418: *tail = ((*tail)+1) % FIPC_RECV_Q_SIZE;
419:
420: if (cfp->bound)
421: thread_wakeup(&(cfp->valid_msg));
422: cfp->valid_msg++;
423: #ifdef FI_DEBUG
424: printf ("valid_msg: %d\n", cfp->valid_msg);
425: #endif
426:
427: return;
428: }
429:
430:
431: /*
432: * loopback(): for fipc_sends to the local host.
433: */
434:
435: inline
436: kern_return_t loopback(char *packet)
437: {
438: fipc_packet(packet+sizeof(struct ether_header),
439: *(struct ether_header*)packet);
440: return KERN_SUCCESS;
441: }
442:
443:
444: /********************************************************************
445: * Routine: fipc_send
446: ********************************************************************/
447:
448: kern_return_t syscall_fipc_send(fipc_endpoint_t dest,
449: char *user_buffer, int len)
450: {
451: #ifdef i386
452: static mach_device_t eth_device = 0;
453: #else
454: static device_t eth_device = 0;
455: #endif
456: static unsigned char hwaddr[ETHER_HWADDR_SIZE+2];
457:
458: io_return_t rc;
459: kern_return_t open_res, kr;
460: dev_mode_t mode = D_WRITE;
461: /* register */ io_req_t ior = NULL;
462: struct ether_header *ehdr;
463: fipc_header_t *fhdr;
464: int *d_addr;
465: int data_count;
466: char *fipc_buf, *data_buffer;
467: #ifdef FIPC_LOOPBACK
468: boolean_t local_send = FALSE;
469: #endif
470:
471: #ifdef FI_DEBUG
472: printf("fipc_send(dest: %s, port:%d, len:%d, buf:x%x) !!!\n",
473: ether_sprintf(dest.hwaddr), dest.port, len, user_buffer);
474: #endif
475:
476: if (dest.port > MAX_FIPC_PORT_NUM ||
477: len > FIPC_MSG_SIZE)
478: {
479: #ifdef FI_DEBUG
480: printf ("len: %d, dest.port: %u\n", len, dest.port);
481: #endif
482: return KERN_INVALID_ARGUMENT;
483: }
484:
485: /* We should only need to probe the device once. */
486:
487: if (!eth_device)
488: {
489: unsigned char net_hwaddr[ETHER_HWADDR_SIZE+2];
490: int stat_count = sizeof(net_hwaddr)/sizeof(int);
491:
492: /* XXX Automatic lookup for ne0 or ne1 was failing... */
493: eth_device = device_lookup(ETHER_DEVICE_NAME);
494: #ifdef i386
495: if (eth_device == (mach_device_t) DEVICE_NULL ||
496: eth_device == (mach_device_t)D_NO_SUCH_DEVICE)
497: #else
498: if (eth_device == DEVICE_NULL ||
499: eth_device == (device_t)D_NO_SUCH_DEVICE)
500: #endif
501: {
502: #ifdef FI_DEBUG
503: printf ("FIPC: Couldn't find ethernet device %s.\n",
504: ETHER_DEVICE_NAME);
505: #endif
506: return (KERN_FAILURE);
507: }
508:
509: /* The device should be open! */
510: if (eth_device->state != DEV_STATE_OPEN)
511: {
512: #ifdef FI_DEBUG
513: printf ("Opening ethernet device.\n");
514: #endif
515:
516: io_req_alloc (ior, 0);
517:
518: io_req_alloc (ior, 0);
519:
520: ior->io_device = eth_device;
521: ior->io_unit = eth_device->dev_number;
522: ior->io_op = IO_OPEN | IO_CALL;
523: ior->io_mode = mode;
524: ior->io_error = 0;
525: ior->io_done = 0;
526: ior->io_reply_port = MACH_PORT_NULL;
527: ior->io_reply_port_type = 0;
528:
529: /* open the device */
530: open_res =
531: (*eth_device->dev_ops->d_open)
532: (eth_device->dev_number,
533: (int)mode, ior);
534: if (ior->io_error != D_SUCCESS)
535: {
536: #ifdef FI_DEBUG
537: printf ("Failed to open device ne0\n");
538: #endif
539: return open_res;
540: }
541: }
542: #ifdef i386
543: rc = mach_device_get_status(eth_device, NET_ADDRESS,
544: net_hwaddr, &stat_count);
545: #else
546: rc = ds_device_get_status(eth_device, NET_ADDRESS, net_hwaddr,
547: &stat_count);
548: #endif
549: if (rc != D_SUCCESS)
550: {
551: #ifdef FI_DEBUG
552: printf("FIPC: Couldn't determine hardware ethernet address: %d\n",
553: rc);
554: #endif
555: return KERN_FAILURE;
556: }
557: *(int*)hwaddr = ntohl(*(int*)net_hwaddr);
558: *(int*)(hwaddr+4) = ntohl(*(int*)(net_hwaddr+4));
559: #ifdef FI_DEBUG
560: printf ("host: %s\n", ether_sprintf(hwaddr));
561: #endif
562: }
563:
564: #ifdef FIPC_LOOPBACK
565: if (!memcmp(dest.hwaddr, hwaddr, ETHER_HWADDR_SIZE))
566: /*
567: if ((*(int*)dest.hwaddr == *(int*)hwaddr) &&
568: ((*(int*)(((char*)dest.hwaddr+4) >> 16)) ==
569: ((*(int*)(((char*)hwaddr+4) >> 16)))))
570: */
571: {
572: local_send = TRUE;
573: #ifdef FI_DEBUG
574: printf ("loopback: \n");
575: printf ("host: %s, ", ether_sprintf(hwaddr));
576: printf ("dest: %s\n", ether_sprintf(dest.hwaddr));
577: #endif
578: }
579: #endif
580:
581: data_count = len + sizeof (struct ether_header)
582: + sizeof (fipc_header_t);
583:
584: #ifdef FIPC_LOOPBACK
585: fipc_buf = get_fipc_buffer(data_count, local_send, FALSE) ;
586: #else
587: fipc_buf = get_fipc_buffer(data_count, FALSE, FALSE) ;
588: #endif
589:
590: if (fipc_buf == NULL)
591: return KERN_RESOURCE_SHORTAGE;
592:
593: ehdr = (struct ether_header *)fipc_buf;
594: d_addr = (int *)ehdr->ether_dhost;
595:
596: *(int *)ehdr->ether_dhost = *(int*)dest.hwaddr;
597: *(int *)(ehdr->ether_dhost+4) = *(int*)(dest.hwaddr+4);
598: *(int *)ehdr->ether_shost = *(int *)hwaddr;
599: *(int *)(ehdr->ether_shost+4) = *(int *)(hwaddr+4);
600: ehdr->ether_type = 0x1234; /* Yep. */
601:
602: #ifdef FIPC_LOOPBACK
603: if (!local_send)
604: {
605: #endif
606: if (!ior)
607: io_req_alloc (ior, 0);
608:
609: /* Set up the device information. */
610: ior->io_device = eth_device;
611: ior->io_unit = eth_device->dev_number;
612: ior->io_op = IO_WRITE | IO_INBAND | IO_INTERNAL;
613: ior->io_mode = D_WRITE;
614: ior->io_recnum = 0;
615: ior->io_data = fipc_buf;
616: ior->io_count = data_count;
617: ior->io_total = data_count;
618: ior->io_alloc_size = 0;
619: ior->io_residual = 0;
620: ior->io_error = 0;
621: ior->io_done = fipc_done;
622: ior->io_reply_port = MACH_PORT_NULL;
623: ior->io_reply_port_type = 0;
624: ior->io_copy = VM_MAP_COPY_NULL;
625: #ifdef FIPC_LOOPBACK
626: }
627: #endif
628:
629: #ifdef FI_DEBUG
630: printf("sending from %s ", ether_sprintf(ehdr->ether_shost));
631: printf("to %s, type x%x, user_port x%x\n",
632: ether_sprintf(ehdr->ether_dhost),
633: (int)ehdr->ether_type,
634: (int)dest.port);
635: #endif
636:
637: if (len <= FIPC_MSG_SIZE)
638: {
639: fhdr = (fipc_header_t*)(fipc_buf+sizeof(struct ether_header));
640: fhdr->dest_port = dest.port;
641: fhdr->msg_size = len;
642: data_buffer = (char*)fhdr+sizeof(fipc_header_t);
643:
644: copyin (user_buffer, data_buffer,
645: min (FIPC_BUFFER_SIZE-sizeof(fipc_header_t), len));
646:
647: #ifdef FIPC_LOOPBACK
648: /*
649: * Sending to same node. Queue on dest.port of this node.
650: * We just call fipc_packet after setting up the necessary info
651: * and return. fipc_packet queues the packet on the receive
652: * queue for the destination port.
653: */
654: if (local_send)
655: return (loopback(fipc_buf));
656: #endif
657:
658: /* Now write to the device */
659: /* d_port_death has been co-opted for fipc stuff.
660: * It maps to nefoutput(). */
661:
662: rc = (*eth_device->dev_ops->d_port_death) /* that's the one */
663: (eth_device->dev_number, ior);
664: }
665: #ifdef FI_DEBUG
666: else /* len > ETHERMTU: multi-packet request */
667: printf ("### multi-packet messages are not supported.\n");
668: #endif
669:
670: if (rc == D_IO_QUEUED)
671: return KERN_SUCCESS;
672: else
673: return KERN_FAILURE;
674: }
675:
676: #ifdef FIPC_LOOPBACK
677: if (!local_send)
678: {
679: #endif
680: if (!ior)
681: io_req_alloc (ior, 0);
682:
683: /* Set up the device information. */
684: ior->io_device = eth_device;
685: ior->io_unit = eth_device->dev_number;
686: ior->io_op = IO_WRITE | IO_INBAND | IO_INTERNAL;
687: ior->io_mode = D_WRITE;
688: ior->io_recnum = 0;
689: ior->io_data = fipc_buf;
690: ior->io_count = data_count;
691: ior->io_total = data_count;
692: ior->io_alloc_size = 0;
693: ior->io_residual = 0;
694: ior->io_error = 0;
695: ior->io_done = fipc_done;
696: ior->io_reply_port = MACH_PORT_NULL;
697: ior->io_reply_port_type = 0;
698: ior->io_copy = VM_MAP_COPY_NULL;
699: #ifdef FIPC_LOOPBACK
700: }
701: #endif
702:
703: /********************************************************************
704: * syscall_fipc_recv()
705: *
706: ********************************************************************/
707:
708: kern_return_t syscall_fipc_recv(unsigned short user_port,
709: char *user_buffer, int *user_size, fipc_endpoint_t *user_sender)
710: {
711: char* f_buffer;
712: fipc_port_t *cfp;
713: fipc_buffer_q_ent *crqe;
714: int *head;
715: int msg_size;
716: int fport_num = fipc_lookup(user_port);
717: spl_t spl;
718:
719: #ifdef FI_DEBUG
720: printf("fipc_recv(0x%x, 0x%x) !!!\n", user_port, user_buffer);
721: #endif
722:
723: if (user_port > MAX_FIPC_PORT_NUM)
724: {
725: #ifdef FI_DEBUG
726: printf ("Invalid FIPC port: %u\n", user_port);
727: #endif
728: return KERN_INVALID_ARGUMENT;
729: }
730:
731: if (fport_num == INVALID)
732: return KERN_RESOURCE_SHORTAGE;
733:
734: cfp = &fports[fport_num];
735: head = &cfp->rq_head;
736: crqe = &cfp->recv_q[*head];
737:
738: if (cfp->bound != FALSE)
739: {
740: #ifdef FI_DEBUG
741: printf ("FIPC Port %u is currently bound.\n", user_port);
742: #endif
743: return KERN_RESOURCE_SHORTAGE;
744: }
745:
746: copyin(user_size, &msg_size, sizeof(int));
747:
748: spl = splimp();
749:
750: cfp->bound = TRUE;
751: while (!(cfp->valid_msg))
752: {
753: assert_wait(&(cfp->valid_msg), TRUE);
754: splx(spl);
755: thread_block ((void(*)())0);
756: if (current_thread()->wait_result != THREAD_AWAKENED)
757: {
758: cfp->bound = FALSE;
759: return KERN_FAILURE;
760: }
761: spl = splimp();
762: }
763:
764: cfp->valid_msg--;
765: f_buffer = crqe->buffer;
766: msg_size = min (crqe->size, msg_size);
767:
768: crqe->buffer = NULL;
769: crqe->size = 0;
770: *head = ((*head)+1) % FIPC_RECV_Q_SIZE;
771: cfp->bound = FALSE;
772:
773: splx(spl);
774:
775: copyout(f_buffer+sizeof(fipc_header_t), user_buffer, msg_size);
776: copyout(&(crqe->sender), user_sender, sizeof(fipc_endpoint_t));
777: copyout(&msg_size, user_size, sizeof(msg_size));
778:
779: return_fipc_buffer(f_buffer, FIPC_BUFFER_SIZE, TRUE, FALSE);
780:
781: return KERN_SUCCESS;
782: }
783:
784:
785: /*
786: * Final clean-up after the packet has been sent off.
787: */
788: int fipc_done(io_req_t ior)
789: {
790: return_fipc_buffer(ior->io_data, FIPC_BUFFER_SIZE, FALSE, FALSE);
791:
792: return 1;
793: }
794:
795: #endif /* FIPC */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.