1 // SPDX-License-Identifier: GPL-2.0
4 * Copyright (C) 1992 Krishna Balasubramanian
6 * Sep 1997 - Call suser() last after "normal" permission checks so we
7 * get BSD style process accounting right.
8 * Occurs in several places in the IPC code.
9 * Chris Evans, <chris@ferret.lmh.ox.ac.uk>
10 * Nov 1999 - ipc helper functions, unified SMP locking
11 * Manfred Spraul <manfred@colorfullife.com>
12 * Oct 2002 - One lock per IPC id. RCU ipc_free for lock-free grow_ary().
13 * Mingming Cao <cmm@us.ibm.com>
14 * Mar 2006 - support for audit of ipc object properties
15 * Dustin Kirkland <dustin.kirkland@us.ibm.com>
16 * Jun 2006 - namespaces ssupport
18 * Pavel Emelianov <xemul@openvz.org>
20 * General sysv ipc locking scheme:
22 * obtain the ipc object (kern_ipc_perm) by looking up the id in an idr
24 * - perform initial checks (capabilities, auditing and permission,
26 * - perform read-only operations, such as INFO command, that
27 * do not demand atomicity
28 * acquire the ipc lock (kern_ipc_perm.lock) through
30 * - perform read-only operations that demand atomicity,
31 * such as STAT command.
32 * - perform data updates, such as SET, RMID commands and
33 * mechanism-specific operations (semop/semtimedop,
34 * msgsnd/msgrcv, shmat/shmdt).
35 * drop the ipc lock, through ipc_unlock_object().
38 * The ids->rwsem must be taken when:
39 * - creating, removing and iterating the existing entries in ipc
41 * - iterating through files under /proc/sysvipc/
43 * Note that sems have a special fast path that avoids kern_ipc_perm.lock -
48 #include <linux/shm.h>
49 #include <linux/init.h>
50 #include <linux/msg.h>
51 #include <linux/vmalloc.h>
52 #include <linux/slab.h>
53 #include <linux/notifier.h>
54 #include <linux/capability.h>
55 #include <linux/highuid.h>
56 #include <linux/security.h>
57 #include <linux/rcupdate.h>
58 #include <linux/workqueue.h>
59 #include <linux/seq_file.h>
60 #include <linux/proc_fs.h>
61 #include <linux/audit.h>
62 #include <linux/nsproxy.h>
63 #include <linux/rwsem.h>
64 #include <linux/memory.h>
65 #include <linux/ipc_namespace.h>
66 #include <linux/rhashtable.h>
68 #include <asm/unistd.h>
72 struct ipc_proc_iface
{
76 int (*show
)(struct seq_file
*, void *);
80 * ipc_init - initialise ipc subsystem
82 * The various sysv ipc resources (semaphores, messages and shared
83 * memory) are initialised.
85 * A callback routine is registered into the memory hotplug notifier
86 * chain: since msgmni scales to lowmem this callback routine will be
87 * called upon successful memory add / remove to recompute msmgni.
89 static int __init
ipc_init(void)
93 proc_mkdir("sysvipc", NULL
);
95 WARN(err_sem
, "ipc: sysv sem_init failed: %d\n", err_sem
);
97 WARN(err_msg
, "ipc: sysv msg_init failed: %d\n", err_msg
);
100 return err_msg
? err_msg
: err_sem
;
102 device_initcall(ipc_init
);
104 static const struct rhashtable_params ipc_kht_params
= {
105 .head_offset
= offsetof(struct kern_ipc_perm
, khtnode
),
106 .key_offset
= offsetof(struct kern_ipc_perm
, key
),
107 .key_len
= FIELD_SIZEOF(struct kern_ipc_perm
, key
),
109 .automatic_shrinking
= true,
113 * ipc_init_ids - initialise ipc identifiers
114 * @ids: ipc identifier set
116 * Set up the sequence range to use for the ipc identifier range (limited
117 * below IPCMNI) then initialise the keys hashtable and ids idr.
119 int ipc_init_ids(struct ipc_ids
*ids
)
124 init_rwsem(&ids
->rwsem
);
125 err
= rhashtable_init(&ids
->key_ht
, &ipc_kht_params
);
128 idr_init(&ids
->ipcs_idr
);
129 ids
->tables_initialized
= true;
131 #ifdef CONFIG_CHECKPOINT_RESTORE
137 #ifdef CONFIG_PROC_FS
138 static const struct file_operations sysvipc_proc_fops
;
140 * ipc_init_proc_interface - create a proc interface for sysipc types using a seq_file interface.
141 * @path: Path in procfs
142 * @header: Banner to be printed at the beginning of the file.
143 * @ids: ipc id table to iterate.
144 * @show: show routine.
146 void __init
ipc_init_proc_interface(const char *path
, const char *header
,
147 int ids
, int (*show
)(struct seq_file
*, void *))
149 struct proc_dir_entry
*pde
;
150 struct ipc_proc_iface
*iface
;
152 iface
= kmalloc(sizeof(*iface
), GFP_KERNEL
);
156 iface
->header
= header
;
160 pde
= proc_create_data(path
,
161 S_IRUGO
, /* world readable */
162 NULL
, /* parent dir */
171 * ipc_findkey - find a key in an ipc identifier set
172 * @ids: ipc identifier set
175 * Returns the locked pointer to the ipc structure if found or NULL
176 * otherwise. If key is found ipc points to the owning ipc structure
178 * Called with writer ipc_ids.rwsem held.
180 static struct kern_ipc_perm
*ipc_findkey(struct ipc_ids
*ids
, key_t key
)
182 struct kern_ipc_perm
*ipcp
= NULL
;
184 if (likely(ids
->tables_initialized
))
185 ipcp
= rhashtable_lookup_fast(&ids
->key_ht
, &key
,
190 ipc_lock_object(ipcp
);
197 #ifdef CONFIG_CHECKPOINT_RESTORE
199 * Specify desired id for next allocated IPC object.
201 #define ipc_idr_alloc(ids, new) \
202 idr_alloc(&(ids)->ipcs_idr, (new), \
203 (ids)->next_id < 0 ? 0 : ipcid_to_idx((ids)->next_id),\
206 static inline int ipc_buildid(int id
, struct ipc_ids
*ids
,
207 struct kern_ipc_perm
*new)
209 if (ids
->next_id
< 0) { /* default, behave as !CHECKPOINT_RESTORE */
210 new->seq
= ids
->seq
++;
211 if (ids
->seq
> IPCID_SEQ_MAX
)
214 new->seq
= ipcid_to_seqx(ids
->next_id
);
218 return SEQ_MULTIPLIER
* new->seq
+ id
;
222 #define ipc_idr_alloc(ids, new) \
223 idr_alloc(&(ids)->ipcs_idr, (new), 0, 0, GFP_NOWAIT)
225 static inline int ipc_buildid(int id
, struct ipc_ids
*ids
,
226 struct kern_ipc_perm
*new)
228 new->seq
= ids
->seq
++;
229 if (ids
->seq
> IPCID_SEQ_MAX
)
232 return SEQ_MULTIPLIER
* new->seq
+ id
;
235 #endif /* CONFIG_CHECKPOINT_RESTORE */
238 * ipc_addid - add an ipc identifier
239 * @ids: ipc identifier set
240 * @new: new ipc permission set
241 * @limit: limit for the number of used ids
243 * Add an entry 'new' to the ipc ids idr. The permissions object is
244 * initialised and the first free entry is set up and the id assigned
245 * is returned. The 'new' entry is returned in a locked state on success.
246 * On failure the entry is not locked and a negative err-code is returned.
248 * Called with writer ipc_ids.rwsem held.
250 int ipc_addid(struct ipc_ids
*ids
, struct kern_ipc_perm
*new, int limit
)
259 if (!ids
->tables_initialized
|| ids
->in_use
>= limit
)
262 idr_preload(GFP_KERNEL
);
264 refcount_set(&new->refcount
, 1);
265 spin_lock_init(&new->lock
);
266 new->deleted
= false;
268 spin_lock(&new->lock
);
270 current_euid_egid(&euid
, &egid
);
271 new->cuid
= new->uid
= euid
;
272 new->gid
= new->cgid
= egid
;
274 id
= ipc_idr_alloc(ids
, new);
277 if (id
>= 0 && new->key
!= IPC_PRIVATE
) {
278 err
= rhashtable_insert_fast(&ids
->key_ht
, &new->khtnode
,
281 idr_remove(&ids
->ipcs_idr
, id
);
286 spin_unlock(&new->lock
);
292 if (id
> ids
->max_id
)
295 new->id
= ipc_buildid(id
, ids
, new);
301 * ipcget_new - create a new ipc object
303 * @ids: ipc identifier set
304 * @ops: the actual creation routine to call
305 * @params: its parameters
307 * This routine is called by sys_msgget, sys_semget() and sys_shmget()
308 * when the key is IPC_PRIVATE.
310 static int ipcget_new(struct ipc_namespace
*ns
, struct ipc_ids
*ids
,
311 const struct ipc_ops
*ops
, struct ipc_params
*params
)
315 down_write(&ids
->rwsem
);
316 err
= ops
->getnew(ns
, params
);
317 up_write(&ids
->rwsem
);
322 * ipc_check_perms - check security and permissions for an ipc object
324 * @ipcp: ipc permission set
325 * @ops: the actual security routine to call
326 * @params: its parameters
328 * This routine is called by sys_msgget(), sys_semget() and sys_shmget()
329 * when the key is not IPC_PRIVATE and that key already exists in the
332 * On success, the ipc id is returned.
334 * It is called with ipc_ids.rwsem and ipcp->lock held.
336 static int ipc_check_perms(struct ipc_namespace
*ns
,
337 struct kern_ipc_perm
*ipcp
,
338 const struct ipc_ops
*ops
,
339 struct ipc_params
*params
)
343 if (ipcperms(ns
, ipcp
, params
->flg
))
346 err
= ops
->associate(ipcp
, params
->flg
);
355 * ipcget_public - get an ipc object or create a new one
357 * @ids: ipc identifier set
358 * @ops: the actual creation routine to call
359 * @params: its parameters
361 * This routine is called by sys_msgget, sys_semget() and sys_shmget()
362 * when the key is not IPC_PRIVATE.
363 * It adds a new entry if the key is not found and does some permission
364 * / security checkings if the key is found.
366 * On success, the ipc id is returned.
368 static int ipcget_public(struct ipc_namespace
*ns
, struct ipc_ids
*ids
,
369 const struct ipc_ops
*ops
, struct ipc_params
*params
)
371 struct kern_ipc_perm
*ipcp
;
372 int flg
= params
->flg
;
376 * Take the lock as a writer since we are potentially going to add
377 * a new entry + read locks are not "upgradable"
379 down_write(&ids
->rwsem
);
380 ipcp
= ipc_findkey(ids
, params
->key
);
383 if (!(flg
& IPC_CREAT
))
386 err
= ops
->getnew(ns
, params
);
388 /* ipc object has been locked by ipc_findkey() */
390 if (flg
& IPC_CREAT
&& flg
& IPC_EXCL
)
394 if (ops
->more_checks
)
395 err
= ops
->more_checks(ipcp
, params
);
398 * ipc_check_perms returns the IPC id on
401 err
= ipc_check_perms(ns
, ipcp
, ops
, params
);
405 up_write(&ids
->rwsem
);
411 * ipc_kht_remove - remove an ipc from the key hashtable
412 * @ids: ipc identifier set
413 * @ipcp: ipc perm structure containing the key to remove
415 * ipc_ids.rwsem (as a writer) and the spinlock for this ID are held
416 * before this function is called, and remain locked on the exit.
418 static void ipc_kht_remove(struct ipc_ids
*ids
, struct kern_ipc_perm
*ipcp
)
420 if (ipcp
->key
!= IPC_PRIVATE
)
421 rhashtable_remove_fast(&ids
->key_ht
, &ipcp
->khtnode
,
426 * ipc_rmid - remove an ipc identifier
427 * @ids: ipc identifier set
428 * @ipcp: ipc perm structure containing the identifier to remove
430 * ipc_ids.rwsem (as a writer) and the spinlock for this ID are held
431 * before this function is called, and remain locked on the exit.
433 void ipc_rmid(struct ipc_ids
*ids
, struct kern_ipc_perm
*ipcp
)
435 int lid
= ipcid_to_idx(ipcp
->id
);
437 idr_remove(&ids
->ipcs_idr
, lid
);
438 ipc_kht_remove(ids
, ipcp
);
440 ipcp
->deleted
= true;
442 if (unlikely(lid
== ids
->max_id
)) {
447 } while (!idr_find(&ids
->ipcs_idr
, lid
));
453 * ipc_set_key_private - switch the key of an existing ipc to IPC_PRIVATE
454 * @ids: ipc identifier set
455 * @ipcp: ipc perm structure containing the key to modify
457 * ipc_ids.rwsem (as a writer) and the spinlock for this ID are held
458 * before this function is called, and remain locked on the exit.
460 void ipc_set_key_private(struct ipc_ids
*ids
, struct kern_ipc_perm
*ipcp
)
462 ipc_kht_remove(ids
, ipcp
);
463 ipcp
->key
= IPC_PRIVATE
;
466 int ipc_rcu_getref(struct kern_ipc_perm
*ptr
)
468 return refcount_inc_not_zero(&ptr
->refcount
);
471 void ipc_rcu_putref(struct kern_ipc_perm
*ptr
,
472 void (*func
)(struct rcu_head
*head
))
474 if (!refcount_dec_and_test(&ptr
->refcount
))
477 call_rcu(&ptr
->rcu
, func
);
481 * ipcperms - check ipc permissions
483 * @ipcp: ipc permission set
484 * @flag: desired permission set
486 * Check user, group, other permissions for access
487 * to ipc resources. return 0 if allowed
489 * @flag will most probably be 0 or ``S_...UGO`` from <linux/stat.h>
491 int ipcperms(struct ipc_namespace
*ns
, struct kern_ipc_perm
*ipcp
, short flag
)
493 kuid_t euid
= current_euid();
494 int requested_mode
, granted_mode
;
497 requested_mode
= (flag
>> 6) | (flag
>> 3) | flag
;
498 granted_mode
= ipcp
->mode
;
499 if (uid_eq(euid
, ipcp
->cuid
) ||
500 uid_eq(euid
, ipcp
->uid
))
502 else if (in_group_p(ipcp
->cgid
) || in_group_p(ipcp
->gid
))
504 /* is there some bit set in requested_mode but not in granted_mode? */
505 if ((requested_mode
& ~granted_mode
& 0007) &&
506 !ns_capable(ns
->user_ns
, CAP_IPC_OWNER
))
509 return security_ipc_permission(ipcp
, flag
);
513 * Functions to convert between the kern_ipc_perm structure and the
514 * old/new ipc_perm structures
518 * kernel_to_ipc64_perm - convert kernel ipc permissions to user
519 * @in: kernel permissions
520 * @out: new style ipc permissions
522 * Turn the kernel object @in into a set of permissions descriptions
523 * for returning to userspace (@out).
525 void kernel_to_ipc64_perm(struct kern_ipc_perm
*in
, struct ipc64_perm
*out
)
528 out
->uid
= from_kuid_munged(current_user_ns(), in
->uid
);
529 out
->gid
= from_kgid_munged(current_user_ns(), in
->gid
);
530 out
->cuid
= from_kuid_munged(current_user_ns(), in
->cuid
);
531 out
->cgid
= from_kgid_munged(current_user_ns(), in
->cgid
);
532 out
->mode
= in
->mode
;
537 * ipc64_perm_to_ipc_perm - convert new ipc permissions to old
538 * @in: new style ipc permissions
539 * @out: old style ipc permissions
541 * Turn the new style permissions object @in into a compatibility
542 * object and store it into the @out pointer.
544 void ipc64_perm_to_ipc_perm(struct ipc64_perm
*in
, struct ipc_perm
*out
)
547 SET_UID(out
->uid
, in
->uid
);
548 SET_GID(out
->gid
, in
->gid
);
549 SET_UID(out
->cuid
, in
->cuid
);
550 SET_GID(out
->cgid
, in
->cgid
);
551 out
->mode
= in
->mode
;
556 * ipc_obtain_object_idr
557 * @ids: ipc identifier set
558 * @id: ipc id to look for
560 * Look for an id in the ipc ids idr and return associated ipc object.
562 * Call inside the RCU critical section.
563 * The ipc object is *not* locked on exit.
565 struct kern_ipc_perm
*ipc_obtain_object_idr(struct ipc_ids
*ids
, int id
)
567 struct kern_ipc_perm
*out
;
568 int lid
= ipcid_to_idx(id
);
570 if (unlikely(!ids
->tables_initialized
))
571 return ERR_PTR(-EINVAL
);
573 out
= idr_find(&ids
->ipcs_idr
, lid
);
575 return ERR_PTR(-EINVAL
);
581 * ipc_lock - lock an ipc structure without rwsem held
582 * @ids: ipc identifier set
583 * @id: ipc id to look for
585 * Look for an id in the ipc ids idr and lock the associated ipc object.
587 * The ipc object is locked on successful exit.
589 struct kern_ipc_perm
*ipc_lock(struct ipc_ids
*ids
, int id
)
591 struct kern_ipc_perm
*out
;
594 out
= ipc_obtain_object_idr(ids
, id
);
598 spin_lock(&out
->lock
);
601 * ipc_rmid() may have already freed the ID while ipc_lock()
602 * was spinning: here verify that the structure is still valid.
603 * Upon races with RMID, return -EIDRM, thus indicating that
604 * the ID points to a removed identifier.
606 if (ipc_valid_object(out
))
609 spin_unlock(&out
->lock
);
610 out
= ERR_PTR(-EIDRM
);
617 * ipc_obtain_object_check
618 * @ids: ipc identifier set
619 * @id: ipc id to look for
621 * Similar to ipc_obtain_object_idr() but also checks
622 * the ipc object reference counter.
624 * Call inside the RCU critical section.
625 * The ipc object is *not* locked on exit.
627 struct kern_ipc_perm
*ipc_obtain_object_check(struct ipc_ids
*ids
, int id
)
629 struct kern_ipc_perm
*out
= ipc_obtain_object_idr(ids
, id
);
634 if (ipc_checkid(out
, id
))
635 return ERR_PTR(-EINVAL
);
641 * ipcget - Common sys_*get() code
643 * @ids: ipc identifier set
644 * @ops: operations to be called on ipc object creation, permission checks
646 * @params: the parameters needed by the previous operations.
648 * Common routine called by sys_msgget(), sys_semget() and sys_shmget().
650 int ipcget(struct ipc_namespace
*ns
, struct ipc_ids
*ids
,
651 const struct ipc_ops
*ops
, struct ipc_params
*params
)
653 if (params
->key
== IPC_PRIVATE
)
654 return ipcget_new(ns
, ids
, ops
, params
);
656 return ipcget_public(ns
, ids
, ops
, params
);
660 * ipc_update_perm - update the permissions of an ipc object
661 * @in: the permission given as input.
662 * @out: the permission of the ipc to set.
664 int ipc_update_perm(struct ipc64_perm
*in
, struct kern_ipc_perm
*out
)
666 kuid_t uid
= make_kuid(current_user_ns(), in
->uid
);
667 kgid_t gid
= make_kgid(current_user_ns(), in
->gid
);
668 if (!uid_valid(uid
) || !gid_valid(gid
))
673 out
->mode
= (out
->mode
& ~S_IRWXUGO
)
674 | (in
->mode
& S_IRWXUGO
);
680 * ipcctl_pre_down_nolock - retrieve an ipc and check permissions for some IPC_XXX cmd
682 * @ids: the table of ids where to look for the ipc
683 * @id: the id of the ipc to retrieve
684 * @cmd: the cmd to check
685 * @perm: the permission to set
686 * @extra_perm: one extra permission parameter used by msq
688 * This function does some common audit and permissions check for some IPC_XXX
689 * cmd and is called from semctl_down, shmctl_down and msgctl_down.
690 * It must be called without any lock held and:
692 * - retrieves the ipc with the given id in the given table.
693 * - performs some audit and permission check, depending on the given cmd
694 * - returns a pointer to the ipc object or otherwise, the corresponding
697 * Call holding the both the rwsem and the rcu read lock.
699 struct kern_ipc_perm
*ipcctl_pre_down_nolock(struct ipc_namespace
*ns
,
700 struct ipc_ids
*ids
, int id
, int cmd
,
701 struct ipc64_perm
*perm
, int extra_perm
)
705 struct kern_ipc_perm
*ipcp
;
707 ipcp
= ipc_obtain_object_check(ids
, id
);
715 audit_ipc_set_perm(extra_perm
, perm
->uid
,
716 perm
->gid
, perm
->mode
);
718 euid
= current_euid();
719 if (uid_eq(euid
, ipcp
->cuid
) || uid_eq(euid
, ipcp
->uid
) ||
720 ns_capable(ns
->user_ns
, CAP_SYS_ADMIN
))
721 return ipcp
; /* successful lookup */
726 #ifdef CONFIG_ARCH_WANT_IPC_PARSE_VERSION
730 * ipc_parse_version - ipc call version
731 * @cmd: pointer to command
733 * Return IPC_64 for new style IPC and IPC_OLD for old style IPC.
734 * The @cmd value is turned from an encoding command and version into
735 * just the command code.
737 int ipc_parse_version(int *cmd
)
747 #endif /* CONFIG_ARCH_WANT_IPC_PARSE_VERSION */
749 #ifdef CONFIG_PROC_FS
750 struct ipc_proc_iter
{
751 struct ipc_namespace
*ns
;
752 struct pid_namespace
*pid_ns
;
753 struct ipc_proc_iface
*iface
;
756 struct pid_namespace
*ipc_seq_pid_ns(struct seq_file
*s
)
758 struct ipc_proc_iter
*iter
= s
->private;
763 * This routine locks the ipc structure found at least at position pos.
765 static struct kern_ipc_perm
*sysvipc_find_ipc(struct ipc_ids
*ids
, loff_t pos
,
768 struct kern_ipc_perm
*ipc
;
772 for (id
= 0; id
< pos
&& total
< ids
->in_use
; id
++) {
773 ipc
= idr_find(&ids
->ipcs_idr
, id
);
778 if (total
>= ids
->in_use
)
781 for (; pos
< IPCMNI
; pos
++) {
782 ipc
= idr_find(&ids
->ipcs_idr
, pos
);
786 ipc_lock_object(ipc
);
791 /* Out of range - return NULL to terminate iteration */
795 static void *sysvipc_proc_next(struct seq_file
*s
, void *it
, loff_t
*pos
)
797 struct ipc_proc_iter
*iter
= s
->private;
798 struct ipc_proc_iface
*iface
= iter
->iface
;
799 struct kern_ipc_perm
*ipc
= it
;
801 /* If we had an ipc id locked before, unlock it */
802 if (ipc
&& ipc
!= SEQ_START_TOKEN
)
805 return sysvipc_find_ipc(&iter
->ns
->ids
[iface
->ids
], *pos
, pos
);
809 * File positions: pos 0 -> header, pos n -> ipc id = n - 1.
810 * SeqFile iterator: iterator value locked ipc pointer or SEQ_TOKEN_START.
812 static void *sysvipc_proc_start(struct seq_file
*s
, loff_t
*pos
)
814 struct ipc_proc_iter
*iter
= s
->private;
815 struct ipc_proc_iface
*iface
= iter
->iface
;
818 ids
= &iter
->ns
->ids
[iface
->ids
];
821 * Take the lock - this will be released by the corresponding
824 down_read(&ids
->rwsem
);
826 /* pos < 0 is invalid */
830 /* pos == 0 means header */
832 return SEQ_START_TOKEN
;
834 /* Find the (pos-1)th ipc */
835 return sysvipc_find_ipc(ids
, *pos
- 1, pos
);
838 static void sysvipc_proc_stop(struct seq_file
*s
, void *it
)
840 struct kern_ipc_perm
*ipc
= it
;
841 struct ipc_proc_iter
*iter
= s
->private;
842 struct ipc_proc_iface
*iface
= iter
->iface
;
845 /* If we had a locked structure, release it */
846 if (ipc
&& ipc
!= SEQ_START_TOKEN
)
849 ids
= &iter
->ns
->ids
[iface
->ids
];
850 /* Release the lock we took in start() */
851 up_read(&ids
->rwsem
);
854 static int sysvipc_proc_show(struct seq_file
*s
, void *it
)
856 struct ipc_proc_iter
*iter
= s
->private;
857 struct ipc_proc_iface
*iface
= iter
->iface
;
859 if (it
== SEQ_START_TOKEN
) {
860 seq_puts(s
, iface
->header
);
864 return iface
->show(s
, it
);
867 static const struct seq_operations sysvipc_proc_seqops
= {
868 .start
= sysvipc_proc_start
,
869 .stop
= sysvipc_proc_stop
,
870 .next
= sysvipc_proc_next
,
871 .show
= sysvipc_proc_show
,
874 static int sysvipc_proc_open(struct inode
*inode
, struct file
*file
)
876 struct ipc_proc_iter
*iter
;
878 iter
= __seq_open_private(file
, &sysvipc_proc_seqops
, sizeof(*iter
));
882 iter
->iface
= PDE_DATA(inode
);
883 iter
->ns
= get_ipc_ns(current
->nsproxy
->ipc_ns
);
884 iter
->pid_ns
= get_pid_ns(task_active_pid_ns(current
));
889 static int sysvipc_proc_release(struct inode
*inode
, struct file
*file
)
891 struct seq_file
*seq
= file
->private_data
;
892 struct ipc_proc_iter
*iter
= seq
->private;
893 put_ipc_ns(iter
->ns
);
894 put_pid_ns(iter
->pid_ns
);
895 return seq_release_private(inode
, file
);
898 static const struct file_operations sysvipc_proc_fops
= {
899 .open
= sysvipc_proc_open
,
902 .release
= sysvipc_proc_release
,
904 #endif /* CONFIG_PROC_FS */