![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to msg386.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / kernel / io.386|
Return to msg386.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / io.386 |
1.1 root 1: /*
2: * System V Compatible Messaging
3: *
4: * This module provides System V compatible messaging operations.
5: */
6: #include <sys/coherent.h>
7: #include <sys/sched.h>
8: #include <sys/types.h>
9: #include <sys/uproc.h>
10: #include <errno.h>
11: #include <sys/stat.h>
12: #include <sys/con.h>
13: #include <sys/seg.h>
14: #include <sys/msg.h>
15:
16: /*
17: * Global Message Parameters. We want them to be patchable.
18: */
19: unsigned NMSQID = 50; /* maximum number of message queues */
20: unsigned NMSQB = 4096; /* default maximum queue size in bytes */
21: unsigned NMSG = 40; /* maximum number of messages per queue */
22: unsigned NMSC = 2048; /* message text size */
23:
24: #ifdef TRACER
25: int dballoc = 0; /* For debug only */
26: int dbfree = 0;
27: #endif
28:
29: /* Message Information */
30: struct msqid_ds *msqs = NULL; /* Array of message queues */
31: GATE *msg_gate; /* Message gates */
32: char **msg_map; /* Memory map */
33:
34: /*
35: * Msgctl - Message Control Operations.
36: */
37: umsgctl(qid, cmd, buf)
38: int qid;
39: int cmd;
40: struct msqid_ds *buf;
41: {
42: register struct msqid_ds *qp; /* message queues */
43: register struct msg *mp; /* single message queue */
44: unsigned short n; /* temporary variable */
45:
46: /* Validate qid */
47: if (qid < 0) {
48: u.u_error = EINVAL;
49: return -1;
50: }
51: qp = &msqs[qid % NMSQID];
52:
53: /* Validate queue existence.*/
54: if (qp->msg_perm.seq != qid || (qp->msg_perm.mode & IPC_ALLOC) == 0) {
55: u.u_error = EINVAL;
56: return -1;
57: }
58:
59: switch (cmd) {
60: case IPC_STAT:
61: /* Validate access authority. */
62: if ((ipcaccess(&qp->msg_perm) & MSG_R) == 0) {
63: u.u_error = EACCES;
64: break;
65: }
66:
67: /* Copy queue info to user buffer */
68: kucopy(qp, buf, sizeof(struct msqid_ds));
69: break;
70: case IPC_SET:
71: /* Validate modify authority. */
72: if ((u.u_uid != 0) && (u.u_uid != qp->msg_perm.uid)) {
73: u.u_error = EPERM;
74: break;
75: }
76:
77: /*
78: * Get desired queue size.
79: */
80: n = getusd(&(buf->msg_qbytes));
81: if (u.u_error)
82: break;
83:
84: /*
85: * Only super-user can increase queue size.
86: */
87: if ((u.u_uid != 0) && (n > qp->msg_qbytes)) {
88: u.u_error = EPERM;
89: break;
90: }
91:
92: /*
93: * Set queue parameters.
94: */
95: qp->msg_perm.uid = getusd(&(buf->msg_perm.uid));
96: qp->msg_perm.gid = getusd(&(buf->msg_perm.gid));
97: qp->msg_perm.mode &= ~0777;
98: qp->msg_perm.mode |= getusd(&(buf->msg_perm.mode)) & 0777;
99: /* We may want to change the max size of a single message too.
100: * It is not obvious how to do it. There is no
101: * description in SVID. So it is possible that at some point
102: * the size of the single message happens to be greater than
103: * the size of message queue ;-(
104: */
105: qp->msg_qbytes = NMSQB = n;
106: break;
107:
108: case IPC_RMID:
109: /* Validate removal authority. */
110: if ((u.u_uid != 0) && (u.u_uid != qp->msg_perm.uid)) {
111: u.u_error = EPERM;
112: break;
113: }
114: /* Free all messages on the queue being removed. */
115: while (mp = qp->msg_first) {
116: qp->msg_first = mp->msg_next;
117: T_MSGQ(0x01, dballoc -= sizeof(struct msg));
118: msgfree(mp);
119: }
120: T_MSGQ(0x01, printf("F%d", dballoc));
121:
122: /* Reset queue parameters. */
123: qp->msg_last = NULL;
124: qp->msg_qnum = 0;
125: qp->msg_cbytes = 0;
126: qp->msg_perm.mode = 0;
127: /* Set last change time */
128: qp->msg_ctime = timer.t_time;
129: /* We have to pick up a new unique sequence number.
130: * There is a "wrap around bug". But, it is BCS.
131: */
132: qp->msg_perm.seq += (unsigned short) 50;
133: break;
134: default:
135: u.u_error = EINVAL;
136: }
137:
138: if (u.u_error)
139: return -1;
140:
141: return 0;
142: }
143:
144: /*
145: * Msgget - Get set of messages
146: */
147: umsgget(mykey, msgflg)
148: key_t mykey;
149: int msgflg;
150: {
151: register struct msqid_ds *qp;
152: register struct msqid_ds *freeidp = NULL;
153: int rwmode;
154:
155: /* Init message queues on the first msgget */
156: if (msqs == NULL)
157: if (msginit()) {
158: u.u_error = ENOSPC;
159: return -1;
160: }
161: /* Extract desired access mode from flags. */
162: rwmode = msgflg & 0777; /* 0666 ??? */
163: T_MSGQ(0x02, printf("U%o", rwmode));
164: /* Search for desired message queue [also for first free queue]. */
165: for (qp = msqs; qp < msqs + NMSQID; qp++) {
166: /* Look for an older free queue */
167: if (!(qp->msg_perm.mode & IPC_ALLOC)) {
168: if (freeidp == NULL
169: || freeidp->msg_ctime > qp->msg_ctime)
170: freeidp = qp;
171: continue;
172: }
173: if (mykey == IPC_PRIVATE) { /* creat a new queue */
174: if (msgflg & IPC_EXCL) /* unique new queue */
175: if (mykey == qp->msg_perm.key) {
176: u.u_error = EEXIST;/* We cannot creat */
177: return -1; /* exclusive queue */
178: }
179: continue;
180: }
181: if (qp->msg_perm.key != mykey)
182: continue;
183: if (mykey == qp->msg_perm.key) { /* found! */
184: if ((msgflg & IPC_CREAT) && (msgflg & IPC_EXCL)) {
185: u.u_error = EEXIST; /* We cannot creat */
186: return -1; /* exclusive queue */
187: }
188: /* PERMISSIONS */
189: /* For super-user or if mode is 0 */
190: if (u.u_uid == 0 || !rwmode)
191: return qp->msg_perm.seq;
192: /* For owner or creator */
193: T_MSGQ(0x02, printf("Q%o", qp->msg_perm.mode));
194: if (u.u_uid == qp->msg_perm.uid
195: || u.u_uid == qp->msg_perm.cuid)
196: if (
197: ((rwmode & 0600)<=(qp->msg_perm.mode & 0600))
198: &&((rwmode & 060)<=(qp->msg_perm.mode & 060))
199: &&((rwmode & 06)<=(qp->msg_perm.mode & 06)))
200: return qp->msg_perm.seq;
201: else {
202: u.u_error = EACCES;
203: return -1;
204: }
205: /* For group */
206: if (u.u_gid == qp->msg_perm.gid
207: || u.u_gid == qp->msg_perm.cgid)
208: if (((rwmode & 0660)<=(qp->msg_perm.mode & 060))
209: &&((rwmode & 06)<=(qp->msg_perm.mode & 06)))
210: return qp->msg_perm.seq;
211: else {
212: u.u_error = EACCES;
213: return -1;
214: }
215: /* For the rest of the world */
216: if ((rwmode & 0666) <= (qp->msg_perm.mode & 06))
217: return qp->msg_perm.seq;
218: else {
219: u.u_error = EACCES;
220: return -1;
221: }
222: }
223: }
224:
225: /* Creat a new queue */
226: if (!(msgflg & IPC_CREAT)) {
227: u.u_error = ENOENT;
228: return -1;
229: }
230: if ((qp = freeidp) == NULL) {
231: u.u_error = ENOSPC;
232: return -1;
233: }
234: /* Set new queue */
235: qp->msg_ctime = timer.t_time;
236: qp->msg_perm.cuid = qp->msg_perm.uid = u.u_uid;
237: qp->msg_perm.cgid = qp->msg_perm.gid = u.u_gid;
238: qp->msg_perm.mode = rwmode | IPC_ALLOC;
239: qp->msg_qnum = qp->msg_lspid = qp->msg_lrpid = qp->msg_stime
240: = qp->msg_rtime = 0;
241: qp->msg_perm.key = mykey;
242:
243: return qp->msg_perm.seq;
244: }
245:
246: /*
247: * Allocate space for the message queues and gates.
248: * Initialize message queue headers
249: * Return -1 on error.
250: */
251: msginit()
252: {
253: struct msqid_ds *qp;
254:
255: T_MSGQ(0x01, printf("A%d",dballoc += sizeof(struct msqid_ds) * NMSQID));
256:
257: /* Allocate space for message headers */
258: if ((msqs =
259: (struct msqid_ds *) kalloc(sizeof(struct msqid_ds) * NMSQID)) == NULL)
260: return -1;
261:
262: T_MSGQ(0x01, printf("A%d", dballoc += sizeof(GATE) * NMSQID));
263:
264: /* Allocate space for message gates */
265: if ((msg_gate = (GATE *) kalloc(sizeof(GATE) * NMSQID)) == NULL) {
266: kfree(msqs);
267: msqs = NULL;
268: return -1;
269: }
270:
271: T_MSGQ(0x01, printf("A%d", dballoc += sizeof(char *) * NMSQID * NMSG));
272:
273: /* Allocate space for the message map */
274: if ((msg_map = kalloc(sizeof(char *) * NMSQID * NMSG)) == NULL) {
275: kfree(msqs);
276: msqs = NULL;
277: kfree(msg_gate);
278: return -1;
279: }
280: /* Clear gate and map areas */
281: kclear(msg_gate, sizeof(GATE) * NMSQID);
282: kclear(msg_map, sizeof(char *) * NMSQID * NMSG);
283: /* Set initial queue values */
284: for (qp = msqs; qp < msqs + NMSQID; qp++) {
285: qp->msg_first = NULL; /* First and last pointers to */
286: qp->msg_last = NULL; /* message queue */
287: qp->msg_cbytes = 0; /* Number of bytes in queue */
288: qp->msg_qnum = 0; /* Number of messages in queue */
289: qp->msg_qbytes = NMSQB; /* Max size of a queue */
290: qp->msg_lspid = 0; /* Pid of last msgsnd */
291: qp->msg_lrpid = 0; /* Pid of last msgrcv */
292: qp->msg_stime = 0; /* Last msgsnd time */
293: qp->msg_rtime = 0; /* Last msgrcv time */
294: qp->msg_ctime = timer.t_time; /* Last change time */
295: qp->msg_perm.seq = qp - msqs;
296: qp->msg_perm.mode = 0;
297: }
298: return 0;
299: }
300:
301: /*
302: * Remove the message. Clear message text and header. Reset values in
303: * message map.
304: */
305: msgfree(mp)
306: struct msg *mp; /* Message header to be remove */
307: {
308:
309: kfree(msg_map[mp->msg_spot]);
310: msg_map[mp->msg_spot] = NULL;
311: kfree(mp);
312: T_MSGQ(0x01, printf("F%d", dballoc-=(mp->msg_ts + sizeof(struct msg))));
313: }
314:
315: /*
316: * Send a Message
317: */
318: umsgsnd(qid, bufp, msgsz, msgflg)
319: int qid; /* queue id */
320: struct msgbuf *bufp; /* message buffer */
321: int msgsz, /* message size */
322: msgflg; /* flags */
323: {
324: register struct msqid_ds *qp; /* message queue */
325: register struct msg *mp, /* message struct */
326: *tmp;
327: int q_num; /* number of a queue */
328: int i_spot; /* # of empty entry in map */
329:
330: /* Validate queue identifier. */
331: for (qp = msqs; qp < msqs + NMSQID; qp++)
332: if (qp->msg_perm.seq == qid) /* found */
333: break;
334:
335: q_num = qp - msqs;
336: /* qid is not a valid qid identifier */
337: if (q_num >= NMSQID) {
338: u.u_error = EINVAL;
339: return -1;
340: }
341:
342: if (!(ipcaccess(&qp->msg_perm) & MSG_W)) { /* can't send mesg */
343: u.u_error = EACCES;
344: return -1;
345: }
346:
347: /* Check if message has a valid message type and size.
348: * The comparisson with NMSQB was done because user could
349: * reduce this value.
350: */
351: if (bufp->mtype < 1 || msgsz < 0 || msgsz > NMSC || msgsz > NMSQB) {
352: u.u_error = EACCES;
353: return -1;
354: }
355:
356: /* Now we have a valid message. Check if we can send it. */
357: lock(msg_gate[q_num]); /* Lock it to avoid race condition */
358: while (qp->msg_qnum >= NMSG ||
359: qp->msg_qbytes < (qp->msg_cbytes + msgsz)) {
360: if (msgflg & IPC_NOWAIT) {
361: u.u_error = EAGAIN;
362: unlock(msg_gate[q_num]);
363: return -1;
364: }
365: /* We have to wait here */
366: qp->msg_perm.mode |= MSG_WWAIT;
367: unlock(msg_gate[q_num]);
368: x_sleep(qp, pritty, slpriSigCatch, "umsgsnd");
369:
370: /* Abort if a signal was received */
371: if (SELF->p_ssig && nondsig()) {
372: u.u_error = EINTR;
373: return -1;
374: }
375:
376: /* Abort if the message queue was removed. */
377: if (qid != qp->msg_perm.seq) {
378: u.u_error = EINVAL;
379: return -1;
380: }
381: lock(msg_gate[q_num]);
382: }
383:
384: /* Find empty entry in message map */
385: for (i_spot = 0; i_spot < NMSQID * NMSG; i_spot++)
386: if (msg_map[i_spot] == NULL)
387: break;
388: /* It cannot happen when we do not have empty entry in map,
389: * but let check it.
390: */
391: if (i_spot >= NMSQID * NMSG) {
392: u.u_error = ENOSPC;
393: return -1;
394: }
395:
396: T_MSGQ(0x01, printf("A%d", dballoc += sizeof(struct msg)));
397:
398: /* Get space for the message header */
399: if ((mp = kalloc(sizeof(struct msg))) == NULL) {
400: unlock(msg_gate[q_num]);
401: u.u_error = ENOSPC;
402: return -1;
403: }
404:
405: T_MSGQ(0x01, printf("A%d", dballoc += msgsz));
406:
407: /* Alloc space for the message text */
408: if ((msg_map[i_spot] = kalloc(msgsz)) == NULL) {
409: kfree(mp);
410: unlock(msg_gate[q_num]);
411: u.u_error = ENOSPC;
412: return -1;
413: }
414:
415: mp->msg_next = NULL;
416: mp->msg_ts = msgsz;
417: /* The map address is a number of msg_map array element */
418: mp->msg_spot = i_spot;
419:
420: /* Transfer the message type and text.*/
421: if (ukcopy(&(bufp->mtype), &(mp->msg_type), sizeof(mp->msg_type)) !=
422: sizeof(mp->msg_type))
423: u.u_error = EFAULT;
424: if (ukcopy(&bufp->mtext[0], msg_map[i_spot], msgsz) != msgsz)
425: u.u_error = EFAULT;
426: if (u.u_error) {
427: msgfree(mp);
428: unlock(msg_gate[q_num]);
429: return -1;
430: }
431:
432: /* Move the message to the desired queue. */
433: if (qp->msg_first == NULL) /* This is the first message per queue */
434: qp->msg_first = qp->msg_last = mp;
435: else { /* There are messages */
436: /* Find last message in gueue */
437: for (tmp = qp->msg_first; ; tmp = tmp->msg_next)
438: if (tmp->msg_next == NULL)
439: break;
440: qp->msg_last = tmp->msg_next = mp;
441: }
442: mp->msg_next = NULL;
443:
444: /* Update queue statistics. */
445: qp->msg_cbytes += msgsz;
446: qp->msg_qnum++;
447: qp->msg_lspid = SELF->p_pid;
448: qp->msg_stime = timer.t_time;
449:
450: /* Unlock queue and wake processes waiting to receive. */
451: unlock(msg_gate[q_num]);
452: if (qp->msg_perm.mode & MSG_RWAIT) {
453: qp->msg_perm.mode &= ~MSG_RWAIT;
454: wakeup(qp);
455: }
456: return 0;
457: }
458:
459: /*
460: * Receive a Message
461: */
462: umsgrcv(qid, bufp, msgsz, msgtyp, msgflg)
463: int qid; /* Message queue id */
464: struct msgbuf *bufp; /* Message buffer */
465: int msgsz; /* Message text size */
466: long msgtyp; /* Message type */
467: int msgflg; /* Message flag */
468: {
469: register struct msqid_ds *qp; /* queue headers */
470: register struct msg *mp, /* message headers */
471: *prev;
472: int q_num; /* queue number */
473: int i_spot;
474:
475: /* Validate queue identifier. */
476: if (qid < 0 || msqs == NULL) {
477: u.u_error = EINVAL;
478: return -1;
479: }
480: q_num = qid % NMSQID;
481: qp = &msqs[q_num];
482:
483: /* Validate queue existence.*/
484: if (qp->msg_perm.seq != qid || (qp->msg_perm.mode & IPC_ALLOC) == 0) {
485: u.u_error = EINVAL;
486: return -1;
487: }
488:
489: /* Permission denied */
490: if ((ipcaccess(&qp->msg_perm) & MSG_R) == 0) {
491: u.u_error = EACCES;
492: return -1;
493: }
494:
495: /* Wait for message */
496: lock(msg_gate[q_num]);
497: for (;;) {
498: prev = NULL;
499: mp = qp->msg_first;
500: /* Find mesg of type <= abs(msgtyp) */
501: if (msgtyp < 0) {
502: struct msg *qmin; /* Message with lowest mtype */
503: struct msg *xprev; /* Previous message */
504:
505: qmin = NULL;
506: xprev = prev;
507: msgtyp = -msgtyp;
508:
509: for (; mp != NULL; prev = mp, mp = mp->msg_next) {
510: if (mp->msg_type > msgtyp)
511: continue;
512: if (qmin == NULL
513: || mp->msg_type < qmin->msg_type) {
514: xprev = prev;
515: qmin = mp;
516: }
517: }
518: prev = xprev;
519: mp = qmin;
520: msgtyp = -msgtyp;
521: } else if (msgtyp > 0) { /* Find message of type == msgtyp */
522: while (mp != NULL && mp->msg_type != msgtyp) {
523: prev = mp;
524: mp = mp->msg_next;
525: }
526: } else /* Else take first message */
527: mp = qp->msg_first;
528:
529: if (mp != NULL) /* Found */
530: break;
531:
532: /* Can't wait to receive mesg */
533: if (msgflg & IPC_NOWAIT) {
534: u.u_error = EAGAIN;
535: unlock(msg_gate[q_num]);
536: return -1;
537: }
538:
539: /* We can go sleep now */
540: qp->msg_perm.mode |= MSG_RWAIT;
541: unlock(msg_gate[q_num]);
542: x_sleep(qp, pritty, slpriSigCatch, "umsgrcv");
543:
544: /* Signal received */
545: if (SELF->p_ssig && nondsig()) {
546: u.u_error = EINTR;
547: return -1;
548: }
549:
550: /* Not same q anymore */
551: if (qid != qp->msg_perm.seq) {
552: u.u_error = EINVAL;
553: return -1;
554: }
555: lock(msg_gate[q_num]);
556: }
557:
558: /* Ensure entire message can be transferred, or MSG_NOERROR asserted.*/
559: if (msgsz < mp->msg_ts && (msgflg & MSG_NOERROR) == 0) {
560: unlock(msg_gate[q_num]);
561: u.u_error = E2BIG;
562: return -1;
563: }
564:
565: /* Transfer message data */
566: if (msgsz > mp->msg_ts)
567: msgsz = mp->msg_ts;
568:
569: kucopy(&(mp->msg_type), &(bufp->mtype), sizeof(mp->msg_type));
570:
571: i_spot = mp->msg_spot;
572: if (kucopy(msg_map[i_spot], bufp->mtext, msgsz) != msgsz)
573: u.u_error = EFAULT;
574:
575: /* Abort if address fault occurred during transfer. */
576: if (u.u_error) {
577: unlock(msg_gate[q_num]);
578: return -1;
579: }
580: /* Remove message from queue */
581: if (prev != NULL)
582: prev->msg_next = mp->msg_next;
583: else
584: qp->msg_first = mp->msg_next;
585:
586: if (qp->msg_last == mp)
587: qp->msg_last = prev;
588:
589:
590: /* Update queue statistics */
591: qp->msg_cbytes -= mp->msg_ts;
592: qp->msg_qnum--;
593: qp->msg_lrpid = SELF->p_pid;
594: qp->msg_rtime = timer.t_time;
595:
596: /* free message */
597: msgfree(mp);
598:
599: unlock(msg_gate[q_num]);
600: /* Wakeup processes waiting to send. */
601: if (qp->msg_perm.mode & MSG_WWAIT) {
602: qp->msg_perm.mode &= ~MSG_WWAIT;
603: wakeup(qp);
604: }
605: return msgsz;
606: }
607:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.