/*
* 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;
}
