blob: bd1863b6ed39c2cd9b6611e18177ebe9d65cb857 [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
3 * linux/ipc/util.c
4 * Copyright (C) 1992 Krishna Balasubramanian
5 *
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
Christian Kujau624dffc2006-01-15 02:43:54 +010011 * Manfred Spraul <manfred@colorfullife.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 * Oct 2002 - One lock per IPC id. RCU ipc_free for lock-free grow_ary().
13 * Mingming Cao <cmm@us.ibm.com>
Steve Grubb073115d2006-04-02 17:07:33 -040014 * Mar 2006 - support for audit of ipc object properties
15 * Dustin Kirkland <dustin.kirkland@us.ibm.com>
Kirill Korotaev73ea4132006-10-02 02:18:20 -070016 * Jun 2006 - namespaces ssupport
17 * OpenVZ, SWsoft Inc.
18 * Pavel Emelianov <xemul@openvz.org>
Davidlohr Bueso05603c42013-09-11 14:26:26 -070019 *
20 * General sysv ipc locking scheme:
Davidlohr Bueso18ccee22013-10-16 13:46:45 -070021 * rcu_read_lock()
22 * obtain the ipc object (kern_ipc_perm) by looking up the id in an idr
23 * tree.
24 * - perform initial checks (capabilities, auditing and permission,
25 * etc).
Philippe Mikoyan87ad4b02018-02-06 15:40:49 -080026 * - perform read-only operations, such as INFO command, that
27 * do not demand atomicity
Davidlohr Bueso18ccee22013-10-16 13:46:45 -070028 * acquire the ipc lock (kern_ipc_perm.lock) through
29 * ipc_lock_object()
Philippe Mikoyan87ad4b02018-02-06 15:40:49 -080030 * - perform read-only operations that demand atomicity,
31 * such as STAT command.
Davidlohr Bueso18ccee22013-10-16 13:46:45 -070032 * - 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().
36 * rcu_read_unlock()
37 *
38 * The ids->rwsem must be taken when:
39 * - creating, removing and iterating the existing entries in ipc
40 * identifier sets.
41 * - iterating through files under /proc/sysvipc/
42 *
43 * Note that sems have a special fast path that avoids kern_ipc_perm.lock -
44 * see sem_lock().
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 */
46
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include <linux/mm.h>
48#include <linux/shm.h>
49#include <linux/init.h>
50#include <linux/msg.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include <linux/vmalloc.h>
52#include <linux/slab.h>
Andrew Morton8f68fa22013-04-29 15:08:05 -070053#include <linux/notifier.h>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080054#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#include <linux/highuid.h>
56#include <linux/security.h>
57#include <linux/rcupdate.h>
58#include <linux/workqueue.h>
Mike Waychisonae781772005-09-06 15:17:09 -070059#include <linux/seq_file.h>
60#include <linux/proc_fs.h>
Steve Grubb073115d2006-04-02 17:07:33 -040061#include <linux/audit.h>
Kirill Korotaev73ea4132006-10-02 02:18:20 -070062#include <linux/nsproxy.h>
Nadia Derbey3e148c72007-10-18 23:40:54 -070063#include <linux/rwsem.h>
Nadia Derbeyb6b337a2008-04-29 01:00:42 -070064#include <linux/memory.h>
Pavel Emelyanovae5e1b22008-02-08 04:18:22 -080065#include <linux/ipc_namespace.h>
NeilBrown0eb71a92018-06-18 12:52:50 +100066#include <linux/rhashtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
68#include <asm/unistd.h>
69
70#include "util.h"
71
Mike Waychisonae781772005-09-06 15:17:09 -070072struct ipc_proc_iface {
73 const char *path;
74 const char *header;
Kirill Korotaev73ea4132006-10-02 02:18:20 -070075 int ids;
Mike Waychisonae781772005-09-06 15:17:09 -070076 int (*show)(struct seq_file *, void *);
77};
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079/**
Davidlohr Bueso8001c852014-01-27 17:07:05 -080080 * ipc_init - initialise ipc subsystem
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -080082 * The various sysv ipc resources (semaphores, messages and shared
83 * memory) are initialised.
84 *
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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070089static int __init ipc_init(void)
90{
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -070091 int err_sem, err_msg;
92
Alexey Dobriyane74a0ef2018-04-10 16:30:58 -070093 proc_mkdir("sysvipc", NULL);
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -070094 err_sem = sem_init();
95 WARN(err_sem, "ipc: sysv sem_init failed: %d\n", err_sem);
96 err_msg = msg_init();
97 WARN(err_msg, "ipc: sysv msg_init failed: %d\n", err_msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 shm_init();
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -070099
100 return err_msg ? err_msg : err_sem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101}
Davidlohr Bueso6d08a252014-04-07 15:39:18 -0700102device_initcall(ipc_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700104static 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),
108 .locks_mul = 1,
109 .automatic_shrinking = true,
110};
111
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112/**
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800113 * ipc_init_ids - initialise ipc identifiers
114 * @ids: ipc identifier set
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800116 * Set up the sequence range to use for the ipc identifier range (limited
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700117 * below IPCMNI) then initialise the keys hashtable and ids idr.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 */
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700119int ipc_init_ids(struct ipc_ids *ids)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120{
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700121 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 ids->in_use = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 ids->seq = 0;
Davidlohr Buesodaf948c2014-01-27 17:07:09 -0800124 init_rwsem(&ids->rwsem);
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700125 err = rhashtable_init(&ids->key_ht, &ipc_kht_params);
126 if (err)
127 return err;
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700128 idr_init(&ids->ipcs_idr);
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700129 ids->tables_initialized = true;
Davidlohr Bueso15df03c82017-11-17 15:31:18 -0800130 ids->max_id = -1;
Davidlohr Buesob8fd9982017-11-17 15:31:08 -0800131#ifdef CONFIG_CHECKPOINT_RESTORE
132 ids->next_id = -1;
133#endif
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700134 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135}
136
Mike Waychisonae781772005-09-06 15:17:09 -0700137#ifdef CONFIG_PROC_FS
Arjan van de Ven9a321442007-02-12 00:55:35 -0800138static const struct file_operations sysvipc_proc_fops;
Mike Waychisonae781772005-09-06 15:17:09 -0700139/**
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800140 * 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.
Mike Waychisonae781772005-09-06 15:17:09 -0700145 */
146void __init ipc_init_proc_interface(const char *path, const char *header,
Kirill Korotaev73ea4132006-10-02 02:18:20 -0700147 int ids, int (*show)(struct seq_file *, void *))
Mike Waychisonae781772005-09-06 15:17:09 -0700148{
149 struct proc_dir_entry *pde;
150 struct ipc_proc_iface *iface;
151
152 iface = kmalloc(sizeof(*iface), GFP_KERNEL);
153 if (!iface)
154 return;
155 iface->path = path;
156 iface->header = header;
157 iface->ids = ids;
158 iface->show = show;
159
Denis V. Lunev6a6375d2008-04-29 01:02:12 -0700160 pde = proc_create_data(path,
161 S_IRUGO, /* world readable */
162 NULL, /* parent dir */
163 &sysvipc_proc_fops,
164 iface);
Davidlohr Bueso3ab08fe2014-01-27 17:07:06 -0800165 if (!pde)
Mike Waychisonae781772005-09-06 15:17:09 -0700166 kfree(iface);
Mike Waychisonae781772005-09-06 15:17:09 -0700167}
168#endif
169
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170/**
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800171 * ipc_findkey - find a key in an ipc identifier set
172 * @ids: ipc identifier set
173 * @key: key to find
Paul McQuade46c0a8c2014-06-06 14:37:37 -0700174 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800175 * 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
177 *
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700178 * Called with writer ipc_ids.rwsem held.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 */
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700180static struct kern_ipc_perm *ipc_findkey(struct ipc_ids *ids, key_t key)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181{
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700182 struct kern_ipc_perm *ipcp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700184 if (likely(ids->tables_initialized))
185 ipcp = rhashtable_lookup_fast(&ids->key_ht, &key,
186 ipc_kht_params);
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700187
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700188 if (ipcp) {
Davidlohr Bueso32a27502013-09-11 14:26:29 -0700189 rcu_read_lock();
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700190 ipc_lock_object(ipcp);
191 return ipcp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 }
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700193
194 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195}
196
Davidlohr Buesob8fd9982017-11-17 15:31:08 -0800197/*
Manfred Spraule2652ae2018-08-21 22:01:25 -0700198 * Insert new IPC object into idr tree, and set sequence number and id
199 * in the correct order.
200 * Especially:
201 * - the sequence number must be set before inserting the object into the idr,
202 * because the sequence number is accessed without a lock.
203 * - the id can/must be set after inserting the object into the idr.
204 * All accesses must be done after getting kern_ipc_perm.lock.
205 *
206 * The caller must own kern_ipc_perm.lock.of the new object.
207 * On error, the function returns a (negative) error code.
Davidlohr Buesob8fd9982017-11-17 15:31:08 -0800208 */
Manfred Spraule2652ae2018-08-21 22:01:25 -0700209static inline int ipc_idr_alloc(struct ipc_ids *ids, struct kern_ipc_perm *new)
Davidlohr Buesob8fd9982017-11-17 15:31:08 -0800210{
Manfred Spraule2652ae2018-08-21 22:01:25 -0700211 int idx, next_id = -1;
212
213#ifdef CONFIG_CHECKPOINT_RESTORE
214 next_id = ids->next_id;
215 ids->next_id = -1;
216#endif
217
218 /*
219 * As soon as a new object is inserted into the idr,
220 * ipc_obtain_object_idr() or ipc_obtain_object_check() can find it,
221 * and the lockless preparations for ipc operations can start.
222 * This means especially: permission checks, audit calls, allocation
223 * of undo structures, ...
224 *
225 * Thus the object must be fully initialized, and if something fails,
226 * then the full tear-down sequence must be followed.
227 * (i.e.: set new->deleted, reduce refcount, call_rcu())
228 */
229
230 if (next_id < 0) { /* !CHECKPOINT_RESTORE or next_id is unset */
Davidlohr Buesob8fd9982017-11-17 15:31:08 -0800231 new->seq = ids->seq++;
232 if (ids->seq > IPCID_SEQ_MAX)
233 ids->seq = 0;
Manfred Spraule2652ae2018-08-21 22:01:25 -0700234 idx = idr_alloc(&ids->ipcs_idr, new, 0, 0, GFP_NOWAIT);
Davidlohr Buesob8fd9982017-11-17 15:31:08 -0800235 } else {
Manfred Spraule2652ae2018-08-21 22:01:25 -0700236 new->seq = ipcid_to_seqx(next_id);
237 idx = idr_alloc(&ids->ipcs_idr, new, ipcid_to_idx(next_id),
238 0, GFP_NOWAIT);
Davidlohr Buesob8fd9982017-11-17 15:31:08 -0800239 }
Manfred Spraule2652ae2018-08-21 22:01:25 -0700240 if (idx >= 0)
241 new->id = SEQ_MULTIPLIER * new->seq + idx;
242 return idx;
Davidlohr Buesob8fd9982017-11-17 15:31:08 -0800243}
244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245/**
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800246 * ipc_addid - add an ipc identifier
247 * @ids: ipc identifier set
248 * @new: new ipc permission set
Davidlohr Buesoebf66792017-11-17 15:31:15 -0800249 * @limit: limit for the number of used ids
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800251 * Add an entry 'new' to the ipc ids idr. The permissions object is
252 * initialised and the first free entry is set up and the id assigned
253 * is returned. The 'new' entry is returned in a locked state on success.
Manfred Spraul39cfffd2018-08-21 22:01:29 -0700254 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800255 * On failure the entry is not locked and a negative err-code is returned.
Manfred Spraul39cfffd2018-08-21 22:01:29 -0700256 * The caller must use ipc_rcu_putref() to free the identifier.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800258 * Called with writer ipc_ids.rwsem held.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 */
Davidlohr Buesoebf66792017-11-17 15:31:15 -0800260int ipc_addid(struct ipc_ids *ids, struct kern_ipc_perm *new, int limit)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261{
Eric W. Biederman1efdb692012-02-07 16:54:11 -0800262 kuid_t euid;
263 kgid_t egid;
Manfred Spraule2652ae2018-08-21 22:01:25 -0700264 int idx, err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
Manfred Spraul39cfffd2018-08-21 22:01:29 -0700266 /* 1) Initialize the refcount so that ipc_rcu_putref works */
267 refcount_set(&new->refcount, 1);
268
Davidlohr Buesoebf66792017-11-17 15:31:15 -0800269 if (limit > IPCMNI)
270 limit = IPCMNI;
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700271
Davidlohr Buesoebf66792017-11-17 15:31:15 -0800272 if (!ids->tables_initialized || ids->in_use >= limit)
Pierre Peiffer283bb7f2007-10-18 23:40:57 -0700273 return -ENOSPC;
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700274
Tejun Heo54924ea2013-02-27 17:04:53 -0800275 idr_preload(GFP_KERNEL);
276
Nadia Derbeye00b4ff7e2008-11-19 15:36:08 -0800277 spin_lock_init(&new->lock);
Nadia Derbeye00b4ff7e2008-11-19 15:36:08 -0800278 rcu_read_lock();
279 spin_lock(&new->lock);
280
Linus Torvaldsb9a53222015-09-30 12:48:40 -0400281 current_euid_egid(&euid, &egid);
282 new->cuid = new->uid = euid;
283 new->gid = new->cgid = egid;
284
Manfred Spraul39cfffd2018-08-21 22:01:29 -0700285 new->deleted = false;
286
Manfred Spraule2652ae2018-08-21 22:01:25 -0700287 idx = ipc_idr_alloc(ids, new);
Tejun Heo54924ea2013-02-27 17:04:53 -0800288 idr_preload_end();
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700289
Manfred Spraule2652ae2018-08-21 22:01:25 -0700290 if (idx >= 0 && new->key != IPC_PRIVATE) {
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700291 err = rhashtable_insert_fast(&ids->key_ht, &new->khtnode,
292 ipc_kht_params);
293 if (err < 0) {
Manfred Spraule2652ae2018-08-21 22:01:25 -0700294 idr_remove(&ids->ipcs_idr, idx);
295 idx = err;
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700296 }
297 }
Manfred Spraule2652ae2018-08-21 22:01:25 -0700298 if (idx < 0) {
Manfred Spraul39cfffd2018-08-21 22:01:29 -0700299 new->deleted = true;
Nadia Derbeye00b4ff7e2008-11-19 15:36:08 -0800300 spin_unlock(&new->lock);
301 rcu_read_unlock();
Manfred Spraule2652ae2018-08-21 22:01:25 -0700302 return idx;
Nadia Derbeye00b4ff7e2008-11-19 15:36:08 -0800303 }
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700304
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 ids->in_use++;
Manfred Spraule2652ae2018-08-21 22:01:25 -0700306 if (idx > ids->max_id)
307 ids->max_id = idx;
308 return idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309}
310
311/**
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800312 * ipcget_new - create a new ipc object
313 * @ns: ipc namespace
Masanari Iidada3dae52014-09-09 01:27:23 +0900314 * @ids: ipc identifier set
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800315 * @ops: the actual creation routine to call
316 * @params: its parameters
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700317 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800318 * This routine is called by sys_msgget, sys_semget() and sys_shmget()
319 * when the key is IPC_PRIVATE.
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700320 */
Pavel Emelyanovb2d75cd2008-02-08 04:18:54 -0800321static int ipcget_new(struct ipc_namespace *ns, struct ipc_ids *ids,
Mathias Krauseeb66ec42014-06-06 14:37:36 -0700322 const struct ipc_ops *ops, struct ipc_params *params)
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700323{
324 int err;
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700325
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700326 down_write(&ids->rwsem);
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700327 err = ops->getnew(ns, params);
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700328 up_write(&ids->rwsem);
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700329 return err;
330}
331
332/**
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800333 * ipc_check_perms - check security and permissions for an ipc object
334 * @ns: ipc namespace
335 * @ipcp: ipc permission set
336 * @ops: the actual security routine to call
337 * @params: its parameters
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700338 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800339 * This routine is called by sys_msgget(), sys_semget() and sys_shmget()
340 * when the key is not IPC_PRIVATE and that key already exists in the
341 * ds IDR.
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700342 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800343 * On success, the ipc id is returned.
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700344 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800345 * It is called with ipc_ids.rwsem and ipcp->lock held.
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700346 */
Serge E. Hallynb0e77592011-03-23 16:43:24 -0700347static int ipc_check_perms(struct ipc_namespace *ns,
348 struct kern_ipc_perm *ipcp,
Mathias Krauseeb66ec42014-06-06 14:37:36 -0700349 const struct ipc_ops *ops,
Serge E. Hallynb0e77592011-03-23 16:43:24 -0700350 struct ipc_params *params)
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700351{
352 int err;
353
Serge E. Hallynb0e77592011-03-23 16:43:24 -0700354 if (ipcperms(ns, ipcp, params->flg))
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700355 err = -EACCES;
356 else {
357 err = ops->associate(ipcp, params->flg);
358 if (!err)
359 err = ipcp->id;
360 }
361
362 return err;
363}
364
365/**
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800366 * ipcget_public - get an ipc object or create a new one
367 * @ns: ipc namespace
Masanari Iidada3dae52014-09-09 01:27:23 +0900368 * @ids: ipc identifier set
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800369 * @ops: the actual creation routine to call
370 * @params: its parameters
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700371 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800372 * This routine is called by sys_msgget, sys_semget() and sys_shmget()
373 * when the key is not IPC_PRIVATE.
374 * It adds a new entry if the key is not found and does some permission
375 * / security checkings if the key is found.
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700376 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800377 * On success, the ipc id is returned.
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700378 */
Pavel Emelyanovb2d75cd2008-02-08 04:18:54 -0800379static int ipcget_public(struct ipc_namespace *ns, struct ipc_ids *ids,
Mathias Krauseeb66ec42014-06-06 14:37:36 -0700380 const struct ipc_ops *ops, struct ipc_params *params)
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700381{
382 struct kern_ipc_perm *ipcp;
383 int flg = params->flg;
384 int err;
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700385
Nadia Derbey3e148c72007-10-18 23:40:54 -0700386 /*
387 * Take the lock as a writer since we are potentially going to add
388 * a new entry + read locks are not "upgradable"
389 */
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700390 down_write(&ids->rwsem);
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700391 ipcp = ipc_findkey(ids, params->key);
392 if (ipcp == NULL) {
393 /* key not used */
394 if (!(flg & IPC_CREAT))
395 err = -ENOENT;
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700396 else
397 err = ops->getnew(ns, params);
398 } else {
399 /* ipc object has been locked by ipc_findkey() */
400
401 if (flg & IPC_CREAT && flg & IPC_EXCL)
402 err = -EEXIST;
403 else {
404 err = 0;
405 if (ops->more_checks)
406 err = ops->more_checks(ipcp, params);
407 if (!err)
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700408 /*
409 * ipc_check_perms returns the IPC id on
410 * success
411 */
Serge E. Hallynb0e77592011-03-23 16:43:24 -0700412 err = ipc_check_perms(ns, ipcp, ops, params);
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700413 }
414 ipc_unlock(ipcp);
415 }
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700416 up_write(&ids->rwsem);
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700417
418 return err;
419}
420
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700421/**
422 * ipc_kht_remove - remove an ipc from the key hashtable
423 * @ids: ipc identifier set
424 * @ipcp: ipc perm structure containing the key to remove
425 *
426 * ipc_ids.rwsem (as a writer) and the spinlock for this ID are held
427 * before this function is called, and remain locked on the exit.
428 */
429static void ipc_kht_remove(struct ipc_ids *ids, struct kern_ipc_perm *ipcp)
430{
431 if (ipcp->key != IPC_PRIVATE)
432 rhashtable_remove_fast(&ids->key_ht, &ipcp->khtnode,
433 ipc_kht_params);
434}
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700435
436/**
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800437 * ipc_rmid - remove an ipc identifier
438 * @ids: ipc identifier set
439 * @ipcp: ipc perm structure containing the identifier to remove
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800441 * ipc_ids.rwsem (as a writer) and the spinlock for this ID are held
442 * before this function is called, and remain locked on the exit.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 */
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700444void ipc_rmid(struct ipc_ids *ids, struct kern_ipc_perm *ipcp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445{
Nadia Derbeyce621f52007-10-18 23:40:52 -0700446 int lid = ipcid_to_idx(ipcp->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700448 idr_remove(&ids->ipcs_idr, lid);
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700449 ipc_kht_remove(ids, ipcp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 ids->in_use--;
Rafael Aquini72a8ff22014-01-27 17:07:02 -0800451 ipcp->deleted = true;
Davidlohr Bueso15df03c82017-11-17 15:31:18 -0800452
453 if (unlikely(lid == ids->max_id)) {
454 do {
455 lid--;
456 if (lid == -1)
457 break;
458 } while (!idr_find(&ids->ipcs_idr, lid));
459 ids->max_id = lid;
460 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461}
462
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700463/**
464 * ipc_set_key_private - switch the key of an existing ipc to IPC_PRIVATE
465 * @ids: ipc identifier set
466 * @ipcp: ipc perm structure containing the key to modify
467 *
468 * ipc_ids.rwsem (as a writer) and the spinlock for this ID are held
469 * before this function is called, and remain locked on the exit.
470 */
471void ipc_set_key_private(struct ipc_ids *ids, struct kern_ipc_perm *ipcp)
472{
473 ipc_kht_remove(ids, ipcp);
474 ipcp->key = IPC_PRIVATE;
475}
476
Manfred Sprauldba4cdd2017-07-12 14:34:41 -0700477int ipc_rcu_getref(struct kern_ipc_perm *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478{
Elena Reshetova9405c032017-09-08 16:17:45 -0700479 return refcount_inc_not_zero(&ptr->refcount);
David Howells65f27f32006-11-22 14:55:48 +0000480}
481
Manfred Sprauldba4cdd2017-07-12 14:34:41 -0700482void ipc_rcu_putref(struct kern_ipc_perm *ptr,
483 void (*func)(struct rcu_head *head))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484{
Elena Reshetova9405c032017-09-08 16:17:45 -0700485 if (!refcount_dec_and_test(&ptr->refcount))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 return;
487
Manfred Sprauldba4cdd2017-07-12 14:34:41 -0700488 call_rcu(&ptr->rcu, func);
Davidlohr Bueso53dad6d2013-09-23 17:04:45 -0700489}
490
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491/**
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800492 * ipcperms - check ipc permissions
493 * @ns: ipc namespace
494 * @ipcp: ipc permission set
495 * @flag: desired permission set
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800497 * Check user, group, other permissions for access
498 * to ipc resources. return 0 if allowed
Serge E. Hallynb0e77592011-03-23 16:43:24 -0700499 *
mchehab@s-opensource.com0e056eb2017-03-30 17:11:36 -0300500 * @flag will most probably be 0 or ``S_...UGO`` from <linux/stat.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 */
Serge E. Hallynb0e77592011-03-23 16:43:24 -0700502int ipcperms(struct ipc_namespace *ns, struct kern_ipc_perm *ipcp, short flag)
503{
Eric W. Biederman1efdb692012-02-07 16:54:11 -0800504 kuid_t euid = current_euid();
Al Viroa33e6752008-12-10 03:40:06 -0500505 int requested_mode, granted_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
Al Viroa33e6752008-12-10 03:40:06 -0500507 audit_ipc_obj(ipcp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 requested_mode = (flag >> 6) | (flag >> 3) | flag;
509 granted_mode = ipcp->mode;
Eric W. Biederman1efdb692012-02-07 16:54:11 -0800510 if (uid_eq(euid, ipcp->cuid) ||
511 uid_eq(euid, ipcp->uid))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 granted_mode >>= 6;
513 else if (in_group_p(ipcp->cgid) || in_group_p(ipcp->gid))
514 granted_mode >>= 3;
515 /* is there some bit set in requested_mode but not in granted_mode? */
Paul McQuade46c0a8c2014-06-06 14:37:37 -0700516 if ((requested_mode & ~granted_mode & 0007) &&
Serge E. Hallynb0e77592011-03-23 16:43:24 -0700517 !ns_capable(ns->user_ns, CAP_IPC_OWNER))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 return -1;
519
520 return security_ipc_permission(ipcp, flag);
521}
522
523/*
524 * Functions to convert between the kern_ipc_perm structure and the
525 * old/new ipc_perm structures
526 */
527
528/**
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800529 * kernel_to_ipc64_perm - convert kernel ipc permissions to user
530 * @in: kernel permissions
531 * @out: new style ipc permissions
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800533 * Turn the kernel object @in into a set of permissions descriptions
534 * for returning to userspace (@out).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 */
Manfred Spraul239521f2014-01-27 17:07:04 -0800536void kernel_to_ipc64_perm(struct kern_ipc_perm *in, struct ipc64_perm *out)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537{
538 out->key = in->key;
Eric W. Biederman1efdb692012-02-07 16:54:11 -0800539 out->uid = from_kuid_munged(current_user_ns(), in->uid);
540 out->gid = from_kgid_munged(current_user_ns(), in->gid);
541 out->cuid = from_kuid_munged(current_user_ns(), in->cuid);
542 out->cgid = from_kgid_munged(current_user_ns(), in->cgid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 out->mode = in->mode;
544 out->seq = in->seq;
545}
546
547/**
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800548 * ipc64_perm_to_ipc_perm - convert new ipc permissions to old
549 * @in: new style ipc permissions
550 * @out: old style ipc permissions
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800552 * Turn the new style permissions object @in into a compatibility
553 * object and store it into the @out pointer.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 */
Manfred Spraul239521f2014-01-27 17:07:04 -0800555void ipc64_perm_to_ipc_perm(struct ipc64_perm *in, struct ipc_perm *out)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556{
557 out->key = in->key;
558 SET_UID(out->uid, in->uid);
559 SET_GID(out->gid, in->gid);
560 SET_UID(out->cuid, in->cuid);
561 SET_GID(out->cgid, in->cgid);
562 out->mode = in->mode;
563 out->seq = in->seq;
564}
565
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700566/**
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700567 * ipc_obtain_object_idr
Davidlohr Bueso4d2bff52013-04-30 19:15:19 -0700568 * @ids: ipc identifier set
569 * @id: ipc id to look for
570 *
571 * Look for an id in the ipc ids idr and return associated ipc object.
572 *
573 * Call inside the RCU critical section.
574 * The ipc object is *not* locked on exit.
575 */
Davidlohr Bueso55b7ae52015-06-30 14:58:42 -0700576struct kern_ipc_perm *ipc_obtain_object_idr(struct ipc_ids *ids, int id)
Davidlohr Bueso4d2bff52013-04-30 19:15:19 -0700577{
578 struct kern_ipc_perm *out;
579 int lid = ipcid_to_idx(id);
580
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700581 if (unlikely(!ids->tables_initialized))
582 return ERR_PTR(-EINVAL);
583
Davidlohr Bueso4d2bff52013-04-30 19:15:19 -0700584 out = idr_find(&ids->ipcs_idr, lid);
585 if (!out)
586 return ERR_PTR(-EINVAL);
587
588 return out;
589}
590
591/**
Davidlohr Bueso4d2bff52013-04-30 19:15:19 -0700592 * ipc_obtain_object_check
593 * @ids: ipc identifier set
594 * @id: ipc id to look for
595 *
Manfred Spraul2e5ceb42018-08-21 22:01:37 -0700596 * Similar to ipc_obtain_object_idr() but also checks the ipc object
597 * sequence number.
Davidlohr Bueso4d2bff52013-04-30 19:15:19 -0700598 *
599 * Call inside the RCU critical section.
600 * The ipc object is *not* locked on exit.
601 */
602struct kern_ipc_perm *ipc_obtain_object_check(struct ipc_ids *ids, int id)
603{
Davidlohr Bueso55b7ae52015-06-30 14:58:42 -0700604 struct kern_ipc_perm *out = ipc_obtain_object_idr(ids, id);
Davidlohr Bueso4d2bff52013-04-30 19:15:19 -0700605
606 if (IS_ERR(out))
607 goto out;
608
609 if (ipc_checkid(out, id))
Davidlohr Bueso6157dbb2015-06-30 14:58:48 -0700610 return ERR_PTR(-EINVAL);
Davidlohr Bueso4d2bff52013-04-30 19:15:19 -0700611out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 return out;
613}
614
Pavel Emelyanovb2d75cd2008-02-08 04:18:54 -0800615/**
616 * ipcget - Common sys_*get() code
Masanari Iidada3dae52014-09-09 01:27:23 +0900617 * @ns: namespace
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800618 * @ids: ipc identifier set
619 * @ops: operations to be called on ipc object creation, permission checks
620 * and further checks
621 * @params: the parameters needed by the previous operations.
Pavel Emelyanovb2d75cd2008-02-08 04:18:54 -0800622 *
623 * Common routine called by sys_msgget(), sys_semget() and sys_shmget().
624 */
625int ipcget(struct ipc_namespace *ns, struct ipc_ids *ids,
Mathias Krauseeb66ec42014-06-06 14:37:36 -0700626 const struct ipc_ops *ops, struct ipc_params *params)
Pavel Emelyanovb2d75cd2008-02-08 04:18:54 -0800627{
628 if (params->key == IPC_PRIVATE)
629 return ipcget_new(ns, ids, ops, params);
630 else
631 return ipcget_public(ns, ids, ops, params);
632}
633
Pierre Peiffer8f4a3802008-04-29 01:00:51 -0700634/**
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800635 * ipc_update_perm - update the permissions of an ipc object
Pierre Peiffer8f4a3802008-04-29 01:00:51 -0700636 * @in: the permission given as input.
637 * @out: the permission of the ipc to set.
638 */
Eric W. Biederman1efdb692012-02-07 16:54:11 -0800639int ipc_update_perm(struct ipc64_perm *in, struct kern_ipc_perm *out)
Pierre Peiffer8f4a3802008-04-29 01:00:51 -0700640{
Eric W. Biederman1efdb692012-02-07 16:54:11 -0800641 kuid_t uid = make_kuid(current_user_ns(), in->uid);
642 kgid_t gid = make_kgid(current_user_ns(), in->gid);
643 if (!uid_valid(uid) || !gid_valid(gid))
644 return -EINVAL;
645
646 out->uid = uid;
647 out->gid = gid;
Pierre Peiffer8f4a3802008-04-29 01:00:51 -0700648 out->mode = (out->mode & ~S_IRWXUGO)
649 | (in->mode & S_IRWXUGO);
Eric W. Biederman1efdb692012-02-07 16:54:11 -0800650
651 return 0;
Pierre Peiffer8f4a3802008-04-29 01:00:51 -0700652}
653
Pierre Peiffera5f75e72008-04-29 01:00:54 -0700654/**
Manfred Spraul4241c1a2018-08-21 22:01:34 -0700655 * ipcctl_obtain_check - retrieve an ipc object and check permissions
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800656 * @ns: ipc namespace
Pierre Peiffera5f75e72008-04-29 01:00:54 -0700657 * @ids: the table of ids where to look for the ipc
658 * @id: the id of the ipc to retrieve
659 * @cmd: the cmd to check
660 * @perm: the permission to set
661 * @extra_perm: one extra permission parameter used by msq
662 *
663 * This function does some common audit and permissions check for some IPC_XXX
664 * cmd and is called from semctl_down, shmctl_down and msgctl_down.
mchehab@s-opensource.com0e056eb2017-03-30 17:11:36 -0300665 *
Manfred Spraul4241c1a2018-08-21 22:01:34 -0700666 * It:
667 * - retrieves the ipc object with the given id in the given table.
mchehab@s-opensource.com0e056eb2017-03-30 17:11:36 -0300668 * - performs some audit and permission check, depending on the given cmd
669 * - returns a pointer to the ipc object or otherwise, the corresponding
670 * error.
Davidlohr Bueso7b4cc5d2013-07-08 16:01:12 -0700671 *
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700672 * Call holding the both the rwsem and the rcu read lock.
Pierre Peiffera5f75e72008-04-29 01:00:54 -0700673 */
Manfred Spraul4241c1a2018-08-21 22:01:34 -0700674struct kern_ipc_perm *ipcctl_obtain_check(struct ipc_namespace *ns,
Davidlohr Bueso3b1c4ad2013-09-11 14:26:17 -0700675 struct ipc_ids *ids, int id, int cmd,
676 struct ipc64_perm *perm, int extra_perm)
Davidlohr Bueso444d0f62013-04-30 19:15:24 -0700677{
Eric W. Biederman1efdb692012-02-07 16:54:11 -0800678 kuid_t euid;
Davidlohr Bueso444d0f62013-04-30 19:15:24 -0700679 int err = -EPERM;
680 struct kern_ipc_perm *ipcp;
Pierre Peiffera5f75e72008-04-29 01:00:54 -0700681
Davidlohr Bueso444d0f62013-04-30 19:15:24 -0700682 ipcp = ipc_obtain_object_check(ids, id);
Pierre Peiffera5f75e72008-04-29 01:00:54 -0700683 if (IS_ERR(ipcp)) {
684 err = PTR_ERR(ipcp);
Davidlohr Bueso7b4cc5d2013-07-08 16:01:12 -0700685 goto err;
Pierre Peiffera5f75e72008-04-29 01:00:54 -0700686 }
687
Al Viroa33e6752008-12-10 03:40:06 -0500688 audit_ipc_obj(ipcp);
Al Viroe816f372008-12-10 03:47:15 -0500689 if (cmd == IPC_SET)
690 audit_ipc_set_perm(extra_perm, perm->uid,
Davidlohr Bueso444d0f62013-04-30 19:15:24 -0700691 perm->gid, perm->mode);
David Howells414c0702008-11-14 10:39:06 +1100692
693 euid = current_euid();
Eric W. Biederman1efdb692012-02-07 16:54:11 -0800694 if (uid_eq(euid, ipcp->cuid) || uid_eq(euid, ipcp->uid) ||
Serge E. Hallynb0e77592011-03-23 16:43:24 -0700695 ns_capable(ns->user_ns, CAP_SYS_ADMIN))
Davidlohr Bueso7b4cc5d2013-07-08 16:01:12 -0700696 return ipcp; /* successful lookup */
697err:
Pierre Peiffera5f75e72008-04-29 01:00:54 -0700698 return ERR_PTR(err);
699}
700
Will Deaconc1d7e012012-07-30 14:42:46 -0700701#ifdef CONFIG_ARCH_WANT_IPC_PARSE_VERSION
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702
703
704/**
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800705 * ipc_parse_version - ipc call version
706 * @cmd: pointer to command
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 *
Davidlohr Bueso8001c852014-01-27 17:07:05 -0800708 * Return IPC_64 for new style IPC and IPC_OLD for old style IPC.
709 * The @cmd value is turned from an encoding command and version into
710 * just the command code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 */
Manfred Spraul239521f2014-01-27 17:07:04 -0800712int ipc_parse_version(int *cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713{
714 if (*cmd & IPC_64) {
715 *cmd ^= IPC_64;
716 return IPC_64;
717 } else {
718 return IPC_OLD;
719 }
720}
721
Will Deaconc1d7e012012-07-30 14:42:46 -0700722#endif /* CONFIG_ARCH_WANT_IPC_PARSE_VERSION */
Mike Waychisonae781772005-09-06 15:17:09 -0700723
724#ifdef CONFIG_PROC_FS
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800725struct ipc_proc_iter {
726 struct ipc_namespace *ns;
Eric W. Biederman03f1fc02018-03-23 00:22:05 -0500727 struct pid_namespace *pid_ns;
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800728 struct ipc_proc_iface *iface;
729};
730
Eric W. Biederman03f1fc02018-03-23 00:22:05 -0500731struct pid_namespace *ipc_seq_pid_ns(struct seq_file *s)
732{
733 struct ipc_proc_iter *iter = s->private;
734 return iter->pid_ns;
735}
736
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700737/*
738 * This routine locks the ipc structure found at least at position pos.
739 */
Adrian Bunkb524b9a2008-02-06 01:36:28 -0800740static struct kern_ipc_perm *sysvipc_find_ipc(struct ipc_ids *ids, loff_t pos,
741 loff_t *new_pos)
Mike Waychisonae781772005-09-06 15:17:09 -0700742{
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700743 struct kern_ipc_perm *ipc;
744 int total, id;
Kirill Korotaev73ea4132006-10-02 02:18:20 -0700745
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700746 total = 0;
747 for (id = 0; id < pos && total < ids->in_use; id++) {
748 ipc = idr_find(&ids->ipcs_idr, id);
749 if (ipc != NULL)
750 total++;
751 }
Mike Waychisonae781772005-09-06 15:17:09 -0700752
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700753 if (total >= ids->in_use)
754 return NULL;
Mike Waychisonae781772005-09-06 15:17:09 -0700755
Manfred Spraul239521f2014-01-27 17:07:04 -0800756 for (; pos < IPCMNI; pos++) {
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700757 ipc = idr_find(&ids->ipcs_idr, pos);
758 if (ipc != NULL) {
759 *new_pos = pos + 1;
Davidlohr Bueso32a27502013-09-11 14:26:29 -0700760 rcu_read_lock();
761 ipc_lock_object(ipc);
Mike Waychisonae781772005-09-06 15:17:09 -0700762 return ipc;
763 }
764 }
765
766 /* Out of range - return NULL to terminate iteration */
767 return NULL;
768}
769
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700770static void *sysvipc_proc_next(struct seq_file *s, void *it, loff_t *pos)
771{
772 struct ipc_proc_iter *iter = s->private;
773 struct ipc_proc_iface *iface = iter->iface;
774 struct kern_ipc_perm *ipc = it;
775
776 /* If we had an ipc id locked before, unlock it */
777 if (ipc && ipc != SEQ_START_TOKEN)
778 ipc_unlock(ipc);
779
Pierre Peiffered2ddbf2008-02-08 04:18:57 -0800780 return sysvipc_find_ipc(&iter->ns->ids[iface->ids], *pos, pos);
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700781}
782
Mike Waychisonae781772005-09-06 15:17:09 -0700783/*
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700784 * File positions: pos 0 -> header, pos n -> ipc id = n - 1.
785 * SeqFile iterator: iterator value locked ipc pointer or SEQ_TOKEN_START.
Mike Waychisonae781772005-09-06 15:17:09 -0700786 */
787static void *sysvipc_proc_start(struct seq_file *s, loff_t *pos)
788{
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800789 struct ipc_proc_iter *iter = s->private;
790 struct ipc_proc_iface *iface = iter->iface;
Kirill Korotaev73ea4132006-10-02 02:18:20 -0700791 struct ipc_ids *ids;
792
Pierre Peiffered2ddbf2008-02-08 04:18:57 -0800793 ids = &iter->ns->ids[iface->ids];
Mike Waychisonae781772005-09-06 15:17:09 -0700794
795 /*
796 * Take the lock - this will be released by the corresponding
797 * call to stop().
798 */
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700799 down_read(&ids->rwsem);
Mike Waychisonae781772005-09-06 15:17:09 -0700800
801 /* pos < 0 is invalid */
802 if (*pos < 0)
803 return NULL;
804
805 /* pos == 0 means header */
806 if (*pos == 0)
807 return SEQ_START_TOKEN;
808
809 /* Find the (pos-1)th ipc */
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700810 return sysvipc_find_ipc(ids, *pos - 1, pos);
Mike Waychisonae781772005-09-06 15:17:09 -0700811}
812
813static void sysvipc_proc_stop(struct seq_file *s, void *it)
814{
815 struct kern_ipc_perm *ipc = it;
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800816 struct ipc_proc_iter *iter = s->private;
817 struct ipc_proc_iface *iface = iter->iface;
Kirill Korotaev73ea4132006-10-02 02:18:20 -0700818 struct ipc_ids *ids;
Mike Waychisonae781772005-09-06 15:17:09 -0700819
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700820 /* If we had a locked structure, release it */
Mike Waychisonae781772005-09-06 15:17:09 -0700821 if (ipc && ipc != SEQ_START_TOKEN)
822 ipc_unlock(ipc);
823
Pierre Peiffered2ddbf2008-02-08 04:18:57 -0800824 ids = &iter->ns->ids[iface->ids];
Mike Waychisonae781772005-09-06 15:17:09 -0700825 /* Release the lock we took in start() */
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700826 up_read(&ids->rwsem);
Mike Waychisonae781772005-09-06 15:17:09 -0700827}
828
829static int sysvipc_proc_show(struct seq_file *s, void *it)
830{
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800831 struct ipc_proc_iter *iter = s->private;
832 struct ipc_proc_iface *iface = iter->iface;
Mike Waychisonae781772005-09-06 15:17:09 -0700833
Joe Perches7f032d62015-04-15 16:17:54 -0700834 if (it == SEQ_START_TOKEN) {
835 seq_puts(s, iface->header);
836 return 0;
837 }
Mike Waychisonae781772005-09-06 15:17:09 -0700838
839 return iface->show(s, it);
840}
841
James Morris88e9d342009-09-22 16:43:43 -0700842static const struct seq_operations sysvipc_proc_seqops = {
Mike Waychisonae781772005-09-06 15:17:09 -0700843 .start = sysvipc_proc_start,
844 .stop = sysvipc_proc_stop,
845 .next = sysvipc_proc_next,
846 .show = sysvipc_proc_show,
847};
848
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800849static int sysvipc_proc_open(struct inode *inode, struct file *file)
850{
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800851 struct ipc_proc_iter *iter;
852
Rob Jonesd66a0522014-10-13 15:54:14 -0700853 iter = __seq_open_private(file, &sysvipc_proc_seqops, sizeof(*iter));
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800854 if (!iter)
Rob Jonesd66a0522014-10-13 15:54:14 -0700855 return -ENOMEM;
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800856
Al Virod9dda782013-03-31 18:16:14 -0400857 iter->iface = PDE_DATA(inode);
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800858 iter->ns = get_ipc_ns(current->nsproxy->ipc_ns);
Eric W. Biederman03f1fc02018-03-23 00:22:05 -0500859 iter->pid_ns = get_pid_ns(task_active_pid_ns(current));
Rob Jonesd66a0522014-10-13 15:54:14 -0700860
861 return 0;
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800862}
863
864static int sysvipc_proc_release(struct inode *inode, struct file *file)
865{
866 struct seq_file *seq = file->private_data;
867 struct ipc_proc_iter *iter = seq->private;
868 put_ipc_ns(iter->ns);
Eric W. Biederman03f1fc02018-03-23 00:22:05 -0500869 put_pid_ns(iter->pid_ns);
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800870 return seq_release_private(inode, file);
Mike Waychisonae781772005-09-06 15:17:09 -0700871}
872
Arjan van de Ven9a321442007-02-12 00:55:35 -0800873static const struct file_operations sysvipc_proc_fops = {
Mike Waychisonae781772005-09-06 15:17:09 -0700874 .open = sysvipc_proc_open,
875 .read = seq_read,
876 .llseek = seq_lseek,
Eric W. Biedermanbc1fc6d2007-02-12 00:52:10 -0800877 .release = sysvipc_proc_release,
Mike Waychisonae781772005-09-06 15:17:09 -0700878};
879#endif /* CONFIG_PROC_FS */