URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [tags/] [before_ORP/] [uclinux/] [uClinux-2.0.x/] [ipc/] [msg.c] - Rev 1782
Go to most recent revision | Compare with Previous | Blame | View Log
/* * linux/ipc/msg.c * Copyright (C) 1992 Krishna Balasubramanian * * Kerneld extensions by Bjorn Ekwall <bj0rn@blox.se> in May 1995, and May 1996 * * See <linux/kerneld.h> for the (optional) new kerneld protocol */ #include <linux/config.h> #include <linux/errno.h> #include <linux/sched.h> #include <linux/msg.h> #include <linux/stat.h> #include <linux/malloc.h> #include <linux/kerneld.h> #include <linux/interrupt.h> #include <asm/segment.h> extern int ipcperms (struct ipc_perm *ipcp, short msgflg); static void freeque (int id); static int newque (key_t key, int msgflg); static int findkey (key_t key); static struct msqid_ds *msgque[MSGMNI]; static int msgbytes = 0; static int msghdrs = 0; static unsigned short msg_seq = 0; static int used_queues = 0; static int max_msqid = 0; static struct wait_queue *msg_lock = NULL; static int kerneld_msqid = -1; #define MAX_KERNELDS 20 static int kerneld_arr[MAX_KERNELDS]; static int n_kernelds = 0; void msg_init (void) { int id; for (id = 0; id < MSGMNI; id++) msgque[id] = (struct msqid_ds *) IPC_UNUSED; msgbytes = msghdrs = msg_seq = max_msqid = used_queues = 0; msg_lock = NULL; return; } /* * If the send queue is full, try to free any old messages. * These are most probably unwanted, since no one has picked them up... */ #define MSG_FLUSH_TIME 10 /* seconds */ static void flush_msg(struct msqid_ds *msq) { struct msg *nmsg; unsigned long flags; int flushed = 0; save_flags(flags); cli(); /* messages were put on the queue in time order */ while ( (nmsg = msq->msg_first) && ((CURRENT_TIME - nmsg->msg_stime) > MSG_FLUSH_TIME)) { msgbytes -= nmsg->msg_ts; msghdrs--; msq->msg_cbytes -= nmsg->msg_ts; msq->msg_qnum--; msq->msg_first = nmsg->msg_next; ++flushed; kfree(nmsg); } if (msq->msg_qnum == 0) msq->msg_first = msq->msg_last = NULL; restore_flags(flags); if (flushed) printk(KERN_WARNING "flushed %d old SYSVIPC messages", flushed); } static int real_msgsnd (int msqid, struct msgbuf *msgp, size_t msgsz, int msgflg) { int id, err; struct msqid_ds *msq; struct ipc_perm *ipcp; struct msg *msgh; long mtype; unsigned long flags; if (msgsz > MSGMAX || (long) msgsz < 0 || msqid < 0) return -EINVAL; if (!msgp) return -EFAULT; /* * Calls from kernel level (IPC_KERNELD set) * have the message somewhere in kernel space already! */ if ((msgflg & IPC_KERNELD)) mtype = msgp->mtype; else { err = verify_area (VERIFY_READ, msgp->mtext, msgsz); if (err) return err; if ((mtype = get_user (&msgp->mtype)) < 1) return -EINVAL; } id = (unsigned int) msqid % MSGMNI; msq = msgque [id]; if (msq == IPC_UNUSED || msq == IPC_NOID) return -EINVAL; ipcp = &msq->msg_perm; slept: if (msq->msg_perm.seq != (unsigned int) msqid / MSGMNI) return -EIDRM; /* * Non-root kernel level processes may send to kerneld! * i.e. no permission check if called from the kernel * otoh we don't want user level non-root snoopers... */ if ((msgflg & IPC_KERNELD) == 0) if (ipcperms(ipcp, S_IWUGO)) return -EACCES; if (msgsz + msq->msg_cbytes > msq->msg_qbytes) { if ((kerneld_msqid != -1) && (kerneld_msqid == msqid)) flush_msg(msq); /* flush the kerneld channel only */ if (msgsz + msq->msg_cbytes > msq->msg_qbytes) { /* still no space in queue */ if (msgflg & IPC_NOWAIT) return -EAGAIN; if (current->signal & ~current->blocked) return -EINTR; if (intr_count) { /* Very unlikely, but better safe than sorry */ printk(KERN_WARNING "Ouch, kerneld:msgsnd buffers full!\n"); return -EINTR; } interruptible_sleep_on (&msq->wwait); goto slept; } } /* allocate message header and text space*/ msgh = (struct msg *) kmalloc (sizeof(*msgh) + msgsz, GFP_ATOMIC); if (!msgh) return -ENOMEM; msgh->msg_spot = (char *) (msgh + 1); /* * Calls from kernel level (IPC_KERNELD set) * have the message somewhere in kernel space already! */ if (msgflg & IPC_KERNELD) { struct kerneld_msg *kdmp = (struct kerneld_msg *)msgp; /* * Note that the kernel supplies a pointer * but the user-level kerneld uses a char array... */ memcpy(msgh->msg_spot, (char *)(&(kdmp->id)), KDHDR); memcpy(msgh->msg_spot + KDHDR, kdmp->text, msgsz - KDHDR); } else memcpy_fromfs (msgh->msg_spot, msgp->mtext, msgsz); if (msgque[id] == IPC_UNUSED || msgque[id] == IPC_NOID || msq->msg_perm.seq != (unsigned int) msqid / MSGMNI) { kfree(msgh); return -EIDRM; } msgh->msg_next = NULL; msgh->msg_ts = msgsz; msgh->msg_type = mtype; msgh->msg_stime = CURRENT_TIME; save_flags(flags); cli(); if (!msq->msg_first) msq->msg_first = msq->msg_last = msgh; else { msq->msg_last->msg_next = msgh; msq->msg_last = msgh; } msq->msg_cbytes += msgsz; msgbytes += msgsz; msghdrs++; msq->msg_qnum++; msq->msg_lspid = current->pid; msq->msg_stime = CURRENT_TIME; restore_flags(flags); wake_up (&msq->rwait); return 0; } /* * Take care of missing kerneld, especially in case of multiple daemons */ #define KERNELD_TIMEOUT 1 * (HZ) #define DROP_TIMER del_timer(&kd_timer) /*#define DROP_TIMER if ((msgflg & IPC_KERNELD) && kd_timer.next && kd_timer.prev) del_timer(&kd_timer)*/ static void kd_timeout(unsigned long msgid) { struct msqid_ds *msq; struct msg *tmsg; unsigned long flags; msq = msgque [ (unsigned int) kerneld_msqid % MSGMNI ]; if (msq == IPC_NOID || msq == IPC_UNUSED) return; save_flags(flags); cli(); for (tmsg = msq->msg_first; tmsg; tmsg = tmsg->msg_next) if (*(long *)(tmsg->msg_spot) == msgid) break; restore_flags(flags); if (tmsg) { /* still there! */ struct kerneld_msg kmsp = { msgid, NULL_KDHDR, "" }; printk(KERN_ALERT "Ouch, no kerneld for message %ld\n", msgid); kmsp.id = -ENODEV; real_msgsnd(kerneld_msqid, (struct msgbuf *)&kmsp, KDHDR, S_IRUSR | S_IWUSR | IPC_KERNELD | MSG_NOERROR); } } static int real_msgrcv (int msqid, struct msgbuf *msgp, size_t msgsz, long msgtyp, int msgflg) { struct timer_list kd_timer = { NULL, NULL, 0, 0, 0}; struct msqid_ds *msq; struct ipc_perm *ipcp; struct msg *tmsg, *leastp = NULL; struct msg *nmsg = NULL; int id, err; unsigned long flags; if (msqid < 0 || (long) msgsz < 0) return -EINVAL; if (!msgp || !msgp->mtext) return -EFAULT; /* * Calls from kernel level (IPC_KERNELD set) * wants the message put in kernel space! */ if ((msgflg & IPC_KERNELD) == 0) { err = verify_area (VERIFY_WRITE, msgp->mtext, msgsz); if (err) return err; } id = (unsigned int) msqid % MSGMNI; msq = msgque [id]; if (msq == IPC_NOID || msq == IPC_UNUSED) return -EINVAL; ipcp = &msq->msg_perm; /* * Start timer for missing kerneld */ if (msgflg & IPC_KERNELD) { kd_timer.data = (unsigned long)msgtyp; kd_timer.expires = jiffies + KERNELD_TIMEOUT; kd_timer.function = kd_timeout; add_timer(&kd_timer); } /* * find message of correct type. * msgtyp = 0 => get first. * msgtyp > 0 => get first message of matching type. * msgtyp < 0 => get message with least type must be < abs(msgtype). */ while (!nmsg) { if (msq->msg_perm.seq != (unsigned int) msqid / MSGMNI) { DROP_TIMER; return -EIDRM; } if ((msgflg & IPC_KERNELD) == 0) { /* * All kernel level processes may receive from kerneld! * i.e. no permission check if called from the kernel * otoh we don't want user level non-root snoopers... */ if (ipcperms (ipcp, S_IRUGO)) { DROP_TIMER; /* Not needed, but doesn't hurt */ return -EACCES; } } save_flags(flags); cli(); if (msgtyp == 0) nmsg = msq->msg_first; else if (msgtyp > 0) { if (msgflg & MSG_EXCEPT) { for (tmsg = msq->msg_first; tmsg; tmsg = tmsg->msg_next) if (tmsg->msg_type != msgtyp) break; nmsg = tmsg; } else { for (tmsg = msq->msg_first; tmsg; tmsg = tmsg->msg_next) if (tmsg->msg_type == msgtyp) break; nmsg = tmsg; } } else { for (leastp = tmsg = msq->msg_first; tmsg; tmsg = tmsg->msg_next) if (tmsg->msg_type < leastp->msg_type) leastp = tmsg; if (leastp && leastp->msg_type <= - msgtyp) nmsg = leastp; } restore_flags(flags); if (nmsg) { /* done finding a message */ DROP_TIMER; if ((msgsz < nmsg->msg_ts) && !(msgflg & MSG_NOERROR)) { return -E2BIG; } msgsz = (msgsz > nmsg->msg_ts)? nmsg->msg_ts : msgsz; save_flags(flags); cli(); if (nmsg == msq->msg_first) msq->msg_first = nmsg->msg_next; else { for (tmsg = msq->msg_first; tmsg; tmsg = tmsg->msg_next) if (tmsg->msg_next == nmsg) break; tmsg->msg_next = nmsg->msg_next; if (nmsg == msq->msg_last) msq->msg_last = tmsg; } if (!(--msq->msg_qnum)) msq->msg_last = msq->msg_first = NULL; msq->msg_rtime = CURRENT_TIME; msq->msg_lrpid = current->pid; msgbytes -= nmsg->msg_ts; msghdrs--; msq->msg_cbytes -= nmsg->msg_ts; restore_flags(flags); wake_up (&msq->wwait); /* * Calls from kernel level (IPC_KERNELD set) * wants the message copied to kernel space! */ if (msgflg & IPC_KERNELD) { struct kerneld_msg *kdmp = (struct kerneld_msg *) msgp; memcpy((char *)(&(kdmp->id)), nmsg->msg_spot, KDHDR); /* * Note that kdmp->text is a pointer * when called from kernel space! */ if ((msgsz > KDHDR) && kdmp->text) memcpy(kdmp->text, nmsg->msg_spot + KDHDR, msgsz - KDHDR); } else { put_user (nmsg->msg_type, &msgp->mtype); memcpy_tofs (msgp->mtext, nmsg->msg_spot, msgsz); } kfree(nmsg); return msgsz; } else { /* did not find a message */ if (msgflg & IPC_NOWAIT) { DROP_TIMER; return -ENOMSG; } if (current->signal & ~current->blocked) { DROP_TIMER; return -EINTR; } interruptible_sleep_on (&msq->rwait); } } /* end while */ DROP_TIMER; return -1; } asmlinkage int sys_msgsnd (int msqid, struct msgbuf *msgp, size_t msgsz, int msgflg) { /* IPC_KERNELD is used as a marker for kernel level calls */ return real_msgsnd(msqid, msgp, msgsz, msgflg & ~IPC_KERNELD); } asmlinkage int sys_msgrcv (int msqid, struct msgbuf *msgp, size_t msgsz, long msgtyp, int msgflg) { /* IPC_KERNELD is used as a marker for kernel level calls */ return real_msgrcv (msqid, msgp, msgsz, msgtyp, msgflg & ~IPC_KERNELD); } static int findkey (key_t key) { int id; struct msqid_ds *msq; for (id = 0; id <= max_msqid; id++) { while ((msq = msgque[id]) == IPC_NOID) interruptible_sleep_on (&msg_lock); if (msq == IPC_UNUSED) continue; if (key == msq->msg_perm.key) return id; } return -1; } static int newque (key_t key, int msgflg) { int id; struct msqid_ds *msq; struct ipc_perm *ipcp; for (id = 0; id < MSGMNI; id++) if (msgque[id] == IPC_UNUSED) { msgque[id] = (struct msqid_ds *) IPC_NOID; goto found; } return -ENOSPC; found: msq = (struct msqid_ds *) kmalloc (sizeof (*msq), GFP_KERNEL); if (!msq) { msgque[id] = (struct msqid_ds *) IPC_UNUSED; wake_up (&msg_lock); return -ENOMEM; } ipcp = &msq->msg_perm; ipcp->mode = (msgflg & S_IRWXUGO); ipcp->key = key; ipcp->cuid = ipcp->uid = current->euid; ipcp->gid = ipcp->cgid = current->egid; msq->msg_perm.seq = msg_seq; msq->msg_first = msq->msg_last = NULL; msq->rwait = msq->wwait = NULL; msq->msg_cbytes = msq->msg_qnum = 0; msq->msg_lspid = msq->msg_lrpid = 0; msq->msg_stime = msq->msg_rtime = 0; msq->msg_qbytes = MSGMNB; msq->msg_ctime = CURRENT_TIME; if (id > max_msqid) max_msqid = id; msgque[id] = msq; used_queues++; wake_up (&msg_lock); return (unsigned int) msq->msg_perm.seq * MSGMNI + id; } asmlinkage int sys_msgget (key_t key, int msgflg) { int id; struct msqid_ds *msq; /* * If the IPC_KERNELD flag is set, the key is forced to IPC_PRIVATE, * and a designated kerneld message queue is created/referred to */ if ((msgflg & IPC_KERNELD)) { int i; if (!suser()) return -EPERM; #ifdef NEW_KERNELD_PROTOCOL if ((msgflg & IPC_KERNELD) == OLDIPC_KERNELD) { printk(KERN_ALERT "Please recompile your kerneld daemons!\n"); return -EPERM; } #endif if ((kerneld_msqid == -1) && (kerneld_msqid = newque(IPC_PRIVATE, msgflg & S_IRWXU)) < 0) return -ENOSPC; for (i = 0; i < MAX_KERNELDS; ++i) { if (kerneld_arr[i] == 0) { kerneld_arr[i] = current->pid; ++n_kernelds; return kerneld_msqid; } } return -ENOSPC; } /* else it is a "normal" request */ if (key == IPC_PRIVATE) return newque(key, msgflg); if ((id = findkey (key)) == -1) { /* key not used */ if (!(msgflg & IPC_CREAT)) return -ENOENT; return newque(key, msgflg); } if (msgflg & IPC_CREAT && msgflg & IPC_EXCL) return -EEXIST; msq = msgque[id]; if (msq == IPC_UNUSED || msq == IPC_NOID) return -EIDRM; if (ipcperms(&msq->msg_perm, msgflg)) return -EACCES; return (unsigned int) msq->msg_perm.seq * MSGMNI + id; } static void freeque (int id) { struct msqid_ds *msq = msgque[id]; struct msg *msgp, *msgh; msq->msg_perm.seq++; msg_seq = (msg_seq+1) % ((unsigned)(1<<31)/MSGMNI); /* increment, but avoid overflow */ msgbytes -= msq->msg_cbytes; if (id == max_msqid) while (max_msqid && (msgque[--max_msqid] == IPC_UNUSED)); msgque[id] = (struct msqid_ds *) IPC_UNUSED; used_queues--; while (waitqueue_active(&msq->rwait) || waitqueue_active(&msq->wwait)) { wake_up (&msq->rwait); wake_up (&msq->wwait); schedule(); } for (msgp = msq->msg_first; msgp; msgp = msgh ) { msgh = msgp->msg_next; msghdrs--; kfree(msgp); } kfree(msq); } asmlinkage int sys_msgctl (int msqid, int cmd, struct msqid_ds *buf) { int id, err; struct msqid_ds *msq; struct msqid_ds tbuf; struct ipc_perm *ipcp; if (msqid < 0 || cmd < 0) return -EINVAL; switch (cmd) { case IPC_INFO: case MSG_INFO: if (!buf) return -EFAULT; { struct msginfo msginfo; msginfo.msgmni = MSGMNI; msginfo.msgmax = MSGMAX; msginfo.msgmnb = MSGMNB; msginfo.msgmap = MSGMAP; msginfo.msgpool = MSGPOOL; msginfo.msgtql = MSGTQL; msginfo.msgssz = MSGSSZ; msginfo.msgseg = MSGSEG; if (cmd == MSG_INFO) { msginfo.msgpool = used_queues; msginfo.msgmap = msghdrs; msginfo.msgtql = msgbytes; } err = verify_area (VERIFY_WRITE, buf, sizeof (struct msginfo)); if (err) return err; memcpy_tofs (buf, &msginfo, sizeof(struct msginfo)); return max_msqid; } case MSG_STAT: if (!buf) return -EFAULT; err = verify_area (VERIFY_WRITE, buf, sizeof (*buf)); if (err) return err; if (msqid > max_msqid) return -EINVAL; msq = msgque[msqid]; if (msq == IPC_UNUSED || msq == IPC_NOID) return -EINVAL; if (ipcperms (&msq->msg_perm, S_IRUGO)) return -EACCES; id = (unsigned int) msq->msg_perm.seq * MSGMNI + msqid; tbuf.msg_perm = msq->msg_perm; tbuf.msg_stime = msq->msg_stime; tbuf.msg_rtime = msq->msg_rtime; tbuf.msg_ctime = msq->msg_ctime; tbuf.msg_cbytes = msq->msg_cbytes; tbuf.msg_qnum = msq->msg_qnum; tbuf.msg_qbytes = msq->msg_qbytes; tbuf.msg_lspid = msq->msg_lspid; tbuf.msg_lrpid = msq->msg_lrpid; memcpy_tofs (buf, &tbuf, sizeof(*buf)); return id; case IPC_SET: if (!buf) return -EFAULT; err = verify_area (VERIFY_READ, buf, sizeof (*buf)); if (err) return err; memcpy_fromfs (&tbuf, buf, sizeof (*buf)); break; case IPC_STAT: if (!buf) return -EFAULT; err = verify_area (VERIFY_WRITE, buf, sizeof(*buf)); if (err) return err; break; } id = (unsigned int) msqid % MSGMNI; msq = msgque [id]; if (msq == IPC_UNUSED || msq == IPC_NOID) return -EINVAL; if (msq->msg_perm.seq != (unsigned int) msqid / MSGMNI) return -EIDRM; ipcp = &msq->msg_perm; switch (cmd) { case IPC_STAT: if (ipcperms (ipcp, S_IRUGO)) return -EACCES; tbuf.msg_perm = msq->msg_perm; tbuf.msg_stime = msq->msg_stime; tbuf.msg_rtime = msq->msg_rtime; tbuf.msg_ctime = msq->msg_ctime; tbuf.msg_cbytes = msq->msg_cbytes; tbuf.msg_qnum = msq->msg_qnum; tbuf.msg_qbytes = msq->msg_qbytes; tbuf.msg_lspid = msq->msg_lspid; tbuf.msg_lrpid = msq->msg_lrpid; memcpy_tofs (buf, &tbuf, sizeof (*buf)); return 0; case IPC_SET: if (!suser() && current->euid != ipcp->cuid && current->euid != ipcp->uid) return -EPERM; if (tbuf.msg_qbytes > MSGMNB && !suser()) return -EPERM; msq->msg_qbytes = tbuf.msg_qbytes; ipcp->uid = tbuf.msg_perm.uid; ipcp->gid = tbuf.msg_perm.gid; ipcp->mode = (ipcp->mode & ~S_IRWXUGO) | (S_IRWXUGO & tbuf.msg_perm.mode); msq->msg_ctime = CURRENT_TIME; return 0; case IPC_RMID: if (!suser() && current->euid != ipcp->cuid && current->euid != ipcp->uid) return -EPERM; /* * There is only one kerneld message queue, * mark it as non-existent */ if ((kerneld_msqid >= 0) && (msqid == kerneld_msqid)) kerneld_msqid = -1; freeque (id); return 0; default: return -EINVAL; } } /* * We do perhaps need a "flush" for waiting processes, * so that if they are terminated, a call from do_exit * will minimize the possibility of orphaned received * messages in the queue. For now we just make sure * that the queue is shut down whenever all kernelds have died. */ void kerneld_exit(void) { int i; if (kerneld_msqid == -1) return; for (i = 0; i < MAX_KERNELDS; ++i) { if (kerneld_arr[i] == current->pid) { kerneld_arr[i] = 0; --n_kernelds; if (n_kernelds == 0) sys_msgctl(kerneld_msqid, IPC_RMID, NULL); break; } } } /* * Kerneld internal message format/syntax: * * The message type from the kernel to kerneld is used to specify _what_ * function we want kerneld to perform. * * The "normal" message area is divided into a header, followed by a char array. * The header is used to hold the sequence number of the request, which will * be used as the return message type from kerneld back to the kernel. * In the return message, the header will be used to store the exit status * of the kerneld "job", or task. * The character array is used to pass parameters to kerneld and (optional) * return information from kerneld back to the kernel. * It is the responsibility of kerneld and the kernel level caller * to set usable sizes on the parameter/return value array, since * that information is _not_ included in the message format */ /* * The basic kernel level entry point to kerneld. * msgtype should correspond to a task type for (a) kerneld * ret_size is the size of the (optional) return _value, * OR-ed with KERNELD_WAIT if we want an answer * msgsize is the size (in bytes) of the message, not including * the header that is always sent first in a kerneld message * text is the parameter for the kerneld specific task * ret_val is NULL or the kernel address where an expected answer * from kerneld should be placed. * * See <linux/kerneld.h> for usage (inline convenience functions) * */ int kerneld_send(int msgtype, int ret_size, int msgsz, const char *text, const char *ret_val) { int status = -ENOSYS; #ifdef CONFIG_KERNELD static int id = KERNELD_MINSEQ; struct kerneld_msg kmsp = { msgtype, NULL_KDHDR, (char *)text }; int msgflg = S_IRUSR | S_IWUSR | IPC_KERNELD | MSG_NOERROR; unsigned long flags; if (kerneld_msqid == -1) return -ENODEV; /* Do not wait for an answer at interrupt-time! */ if (intr_count) ret_size &= ~KERNELD_WAIT; #ifdef NEW_KERNELD_PROTOCOL else kmsp.pid = current->pid; #endif msgsz += KDHDR; if (ret_size & KERNELD_WAIT) { save_flags(flags); cli(); if (++id <= 0) /* overflow */ id = KERNELD_MINSEQ; kmsp.id = id; restore_flags(flags); } status = real_msgsnd(kerneld_msqid, (struct msgbuf *)&kmsp, msgsz, msgflg); if ((status >= 0) && (ret_size & KERNELD_WAIT)) { ret_size &= ~KERNELD_WAIT; kmsp.text = (char *)ret_val; status = real_msgrcv(kerneld_msqid, (struct msgbuf *)&kmsp, KDHDR + ((ret_val)?ret_size:0), kmsp.id, msgflg); if (status > 0) /* a valid answer contains at least a long */ status = kmsp.id; } #endif /* CONFIG_KERNELD */ return status; }
Go to most recent revision | Compare with Previous | Blame | View Log