ipc: store ipcs into IDRs
[linux-3.10.git] / ipc / util.c
1 /*
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
10  *            Manfred Spraul <manfred@colorfullife.com>
11  * Oct 2002 - One lock per IPC id. RCU ipc_free for lock-free grow_ary().
12  *            Mingming Cao <cmm@us.ibm.com>
13  * Mar 2006 - support for audit of ipc object properties
14  *            Dustin Kirkland <dustin.kirkland@us.ibm.com>
15  * Jun 2006 - namespaces ssupport
16  *            OpenVZ, SWsoft Inc.
17  *            Pavel Emelianov <xemul@openvz.org>
18  */
19
20 #include <linux/mm.h>
21 #include <linux/shm.h>
22 #include <linux/init.h>
23 #include <linux/msg.h>
24 #include <linux/vmalloc.h>
25 #include <linux/slab.h>
26 #include <linux/capability.h>
27 #include <linux/highuid.h>
28 #include <linux/security.h>
29 #include <linux/rcupdate.h>
30 #include <linux/workqueue.h>
31 #include <linux/seq_file.h>
32 #include <linux/proc_fs.h>
33 #include <linux/audit.h>
34 #include <linux/nsproxy.h>
35
36 #include <asm/unistd.h>
37
38 #include "util.h"
39
40 struct ipc_proc_iface {
41         const char *path;
42         const char *header;
43         int ids;
44         int (*show)(struct seq_file *, void *);
45 };
46
47 struct ipc_namespace init_ipc_ns = {
48         .kref = {
49                 .refcount       = ATOMIC_INIT(2),
50         },
51 };
52
53 static 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
76 err_shm:
77         msg_exit_ns(ns);
78 err_msg:
79         sem_exit_ns(ns);
80 err_sem:
81         kfree(ns);
82 err_mem:
83         return ERR_PTR(err);
84 }
85
86 struct ipc_namespace *copy_ipcs(unsigned long flags, struct ipc_namespace *ns)
87 {
88         struct ipc_namespace *new_ns;
89
90         BUG_ON(!ns);
91         get_ipc_ns(ns);
92
93         if (!(flags & CLONE_NEWIPC))
94                 return ns;
95
96         new_ns = clone_ipc_ns(ns);
97
98         put_ipc_ns(ns);
99         return new_ns;
100 }
101
102 void 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 }
112
113 /**
114  *      ipc_init        -       initialise IPC subsystem
115  *
116  *      The various system5 IPC resources (semaphores, messages and shared
117  *      memory) are initialised
118  */
119  
120 static 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
132  *
133  *      Set up the sequence range to use for the ipc identifier range (limited
134  *      below IPCMNI) then initialise the ids idr.
135  */
136  
137 void ipc_init_ids(struct ipc_ids *ids)
138 {
139         mutex_init(&ids->mutex);
140
141         ids->in_use = 0;
142         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
151         idr_init(&ids->ipcs_idr);
152 }
153
154 #ifdef CONFIG_PROC_FS
155 static const struct file_operations sysvipc_proc_fops;
156 /**
157  *      ipc_init_proc_interface -  Create a proc interface for sysipc types using a seq_file interface.
158  *      @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  */
163 void __init ipc_init_proc_interface(const char *path, const char *header,
164                 int ids, int (*show)(struct seq_file *, void *))
165 {
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
189 /**
190  *      ipc_findkey     -       find a key in an ipc identifier set     
191  *      @ids: Identifier set
192  *      @key: The key to find
193  *      
194  *      Requires ipc_ids.mutex locked.
195  *      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
198  */
199  
200 struct kern_ipc_perm *ipc_findkey(struct ipc_ids *ids, key_t key)
201 {
202         struct kern_ipc_perm *ipc;
203         int next_id;
204         int total;
205
206         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)
210                         continue;
211
212                 if (ipc->key != key) {
213                         total++;
214                         continue;
215                 }
216
217                 ipc_lock_by_ptr(ipc);
218                 return ipc;
219         }
220
221         return NULL;
222 }
223
224 /**
225  *      ipc_get_maxid   -       get the last assigned id
226  *      @ids: IPC identifier set
227  *
228  *      Called with ipc_ids.mutex held.
229  */
230
231 int ipc_get_maxid(struct ipc_ids *ids)
232 {
233         struct kern_ipc_perm *ipc;
234         int max_id = -1;
235         int total, id;
236
237         if (ids->in_use == 0)
238                 return -1;
239
240         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                 }
251         }
252         return max_id;
253 }
254
255 /**
256  *      ipc_addid       -       add an IPC identifier
257  *      @ids: IPC identifier set
258  *      @new: new IPC permission set
259  *      @size: limit for the number of used ids
260  *
261  *      Add an entry 'new' to the IPC idr. The permissions object is
262  *      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  *
266  *      Called with ipc_ids.mutex held.
267  */
268  
269 int ipc_addid(struct ipc_ids* ids, struct kern_ipc_perm* new, int size)
270 {
271         int id, err;
272
273         /*
274          * rcu_dereference()() is not needed here since
275          * ipc_ids.mutex is held
276          */
277         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
287         ids->in_use++;
288
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);
300         return id;
301 }
302
303 /**
304  *      ipc_rmid        -       remove an IPC identifier
305  *      @ids: identifier set
306  *      @id: ipc perm structure containing the identifier to remove
307  *
308  *      The identifier must be valid, and in use. The kernel will panic if
309  *      fed an invalid identifier. The entry is removed and internal
310  *      variables recomputed.
311  *      ipc_ids.mutex and the spinlock for this ID are held before this
312  *      function is called, and remain locked on the exit.
313  */
314  
315 void ipc_rmid(struct ipc_ids *ids, struct kern_ipc_perm *ipcp)
316 {
317         int lid = ipcp->id % SEQ_MULTIPLIER;
318
319         idr_remove(&ids->ipcs_idr, lid);
320
321         ids->in_use--;
322
323         ipcp->deleted = 1;
324
325         return;
326 }
327
328 /**
329  *      ipc_alloc       -       allocate ipc space
330  *      @size: size desired
331  *
332  *      Allocate memory from the appropriate pools and return a pointer to it.
333  *      NULL is returned if the allocation fails
334  */
335  
336 void* ipc_alloc(int size)
337 {
338         void* out;
339         if(size > PAGE_SIZE)
340                 out = vmalloc(size);
341         else
342                 out = kmalloc(size, GFP_KERNEL);
343         return out;
344 }
345
346 /**
347  *      ipc_free        -       free ipc space
348  *      @ptr: pointer returned by ipc_alloc
349  *      @size: size of block
350  *
351  *      Free a block created with ipc_alloc(). The caller must know the size
352  *      used in the allocation call.
353  */
354
355 void ipc_free(void* ptr, int size)
356 {
357         if(size > PAGE_SIZE)
358                 vfree(ptr);
359         else
360                 kfree(ptr);
361 }
362
363 /*
364  * rcu allocations:
365  * There are three headers that are prepended to the actual allocation:
366  * - during use: ipc_rcu_hdr.
367  * - during the rcu grace period: ipc_rcu_grace.
368  * - [only if vmalloc]: ipc_rcu_sched.
369  * Their lifetime doesn't overlap, thus the headers share the same memory.
370  * Unlike a normal union, they are right-aligned, thus some container_of
371  * forward/backward casting is necessary:
372  */
373 struct ipc_rcu_hdr
374 {
375         int refcount;
376         int is_vmalloc;
377         void *data[0];
378 };
379
380
381 struct ipc_rcu_grace
382 {
383         struct rcu_head rcu;
384         /* "void *" makes sure alignment of following data is sane. */
385         void *data[0];
386 };
387
388 struct ipc_rcu_sched
389 {
390         struct work_struct work;
391         /* "void *" makes sure alignment of following data is sane. */
392         void *data[0];
393 };
394
395 #define HDRLEN_KMALLOC          (sizeof(struct ipc_rcu_grace) > sizeof(struct ipc_rcu_hdr) ? \
396                                         sizeof(struct ipc_rcu_grace) : sizeof(struct ipc_rcu_hdr))
397 #define HDRLEN_VMALLOC          (sizeof(struct ipc_rcu_sched) > HDRLEN_KMALLOC ? \
398                                         sizeof(struct ipc_rcu_sched) : HDRLEN_KMALLOC)
399
400 static inline int rcu_use_vmalloc(int size)
401 {
402         /* Too big for a single page? */
403         if (HDRLEN_KMALLOC + size > PAGE_SIZE)
404                 return 1;
405         return 0;
406 }
407
408 /**
409  *      ipc_rcu_alloc   -       allocate ipc and rcu space 
410  *      @size: size desired
411  *
412  *      Allocate memory for the rcu header structure +  the object.
413  *      Returns the pointer to the object.
414  *      NULL is returned if the allocation fails. 
415  */
416  
417 void* ipc_rcu_alloc(int size)
418 {
419         void* out;
420         /* 
421          * We prepend the allocation with the rcu struct, and
422          * workqueue if necessary (for vmalloc). 
423          */
424         if (rcu_use_vmalloc(size)) {
425                 out = vmalloc(HDRLEN_VMALLOC + size);
426                 if (out) {
427                         out += HDRLEN_VMALLOC;
428                         container_of(out, struct ipc_rcu_hdr, data)->is_vmalloc = 1;
429                         container_of(out, struct ipc_rcu_hdr, data)->refcount = 1;
430                 }
431         } else {
432                 out = kmalloc(HDRLEN_KMALLOC + size, GFP_KERNEL);
433                 if (out) {
434                         out += HDRLEN_KMALLOC;
435                         container_of(out, struct ipc_rcu_hdr, data)->is_vmalloc = 0;
436                         container_of(out, struct ipc_rcu_hdr, data)->refcount = 1;
437                 }
438         }
439
440         return out;
441 }
442
443 void ipc_rcu_getref(void *ptr)
444 {
445         container_of(ptr, struct ipc_rcu_hdr, data)->refcount++;
446 }
447
448 static void ipc_do_vfree(struct work_struct *work)
449 {
450         vfree(container_of(work, struct ipc_rcu_sched, work));
451 }
452
453 /**
454  * ipc_schedule_free - free ipc + rcu space
455  * @head: RCU callback structure for queued work
456  * 
457  * Since RCU callback function is called in bh,
458  * we need to defer the vfree to schedule_work().
459  */
460 static void ipc_schedule_free(struct rcu_head *head)
461 {
462         struct ipc_rcu_grace *grace =
463                 container_of(head, struct ipc_rcu_grace, rcu);
464         struct ipc_rcu_sched *sched =
465                         container_of(&(grace->data[0]), struct ipc_rcu_sched, data[0]);
466
467         INIT_WORK(&sched->work, ipc_do_vfree);
468         schedule_work(&sched->work);
469 }
470
471 /**
472  * ipc_immediate_free - free ipc + rcu space
473  * @head: RCU callback structure that contains pointer to be freed
474  *
475  * Free from the RCU callback context.
476  */
477 static void ipc_immediate_free(struct rcu_head *head)
478 {
479         struct ipc_rcu_grace *free =
480                 container_of(head, struct ipc_rcu_grace, rcu);
481         kfree(free);
482 }
483
484 void ipc_rcu_putref(void *ptr)
485 {
486         if (--container_of(ptr, struct ipc_rcu_hdr, data)->refcount > 0)
487                 return;
488
489         if (container_of(ptr, struct ipc_rcu_hdr, data)->is_vmalloc) {
490                 call_rcu(&container_of(ptr, struct ipc_rcu_grace, data)->rcu,
491                                 ipc_schedule_free);
492         } else {
493                 call_rcu(&container_of(ptr, struct ipc_rcu_grace, data)->rcu,
494                                 ipc_immediate_free);
495         }
496 }
497
498 /**
499  *      ipcperms        -       check IPC permissions
500  *      @ipcp: IPC permission set
501  *      @flag: desired permission set.
502  *
503  *      Check user, group, other permissions for access
504  *      to ipc resources. return 0 if allowed
505  */
506  
507 int ipcperms (struct kern_ipc_perm *ipcp, short flag)
508 {       /* flag will most probably be 0 or S_...UGO from <linux/stat.h> */
509         int requested_mode, granted_mode, err;
510
511         if (unlikely((err = audit_ipc_obj(ipcp))))
512                 return err;
513         requested_mode = (flag >> 6) | (flag >> 3) | flag;
514         granted_mode = ipcp->mode;
515         if (current->euid == ipcp->cuid || current->euid == ipcp->uid)
516                 granted_mode >>= 6;
517         else if (in_group_p(ipcp->cgid) || in_group_p(ipcp->gid))
518                 granted_mode >>= 3;
519         /* is there some bit set in requested_mode but not in granted_mode? */
520         if ((requested_mode & ~granted_mode & 0007) && 
521             !capable(CAP_IPC_OWNER))
522                 return -1;
523
524         return security_ipc_permission(ipcp, flag);
525 }
526
527 /*
528  * Functions to convert between the kern_ipc_perm structure and the
529  * old/new ipc_perm structures
530  */
531
532 /**
533  *      kernel_to_ipc64_perm    -       convert kernel ipc permissions to user
534  *      @in: kernel permissions
535  *      @out: new style IPC permissions
536  *
537  *      Turn the kernel object @in into a set of permissions descriptions
538  *      for returning to userspace (@out).
539  */
540  
541
542 void kernel_to_ipc64_perm (struct kern_ipc_perm *in, struct ipc64_perm *out)
543 {
544         out->key        = in->key;
545         out->uid        = in->uid;
546         out->gid        = in->gid;
547         out->cuid       = in->cuid;
548         out->cgid       = in->cgid;
549         out->mode       = in->mode;
550         out->seq        = in->seq;
551 }
552
553 /**
554  *      ipc64_perm_to_ipc_perm  -       convert old ipc permissions to new
555  *      @in: new style IPC permissions
556  *      @out: old style IPC permissions
557  *
558  *      Turn the new style permissions object @in into a compatibility
559  *      object and store it into the @out pointer.
560  */
561  
562 void ipc64_perm_to_ipc_perm (struct ipc64_perm *in, struct ipc_perm *out)
563 {
564         out->key        = in->key;
565         SET_UID(out->uid, in->uid);
566         SET_GID(out->gid, in->gid);
567         SET_UID(out->cuid, in->cuid);
568         SET_GID(out->cgid, in->cgid);
569         out->mode       = in->mode;
570         out->seq        = in->seq;
571 }
572
573 /*
574  * So far only shm_get_stat() calls ipc_get() via shm_get(), so ipc_get()
575  * is called with shm_ids.mutex locked.  Since grow_ary() is also called with
576  * shm_ids.mutex down(for Shared Memory), there is no need to add read
577  * barriers here to gurantee the writes in grow_ary() are seen in order 
578  * here (for Alpha).
579  *
580  * However ipc_get() itself does not necessary require ipc_ids.mutex down. So
581  * if in the future ipc_get() is used by other places without ipc_ids.mutex
582  * down, then ipc_get() needs read memery barriers as ipc_lock() does.
583  */
584 struct kern_ipc_perm *ipc_get(struct ipc_ids *ids, int id)
585 {
586         struct kern_ipc_perm *out;
587         int lid = id % SEQ_MULTIPLIER;
588         out = idr_find(&ids->ipcs_idr, lid);
589         return out;
590 }
591
592 struct kern_ipc_perm *ipc_lock(struct ipc_ids *ids, int id)
593 {
594         struct kern_ipc_perm *out;
595         int lid = id % SEQ_MULTIPLIER;
596
597         rcu_read_lock();
598         out = idr_find(&ids->ipcs_idr, lid);
599         if (out == NULL) {
600                 rcu_read_unlock();
601                 return NULL;
602         }
603
604         spin_lock(&out->lock);
605         
606         /* ipc_rmid() may have already freed the ID while ipc_lock
607          * was spinning: here verify that the structure is still valid
608          */
609         if (out->deleted) {
610                 spin_unlock(&out->lock);
611                 rcu_read_unlock();
612                 return NULL;
613         }
614
615         return out;
616 }
617
618 void ipc_lock_by_ptr(struct kern_ipc_perm *perm)
619 {
620         rcu_read_lock();
621         spin_lock(&perm->lock);
622 }
623
624 void ipc_unlock(struct kern_ipc_perm* perm)
625 {
626         spin_unlock(&perm->lock);
627         rcu_read_unlock();
628 }
629
630 int ipc_buildid(struct ipc_ids* ids, int id, int seq)
631 {
632         return SEQ_MULTIPLIER*seq + id;
633 }
634
635 int ipc_checkid(struct ipc_ids* ids, struct kern_ipc_perm* ipcp, int uid)
636 {
637         if(uid/SEQ_MULTIPLIER != ipcp->seq)
638                 return 1;
639         return 0;
640 }
641
642 #ifdef __ARCH_WANT_IPC_PARSE_VERSION
643
644
645 /**
646  *      ipc_parse_version       -       IPC call version
647  *      @cmd: pointer to command
648  *
649  *      Return IPC_64 for new style IPC and IPC_OLD for old style IPC. 
650  *      The @cmd value is turned from an encoding command and version into
651  *      just the command code.
652  */
653  
654 int ipc_parse_version (int *cmd)
655 {
656         if (*cmd & IPC_64) {
657                 *cmd ^= IPC_64;
658                 return IPC_64;
659         } else {
660                 return IPC_OLD;
661         }
662 }
663
664 #endif /* __ARCH_WANT_IPC_PARSE_VERSION */
665
666 #ifdef CONFIG_PROC_FS
667 struct ipc_proc_iter {
668         struct ipc_namespace *ns;
669         struct ipc_proc_iface *iface;
670 };
671
672 /*
673  * This routine locks the ipc structure found at least at position pos.
674  */
675 struct kern_ipc_perm *sysvipc_find_ipc(struct ipc_ids *ids, loff_t pos,
676                                         loff_t *new_pos)
677 {
678         struct kern_ipc_perm *ipc;
679         int total, id;
680
681         total = 0;
682         for (id = 0; id < pos && total < ids->in_use; id++) {
683                 ipc = idr_find(&ids->ipcs_idr, id);
684                 if (ipc != NULL)
685                         total++;
686         }
687
688         if (total >= ids->in_use)
689                 return NULL;
690
691         for ( ; pos < IPCMNI; pos++) {
692                 ipc = idr_find(&ids->ipcs_idr, pos);
693                 if (ipc != NULL) {
694                         *new_pos = pos + 1;
695                         ipc_lock_by_ptr(ipc);
696                         return ipc;
697                 }
698         }
699
700         /* Out of range - return NULL to terminate iteration */
701         return NULL;
702 }
703
704 static void *sysvipc_proc_next(struct seq_file *s, void *it, loff_t *pos)
705 {
706         struct ipc_proc_iter *iter = s->private;
707         struct ipc_proc_iface *iface = iter->iface;
708         struct kern_ipc_perm *ipc = it;
709
710         /* If we had an ipc id locked before, unlock it */
711         if (ipc && ipc != SEQ_START_TOKEN)
712                 ipc_unlock(ipc);
713
714         return sysvipc_find_ipc(iter->ns->ids[iface->ids], *pos, pos);
715 }
716
717 /*
718  * File positions: pos 0 -> header, pos n -> ipc id + 1.
719  * SeqFile iterator: iterator value locked shp or SEQ_TOKEN_START.
720  */
721 static void *sysvipc_proc_start(struct seq_file *s, loff_t *pos)
722 {
723         struct ipc_proc_iter *iter = s->private;
724         struct ipc_proc_iface *iface = iter->iface;
725         struct ipc_ids *ids;
726
727         ids = iter->ns->ids[iface->ids];
728
729         /*
730          * Take the lock - this will be released by the corresponding
731          * call to stop().
732          */
733         mutex_lock(&ids->mutex);
734
735         /* pos < 0 is invalid */
736         if (*pos < 0)
737                 return NULL;
738
739         /* pos == 0 means header */
740         if (*pos == 0)
741                 return SEQ_START_TOKEN;
742
743         /* Find the (pos-1)th ipc */
744         return sysvipc_find_ipc(ids, *pos - 1, pos);
745 }
746
747 static void sysvipc_proc_stop(struct seq_file *s, void *it)
748 {
749         struct kern_ipc_perm *ipc = it;
750         struct ipc_proc_iter *iter = s->private;
751         struct ipc_proc_iface *iface = iter->iface;
752         struct ipc_ids *ids;
753
754         /* If we had a locked segment, release it */
755         if (ipc && ipc != SEQ_START_TOKEN)
756                 ipc_unlock(ipc);
757
758         ids = iter->ns->ids[iface->ids];
759         /* Release the lock we took in start() */
760         mutex_unlock(&ids->mutex);
761 }
762
763 static int sysvipc_proc_show(struct seq_file *s, void *it)
764 {
765         struct ipc_proc_iter *iter = s->private;
766         struct ipc_proc_iface *iface = iter->iface;
767
768         if (it == SEQ_START_TOKEN)
769                 return seq_puts(s, iface->header);
770
771         return iface->show(s, it);
772 }
773
774 static struct seq_operations sysvipc_proc_seqops = {
775         .start = sysvipc_proc_start,
776         .stop  = sysvipc_proc_stop,
777         .next  = sysvipc_proc_next,
778         .show  = sysvipc_proc_show,
779 };
780
781 static int sysvipc_proc_open(struct inode *inode, struct file *file)
782 {
783         int ret;
784         struct seq_file *seq;
785         struct ipc_proc_iter *iter;
786
787         ret = -ENOMEM;
788         iter = kmalloc(sizeof(*iter), GFP_KERNEL);
789         if (!iter)
790                 goto out;
791
792         ret = seq_open(file, &sysvipc_proc_seqops);
793         if (ret)
794                 goto out_kfree;
795
796         seq = file->private_data;
797         seq->private = iter;
798
799         iter->iface = PDE(inode)->data;
800         iter->ns    = get_ipc_ns(current->nsproxy->ipc_ns);
801 out:
802         return ret;
803 out_kfree:
804         kfree(iter);
805         goto out;
806 }
807
808 static int sysvipc_proc_release(struct inode *inode, struct file *file)
809 {
810         struct seq_file *seq = file->private_data;
811         struct ipc_proc_iter *iter = seq->private;
812         put_ipc_ns(iter->ns);
813         return seq_release_private(inode, file);
814 }
815
816 static const struct file_operations sysvipc_proc_fops = {
817         .open    = sysvipc_proc_open,
818         .read    = seq_read,
819         .llseek  = seq_lseek,
820         .release = sysvipc_proc_release,
821 };
822 #endif /* CONFIG_PROC_FS */