blob: 03b88798f71f642e4e1a070137c97f5110d8b4da [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/ipc/util.c
3 * Copyright (C) 1992 Krishna Balasubramanian
4 *
5 * Sep 1997 - Call suser() last after "normal" permission checks so we
6 * get BSD style process accounting right.
7 * Occurs in several places in the IPC code.
8 * Chris Evans, <chris@ferret.lmh.ox.ac.uk>
9 * Nov 1999 - ipc helper functions, unified SMP locking
Christian Kujau624dffc2006-01-15 02:43:54 +010010 * Manfred Spraul <manfred@colorfullife.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 * Oct 2002 - One lock per IPC id. RCU ipc_free for lock-free grow_ary().
12 * Mingming Cao <cmm@us.ibm.com>
Steve Grubb073115d2006-04-02 17:07:33 -040013 * Mar 2006 - support for audit of ipc object properties
14 * Dustin Kirkland <dustin.kirkland@us.ibm.com>
Kirill Korotaev73ea4132006-10-02 02:18:20 -070015 * Jun 2006 - namespaces ssupport
16 * OpenVZ, SWsoft Inc.
17 * Pavel Emelianov <xemul@openvz.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 */
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/mm.h>
21#include <linux/shm.h>
22#include <linux/init.h>
23#include <linux/msg.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/vmalloc.h>
25#include <linux/slab.h>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080026#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/highuid.h>
28#include <linux/security.h>
29#include <linux/rcupdate.h>
30#include <linux/workqueue.h>
Mike Waychisonae781772005-09-06 15:17:09 -070031#include <linux/seq_file.h>
32#include <linux/proc_fs.h>
Steve Grubb073115d2006-04-02 17:07:33 -040033#include <linux/audit.h>
Kirill Korotaev73ea4132006-10-02 02:18:20 -070034#include <linux/nsproxy.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
36#include <asm/unistd.h>
37
38#include "util.h"
39
Mike Waychisonae781772005-09-06 15:17:09 -070040struct ipc_proc_iface {
41 const char *path;
42 const char *header;
Kirill Korotaev73ea4132006-10-02 02:18:20 -070043 int ids;
Mike Waychisonae781772005-09-06 15:17:09 -070044 int (*show)(struct seq_file *, void *);
45};
46
Kirill Korotaev73ea4132006-10-02 02:18:20 -070047struct ipc_namespace init_ipc_ns = {
48 .kref = {
49 .refcount = ATOMIC_INIT(2),
50 },
51};
52
Kirill Korotaev73ea4132006-10-02 02:18:20 -070053static struct ipc_namespace *clone_ipc_ns(struct ipc_namespace *old_ns)
54{
55 int err;
56 struct ipc_namespace *ns;
57
58 err = -ENOMEM;
59 ns = kmalloc(sizeof(struct ipc_namespace), GFP_KERNEL);
60 if (ns == NULL)
61 goto err_mem;
62
63 err = sem_init_ns(ns);
64 if (err)
65 goto err_sem;
66 err = msg_init_ns(ns);
67 if (err)
68 goto err_msg;
69 err = shm_init_ns(ns);
70 if (err)
71 goto err_shm;
72
73 kref_init(&ns->kref);
74 return ns;
75
76err_shm:
77 msg_exit_ns(ns);
78err_msg:
79 sem_exit_ns(ns);
80err_sem:
81 kfree(ns);
82err_mem:
83 return ERR_PTR(err);
84}
85
Badari Pulavartye3222c42007-05-08 00:25:21 -070086struct ipc_namespace *copy_ipcs(unsigned long flags, struct ipc_namespace *ns)
Kirill Korotaev73ea4132006-10-02 02:18:20 -070087{
Kirill Korotaev73ea4132006-10-02 02:18:20 -070088 struct ipc_namespace *new_ns;
Kirill Korotaev73ea4132006-10-02 02:18:20 -070089
Badari Pulavartye3222c42007-05-08 00:25:21 -070090 BUG_ON(!ns);
91 get_ipc_ns(ns);
Kirill Korotaev73ea4132006-10-02 02:18:20 -070092
93 if (!(flags & CLONE_NEWIPC))
Badari Pulavartye3222c42007-05-08 00:25:21 -070094 return ns;
Kirill Korotaev73ea4132006-10-02 02:18:20 -070095
Badari Pulavartye3222c42007-05-08 00:25:21 -070096 new_ns = clone_ipc_ns(ns);
Kirill Korotaev73ea4132006-10-02 02:18:20 -070097
Badari Pulavartye3222c42007-05-08 00:25:21 -070098 put_ipc_ns(ns);
99 return new_ns;
Kirill Korotaev73ea4132006-10-02 02:18:20 -0700100}
101
102void free_ipc_ns(struct kref *kref)
103{
104 struct ipc_namespace *ns;
105
106 ns = container_of(kref, struct ipc_namespace, kref);
107 sem_exit_ns(ns);
108 msg_exit_ns(ns);
109 shm_exit_ns(ns);
110 kfree(ns);
111}
Kirill Korotaev73ea4132006-10-02 02:18:20 -0700112
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113/**
114 * ipc_init - initialise IPC subsystem
115 *
116 * The various system5 IPC resources (semaphores, messages and shared
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800117 * memory) are initialised
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 */
119
120static int __init ipc_init(void)
121{
122 sem_init();
123 msg_init();
124 shm_init();
125 return 0;
126}
127__initcall(ipc_init);
128
129/**
130 * ipc_init_ids - initialise IPC identifiers
131 * @ids: Identifier set
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 *
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700133 * Set up the sequence range to use for the ipc identifier range (limited
134 * below IPCMNI) then initialise the ids idr.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 */
136
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700137void ipc_init_ids(struct ipc_ids *ids)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138{
Ingo Molnar5f921ae2006-03-26 01:37:17 -0800139 mutex_init(&ids->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 ids->in_use = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 ids->seq = 0;
143 {
144 int seq_limit = INT_MAX/SEQ_MULTIPLIER;
145 if(seq_limit > USHRT_MAX)
146 ids->seq_max = USHRT_MAX;
147 else
148 ids->seq_max = seq_limit;
149 }
150
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700151 idr_init(&ids->ipcs_idr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152}
153
Mike Waychisonae781772005-09-06 15:17:09 -0700154#ifdef CONFIG_PROC_FS
Arjan van de Ven9a321442007-02-12 00:55:35 -0800155static const struct file_operations sysvipc_proc_fops;
Mike Waychisonae781772005-09-06 15:17:09 -0700156/**
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800157 * ipc_init_proc_interface - Create a proc interface for sysipc types using a seq_file interface.
Mike Waychisonae781772005-09-06 15:17:09 -0700158 * @path: Path in procfs
159 * @header: Banner to be printed at the beginning of the file.
160 * @ids: ipc id table to iterate.
161 * @show: show routine.
162 */
163void __init ipc_init_proc_interface(const char *path, const char *header,
Kirill Korotaev73ea4132006-10-02 02:18:20 -0700164 int ids, int (*show)(struct seq_file *, void *))
Mike Waychisonae781772005-09-06 15:17:09 -0700165{
166 struct proc_dir_entry *pde;
167 struct ipc_proc_iface *iface;
168
169 iface = kmalloc(sizeof(*iface), GFP_KERNEL);
170 if (!iface)
171 return;
172 iface->path = path;
173 iface->header = header;
174 iface->ids = ids;
175 iface->show = show;
176
177 pde = create_proc_entry(path,
178 S_IRUGO, /* world readable */
179 NULL /* parent dir */);
180 if (pde) {
181 pde->data = iface;
182 pde->proc_fops = &sysvipc_proc_fops;
183 } else {
184 kfree(iface);
185 }
186}
187#endif
188
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189/**
190 * ipc_findkey - find a key in an ipc identifier set
191 * @ids: Identifier set
192 * @key: The key to find
193 *
Ingo Molnar5f921ae2006-03-26 01:37:17 -0800194 * Requires ipc_ids.mutex locked.
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700195 * Returns the LOCKED pointer to the ipc structure if found or NULL
196 * if not.
197 * If key is found ipc contains its ipc structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 */
199
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700200static struct kern_ipc_perm *ipc_findkey(struct ipc_ids *ids, key_t key)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201{
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700202 struct kern_ipc_perm *ipc;
203 int next_id;
204 int total;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700206 for (total = 0, next_id = 0; total < ids->in_use; next_id++) {
207 ipc = idr_find(&ids->ipcs_idr, next_id);
208
209 if (ipc == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 continue;
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700211
212 if (ipc->key != key) {
213 total++;
214 continue;
215 }
216
217 ipc_lock_by_ptr(ipc);
218 return ipc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 }
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700220
221 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222}
223
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700224/**
225 * ipc_get_maxid - get the last assigned id
226 * @ids: IPC identifier set
227 *
228 * Called with ipc_ids.mutex held.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 */
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700230
231int ipc_get_maxid(struct ipc_ids *ids)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232{
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700233 struct kern_ipc_perm *ipc;
234 int max_id = -1;
235 int total, id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700237 if (ids->in_use == 0)
238 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700240 if (ids->in_use == IPCMNI)
241 return IPCMNI - 1;
242
243 /* Look for the last assigned id */
244 total = 0;
245 for (id = 0; id < IPCMNI && total < ids->in_use; id++) {
246 ipc = idr_find(&ids->ipcs_idr, id);
247 if (ipc != NULL) {
248 max_id = id;
249 total++;
250 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 }
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700252 return max_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253}
254
255/**
256 * ipc_addid - add an IPC identifier
257 * @ids: IPC identifier set
258 * @new: new IPC permission set
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700259 * @size: limit for the number of used ids
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 *
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700261 * Add an entry 'new' to the IPC idr. The permissions object is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 * initialised and the first free entry is set up and the id assigned
263 * is returned. The list is returned in a locked state on success.
264 * On failure the list is not locked and -1 is returned.
265 *
Ingo Molnar5f921ae2006-03-26 01:37:17 -0800266 * Called with ipc_ids.mutex held.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 */
268
269int ipc_addid(struct ipc_ids* ids, struct kern_ipc_perm* new, int size)
270{
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700271 int id, err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
273 /*
274 * rcu_dereference()() is not needed here since
Ingo Molnar5f921ae2006-03-26 01:37:17 -0800275 * ipc_ids.mutex is held
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 */
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700277 if (size > IPCMNI)
278 size = IPCMNI;
279
280 if (ids->in_use >= size)
281 return -1;
282
283 err = idr_get_new(&ids->ipcs_idr, new, &id);
284 if (err)
285 return -1;
286
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 ids->in_use++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
289 new->cuid = new->uid = current->euid;
290 new->gid = new->cgid = current->egid;
291
292 new->seq = ids->seq++;
293 if(ids->seq > ids->seq_max)
294 ids->seq = 0;
295
296 spin_lock_init(&new->lock);
297 new->deleted = 0;
298 rcu_read_lock();
299 spin_lock(&new->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 return id;
301}
302
303/**
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700304 * ipcget_new - create a new ipc object
305 * @ns: namespace
306 * @ids: identifer set
307 * @ops: the actual creation routine to call
308 * @params: its parameters
309 *
310 * This routine is called sys_msgget, sys_semget() and sys_shmget() when
311 * the key is IPC_PRIVATE
312 */
313int ipcget_new(struct ipc_namespace *ns, struct ipc_ids *ids,
314 struct ipc_ops *ops, struct ipc_params *params)
315{
316 int err;
317
318 err = idr_pre_get(&ids->ipcs_idr, GFP_KERNEL);
319
320 if (!err)
321 return -ENOMEM;
322
323 mutex_lock(&ids->mutex);
324 err = ops->getnew(ns, params);
325 mutex_unlock(&ids->mutex);
326
327 return err;
328}
329
330/**
331 * ipc_check_perms - check security and permissions for an IPC
332 * @ipcp: ipc permission set
333 * @ids: identifer set
334 * @ops: the actual security routine to call
335 * @params: its parameters
336 */
337static int ipc_check_perms(struct kern_ipc_perm *ipcp, struct ipc_ops *ops,
338 struct ipc_params *params)
339{
340 int err;
341
342 if (ipcperms(ipcp, params->flg))
343 err = -EACCES;
344 else {
345 err = ops->associate(ipcp, params->flg);
346 if (!err)
347 err = ipcp->id;
348 }
349
350 return err;
351}
352
353/**
354 * ipcget_public - get an ipc object or create a new one
355 * @ns: namespace
356 * @ids: identifer set
357 * @ops: the actual creation routine to call
358 * @params: its parameters
359 *
360 * This routine is called sys_msgget, sys_semget() and sys_shmget() when
361 * the key is not IPC_PRIVATE
362 */
363int ipcget_public(struct ipc_namespace *ns, struct ipc_ids *ids,
364 struct ipc_ops *ops, struct ipc_params *params)
365{
366 struct kern_ipc_perm *ipcp;
367 int flg = params->flg;
368 int err;
369
370 err = idr_pre_get(&ids->ipcs_idr, GFP_KERNEL);
371
372 mutex_lock(&ids->mutex);
373 ipcp = ipc_findkey(ids, params->key);
374 if (ipcp == NULL) {
375 /* key not used */
376 if (!(flg & IPC_CREAT))
377 err = -ENOENT;
378 else if (!err)
379 err = -ENOMEM;
380 else
381 err = ops->getnew(ns, params);
382 } else {
383 /* ipc object has been locked by ipc_findkey() */
384
385 if (flg & IPC_CREAT && flg & IPC_EXCL)
386 err = -EEXIST;
387 else {
388 err = 0;
389 if (ops->more_checks)
390 err = ops->more_checks(ipcp, params);
391 if (!err)
392 err = ipc_check_perms(ipcp, ops, params);
393 }
394 ipc_unlock(ipcp);
395 }
396 mutex_unlock(&ids->mutex);
397
398 return err;
399}
400
401
402/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 * ipc_rmid - remove an IPC identifier
404 * @ids: identifier set
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700405 * @id: ipc perm structure containing the identifier to remove
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 *
407 * The identifier must be valid, and in use. The kernel will panic if
408 * fed an invalid identifier. The entry is removed and internal
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700409 * variables recomputed.
410 * ipc_ids.mutex and the spinlock for this ID are held before this
411 * function is called, and remain locked on the exit.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 */
413
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700414void ipc_rmid(struct ipc_ids *ids, struct kern_ipc_perm *ipcp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415{
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700416 int lid = ipcp->id % SEQ_MULTIPLIER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700418 idr_remove(&ids->ipcs_idr, lid);
419
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 ids->in_use--;
421
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700422 ipcp->deleted = 1;
423
424 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425}
426
427/**
428 * ipc_alloc - allocate ipc space
429 * @size: size desired
430 *
431 * Allocate memory from the appropriate pools and return a pointer to it.
432 * NULL is returned if the allocation fails
433 */
434
435void* ipc_alloc(int size)
436{
437 void* out;
438 if(size > PAGE_SIZE)
439 out = vmalloc(size);
440 else
441 out = kmalloc(size, GFP_KERNEL);
442 return out;
443}
444
445/**
446 * ipc_free - free ipc space
447 * @ptr: pointer returned by ipc_alloc
448 * @size: size of block
449 *
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800450 * Free a block created with ipc_alloc(). The caller must know the size
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 * used in the allocation call.
452 */
453
454void ipc_free(void* ptr, int size)
455{
456 if(size > PAGE_SIZE)
457 vfree(ptr);
458 else
459 kfree(ptr);
460}
461
462/*
463 * rcu allocations:
464 * There are three headers that are prepended to the actual allocation:
465 * - during use: ipc_rcu_hdr.
466 * - during the rcu grace period: ipc_rcu_grace.
467 * - [only if vmalloc]: ipc_rcu_sched.
468 * Their lifetime doesn't overlap, thus the headers share the same memory.
469 * Unlike a normal union, they are right-aligned, thus some container_of
470 * forward/backward casting is necessary:
471 */
472struct ipc_rcu_hdr
473{
474 int refcount;
475 int is_vmalloc;
476 void *data[0];
477};
478
479
480struct ipc_rcu_grace
481{
482 struct rcu_head rcu;
483 /* "void *" makes sure alignment of following data is sane. */
484 void *data[0];
485};
486
487struct ipc_rcu_sched
488{
489 struct work_struct work;
490 /* "void *" makes sure alignment of following data is sane. */
491 void *data[0];
492};
493
494#define HDRLEN_KMALLOC (sizeof(struct ipc_rcu_grace) > sizeof(struct ipc_rcu_hdr) ? \
495 sizeof(struct ipc_rcu_grace) : sizeof(struct ipc_rcu_hdr))
496#define HDRLEN_VMALLOC (sizeof(struct ipc_rcu_sched) > HDRLEN_KMALLOC ? \
497 sizeof(struct ipc_rcu_sched) : HDRLEN_KMALLOC)
498
499static inline int rcu_use_vmalloc(int size)
500{
501 /* Too big for a single page? */
502 if (HDRLEN_KMALLOC + size > PAGE_SIZE)
503 return 1;
504 return 0;
505}
506
507/**
508 * ipc_rcu_alloc - allocate ipc and rcu space
509 * @size: size desired
510 *
511 * Allocate memory for the rcu header structure + the object.
512 * Returns the pointer to the object.
513 * NULL is returned if the allocation fails.
514 */
515
516void* ipc_rcu_alloc(int size)
517{
518 void* out;
519 /*
520 * We prepend the allocation with the rcu struct, and
521 * workqueue if necessary (for vmalloc).
522 */
523 if (rcu_use_vmalloc(size)) {
524 out = vmalloc(HDRLEN_VMALLOC + size);
525 if (out) {
526 out += HDRLEN_VMALLOC;
527 container_of(out, struct ipc_rcu_hdr, data)->is_vmalloc = 1;
528 container_of(out, struct ipc_rcu_hdr, data)->refcount = 1;
529 }
530 } else {
531 out = kmalloc(HDRLEN_KMALLOC + size, GFP_KERNEL);
532 if (out) {
533 out += HDRLEN_KMALLOC;
534 container_of(out, struct ipc_rcu_hdr, data)->is_vmalloc = 0;
535 container_of(out, struct ipc_rcu_hdr, data)->refcount = 1;
536 }
537 }
538
539 return out;
540}
541
542void ipc_rcu_getref(void *ptr)
543{
544 container_of(ptr, struct ipc_rcu_hdr, data)->refcount++;
545}
546
David Howells65f27f32006-11-22 14:55:48 +0000547static void ipc_do_vfree(struct work_struct *work)
548{
549 vfree(container_of(work, struct ipc_rcu_sched, work));
550}
551
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552/**
Randy Dunlap1e5d5332005-11-07 01:01:06 -0800553 * ipc_schedule_free - free ipc + rcu space
554 * @head: RCU callback structure for queued work
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 *
556 * Since RCU callback function is called in bh,
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800557 * we need to defer the vfree to schedule_work().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 */
559static void ipc_schedule_free(struct rcu_head *head)
560{
561 struct ipc_rcu_grace *grace =
562 container_of(head, struct ipc_rcu_grace, rcu);
563 struct ipc_rcu_sched *sched =
564 container_of(&(grace->data[0]), struct ipc_rcu_sched, data[0]);
565
David Howells65f27f32006-11-22 14:55:48 +0000566 INIT_WORK(&sched->work, ipc_do_vfree);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 schedule_work(&sched->work);
568}
569
570/**
Randy Dunlap1e5d5332005-11-07 01:01:06 -0800571 * ipc_immediate_free - free ipc + rcu space
572 * @head: RCU callback structure that contains pointer to be freed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 *
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800574 * Free from the RCU callback context.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 */
576static void ipc_immediate_free(struct rcu_head *head)
577{
578 struct ipc_rcu_grace *free =
579 container_of(head, struct ipc_rcu_grace, rcu);
580 kfree(free);
581}
582
583void ipc_rcu_putref(void *ptr)
584{
585 if (--container_of(ptr, struct ipc_rcu_hdr, data)->refcount > 0)
586 return;
587
588 if (container_of(ptr, struct ipc_rcu_hdr, data)->is_vmalloc) {
589 call_rcu(&container_of(ptr, struct ipc_rcu_grace, data)->rcu,
590 ipc_schedule_free);
591 } else {
592 call_rcu(&container_of(ptr, struct ipc_rcu_grace, data)->rcu,
593 ipc_immediate_free);
594 }
595}
596
597/**
598 * ipcperms - check IPC permissions
599 * @ipcp: IPC permission set
600 * @flag: desired permission set.
601 *
602 * Check user, group, other permissions for access
603 * to ipc resources. return 0 if allowed
604 */
605
606int ipcperms (struct kern_ipc_perm *ipcp, short flag)
607{ /* flag will most probably be 0 or S_...UGO from <linux/stat.h> */
Steve Grubb073115d2006-04-02 17:07:33 -0400608 int requested_mode, granted_mode, err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
Steve Grubb073115d2006-04-02 17:07:33 -0400610 if (unlikely((err = audit_ipc_obj(ipcp))))
611 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 requested_mode = (flag >> 6) | (flag >> 3) | flag;
613 granted_mode = ipcp->mode;
614 if (current->euid == ipcp->cuid || current->euid == ipcp->uid)
615 granted_mode >>= 6;
616 else if (in_group_p(ipcp->cgid) || in_group_p(ipcp->gid))
617 granted_mode >>= 3;
618 /* is there some bit set in requested_mode but not in granted_mode? */
619 if ((requested_mode & ~granted_mode & 0007) &&
620 !capable(CAP_IPC_OWNER))
621 return -1;
622
623 return security_ipc_permission(ipcp, flag);
624}
625
626/*
627 * Functions to convert between the kern_ipc_perm structure and the
628 * old/new ipc_perm structures
629 */
630
631/**
632 * kernel_to_ipc64_perm - convert kernel ipc permissions to user
633 * @in: kernel permissions
634 * @out: new style IPC permissions
635 *
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800636 * Turn the kernel object @in into a set of permissions descriptions
637 * for returning to userspace (@out).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 */
639
640
641void kernel_to_ipc64_perm (struct kern_ipc_perm *in, struct ipc64_perm *out)
642{
643 out->key = in->key;
644 out->uid = in->uid;
645 out->gid = in->gid;
646 out->cuid = in->cuid;
647 out->cgid = in->cgid;
648 out->mode = in->mode;
649 out->seq = in->seq;
650}
651
652/**
653 * ipc64_perm_to_ipc_perm - convert old ipc permissions to new
654 * @in: new style IPC permissions
655 * @out: old style IPC permissions
656 *
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800657 * Turn the new style permissions object @in into a compatibility
658 * object and store it into the @out pointer.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 */
660
661void ipc64_perm_to_ipc_perm (struct ipc64_perm *in, struct ipc_perm *out)
662{
663 out->key = in->key;
664 SET_UID(out->uid, in->uid);
665 SET_GID(out->gid, in->gid);
666 SET_UID(out->cuid, in->cuid);
667 SET_GID(out->cgid, in->cgid);
668 out->mode = in->mode;
669 out->seq = in->seq;
670}
671
672/*
673 * So far only shm_get_stat() calls ipc_get() via shm_get(), so ipc_get()
Ingo Molnar5f921ae2006-03-26 01:37:17 -0800674 * is called with shm_ids.mutex locked. Since grow_ary() is also called with
675 * shm_ids.mutex down(for Shared Memory), there is no need to add read
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 * barriers here to gurantee the writes in grow_ary() are seen in order
677 * here (for Alpha).
678 *
Ingo Molnar5f921ae2006-03-26 01:37:17 -0800679 * However ipc_get() itself does not necessary require ipc_ids.mutex down. So
680 * if in the future ipc_get() is used by other places without ipc_ids.mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 * down, then ipc_get() needs read memery barriers as ipc_lock() does.
682 */
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700683struct kern_ipc_perm *ipc_get(struct ipc_ids *ids, int id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684{
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700685 struct kern_ipc_perm *out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 int lid = id % SEQ_MULTIPLIER;
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700687 out = idr_find(&ids->ipcs_idr, lid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 return out;
689}
690
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700691struct kern_ipc_perm *ipc_lock(struct ipc_ids *ids, int id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692{
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700693 struct kern_ipc_perm *out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 int lid = id % SEQ_MULTIPLIER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
696 rcu_read_lock();
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700697 out = idr_find(&ids->ipcs_idr, lid);
698 if (out == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 rcu_read_unlock();
700 return NULL;
701 }
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700702
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 spin_lock(&out->lock);
704
705 /* ipc_rmid() may have already freed the ID while ipc_lock
706 * was spinning: here verify that the structure is still valid
707 */
708 if (out->deleted) {
709 spin_unlock(&out->lock);
710 rcu_read_unlock();
711 return NULL;
712 }
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700713
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 return out;
715}
716
717void ipc_lock_by_ptr(struct kern_ipc_perm *perm)
718{
719 rcu_read_lock();
720 spin_lock(&perm->lock);
721}
722
723void ipc_unlock(struct kern_ipc_perm* perm)
724{
725 spin_unlock(&perm->lock);
726 rcu_read_unlock();
727}
728
729int ipc_buildid(struct ipc_ids* ids, int id, int seq)
730{
731 return SEQ_MULTIPLIER*seq + id;
732}
733
734int ipc_checkid(struct ipc_ids* ids, struct kern_ipc_perm* ipcp, int uid)
735{
736 if(uid/SEQ_MULTIPLIER != ipcp->seq)
737 return 1;
738 return 0;
739}
740
741#ifdef __ARCH_WANT_IPC_PARSE_VERSION
742
743
744/**
745 * ipc_parse_version - IPC call version
746 * @cmd: pointer to command
747 *
748 * Return IPC_64 for new style IPC and IPC_OLD for old style IPC.
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800749 * The @cmd value is turned from an encoding command and version into
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 * just the command code.
751 */
752
753int ipc_parse_version (int *cmd)
754{
755 if (*cmd & IPC_64) {
756 *cmd ^= IPC_64;
757 return IPC_64;
758 } else {
759 return IPC_OLD;
760 }
761}
762
763#endif /* __ARCH_WANT_IPC_PARSE_VERSION */
Mike Waychisonae781772005-09-06 15:17:09 -0700764
765#ifdef CONFIG_PROC_FS
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800766struct ipc_proc_iter {
767 struct ipc_namespace *ns;
768 struct ipc_proc_iface *iface;
769};
770
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700771/*
772 * This routine locks the ipc structure found at least at position pos.
773 */
774struct kern_ipc_perm *sysvipc_find_ipc(struct ipc_ids *ids, loff_t pos,
775 loff_t *new_pos)
Mike Waychisonae781772005-09-06 15:17:09 -0700776{
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700777 struct kern_ipc_perm *ipc;
778 int total, id;
Kirill Korotaev73ea4132006-10-02 02:18:20 -0700779
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700780 total = 0;
781 for (id = 0; id < pos && total < ids->in_use; id++) {
782 ipc = idr_find(&ids->ipcs_idr, id);
783 if (ipc != NULL)
784 total++;
785 }
Mike Waychisonae781772005-09-06 15:17:09 -0700786
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700787 if (total >= ids->in_use)
788 return NULL;
Mike Waychisonae781772005-09-06 15:17:09 -0700789
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700790 for ( ; pos < IPCMNI; pos++) {
791 ipc = idr_find(&ids->ipcs_idr, pos);
792 if (ipc != NULL) {
793 *new_pos = pos + 1;
794 ipc_lock_by_ptr(ipc);
Mike Waychisonae781772005-09-06 15:17:09 -0700795 return ipc;
796 }
797 }
798
799 /* Out of range - return NULL to terminate iteration */
800 return NULL;
801}
802
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700803static void *sysvipc_proc_next(struct seq_file *s, void *it, loff_t *pos)
804{
805 struct ipc_proc_iter *iter = s->private;
806 struct ipc_proc_iface *iface = iter->iface;
807 struct kern_ipc_perm *ipc = it;
808
809 /* If we had an ipc id locked before, unlock it */
810 if (ipc && ipc != SEQ_START_TOKEN)
811 ipc_unlock(ipc);
812
813 return sysvipc_find_ipc(iter->ns->ids[iface->ids], *pos, pos);
814}
815
Mike Waychisonae781772005-09-06 15:17:09 -0700816/*
817 * File positions: pos 0 -> header, pos n -> ipc id + 1.
818 * SeqFile iterator: iterator value locked shp or SEQ_TOKEN_START.
819 */
820static void *sysvipc_proc_start(struct seq_file *s, loff_t *pos)
821{
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800822 struct ipc_proc_iter *iter = s->private;
823 struct ipc_proc_iface *iface = iter->iface;
Kirill Korotaev73ea4132006-10-02 02:18:20 -0700824 struct ipc_ids *ids;
825
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800826 ids = iter->ns->ids[iface->ids];
Mike Waychisonae781772005-09-06 15:17:09 -0700827
828 /*
829 * Take the lock - this will be released by the corresponding
830 * call to stop().
831 */
Kirill Korotaev73ea4132006-10-02 02:18:20 -0700832 mutex_lock(&ids->mutex);
Mike Waychisonae781772005-09-06 15:17:09 -0700833
834 /* pos < 0 is invalid */
835 if (*pos < 0)
836 return NULL;
837
838 /* pos == 0 means header */
839 if (*pos == 0)
840 return SEQ_START_TOKEN;
841
842 /* Find the (pos-1)th ipc */
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700843 return sysvipc_find_ipc(ids, *pos - 1, pos);
Mike Waychisonae781772005-09-06 15:17:09 -0700844}
845
846static void sysvipc_proc_stop(struct seq_file *s, void *it)
847{
848 struct kern_ipc_perm *ipc = it;
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800849 struct ipc_proc_iter *iter = s->private;
850 struct ipc_proc_iface *iface = iter->iface;
Kirill Korotaev73ea4132006-10-02 02:18:20 -0700851 struct ipc_ids *ids;
Mike Waychisonae781772005-09-06 15:17:09 -0700852
853 /* If we had a locked segment, release it */
854 if (ipc && ipc != SEQ_START_TOKEN)
855 ipc_unlock(ipc);
856
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800857 ids = iter->ns->ids[iface->ids];
Mike Waychisonae781772005-09-06 15:17:09 -0700858 /* Release the lock we took in start() */
Kirill Korotaev73ea4132006-10-02 02:18:20 -0700859 mutex_unlock(&ids->mutex);
Mike Waychisonae781772005-09-06 15:17:09 -0700860}
861
862static int sysvipc_proc_show(struct seq_file *s, void *it)
863{
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800864 struct ipc_proc_iter *iter = s->private;
865 struct ipc_proc_iface *iface = iter->iface;
Mike Waychisonae781772005-09-06 15:17:09 -0700866
867 if (it == SEQ_START_TOKEN)
868 return seq_puts(s, iface->header);
869
870 return iface->show(s, it);
871}
872
873static struct seq_operations sysvipc_proc_seqops = {
874 .start = sysvipc_proc_start,
875 .stop = sysvipc_proc_stop,
876 .next = sysvipc_proc_next,
877 .show = sysvipc_proc_show,
878};
879
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800880static int sysvipc_proc_open(struct inode *inode, struct file *file)
881{
Mike Waychisonae781772005-09-06 15:17:09 -0700882 int ret;
883 struct seq_file *seq;
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800884 struct ipc_proc_iter *iter;
885
886 ret = -ENOMEM;
887 iter = kmalloc(sizeof(*iter), GFP_KERNEL);
888 if (!iter)
889 goto out;
Mike Waychisonae781772005-09-06 15:17:09 -0700890
891 ret = seq_open(file, &sysvipc_proc_seqops);
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800892 if (ret)
893 goto out_kfree;
894
895 seq = file->private_data;
896 seq->private = iter;
897
898 iter->iface = PDE(inode)->data;
899 iter->ns = get_ipc_ns(current->nsproxy->ipc_ns);
900out:
Mike Waychisonae781772005-09-06 15:17:09 -0700901 return ret;
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800902out_kfree:
903 kfree(iter);
904 goto out;
905}
906
907static int sysvipc_proc_release(struct inode *inode, struct file *file)
908{
909 struct seq_file *seq = file->private_data;
910 struct ipc_proc_iter *iter = seq->private;
911 put_ipc_ns(iter->ns);
912 return seq_release_private(inode, file);
Mike Waychisonae781772005-09-06 15:17:09 -0700913}
914
Arjan van de Ven9a321442007-02-12 00:55:35 -0800915static const struct file_operations sysvipc_proc_fops = {
Mike Waychisonae781772005-09-06 15:17:09 -0700916 .open = sysvipc_proc_open,
917 .read = seq_read,
918 .llseek = seq_lseek,
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800919 .release = sysvipc_proc_release,
Mike Waychisonae781772005-09-06 15:17:09 -0700920};
921#endif /* CONFIG_PROC_FS */