cregit-Linux how code gets into the kernel

Release 4.7 ipc/msg.c

Directory: ipc
/*
 * linux/ipc/msg.c
 * Copyright (C) 1992 Krishna Balasubramanian
 *
 * Removed all the remaining kerneld mess
 * Catch the -EFAULT stuff properly
 * Use GFP_KERNEL for messages as in 1.2
 * Fixed up the unchecked user space derefs
 * Copyright (C) 1998 Alan Cox & Andi Kleen
 *
 * /proc/sysvipc/msg support (c) 1999 Dragos Acostachioaie <dragos@iname.com>
 *
 * mostly rewritten, threaded and wake-one semantics added
 * MSGMAX limit removed, sysctl's added
 * (c) 1999 Manfred Spraul <manfred@colorfullife.com>
 *
 * support for audit of ipc object properties and permission changes
 * Dustin Kirkland <dustin.kirkland@us.ibm.com>
 *
 * namespaces support
 * OpenVZ, SWsoft Inc.
 * Pavel Emelianov <xemul@openvz.org>
 */

#include <linux/capability.h>
#include <linux/msg.h>
#include <linux/spinlock.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/proc_fs.h>
#include <linux/list.h>
#include <linux/security.h>
#include <linux/sched.h>
#include <linux/syscalls.h>
#include <linux/audit.h>
#include <linux/seq_file.h>
#include <linux/rwsem.h>
#include <linux/nsproxy.h>
#include <linux/ipc_namespace.h>

#include <asm/current.h>
#include <linux/uaccess.h>
#include "util.h"

/* one msg_receiver structure for each sleeping receiver */

struct msg_receiver {
	
struct list_head	r_list;
	
struct task_struct	*r_tsk;

	
int			r_mode;
	
long			r_msgtype;
	
long			r_maxsize;

	/*
         * Mark r_msg volatile so that the compiler
         * does not try to get smart and optimize
         * it. We rely on this for the lockless
         * receive algorithm.
         */
	
struct msg_msg		*volatile r_msg;
};

/* one msg_sender for each sleeping sender */

struct msg_sender {
	
struct list_head	list;
	
struct task_struct	*tsk;
};


#define SEARCH_ANY		1

#define SEARCH_EQUAL		2

#define SEARCH_NOTEQUAL		3

#define SEARCH_LESSEQUAL	4

#define SEARCH_NUMBER		5


#define msg_ids(ns)	((ns)->ids[IPC_MSG_IDS])


static inline struct msg_queue *msq_obtain_object(struct ipc_namespace *ns, int id) { struct kern_ipc_perm *ipcp = ipc_obtain_object_idr(&msg_ids(ns), id); if (IS_ERR(ipcp)) return ERR_CAST(ipcp); return container_of(ipcp, struct msg_queue, q_perm); }

Contributors

PersonTokensPropCommitsCommitProp
davidlohr buesodavidlohr bueso57100.00%2100.00%
Total57100.00%2100.00%


static inline struct msg_queue *msq_obtain_object_check(struct ipc_namespace *ns, int id) { struct kern_ipc_perm *ipcp = ipc_obtain_object_check(&msg_ids(ns), id); if (IS_ERR(ipcp)) return ERR_CAST(ipcp); return container_of(ipcp, struct msg_queue, q_perm); }

Contributors

PersonTokensPropCommitsCommitProp
davidlohr buesodavidlohr bueso5392.98%133.33%
nadia derbeynadia derbey47.02%266.67%
Total57100.00%3100.00%


static inline void msg_rmid(struct ipc_namespace *ns, struct msg_queue *s) { ipc_rmid(&msg_ids(ns), &s->q_perm); }

Contributors

PersonTokensPropCommitsCommitProp
nadia derbeynadia derbey31100.00%1100.00%
Total31100.00%1100.00%


static void msg_rcu_free(struct rcu_head *head) { struct ipc_rcu *p = container_of(head, struct ipc_rcu, rcu); struct msg_queue *msq = ipc_rcu_to_struct(p); security_msg_queue_free(msq); ipc_rcu_free(head); }

Contributors

PersonTokensPropCommitsCommitProp
davidlohr buesodavidlohr bueso46100.00%1100.00%
Total46100.00%1100.00%

/** * newque - Create a new msg queue * @ns: namespace * @params: ptr to the structure that contains the key and msgflg * * Called with msg_ids.rwsem held (writer) */
static int newque(struct ipc_namespace *ns, struct ipc_params *params) { struct msg_queue *msq; int id, retval; key_t key = params->key; int msgflg = params->flg; msq = ipc_rcu_alloc(sizeof(*msq)); if (!msq) return -ENOMEM; msq->q_perm.mode = msgflg & S_IRWXUGO; msq->q_perm.key = key; msq->q_perm.security = NULL; retval = security_msg_queue_alloc(msq); if (retval) { ipc_rcu_putref(msq, ipc_rcu_free); return retval; } msq->q_stime = msq->q_rtime = 0; msq->q_ctime = get_seconds(); msq->q_cbytes = msq->q_qnum = 0; msq->q_qbytes = ns->msg_ctlmnb; msq->q_lspid = msq->q_lrpid = 0; INIT_LIST_HEAD(&msq->q_messages); INIT_LIST_HEAD(&msq->q_receivers); INIT_LIST_HEAD(&msq->q_senders); /* ipc_addid() locks msq upon success. */ id = ipc_addid(&msg_ids(ns), &msq->q_perm, ns->msg_ctlmni); if (id < 0) { ipc_rcu_putref(msq, msg_rcu_free); return id; } ipc_unlock_object(&msq->q_perm); rcu_read_unlock(); return msq->q_perm.id; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git10343.83%421.05%
linus torvaldslinus torvalds3916.60%15.26%
stephen d. smalleystephen d. smalley239.79%15.26%
greg kroah-hartmangreg kroah-hartman239.79%315.79%
nadia derbeynadia derbey218.94%210.53%
davidlohr buesodavidlohr bueso93.83%315.79%
kirill korotaevkirill korotaev72.98%15.26%
ingo molnaringo molnar52.13%15.26%
andi kleenandi kleen20.85%15.26%
andrew mortonandrew morton20.85%15.26%
manfred spraulmanfred spraul10.43%15.26%
Total235100.00%19100.00%


static inline void ss_add(struct msg_queue *msq, struct msg_sender *mss) { mss->tsk = current; __set_current_state(TASK_INTERRUPTIBLE); list_add_tail(&mss->list, &msq->q_senders); }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git3892.68%150.00%
davidlohr buesodavidlohr bueso37.32%150.00%
Total41100.00%2100.00%


static inline void ss_del(struct msg_sender *mss) { if (mss->list.next != NULL) list_del(&mss->list); }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git30100.00%1100.00%
Total30100.00%1100.00%


static void ss_wakeup(struct list_head *h, int kill) { struct msg_sender *mss, *t; list_for_each_entry_safe(mss, t, h, list) { if (kill) mss->list.next = NULL; wake_up_process(mss->tsk); } }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git4381.13%375.00%
nikola pajkovskynikola pajkovsky1018.87%125.00%
Total53100.00%4100.00%


static void expunge_all(struct msg_queue *msq, int res) { struct msg_receiver *msr, *t; list_for_each_entry_safe(msr, t, &msq->q_receivers, r_list) { msr->r_msg = NULL; /* initialize expunge ordering */ wake_up_process(msr->r_tsk); /* * Ensure that the wakeup is visible before setting r_msg as * the receiving end depends on it: either spinning on a nil, * or dealing with -EAGAIN cases. See lockless receive part 1 * and 2 in do_msgrcv(). */ smp_wmb(); /* barrier (B) */ msr->r_msg = ERR_PTR(res); } }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git3658.06%342.86%
manfred spraulmanfred spraul1219.35%114.29%
nikola pajkovskynikola pajkovsky1016.13%114.29%
davidlohr buesodavidlohr bueso46.45%228.57%
Total62100.00%7100.00%

/* * freeque() wakes up waiters on the sender and receiver waiting queue, * removes the message queue from message queue ID IDR, and cleans up all the * messages associated with this queue. * * msg_ids.rwsem (writer) and the spinlock for this message queue are held * before freeque() is called. msg_ids.rwsem remains locked on exit. */
static void freeque(struct ipc_namespace *ns, struct kern_ipc_perm *ipcp) { struct msg_msg *msg, *t; struct msg_queue *msq = container_of(ipcp, struct msg_queue, q_perm); expunge_all(msq, -EIDRM); ss_wakeup(&msq->q_senders, 1); msg_rmid(ns, msq); ipc_unlock_object(&msq->q_perm); rcu_read_unlock(); list_for_each_entry_safe(msg, t, &msq->q_messages, m_list) { atomic_dec(&ns->msg_hdrs); free_msg(msg); } atomic_sub(msq->q_cbytes, &ns->msg_bytes); ipc_rcu_putref(msq, msg_rcu_free); }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git6151.26%428.57%
pierre peifferpierre peiffer1714.29%17.14%
nikola pajkovskynikola pajkovsky1210.08%17.14%
kirill korotaevkirill korotaev119.24%214.29%
davidlohr buesodavidlohr bueso97.56%214.29%
andrew mortonandrew morton75.88%214.29%
manfred spraulmanfred spraul10.84%17.14%
nadia derbeynadia derbey10.84%17.14%
Total119100.00%14100.00%

/* * Called with msg_ids.rwsem and ipcp locked. */
static inline int msg_security(struct kern_ipc_perm *ipcp, int msgflg) { struct msg_queue *msq = container_of(ipcp, struct msg_queue, q_perm); return security_msg_queue_associate(msq, msgflg); }

Contributors

PersonTokensPropCommitsCommitProp
nadia derbeynadia derbey38100.00%2100.00%
Total38100.00%2100.00%

SYSCALL_DEFINE2(msgget, key_t, key, int, msgflg) { struct ipc_namespace *ns; static const struct ipc_ops msg_ops = { .getnew = newque, .associate = msg_security, }; struct ipc_params msg_params; ns = current->nsproxy->ipc_ns; msg_params.key = key; msg_params.flg = msgflg; return ipcget(ns, &msg_ids(ns), &msg_ops, &msg_params); }
static inline unsigned long copy_msqid_to_user(void __user *buf, struct msqid64_ds *in, int version) { switch (version) { case IPC_64: return copy_to_user(buf, in, sizeof(*in)); case IPC_OLD: { struct msqid_ds out; memset(&out, 0, sizeof(out)); ipc64_perm_to_ipc_perm(&in->msg_perm, &out.msg_perm); out.msg_stime = in->msg_stime; out.msg_rtime = in->msg_rtime; out.msg_ctime = in->msg_ctime; if (in->msg_cbytes > USHRT_MAX) out.msg_cbytes = USHRT_MAX; else out.msg_cbytes = in->msg_cbytes; out.msg_lcbytes = in->msg_cbytes; if (in->msg_qnum > USHRT_MAX) out.msg_qnum = USHRT_MAX; else out.msg_qnum = in->msg_qnum; if (in->msg_qbytes > USHRT_MAX) out.msg_qbytes = USHRT_MAX; else out.msg_qbytes = in->msg_qbytes; out.msg_lqbytes = in->msg_qbytes; out.msg_lspid = in->msg_lspid; out.msg_lrpid = in->msg_lrpid; return copy_to_user(buf, &out, sizeof(out)); } default: return -EINVAL; } }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git21696.86%133.33%
alexey dobriyanalexey dobriyan62.69%133.33%
al viroal viro10.45%133.33%
Total223100.00%3100.00%


static inline unsigned long copy_msqid_from_user(struct msqid64_ds *out, void __user *buf, int version) { switch (version) { case IPC_64: if (copy_from_user(out, buf, sizeof(*out))) return -EFAULT; return 0; case IPC_OLD: { struct msqid_ds tbuf_old; if (copy_from_user(&tbuf_old, buf, sizeof(tbuf_old))) return -EFAULT; out->msg_perm.uid = tbuf_old.msg_perm.uid; out->msg_perm.gid = tbuf_old.msg_perm.gid; out->msg_perm.mode = tbuf_old.msg_perm.mode; if (tbuf_old.msg_qbytes == 0) out->msg_qbytes = tbuf_old.msg_lqbytes; else out->msg_qbytes = tbuf_old.msg_qbytes; return 0; } default: return -EINVAL; } }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git13691.28%133.33%
pierre peifferpierre peiffer128.05%133.33%
al viroal viro10.67%133.33%
Total149100.00%3100.00%

/* * This function handles some msgctl commands which require the rwsem * to be held in write mode. * NOTE: no locks must be held, the rwsem is taken inside this function. */
static int msgctl_down(struct ipc_namespace *ns, int msqid, int cmd, struct msqid_ds __user *buf, int version) { struct kern_ipc_perm *ipcp; struct msqid64_ds uninitialized_var(msqid64); struct msg_queue *msq; int err; if (cmd == IPC_SET) { if (copy_msqid_from_user(&msqid64, buf, version)) return -EFAULT; } down_write(&msg_ids(ns).rwsem); rcu_read_lock(); ipcp = ipcctl_pre_down_nolock(ns, &msg_ids(ns), msqid, cmd, &msqid64.msg_perm, msqid64.msg_qbytes); if (IS_ERR(ipcp)) { err = PTR_ERR(ipcp); goto out_unlock1; } msq = container_of(ipcp, struct msg_queue, q_perm); err = security_msg_queue_msgctl(msq, cmd); if (err) goto out_unlock1; switch (cmd) { case IPC_RMID: ipc_lock_object(&msq->q_perm); /* freeque unlocks the ipc object and rcu */ freeque(ns, ipcp); goto out_up; case IPC_SET: if (msqid64.msg_qbytes > ns->msg_ctlmnb && !capable(CAP_SYS_RESOURCE)) { err = -EPERM; goto out_unlock1; } ipc_lock_object(&msq->q_perm); err = ipc_update_perm(&msqid64.msg_perm, ipcp); if (err) goto out_unlock0; msq->q_qbytes = msqid64.msg_qbytes; msq->q_ctime = get_seconds(); /* sleeping receivers might be excluded by * stricter permissions. */ expunge_all(msq, -EAGAIN); /* sleeping senders might be able to send * due to a larger queue size. */ ss_wakeup(&msq->q_senders, 0); break; default: err = -EINVAL; goto out_unlock1; } out_unlock0: ipc_unlock_object(&msq->q_perm); out_unlock1: rcu_read_unlock(); out_up: up_write(&msg_ids(ns).rwsem); return err; }

Contributors

PersonTokensPropCommitsCommitProp
pierre peifferpierre peiffer16752.68%422.22%
davidlohr buesodavidlohr bueso5717.98%316.67%
pre-gitpre-git5015.77%316.67%
eric w. biedermaneric w. biederman154.73%15.56%
kirill korotaevkirill korotaev72.21%15.56%
ingo molnaringo molnar72.21%15.56%
stephen d. smalleystephen d. smalley61.89%15.56%
felipe contrerasfelipe contreras30.95%15.56%
nadia derbeynadia derbey20.63%15.56%
serge hallynserge hallyn20.63%15.56%
al viroal viro10.32%15.56%
Total317100.00%18100.00%


static int msgctl_nolock(struct ipc_namespace *ns, int msqid, int cmd, int version, void __user *buf) { int err; struct msg_queue *msq; switch (cmd) { case IPC_INFO: case MSG_INFO: { struct msginfo msginfo; int max_id; if (!buf) return -EFAULT; /* * We must not return kernel stack data. * due to padding, it's not enough * to set all member fields. */ err = security_msg_queue_msgctl(NULL, cmd); if (err) return err; memset(&msginfo, 0, sizeof(msginfo)); msginfo.msgmni = ns->msg_ctlmni; msginfo.msgmax = ns->msg_ctlmax; msginfo.msgmnb = ns->msg_ctlmnb; msginfo.msgssz = MSGSSZ; msginfo.msgseg = MSGSEG; down_read(&msg_ids(ns).rwsem); if (cmd == MSG_INFO) { msginfo.msgpool = msg_ids(ns).in_use; msginfo.msgmap = atomic_read(&ns->msg_hdrs); msginfo.msgtql = atomic_read(&ns->msg_bytes); } else { msginfo.msgmap = MSGMAP; msginfo.msgpool = MSGPOOL; msginfo.msgtql = MSGTQL; } max_id = ipc_get_maxid(&msg_ids(ns)); up_read(&msg_ids(ns).rwsem); if (copy_to_user(buf, &msginfo, sizeof(struct msginfo))) return -EFAULT; return (max_id < 0) ? 0 : max_id; } case MSG_STAT: case IPC_STAT: { struct msqid64_ds tbuf; int success_return; if (!buf) return -EFAULT; memset(&tbuf, 0, sizeof(tbuf)); rcu_read_lock(); if (cmd == MSG_STAT) { msq = msq_obtain_object(ns, msqid); if (IS_ERR(msq)) { err = PTR_ERR(msq); goto out_unlock; } success_return = msq->q_perm.id; } else { msq = msq_obtain_object_check(ns, msqid); if (IS_ERR(msq)) { err = PTR_ERR(msq); goto out_unlock; } success_return = 0; } err = -EACCES; if (ipcperms(ns, &msq->q_perm, S_IRUGO)) goto out_unlock; err = security_msg_queue_msgctl(msq, cmd); if (err) goto out_unlock; kernel_to_ipc64_perm(&msq->q_perm, &tbuf.msg_perm); tbuf.msg_stime = msq->q_stime; tbuf.msg_rtime = msq->q_rtime; tbuf.msg_ctime = msq->q_ctime; tbuf.msg_cbytes = msq->q_cbytes; tbuf.msg_qnum = msq->q_qnum; tbuf.msg_qbytes = msq->q_qbytes; tbuf.msg_lspid = msq->q_lspid; tbuf.msg_lrpid = msq->q_lrpid; rcu_read_unlock(); if (copy_msqid_to_user(buf, &tbuf, version)) return -EFAULT; return success_return; } default: return -EINVAL; } return err; out_unlock: rcu_read_unlock(); return err; }

Contributors

PersonTokensPropCommitsCommitProp
pierre peifferpierre peiffer26950.85%211.11%
pre-gitpre-git12022.68%738.89%
davidlohr buesodavidlohr bueso8015.12%316.67%
stephen d. smalleystephen d. smalley275.10%15.56%
nadia derbeynadia derbey163.02%15.56%
steve grubbsteve grubb71.32%15.56%
linda knipperslinda knippers50.95%15.56%
kirill korotaevkirill korotaev30.57%15.56%
serge hallynserge hallyn20.38%15.56%
Total529100.00%18100.00%

SYSCALL_DEFINE3(msgctl, int, msqid, int, cmd, struct msqid_ds __user *, buf) { int version; struct ipc_namespace *ns; if (msqid < 0 || cmd < 0) return -EINVAL; version = ipc_parse_version(&cmd); ns = current->nsproxy->ipc_ns; switch (cmd) { case IPC_INFO: case MSG_INFO: case MSG_STAT: /* msqid is an index rather than a msg queue id */ case IPC_STAT: return msgctl_nolock(ns, msqid, cmd, version, buf); case IPC_SET: case IPC_RMID: return msgctl_down(ns, msqid, cmd, buf, version); default: return -EINVAL; } }
static int testmsg(struct msg_msg *msg, long type, int mode) { switch (mode) { case SEARCH_ANY: case SEARCH_NUMBER: return 1; case SEARCH_LESSEQUAL: if (msg->m_type <= type) return 1; break; case SEARCH_EQUAL: if (msg->m_type == type) return 1; break; case SEARCH_NOTEQUAL: if (msg->m_type != type) return 1; break; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git7796.25%480.00%
peter hurleypeter hurley33.75%120.00%
Total80100.00%5100.00%


static inline int pipelined_send(struct msg_queue *msq, struct msg_msg *msg) { struct msg_receiver *msr, *t; list_for_each_entry_safe(msr, t, &msq->q_receivers, r_list) { if (testmsg(msg, msr->r_msgtype, msr->r_mode) && !security_msg_queue_msgrcv(msq, msg, msr->r_tsk, msr->r_msgtype, msr->r_mode)) { list_del(&msr->r_list); if (msr->r_maxsize < msg->m_ts) { /* initialize pipelined send ordering */ msr->r_msg = NULL; wake_up_process(msr->r_tsk); /* barrier (B) see barrier comment below */ smp_wmb(); msr->r_msg = ERR_PTR(-E2BIG); } else { msr->r_msg = NULL; msq->q_lrpid = task_pid_vnr(msr->r_tsk); msq->q_rtime = get_seconds(); wake_up_process(msr->r_tsk); /* * Ensure that the wakeup is visible before * setting r_msg, as the receiving can otherwise * exit - once r_msg is set, the receiver can * continue. See lockless receive part 1 and 2 * in do_msgrcv(). Barrier (B). */ smp_wmb(); msr->r_msg = msg; return 1; } } } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git10762.21%428.57%
manfred spraulmanfred spraul2212.79%17.14%
stephen d. smalleystephen d. smalley2011.63%17.14%
nikola pajkovskynikola pajkovsky105.81%17.14%
davidlohr buesodavidlohr bueso52.91%214.29%
pavel emelianovpavel emelianov31.74%17.14%
andi kleenandi kleen21.16%17.14%
linus torvaldslinus torvalds10.58%17.14%
stephen rothwellstephen rothwell10.58%17.14%
dave jonesdave jones10.58%17.14%
Total172100.00%14100.00%


long do_msgsnd(int msqid, long mtype, void __user *mtext, size_t msgsz, int msgflg) { struct msg_queue *msq; struct msg_msg *msg; int err; struct ipc_namespace *ns; ns = current->nsproxy->ipc_ns; if (msgsz > ns->msg_ctlmax || (long) msgsz < 0 || msqid < 0) return -EINVAL; if (mtype < 1) return -EINVAL; msg = load_msg(mtext, msgsz); if (IS_ERR(msg)) return PTR_ERR(msg); msg->m_type = mtype; msg->m_ts = msgsz; rcu_read_lock(); msq = msq_obtain_object_check(ns, msqid); if (IS_ERR(msq)) { err = PTR_ERR(msq); goto out_unlock1; } ipc_lock_object(&msq->q_perm); for (;;) { struct msg_sender s; err = -EACCES; if (ipcperms(ns, &msq->q_perm, S_IWUGO)) goto out_unlock0; /* raced with RMID? */ if (!ipc_valid_object(&msq->q_perm)) { err = -EIDRM; goto out_unlock0; } err = security_msg_queue_msgsnd(msq, msg, msgflg); if (err) goto out_unlock0; if (msgsz + msq->q_cbytes <= msq->q_qbytes && 1 + msq->q_qnum <= msq->q_qbytes) { break; } /* queue full, wait: */ if (msgflg & IPC_NOWAIT) { err = -EAGAIN; goto out_unlock0; } /* enqueue the sender and prepare to block */ ss_add(msq, &s); if (!ipc_rcu_getref(msq)) { err = -EIDRM; goto out_unlock0; } ipc_unlock_object(&msq->q_perm); rcu_read_unlock(); schedule(); rcu_read_lock(); ipc_lock_object(&msq->q_perm); ipc_rcu_putref(msq, ipc_rcu_free); /* raced with RMID? */ if (!ipc_valid_object(&msq->q_perm)) { err = -EIDRM; goto out_unlock0; } ss_del(&s); if (signal_pending(current)) { err = -ERESTARTNOHAND; goto out_unlock0; } } msq->q_lspid = task_tgid_vnr(current); msq->q_stime = get_seconds(); if (!pipelined_send(msq, msg)) { /* no one is waiting for this message, enqueue it */ list_add_tail(&msg->m_list, &msq->q_messages); msq->q_cbytes += msgsz; msq->q_qnum++; atomic_add(msgsz, &ns->msg_bytes); atomic_inc(&ns->msg_hdrs); } err = 0; msg = NULL; out_unlock0: ipc_unlock_object(&msq->q_perm); out_unlock1: rcu_read_unlock(); if (msg != NULL) free_msg(msg); return err; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git28960.08%828.57%
davidlohr buesodavidlohr bueso489.98%414.29%
manfred spraulmanfred spraul489.98%27.14%
kirill korotaevkirill korotaev214.37%27.14%
stephen d. smalleystephen d. smalley173.53%13.57%
rik van rielrik van riel122.49%13.57%
rafael aquinirafael aquini112.29%13.57%
linus torvaldslinus torvalds112.29%13.57%
nadia derbeynadia derbey71.46%13.57%
suzuki k poulosesuzuki k poulose61.25%13.57%
pavel emelianovpavel emelianov30.62%13.57%
serge hallynserge hallyn20.42%13.57%
andi kleenandi kleen20.42%13.57%
andrew mortonandrew morton20.42%13.57%
lucas de marchilucas de marchi10.21%13.57%
al viroal viro10.21%13.57%
Total481100.00%28100.00%

SYSCALL_DEFINE4(msgsnd, int, msqid, struct msgbuf __user *, msgp, size_t, msgsz, int, msgflg) { long mtype; if (get_user(mtype, &msgp->mtype)) return -EFAULT; return do_msgsnd(msqid, mtype, msgp->mtext, msgsz, msgflg); }
static inline int convert_mode(long *msgtyp, int msgflg) { if (msgflg & MSG_COPY) return SEARCH_NUMBER; /* * 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). */ if (*msgtyp == 0) return SEARCH_ANY; if (*msgtyp < 0) { *msgtyp = -*msgtyp; return SEARCH_LESSEQUAL; } if (msgflg & MSG_EXCEPT) return SEARCH_NOTEQUAL; return SEARCH_EQUAL; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git5381.54%233.33%
peter hurleypeter hurley913.85%116.67%
ingo molnaringo molnar11.54%116.67%
stephen rothwellstephen rothwell11.54%116.67%
dave jonesdave jones11.54%116.67%
Total65100.00%6100.00%


static long do_msg_fill(void __user *dest, struct msg_msg *msg, size_t bufsz) { struct msgbuf __user *msgp = dest; size_t msgsz; if (put_user(msg->m_type, &msgp->mtype)) return -EFAULT; msgsz = (bufsz > msg->m_ts) ? msg->m_ts : bufsz; if (store_msg(msgp->mtext, msg, msgsz)) return -EFAULT; return msgsz; }

Contributors

PersonTokensPropCommitsCommitProp
stanislav kinsburskystanislav kinsbursky84100.00%1100.00%
Total84100.00%1100.00%

#ifdef CONFIG_CHECKPOINT_RESTORE /* * This function creates new kernel message structure, large enough to store * bufsz message bytes. */
static inline struct msg_msg *prepare_copy(void __user *buf, size_t bufsz) { struct msg_msg *copy; /* * Create dummy message to copy real message to. */ copy = load_msg(buf, bufsz); if (!IS_ERR(copy)) copy->m_ts = bufsz; return copy; }

Contributors

PersonTokensPropCommitsCommitProp
stanislav kinsburskystanislav kinsbursky49100.00%1100.00%
Total49100.00%1100.00%


static inline void free_copy(struct msg_msg *copy) { if (copy) free_msg(copy); }

Contributors

PersonTokensPropCommitsCommitProp
stanislav kinsburskystanislav kinsbursky21100.00%2100.00%
Total21100.00%2100.00%

#else
static inline struct msg_msg *prepare_copy(void __user *buf, size_t bufsz) { return ERR_PTR(-ENOSYS); }

Contributors

PersonTokensPropCommitsCommitProp
stanislav kinsburskystanislav kinsbursky24100.00%1100.00%
Total24100.00%1100.00%


static inline void free_copy(struct msg_msg *copy) { }

Contributors

PersonTokensPropCommitsCommitProp
stanislav kinsburskystanislav kinsbursky11100.00%1100.00%
Total11100.00%1100.00%

#endif
static struct msg_msg *find_msg(struct msg_queue *msq, long *msgtyp, int mode) { struct msg_msg *msg, *found = NULL; long count = 0; list_for_each_entry(msg, &msq->q_messages, m_list) { if (testmsg(msg, *msgtyp, mode) && !security_msg_queue_msgrcv(msq, msg, current, *msgtyp, mode)) { if (mode == SEARCH_LESSEQUAL && msg->m_type != 1) { *msgtyp = msg->m_type - 1; found = msg; } else if (mode == SEARCH_NUMBER) { if (*msgtyp == count) return msg; } else return msg; count++; } } return found ?: ERR_PTR(-EAGAIN); }

Contributors

PersonTokensPropCommitsCommitProp
peter hurleypeter hurley12591.24%150.00%
svenning sorensensvenning sorensen128.76%150.00%
Total137100.00%2100.00%


long do_msgrcv(int msqid, void __user *buf, size_t bufsz, long msgtyp, int msgflg, long (*msg_handler)(void __user *, struct msg_msg *, size_t)) { int mode; struct msg_queue *msq; struct ipc_namespace *ns; struct msg_msg *msg, *copy = NULL; ns = current->nsproxy->ipc_ns; if (msqid < 0 || (long) bufsz < 0) return -EINVAL; if (msgflg & MSG_COPY) { if ((msgflg & MSG_EXCEPT) || !(msgflg & IPC_NOWAIT)) return -EINVAL; copy = prepare_copy(buf, min_t(size_t, bufsz, ns->msg_ctlmax)); if (IS_ERR(copy)) return PTR_ERR(copy); } mode = convert_mode(&msgtyp, msgflg); rcu_read_lock(); msq = msq_obtain_object_check(ns, msqid); if (IS_ERR(msq)) { rcu_read_unlock(); free_copy(copy); return PTR_ERR(msq); } for (;;) { struct msg_receiver msr_d; msg = ERR_PTR(-EACCES); if (ipcperms(ns, &msq->q_perm, S_IRUGO)) goto out_unlock1; ipc_lock_object(&msq->q_perm); /* raced with RMID? */ if (!ipc_valid_object(&msq->q_perm)) { msg = ERR_PTR(-EIDRM); goto out_unlock0; } msg = find_msg(msq, &msgtyp, mode); if (!IS_ERR(msg)) { /* * Found a suitable message. * Unlink it from the queue. */ if ((bufsz < msg->m_ts) && !(msgflg & MSG_NOERROR)) { msg = ERR_PTR(-E2BIG); goto out_unlock0; } /* * If we are copying, then do not unlink message and do * not update queue parameters. */ if (msgflg & MSG_COPY) { msg = copy_msg(msg, copy); goto out_unlock0; } list_del(&msg->m_list); msq->q_qnum--; msq->q_rtime = get_seconds(); msq->q_lrpid = task_tgid_vnr(current); msq->q_cbytes -= msg->m_ts; atomic_sub(msg->m_ts, &ns->msg_bytes); atomic_dec(&ns->msg_hdrs); ss_wakeup(&msq->q_senders, 0); goto out_unlock0; } /* No message waiting. Wait for a message */ if (msgflg & IPC_NOWAIT) { msg = ERR_PTR(-ENOMSG); goto out_unlock0; } list_add_tail(&msr_d.r_list, &msq->q_receivers); msr_d.r_tsk = current; msr_d.r_msgtype = msgtyp; msr_d.r_mode = mode; if (msgflg & MSG_NOERROR) msr_d.r_maxsize = INT_MAX; else msr_d.r_maxsize = bufsz; msr_d.r_msg = ERR_PTR(-EAGAIN); __set_current_state(TASK_INTERRUPTIBLE); ipc_unlock_object(&msq->q_perm); rcu_read_unlock(); schedule(); /* Lockless receive, part 1: * Disable preemption. We don't hold a reference to the queue * and getting a reference would defeat the idea of a lockless * operation, thus the code relies on rcu to guarantee the * existence of msq: * Prior to destruction, expunge_all(-EIRDM) changes r_msg. * Thus if r_msg is -EAGAIN, then the queue not yet destroyed. * rcu_read_lock() prevents preemption between reading r_msg * and acquiring the q_perm.lock in ipc_lock_object(). */ rcu_read_lock(); /* Lockless receive, part 2: * Wait until pipelined_send or expunge_all are outside of * wake_up_process(). There is a race with exit(), see * ipc/mqueue.c for the details. The correct serialization * ensures that a receiver cannot continue without the wakeup * being visibible _before_ setting r_msg: * * CPU 0 CPU 1 * <loop receiver> * smp_rmb(); (A) <-- pair -. <waker thread> * <load ->r_msg> | msr->r_msg = NULL; * | wake_up_process(); * <continue> `------> smp_wmb(); (B) * msr->r_msg = msg; * * Where (A) orders the message value read and where (B) orders * the write to the r_msg -- done in both pipelined_send and * expunge_all. */ for (;;) { /* * Pairs with writer barrier in pipelined_send * or expunge_all. */ smp_rmb(); /* barrier (A) */ msg = (struct msg_msg *)msr_d.r_msg; if (msg) break; /* * The cpu_relax() call is a compiler barrier * which forces everything in this loop to be * re-loaded. */ cpu_relax(); } /* Lockless receive, part 3: * If there is a message or an error then accept it without * locking. */ if (msg != ERR_PTR(-EAGAIN)) goto out_unlock1; /* Lockless receive, part 3: * Acquire the queue spinlock. */ ipc_lock_object(&msq->q_perm); /* Lockless receive, part 4: * Repeat test after acquiring the spinlock. */ msg = (struct msg_msg *)msr_d.r_msg; if (msg != ERR_PTR(-EAGAIN)) goto out_unlock0; list_del(&msr_d.r_list); if (signal_pending(current)) { msg = ERR_PTR(-ERESTARTNOHAND); goto out_unlock0; } ipc_unlock_object(&msq->q_perm); } out_unlock0: ipc_unlock_object(&msq->q_perm); out_unlock1: rcu_read_unlock(); if (IS_ERR(msg)) { free_copy(copy); return PTR_ERR(msg); } bufsz = msg_handler(buf, msg, bufsz); free_msg(msg); return bufsz; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git29844.02%1129.73%
davidlohr buesodavidlohr bueso10215.07%410.81%
manfred spraulmanfred spraul9714.33%12.70%
stanislav kinsburskystanislav kinsbursky8813.00%410.81%
peter hurleypeter hurley294.28%38.11%
michael kerriskmichael kerrisk192.81%12.70%
kirill korotaevkirill korotaev101.48%25.41%
stephen d. smalleystephen d. smalley71.03%12.70%
nadia derbeynadia derbey50.74%12.70%
rafael aquinirafael aquini50.74%12.70%
linus torvaldslinus torvalds50.74%12.70%
pavel emelianovpavel emelianov30.44%12.70%
serge hallynserge hallyn20.30%12.70%
suzuki k poulosesuzuki k poulose20.30%12.70%
andi kleenandi kleen20.30%12.70%
ingo molnaringo molnar10.15%12.70%
al viroal viro10.15%12.70%
andrew mortonandrew morton10.15%12.70%
Total677100.00%37100.00%

SYSCALL_DEFINE5(msgrcv, int, msqid, struct msgbuf __user *, msgp, size_t, msgsz, long, msgtyp, int, msgflg) { return do_msgrcv(msqid, msgp, msgsz, msgtyp, msgflg, do_msg_fill); }
void msg_init_ns(struct ipc_namespace *ns) { ns->msg_ctlmax = MSGMAX; ns->msg_ctlmnb = MSGMNB; ns->msg_ctlmni = MSGMNI; atomic_set(&ns->msg_bytes, 0); atomic_set(&ns->msg_hdrs, 0); ipc_init_ids(&ns->ids[IPC_MSG_IDS]); }

Contributors

PersonTokensPropCommitsCommitProp
davidlohr buesodavidlohr bueso5593.22%150.00%
manfred spraulmanfred spraul46.78%150.00%
Total59100.00%2100.00%

#ifdef CONFIG_IPC_NS
void msg_exit_ns(struct ipc_namespace *ns) { free_ipcs(ns, &msg_ids(ns), freeque); idr_destroy(&ns->ids[IPC_MSG_IDS].ipcs_idr); }

Contributors

PersonTokensPropCommitsCommitProp
davidlohr buesodavidlohr bueso36100.00%1100.00%
Total36100.00%1100.00%

#endif #ifdef CONFIG_PROC_FS
static int sysvipc_msg_proc_show(struct seq_file *s, void *it) { struct user_namespace *user_ns = seq_user_ns(s); struct msg_queue *msq = it; seq_printf(s, "%10d %10d %4o %10lu %10lu %5u %5u %5u %5u %5u %5u %10lu %10lu %10lu\n", msq->q_perm.key, msq->q_perm.id, msq->q_perm.mode, msq->q_cbytes, msq->q_qnum, msq->q_lspid, msq->q_lrpid, from_kuid_munged(user_ns, msq->q_perm.uid), from_kgid_munged(user_ns, msq->q_perm.gid), from_kuid_munged(user_ns, msq->q_perm.cuid), from_kgid_munged(user_ns, msq->q_perm.cgid), msq->q_stime, msq->q_rtime, msq->q_ctime); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git8765.91%450.00%
eric w. biedermaneric w. biederman3022.73%112.50%
mike waychisonmike waychison96.82%112.50%
nadia derbeynadia derbey32.27%112.50%
joe perchesjoe perches32.27%112.50%
Total132100.00%8100.00%

#endif
void __init msg_init(void) { msg_init_ns(&init_ipc_ns); ipc_init_proc_interface("sysvipc/msg", " key msqid perms cbytes qnum lspid lrpid uid gid cuid cgid stime rtime ctime\n", IPC_MSG_IDS, sysvipc_msg_proc_show); }

Contributors

PersonTokensPropCommitsCommitProp
davidlohr buesodavidlohr bueso25100.00%1100.00%
Total25100.00%1100.00%


Overall Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git184441.14%2018.87%
davidlohr buesodavidlohr bueso68815.35%1917.92%
pierre peifferpierre peiffer48710.87%65.66%
stanislav kinsburskystanislav kinsbursky2876.40%54.72%
manfred spraulmanfred spraul1854.13%43.77%
peter hurleypeter hurley1703.79%43.77%
nadia derbeynadia derbey1543.44%65.66%
stephen d. smalleystephen d. smalley1072.39%21.89%
kirill korotaevkirill korotaev841.87%21.89%
suzuki k poulosesuzuki k poulose611.36%10.94%
linus torvaldslinus torvalds571.27%32.83%
heiko carstensheiko carstens561.25%10.94%
eric w. biedermaneric w. biederman451.00%10.94%
nikola pajkovskynikola pajkovsky420.94%10.94%
greg kroah-hartmangreg kroah-hartman230.51%32.83%
michael kerriskmichael kerrisk190.42%10.94%
ingo molnaringo molnar190.42%21.89%
rafael aquinirafael aquini160.36%10.94%
mathias krausemathias krause140.31%10.94%
pavel emelianovpavel emelianov120.27%21.89%
andrew mortonandrew morton120.27%21.89%
svenning sorensensvenning sorensen120.27%10.94%
rik van rielrik van riel120.27%10.94%
mike waychisonmike waychison120.27%10.94%
andi kleenandi kleen80.18%10.94%
serge hallynserge hallyn80.18%10.94%
steve grubbsteve grubb70.16%10.94%
alexey dobriyanalexey dobriyan60.13%10.94%
al viroal viro50.11%10.94%
linda knipperslinda knippers50.11%10.94%
arnaldo carvalho de meloarnaldo carvalho de melo40.09%10.94%
david woodhousedavid woodhouse30.07%10.94%
felipe contrerasfelipe contreras30.07%10.94%
arnd bergmannarnd bergmann30.07%10.94%
randy dunlaprandy dunlap30.07%10.94%
joe perchesjoe perches30.07%10.94%
dave jonesdave jones20.04%10.94%
stephen rothwellstephen rothwell20.04%10.94%
paul mcquadepaul mcquade10.02%10.94%
lucas de marchilucas de marchi10.02%10.94%
Total4482100.00%106100.00%
Directory: ipc
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
{% endraw %}