blob: 932b7e411c6ce9d3faef419900bd1efe18979b04 [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/shm.c
4 * Copyright (C) 1992, 1993 Krishna Balasubramanian
5 * Many improvements/fixes by Bruno Haible.
6 * Replaced `struct shm_desc' by `struct vm_area_struct', July 1994.
7 * Fixed the shm swap deallocation (shm_unuse()), August 1998 Andrea Arcangeli.
8 *
9 * /proc/sysvipc/shm support (c) 1999 Dragos Acostachioaie <dragos@iname.com>
10 * BIGMEM support, Andrea Arcangeli <andrea@suse.de>
11 * SMP thread shm, Jean-Luc Boyard <jean-luc.boyard@siemens.fr>
12 * HIGHMEM support, Ingo Molnar <mingo@redhat.com>
13 * Make shmmax, shmall, shmmni sysctl'able, Christoph Rohland <cr@sap.com>
14 * Shared /dev/zero support, Kanoj Sarcar <kanoj@sgi.com>
15 * Move the mm functionality over to mm/shmem.c, Christoph Rohland <cr@sap.com>
16 *
Steve Grubb073115d2006-04-02 17:07:33 -040017 * support for audit of ipc object properties and permission changes
18 * Dustin Kirkland <dustin.kirkland@us.ibm.com>
Kirill Korotaev4e982312006-10-02 02:18:22 -070019 *
20 * namespaces support
21 * OpenVZ, SWsoft Inc.
22 * Pavel Emelianov <xemul@openvz.org>
Davidlohr Buesoc2c737a2013-09-11 14:26:23 -070023 *
24 * Better ipc lock (kern_ipc_perm.lock) handling
25 * Davidlohr Bueso <davidlohr.bueso@hp.com>, June 2013.
Linus Torvalds1da177e2005-04-16 15:20:36 -070026 */
27
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/slab.h>
29#include <linux/mm.h>
30#include <linux/hugetlb.h>
31#include <linux/shm.h>
32#include <linux/init.h>
33#include <linux/file.h>
34#include <linux/mman.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/shmem_fs.h>
36#include <linux/security.h>
37#include <linux/syscalls.h>
38#include <linux/audit.h>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080039#include <linux/capability.h>
Stephen Rothwell7d87e14c2005-05-01 08:59:12 -070040#include <linux/ptrace.h>
Mike Waychison19b49462005-09-06 15:17:10 -070041#include <linux/seq_file.h>
Nadia Derbey3e148c72007-10-18 23:40:54 -070042#include <linux/rwsem.h>
Kirill Korotaev4e982312006-10-02 02:18:22 -070043#include <linux/nsproxy.h>
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -080044#include <linux/mount.h>
Pavel Emelyanovae5e1b22008-02-08 04:18:22 -080045#include <linux/ipc_namespace.h>
Stephen Rothwell7d87e14c2005-05-01 08:59:12 -070046
Paul McQuade7153e402014-06-06 14:37:37 -070047#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
49#include "util.h"
50
Eric W. Biedermana2e102c2018-03-22 21:34:44 -050051struct shmid_kernel /* private to the kernel */
52{
53 struct kern_ipc_perm shm_perm;
54 struct file *shm_file;
55 unsigned long shm_nattch;
56 unsigned long shm_segsz;
57 time64_t shm_atim;
58 time64_t shm_dtim;
59 time64_t shm_ctim;
Eric W. Biederman98f929b12018-03-23 00:29:57 -050060 struct pid *shm_cprid;
61 struct pid *shm_lprid;
Eric W. Biedermana2e102c2018-03-22 21:34:44 -050062 struct user_struct *mlock_user;
63
64 /* The task created the shm object. NULL if the task is dead. */
65 struct task_struct *shm_creator;
66 struct list_head shm_clist; /* list by creator */
67} __randomize_layout;
68
69/* shm_mode upper byte flags */
70#define SHM_DEST 01000 /* segment will be destroyed on last detach */
71#define SHM_LOCKED 02000 /* segment will not be swapped */
72
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -080073struct shm_file_data {
74 int id;
75 struct ipc_namespace *ns;
76 struct file *file;
77 const struct vm_operations_struct *vm_ops;
78};
79
80#define shm_file_data(file) (*((struct shm_file_data **)&(file)->private_data))
81
Arjan van de Ven9a321442007-02-12 00:55:35 -080082static const struct file_operations shm_file_operations;
Alexey Dobriyanf0f37e2f2009-09-27 22:29:37 +040083static const struct vm_operations_struct shm_vm_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
Pierre Peiffered2ddbf2008-02-08 04:18:57 -080085#define shm_ids(ns) ((ns)->ids[IPC_SHM_IDS])
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
Kirill Korotaev4e982312006-10-02 02:18:22 -070087#define shm_unlock(shp) \
88 ipc_unlock(&(shp)->shm_perm)
Kirill Korotaev4e982312006-10-02 02:18:22 -070089
Nadia Derbey7748dbf2007-10-18 23:40:49 -070090static int newseg(struct ipc_namespace *, struct ipc_params *);
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -080091static void shm_open(struct vm_area_struct *vma);
92static void shm_close(struct vm_area_struct *vma);
Manfred Spraul239521f2014-01-27 17:07:04 -080093static void shm_destroy(struct ipc_namespace *ns, struct shmid_kernel *shp);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094#ifdef CONFIG_PROC_FS
Mike Waychison19b49462005-09-06 15:17:10 -070095static int sysvipc_shm_proc_show(struct seq_file *s, void *it);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096#endif
97
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -070098int shm_init_ns(struct ipc_namespace *ns)
Kirill Korotaev4e982312006-10-02 02:18:22 -070099{
Kirill Korotaev4e982312006-10-02 02:18:22 -0700100 ns->shm_ctlmax = SHMMAX;
101 ns->shm_ctlall = SHMALL;
102 ns->shm_ctlmni = SHMMNI;
Vasiliy Kulikovb34a6b12011-07-26 16:08:48 -0700103 ns->shm_rmid_forced = 0;
Kirill Korotaev4e982312006-10-02 02:18:22 -0700104 ns->shm_tot = 0;
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700105 return ipc_init_ids(&shm_ids(ns));
Kirill Korotaev4e982312006-10-02 02:18:22 -0700106}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700108/*
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700109 * Called with shm_ids.rwsem (writer) and the shp structure locked.
110 * Only shm_ids.rwsem remains locked on exit.
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700111 */
Pierre Peiffer01b8b072008-02-08 04:18:57 -0800112static void do_shm_rmid(struct ipc_namespace *ns, struct kern_ipc_perm *ipcp)
Kirill Korotaev4e982312006-10-02 02:18:22 -0700113{
Pierre Peiffer01b8b072008-02-08 04:18:57 -0800114 struct shmid_kernel *shp;
Shailesh Pandey63980c82016-12-14 15:06:10 -0800115
Pierre Peiffer01b8b072008-02-08 04:18:57 -0800116 shp = container_of(ipcp, struct shmid_kernel, shm_perm);
117
Manfred Spraul239521f2014-01-27 17:07:04 -0800118 if (shp->shm_nattch) {
Kirill Korotaev4e982312006-10-02 02:18:22 -0700119 shp->shm_perm.mode |= SHM_DEST;
120 /* Do not find it any more */
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700121 ipc_set_key_private(&shm_ids(ns), &shp->shm_perm);
Kirill Korotaev4e982312006-10-02 02:18:22 -0700122 shm_unlock(shp);
123 } else
124 shm_destroy(ns, shp);
125}
126
Pavel Emelyanovae5e1b22008-02-08 04:18:22 -0800127#ifdef CONFIG_IPC_NS
Kirill Korotaev4e982312006-10-02 02:18:22 -0700128void shm_exit_ns(struct ipc_namespace *ns)
129{
Pierre Peiffer01b8b072008-02-08 04:18:57 -0800130 free_ipcs(ns, &shm_ids(ns), do_shm_rmid);
Serge E. Hallyn7d6feeb2009-12-15 16:47:27 -0800131 idr_destroy(&ns->ids[IPC_SHM_IDS].ipcs_idr);
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700132 rhashtable_destroy(&ns->ids[IPC_SHM_IDS].key_ht);
Kirill Korotaev4e982312006-10-02 02:18:22 -0700133}
Pavel Emelyanovae5e1b22008-02-08 04:18:22 -0800134#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135
Linus Torvalds140d0b22011-08-04 19:35:59 -1000136static int __init ipc_ns_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137{
Guillaume Knispel0cfb6ae2017-09-08 16:17:55 -0700138 const int err = shm_init_ns(&init_ipc_ns);
139 WARN(err, "ipc: sysv shm_init_ns failed: %d\n", err);
140 return err;
Linus Torvalds140d0b22011-08-04 19:35:59 -1000141}
142
143pure_initcall(ipc_ns_init);
144
Manfred Spraul239521f2014-01-27 17:07:04 -0800145void __init shm_init(void)
Linus Torvalds140d0b22011-08-04 19:35:59 -1000146{
Mike Waychison19b49462005-09-06 15:17:10 -0700147 ipc_init_proc_interface("sysvipc/shm",
Helge Dellerb7952182010-10-27 15:34:16 -0700148#if BITS_PER_LONG <= 32
149 " key shmid perms size cpid lpid nattch uid gid cuid cgid atime dtime ctime rss swap\n",
150#else
151 " key shmid perms size cpid lpid nattch uid gid cuid cgid atime dtime ctime rss swap\n",
152#endif
Kirill Korotaev4e982312006-10-02 02:18:22 -0700153 IPC_SHM_IDS, sysvipc_shm_proc_show);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154}
155
Davidlohr Bueso8b8d52a2013-09-11 14:26:15 -0700156static inline struct shmid_kernel *shm_obtain_object(struct ipc_namespace *ns, int id)
157{
Davidlohr Bueso55b7ae52015-06-30 14:58:42 -0700158 struct kern_ipc_perm *ipcp = ipc_obtain_object_idr(&shm_ids(ns), id);
Davidlohr Bueso8b8d52a2013-09-11 14:26:15 -0700159
160 if (IS_ERR(ipcp))
161 return ERR_CAST(ipcp);
162
163 return container_of(ipcp, struct shmid_kernel, shm_perm);
164}
165
166static inline struct shmid_kernel *shm_obtain_object_check(struct ipc_namespace *ns, int id)
167{
168 struct kern_ipc_perm *ipcp = ipc_obtain_object_check(&shm_ids(ns), id);
169
170 if (IS_ERR(ipcp))
171 return ERR_CAST(ipcp);
172
173 return container_of(ipcp, struct shmid_kernel, shm_perm);
174}
175
Nadia Derbey3e148c72007-10-18 23:40:54 -0700176/*
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700177 * shm_lock_(check_) routines are called in the paths where the rwsem
Nadia Derbey00c2bf82008-07-25 01:48:03 -0700178 * is not necessarily held.
Nadia Derbey3e148c72007-10-18 23:40:54 -0700179 */
Nadia Derbey023a5352007-10-18 23:40:51 -0700180static inline struct shmid_kernel *shm_lock(struct ipc_namespace *ns, int id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181{
Nadia Derbey03f02c72007-10-18 23:40:51 -0700182 struct kern_ipc_perm *ipcp = ipc_lock(&shm_ids(ns), id);
183
Davidlohr Buesoc5c89752015-06-30 14:58:36 -0700184 /*
Kirill A. Shutemov1ac0b6d2016-02-17 13:11:35 -0800185 * Callers of shm_lock() must validate the status of the returned ipc
186 * object pointer (as returned by ipc_lock()), and error out as
187 * appropriate.
Davidlohr Buesoc5c89752015-06-30 14:58:36 -0700188 */
Kirill A. Shutemov1ac0b6d2016-02-17 13:11:35 -0800189 if (IS_ERR(ipcp))
190 return (void *)ipcp;
Nadia Derbey03f02c72007-10-18 23:40:51 -0700191 return container_of(ipcp, struct shmid_kernel, shm_perm);
Nadia Derbey023a5352007-10-18 23:40:51 -0700192}
193
Vasiliy Kulikov4c677e22011-07-29 03:56:40 +0400194static inline void shm_lock_by_ptr(struct shmid_kernel *ipcp)
195{
196 rcu_read_lock();
Davidlohr Buesocf9d5d72013-07-08 16:01:11 -0700197 ipc_lock_object(&ipcp->shm_perm);
Vasiliy Kulikov4c677e22011-07-29 03:56:40 +0400198}
199
Davidlohr Bueso53dad6d2013-09-23 17:04:45 -0700200static void shm_rcu_free(struct rcu_head *head)
201{
Manfred Sprauldba4cdd2017-07-12 14:34:41 -0700202 struct kern_ipc_perm *ptr = container_of(head, struct kern_ipc_perm,
203 rcu);
204 struct shmid_kernel *shp = container_of(ptr, struct shmid_kernel,
205 shm_perm);
Eric W. Biederman7191adf2018-03-22 21:08:27 -0500206 security_shm_free(&shp->shm_perm);
Kees Cook42e618f2017-07-12 14:35:25 -0700207 kvfree(shp);
Davidlohr Bueso53dad6d2013-09-23 17:04:45 -0700208}
209
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700210static inline void shm_rmid(struct ipc_namespace *ns, struct shmid_kernel *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211{
Jack Millerab602f72014-08-08 14:23:19 -0700212 list_del(&s->shm_clist);
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700213 ipc_rmid(&shm_ids(ns), &s->shm_perm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214}
215
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
Kirill A. Shutemov1ac0b6d2016-02-17 13:11:35 -0800217static int __shm_open(struct vm_area_struct *vma)
Kirill Korotaev4e982312006-10-02 02:18:22 -0700218{
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800219 struct file *file = vma->vm_file;
220 struct shm_file_data *sfd = shm_file_data(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 struct shmid_kernel *shp;
222
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800223 shp = shm_lock(sfd->ns, sfd->id);
Kirill A. Shutemov1ac0b6d2016-02-17 13:11:35 -0800224
225 if (IS_ERR(shp))
226 return PTR_ERR(shp);
227
Deepa Dinamani7ff28192017-08-02 19:51:14 -0700228 shp->shm_atim = ktime_get_real_seconds();
Eric W. Biederman98f929b12018-03-23 00:29:57 -0500229 ipc_update_pid(&shp->shm_lprid, task_tgid(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 shp->shm_nattch++;
231 shm_unlock(shp);
Kirill A. Shutemov1ac0b6d2016-02-17 13:11:35 -0800232 return 0;
233}
234
235/* This is called by fork, once for every shm attach. */
236static void shm_open(struct vm_area_struct *vma)
237{
238 int err = __shm_open(vma);
239 /*
240 * We raced in the idr lookup or with shm_destroy().
241 * Either way, the ID is busted.
242 */
243 WARN_ON_ONCE(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244}
245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246/*
247 * shm_destroy - free the struct shmid_kernel
248 *
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700249 * @ns: namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 * @shp: struct to free
251 *
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700252 * It has to be called with shp and shm_ids.rwsem (writer) locked,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 * but returns with shp unlocked and freed.
254 */
Kirill Korotaev4e982312006-10-02 02:18:22 -0700255static void shm_destroy(struct ipc_namespace *ns, struct shmid_kernel *shp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256{
Greg Thelena399b292013-11-21 14:32:00 -0800257 struct file *shm_file;
258
259 shm_file = shp->shm_file;
260 shp->shm_file = NULL;
Kirill Korotaev4e982312006-10-02 02:18:22 -0700261 ns->shm_tot -= (shp->shm_segsz + PAGE_SIZE - 1) >> PAGE_SHIFT;
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700262 shm_rmid(ns, shp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 shm_unlock(shp);
Greg Thelena399b292013-11-21 14:32:00 -0800264 if (!is_file_hugepages(shm_file))
265 shmem_lock(shm_file, 0, shp->mlock_user);
Hugh Dickins353d5c32009-08-24 16:30:28 +0100266 else if (shp->mlock_user)
Dave Hansen07a46ed2014-12-12 16:58:22 -0800267 user_shm_unlock(i_size_read(file_inode(shm_file)),
268 shp->mlock_user);
Greg Thelena399b292013-11-21 14:32:00 -0800269 fput(shm_file);
Eric W. Biederman98f929b12018-03-23 00:29:57 -0500270 ipc_update_pid(&shp->shm_cprid, NULL);
271 ipc_update_pid(&shp->shm_lprid, NULL);
Manfred Sprauldba4cdd2017-07-12 14:34:41 -0700272 ipc_rcu_putref(&shp->shm_perm, shm_rcu_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273}
274
275/*
Vasiliy Kulikovb34a6b12011-07-26 16:08:48 -0700276 * shm_may_destroy - identifies whether shm segment should be destroyed now
277 *
278 * Returns true if and only if there are no active users of the segment and
279 * one of the following is true:
280 *
281 * 1) shmctl(id, IPC_RMID, NULL) was called for this shp
282 *
283 * 2) sysctl kernel.shm_rmid_forced is set to 1.
284 */
285static bool shm_may_destroy(struct ipc_namespace *ns, struct shmid_kernel *shp)
286{
287 return (shp->shm_nattch == 0) &&
288 (ns->shm_rmid_forced ||
289 (shp->shm_perm.mode & SHM_DEST));
290}
291
292/*
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800293 * remove the attach descriptor vma.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 * free memory for segment if it is marked destroyed.
295 * The descriptor has already been removed from the current->mm->mmap list
296 * and will later be kfree()d.
297 */
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800298static void shm_close(struct vm_area_struct *vma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299{
Manfred Spraul239521f2014-01-27 17:07:04 -0800300 struct file *file = vma->vm_file;
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800301 struct shm_file_data *sfd = shm_file_data(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 struct shmid_kernel *shp;
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800303 struct ipc_namespace *ns = sfd->ns;
Kirill Korotaev4e982312006-10-02 02:18:22 -0700304
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700305 down_write(&shm_ids(ns).rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 /* remove from the list of attaches of the shm segment */
Nadia Derbey00c2bf82008-07-25 01:48:03 -0700307 shp = shm_lock(ns, sfd->id);
Kirill A. Shutemov1ac0b6d2016-02-17 13:11:35 -0800308
309 /*
310 * We raced in the idr lookup or with shm_destroy().
311 * Either way, the ID is busted.
312 */
313 if (WARN_ON_ONCE(IS_ERR(shp)))
314 goto done; /* no-op */
315
Eric W. Biederman98f929b12018-03-23 00:29:57 -0500316 ipc_update_pid(&shp->shm_lprid, task_tgid(current));
Deepa Dinamani7ff28192017-08-02 19:51:14 -0700317 shp->shm_dtim = ktime_get_real_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 shp->shm_nattch--;
Vasiliy Kulikovb34a6b12011-07-26 16:08:48 -0700319 if (shm_may_destroy(ns, shp))
Kirill Korotaev4e982312006-10-02 02:18:22 -0700320 shm_destroy(ns, shp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 else
322 shm_unlock(shp);
Kirill A. Shutemov1ac0b6d2016-02-17 13:11:35 -0800323done:
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700324 up_write(&shm_ids(ns).rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325}
326
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700327/* Called with ns->shm_ids(ns).rwsem locked */
Vasiliy Kulikovb34a6b12011-07-26 16:08:48 -0700328static int shm_try_destroy_orphaned(int id, void *p, void *data)
329{
330 struct ipc_namespace *ns = data;
Vasiliy Kulikov4c677e22011-07-29 03:56:40 +0400331 struct kern_ipc_perm *ipcp = p;
332 struct shmid_kernel *shp = container_of(ipcp, struct shmid_kernel, shm_perm);
Vasiliy Kulikovb34a6b12011-07-26 16:08:48 -0700333
334 /*
335 * We want to destroy segments without users and with already
336 * exit'ed originating process.
Vasiliy Kulikov4c677e22011-07-29 03:56:40 +0400337 *
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700338 * As shp->* are changed under rwsem, it's safe to skip shp locking.
Vasiliy Kulikovb34a6b12011-07-26 16:08:48 -0700339 */
Vasiliy Kulikov4c677e22011-07-29 03:56:40 +0400340 if (shp->shm_creator != NULL)
Vasiliy Kulikovb34a6b12011-07-26 16:08:48 -0700341 return 0;
Vasiliy Kulikovb34a6b12011-07-26 16:08:48 -0700342
Vasiliy Kulikov4c677e22011-07-29 03:56:40 +0400343 if (shm_may_destroy(ns, shp)) {
344 shm_lock_by_ptr(shp);
Vasiliy Kulikovb34a6b12011-07-26 16:08:48 -0700345 shm_destroy(ns, shp);
Vasiliy Kulikov4c677e22011-07-29 03:56:40 +0400346 }
Vasiliy Kulikovb34a6b12011-07-26 16:08:48 -0700347 return 0;
348}
349
350void shm_destroy_orphaned(struct ipc_namespace *ns)
351{
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700352 down_write(&shm_ids(ns).rwsem);
Vasiliy Kulikov33a30ed2011-08-03 22:26:55 +0400353 if (shm_ids(ns).in_use)
Vasiliy Kulikov4c677e22011-07-29 03:56:40 +0400354 idr_for_each(&shm_ids(ns).ipcs_idr, &shm_try_destroy_orphaned, ns);
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700355 up_write(&shm_ids(ns).rwsem);
Vasiliy Kulikovb34a6b12011-07-26 16:08:48 -0700356}
357
Jack Miller83293c0f52014-08-08 14:23:21 -0700358/* Locking assumes this will only be called with task == current */
Vasiliy Kulikovb34a6b12011-07-26 16:08:48 -0700359void exit_shm(struct task_struct *task)
360{
Vasiliy Kulikov4c677e22011-07-29 03:56:40 +0400361 struct ipc_namespace *ns = task->nsproxy->ipc_ns;
Jack Millerab602f72014-08-08 14:23:19 -0700362 struct shmid_kernel *shp, *n;
Vasiliy Kulikovb34a6b12011-07-26 16:08:48 -0700363
Jack Miller83293c0f52014-08-08 14:23:21 -0700364 if (list_empty(&task->sysvshm.shm_clist))
Vasiliy Kulikov298507d2011-08-03 22:28:26 +0400365 return;
366
Jack Miller83293c0f52014-08-08 14:23:21 -0700367 /*
368 * If kernel.shm_rmid_forced is not set then only keep track of
369 * which shmids are orphaned, so that a later set of the sysctl
370 * can clean them up.
371 */
372 if (!ns->shm_rmid_forced) {
373 down_read(&shm_ids(ns).rwsem);
374 list_for_each_entry(shp, &task->sysvshm.shm_clist, shm_clist)
375 shp->shm_creator = NULL;
376 /*
377 * Only under read lock but we are only called on current
378 * so no entry on the list will be shared.
379 */
380 list_del(&task->sysvshm.shm_clist);
381 up_read(&shm_ids(ns).rwsem);
382 return;
383 }
384
385 /*
386 * Destroy all already created segments, that were not yet mapped,
387 * and mark any mapped as orphan to cover the sysctl toggling.
388 * Destroy is skipped if shm_may_destroy() returns false.
389 */
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700390 down_write(&shm_ids(ns).rwsem);
Jack Miller83293c0f52014-08-08 14:23:21 -0700391 list_for_each_entry_safe(shp, n, &task->sysvshm.shm_clist, shm_clist) {
392 shp->shm_creator = NULL;
393
394 if (shm_may_destroy(ns, shp)) {
395 shm_lock_by_ptr(shp);
396 shm_destroy(ns, shp);
397 }
398 }
399
400 /* Remove the list head from any segments still attached. */
Jack Millerab602f72014-08-08 14:23:19 -0700401 list_del(&task->sysvshm.shm_clist);
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700402 up_write(&shm_ids(ns).rwsem);
Vasiliy Kulikovb34a6b12011-07-26 16:08:48 -0700403}
404
Dave Jiang11bac802017-02-24 14:56:41 -0800405static int shm_fault(struct vm_fault *vmf)
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800406{
Dave Jiang11bac802017-02-24 14:56:41 -0800407 struct file *file = vmf->vma->vm_file;
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800408 struct shm_file_data *sfd = shm_file_data(file);
409
Dave Jiang11bac802017-02-24 14:56:41 -0800410 return sfd->vm_ops->fault(vmf);
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800411}
412
413#ifdef CONFIG_NUMA
Adrian Bunkd823e3e2007-10-16 23:26:42 -0700414static int shm_set_policy(struct vm_area_struct *vma, struct mempolicy *new)
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800415{
416 struct file *file = vma->vm_file;
417 struct shm_file_data *sfd = shm_file_data(file);
418 int err = 0;
Shailesh Pandey63980c82016-12-14 15:06:10 -0800419
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800420 if (sfd->vm_ops->set_policy)
421 err = sfd->vm_ops->set_policy(vma, new);
422 return err;
423}
424
Adrian Bunkd823e3e2007-10-16 23:26:42 -0700425static struct mempolicy *shm_get_policy(struct vm_area_struct *vma,
426 unsigned long addr)
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800427{
428 struct file *file = vma->vm_file;
429 struct shm_file_data *sfd = shm_file_data(file);
430 struct mempolicy *pol = NULL;
431
432 if (sfd->vm_ops->get_policy)
433 pol = sfd->vm_ops->get_policy(vma, addr);
Lee Schermerhorn52cd3b02008-04-28 02:13:16 -0700434 else if (vma->vm_policy)
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800435 pol = vma->vm_policy;
Lee Schermerhorn52cd3b02008-04-28 02:13:16 -0700436
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800437 return pol;
438}
439#endif
440
Manfred Spraul239521f2014-01-27 17:07:04 -0800441static int shm_mmap(struct file *file, struct vm_area_struct *vma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442{
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800443 struct shm_file_data *sfd = shm_file_data(file);
David Howellsb0e15192006-01-06 00:11:42 -0800444 int ret;
445
Kirill A. Shutemov1ac0b6d2016-02-17 13:11:35 -0800446 /*
447 * In case of remap_file_pages() emulation, the file can represent
448 * removed IPC ID: propogate shm_lock() error to caller.
449 */
Shailesh Pandey63980c82016-12-14 15:06:10 -0800450 ret = __shm_open(vma);
Kirill A. Shutemov1ac0b6d2016-02-17 13:11:35 -0800451 if (ret)
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800452 return ret;
Kirill A. Shutemov1ac0b6d2016-02-17 13:11:35 -0800453
Miklos Szeredif74ac012017-02-20 16:51:23 +0100454 ret = call_mmap(sfd->file, vma);
Kirill A. Shutemov1ac0b6d2016-02-17 13:11:35 -0800455 if (ret) {
456 shm_close(vma);
457 return ret;
458 }
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800459 sfd->vm_ops = vma->vm_ops;
David Howells2e92a3b2007-07-31 00:37:24 -0700460#ifdef CONFIG_MMU
Davidlohr Buesod0edd852015-09-09 15:39:20 -0700461 WARN_ON(!sfd->vm_ops->fault);
David Howells2e92a3b2007-07-31 00:37:24 -0700462#endif
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800463 vma->vm_ops = &shm_vm_ops;
Kirill A. Shutemov1ac0b6d2016-02-17 13:11:35 -0800464 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465}
466
Kirill Korotaev4e982312006-10-02 02:18:22 -0700467static int shm_release(struct inode *ino, struct file *file)
468{
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800469 struct shm_file_data *sfd = shm_file_data(file);
Kirill Korotaev4e982312006-10-02 02:18:22 -0700470
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800471 put_ipc_ns(sfd->ns);
472 shm_file_data(file) = NULL;
473 kfree(sfd);
Kirill Korotaev4e982312006-10-02 02:18:22 -0700474 return 0;
475}
476
Josef Bacik02c24a82011-07-16 20:44:56 -0400477static int shm_fsync(struct file *file, loff_t start, loff_t end, int datasync)
Adam Litke516dffd2007-03-01 15:46:08 -0800478{
Adam Litke516dffd2007-03-01 15:46:08 -0800479 struct shm_file_data *sfd = shm_file_data(file);
Adam Litke516dffd2007-03-01 15:46:08 -0800480
Christoph Hellwig7ea80852010-05-26 17:53:25 +0200481 if (!sfd->file->f_op->fsync)
482 return -EINVAL;
Jeff Layton0f410742017-07-05 15:26:50 -0400483 return sfd->file->f_op->fsync(sfd->file, start, end, datasync);
Adam Litke516dffd2007-03-01 15:46:08 -0800484}
485
Will Deacon7d8a4562012-06-07 14:21:13 -0700486static long shm_fallocate(struct file *file, int mode, loff_t offset,
487 loff_t len)
488{
489 struct shm_file_data *sfd = shm_file_data(file);
490
491 if (!sfd->file->f_op->fallocate)
492 return -EOPNOTSUPP;
493 return sfd->file->f_op->fallocate(file, mode, offset, len);
494}
495
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800496static unsigned long shm_get_unmapped_area(struct file *file,
497 unsigned long addr, unsigned long len, unsigned long pgoff,
498 unsigned long flags)
499{
500 struct shm_file_data *sfd = shm_file_data(file);
Shailesh Pandey63980c82016-12-14 15:06:10 -0800501
Al Viroc4caa772009-11-30 08:38:43 -0500502 return sfd->file->f_op->get_unmapped_area(sfd->file, addr, len,
503 pgoff, flags);
Adam Litke516dffd2007-03-01 15:46:08 -0800504}
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800505
Arjan van de Ven9a321442007-02-12 00:55:35 -0800506static const struct file_operations shm_file_operations = {
Kirill Korotaev4e982312006-10-02 02:18:22 -0700507 .mmap = shm_mmap,
Adam Litke516dffd2007-03-01 15:46:08 -0800508 .fsync = shm_fsync,
Kirill Korotaev4e982312006-10-02 02:18:22 -0700509 .release = shm_release,
David Howellsed5e5892010-01-15 17:01:32 -0800510 .get_unmapped_area = shm_get_unmapped_area,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200511 .llseek = noop_llseek,
Will Deacon7d8a4562012-06-07 14:21:13 -0700512 .fallocate = shm_fallocate,
Al Viroc4caa772009-11-30 08:38:43 -0500513};
514
Hugh Dickinsc01d5b32016-07-26 15:26:15 -0700515/*
516 * shm_file_operations_huge is now identical to shm_file_operations,
517 * but we keep it distinct for the sake of is_file_shm_hugepages().
518 */
Al Viroc4caa772009-11-30 08:38:43 -0500519static const struct file_operations shm_file_operations_huge = {
520 .mmap = shm_mmap,
521 .fsync = shm_fsync,
522 .release = shm_release,
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800523 .get_unmapped_area = shm_get_unmapped_area,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200524 .llseek = noop_llseek,
Will Deacon7d8a4562012-06-07 14:21:13 -0700525 .fallocate = shm_fallocate,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526};
527
Yaowei Bai2954e4402016-01-20 15:01:11 -0800528bool is_file_shm_hugepages(struct file *file)
Al Viroc4caa772009-11-30 08:38:43 -0500529{
530 return file->f_op == &shm_file_operations_huge;
531}
532
Alexey Dobriyanf0f37e2f2009-09-27 22:29:37 +0400533static const struct vm_operations_struct shm_vm_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 .open = shm_open, /* callback for a new vm-area open */
535 .close = shm_close, /* callback for when the vm-area is released */
Nick Piggin54cb8822007-07-19 01:46:59 -0700536 .fault = shm_fault,
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -0800537#if defined(CONFIG_NUMA)
538 .set_policy = shm_set_policy,
539 .get_policy = shm_get_policy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540#endif
541};
542
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700543/**
544 * newseg - Create a new shared memory segment
545 * @ns: namespace
546 * @params: ptr to the structure that contains key, size and shmflg
547 *
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700548 * Called with shm_ids.rwsem held as a writer.
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700549 */
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700550static int newseg(struct ipc_namespace *ns, struct ipc_params *params)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551{
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700552 key_t key = params->key;
553 int shmflg = params->flg;
554 size_t size = params->u.size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 int error;
556 struct shmid_kernel *shp;
Robin Holtd69f3ba2013-04-30 19:15:54 -0700557 size_t numpages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
Manfred Spraul239521f2014-01-27 17:07:04 -0800558 struct file *file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 char name[13];
KOSAKI Motohiroca16d142011-05-26 19:16:19 +0900560 vm_flags_t acctflag = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
Kirill Korotaev4e982312006-10-02 02:18:22 -0700562 if (size < SHMMIN || size > ns->shm_ctlmax)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 return -EINVAL;
564
Manfred Spraul13763272014-06-06 14:37:41 -0700565 if (numpages << PAGE_SHIFT < size)
566 return -ENOSPC;
567
Manfred Spraul09c6eb12014-06-06 14:37:40 -0700568 if (ns->shm_tot + numpages < ns->shm_tot ||
569 ns->shm_tot + numpages > ns->shm_ctlall)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 return -ENOSPC;
571
Kees Cook42e618f2017-07-12 14:35:25 -0700572 shp = kvmalloc(sizeof(*shp), GFP_KERNEL);
573 if (unlikely(!shp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 return -ENOMEM;
575
576 shp->shm_perm.key = key;
Andrew Mortonb33291c2006-01-08 01:02:21 -0800577 shp->shm_perm.mode = (shmflg & S_IRWXUGO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 shp->mlock_user = NULL;
579
580 shp->shm_perm.security = NULL;
Eric W. Biederman7191adf2018-03-22 21:08:27 -0500581 error = security_shm_alloc(&shp->shm_perm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 if (error) {
Kees Cook42e618f2017-07-12 14:35:25 -0700583 kvfree(shp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 return error;
585 }
586
Manfred Spraul239521f2014-01-27 17:07:04 -0800587 sprintf(name, "SYSV%08x", key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 if (shmflg & SHM_HUGETLB) {
Andrew Mortonc103a4d2013-07-08 16:01:08 -0700589 struct hstate *hs;
Li Zefan091d0d52013-05-09 15:08:15 +0800590 size_t hugesize;
591
Andrew Mortonc103a4d2013-07-08 16:01:08 -0700592 hs = hstate_sizelog((shmflg >> SHM_HUGE_SHIFT) & SHM_HUGE_MASK);
Li Zefan091d0d52013-05-09 15:08:15 +0800593 if (!hs) {
594 error = -EINVAL;
595 goto no_file;
596 }
597 hugesize = ALIGN(size, huge_page_size(hs));
Naoya Horiguchiaf73e4d2013-05-07 16:18:13 -0700598
Mel Gorman5a6fe122009-02-10 14:02:27 +0000599 /* hugetlb_file_setup applies strict accounting */
600 if (shmflg & SHM_NORESERVE)
601 acctflag = VM_NORESERVE;
Naoya Horiguchiaf73e4d2013-05-07 16:18:13 -0700602 file = hugetlb_file_setup(name, hugesize, acctflag,
Andi Kleen42d73952012-12-11 16:01:34 -0800603 &shp->mlock_user, HUGETLB_SHMFS_INODE,
604 (shmflg >> SHM_HUGE_SHIFT) & SHM_HUGE_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 } else {
Badari Pulavartybf8f9722005-11-07 00:59:27 -0800606 /*
607 * Do not allow no accounting for OVERCOMMIT_NEVER, even
Manfred Spraul239521f2014-01-27 17:07:04 -0800608 * if it's asked for.
Badari Pulavartybf8f9722005-11-07 00:59:27 -0800609 */
610 if ((shmflg & SHM_NORESERVE) &&
611 sysctl_overcommit_memory != OVERCOMMIT_NEVER)
Linus Torvaldsfc8744a2009-01-31 15:08:56 -0800612 acctflag = VM_NORESERVE;
Stephen Smalleye1832f22015-08-06 15:46:55 -0700613 file = shmem_kernel_file_setup(name, size, acctflag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 }
615 error = PTR_ERR(file);
616 if (IS_ERR(file))
617 goto no_file;
618
Eric W. Biederman98f929b12018-03-23 00:29:57 -0500619 shp->shm_cprid = get_pid(task_tgid(current));
620 shp->shm_lprid = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 shp->shm_atim = shp->shm_dtim = 0;
Deepa Dinamani7ff28192017-08-02 19:51:14 -0700622 shp->shm_ctim = ktime_get_real_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 shp->shm_segsz = size;
624 shp->shm_nattch = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 shp->shm_file = file;
Vasiliy Kulikov5774ed02011-07-29 03:55:31 +0400626 shp->shm_creator = current;
Linus Torvaldsb9a53222015-09-30 12:48:40 -0400627
Davidlohr Bueso39c96a12017-11-17 15:31:11 -0800628 /* ipc_addid() locks shp upon success. */
Manfred Spraula2642f82017-07-12 14:35:16 -0700629 error = ipc_addid(&shm_ids(ns), &shp->shm_perm, ns->shm_ctlmni);
630 if (error < 0)
Linus Torvaldsb9a53222015-09-30 12:48:40 -0400631 goto no_id;
Linus Torvaldsb9a53222015-09-30 12:48:40 -0400632
Jack Millerab602f72014-08-08 14:23:19 -0700633 list_add(&shp->shm_clist, &current->sysvshm.shm_clist);
Davidlohr Buesodbfcd912013-07-08 16:01:09 -0700634
Badari Pulavarty30475cc2007-06-16 10:15:59 -0700635 /*
636 * shmid gets reported as "inode#" in /proc/pid/maps.
637 * proc-ps tools use this. Changing this will break them.
638 */
Al Viro496ad9a2013-01-23 17:07:38 -0500639 file_inode(file)->i_ino = shp->shm_perm.id;
Krishnakumar R551110a2005-10-29 18:16:45 -0700640
Kirill Korotaev4e982312006-10-02 02:18:22 -0700641 ns->shm_tot += numpages;
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700642 error = shp->shm_perm.id;
Davidlohr Buesodbfcd912013-07-08 16:01:09 -0700643
Davidlohr Buesocf9d5d72013-07-08 16:01:11 -0700644 ipc_unlock_object(&shp->shm_perm);
Davidlohr Buesodbfcd912013-07-08 16:01:09 -0700645 rcu_read_unlock();
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700646 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647
648no_id:
Hugh Dickins2195d2812009-09-12 12:21:27 +0100649 if (is_file_hugepages(file) && shp->mlock_user)
Hugh Dickins353d5c32009-08-24 16:30:28 +0100650 user_shm_unlock(size, shp->mlock_user);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 fput(file);
652no_file:
Eric W. Biederman98f929b12018-03-23 00:29:57 -0500653 ipc_update_pid(&shp->shm_cprid, NULL);
654 ipc_update_pid(&shp->shm_lprid, NULL);
Manfred Spraula2642f82017-07-12 14:35:16 -0700655 call_rcu(&shp->shm_perm.rcu, shm_rcu_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 return error;
657}
658
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700659/*
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700660 * Called with shm_ids.rwsem and ipcp locked.
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700661 */
Nadia Derbey03f02c72007-10-18 23:40:51 -0700662static inline int shm_security(struct kern_ipc_perm *ipcp, int shmflg)
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700663{
Eric W. Biederman7191adf2018-03-22 21:08:27 -0500664 return security_shm_associate(ipcp, shmflg);
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700665}
666
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700667/*
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700668 * Called with shm_ids.rwsem and ipcp locked.
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700669 */
Nadia Derbey03f02c72007-10-18 23:40:51 -0700670static inline int shm_more_checks(struct kern_ipc_perm *ipcp,
671 struct ipc_params *params)
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700672{
Nadia Derbey03f02c72007-10-18 23:40:51 -0700673 struct shmid_kernel *shp;
674
675 shp = container_of(ipcp, struct shmid_kernel, shm_perm);
676 if (shp->shm_segsz < params->u.size)
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700677 return -EINVAL;
678
679 return 0;
680}
681
Heiko Carstensd5460c92009-01-14 14:14:27 +0100682SYSCALL_DEFINE3(shmget, key_t, key, size_t, size, int, shmflg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683{
Kirill Korotaev4e982312006-10-02 02:18:22 -0700684 struct ipc_namespace *ns;
Mathias Krauseeb66ec42014-06-06 14:37:36 -0700685 static const struct ipc_ops shm_ops = {
686 .getnew = newseg,
687 .associate = shm_security,
688 .more_checks = shm_more_checks,
689 };
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700690 struct ipc_params shm_params;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
Kirill Korotaev4e982312006-10-02 02:18:22 -0700692 ns = current->nsproxy->ipc_ns;
693
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700694 shm_params.key = key;
695 shm_params.flg = shmflg;
696 shm_params.u.size = size;
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700697
Nadia Derbey7748dbf2007-10-18 23:40:49 -0700698 return ipcget(ns, &shm_ids(ns), &shm_ops, &shm_params);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699}
700
701static inline unsigned long copy_shmid_to_user(void __user *buf, struct shmid64_ds *in, int version)
702{
Manfred Spraul239521f2014-01-27 17:07:04 -0800703 switch (version) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 case IPC_64:
705 return copy_to_user(buf, in, sizeof(*in));
706 case IPC_OLD:
707 {
708 struct shmid_ds out;
709
Vasiliy Kulikov3af54c92010-10-30 18:22:49 +0400710 memset(&out, 0, sizeof(out));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 ipc64_perm_to_ipc_perm(&in->shm_perm, &out.shm_perm);
712 out.shm_segsz = in->shm_segsz;
713 out.shm_atime = in->shm_atime;
714 out.shm_dtime = in->shm_dtime;
715 out.shm_ctime = in->shm_ctime;
716 out.shm_cpid = in->shm_cpid;
717 out.shm_lpid = in->shm_lpid;
718 out.shm_nattch = in->shm_nattch;
719
720 return copy_to_user(buf, &out, sizeof(out));
721 }
722 default:
723 return -EINVAL;
724 }
725}
726
Pierre Peiffer016d7132008-04-29 01:00:50 -0700727static inline unsigned long
728copy_shmid_from_user(struct shmid64_ds *out, void __user *buf, int version)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729{
Manfred Spraul239521f2014-01-27 17:07:04 -0800730 switch (version) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 case IPC_64:
Pierre Peiffer016d7132008-04-29 01:00:50 -0700732 if (copy_from_user(out, buf, sizeof(*out)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 case IPC_OLD:
736 {
737 struct shmid_ds tbuf_old;
738
739 if (copy_from_user(&tbuf_old, buf, sizeof(tbuf_old)))
740 return -EFAULT;
741
Pierre Peiffer016d7132008-04-29 01:00:50 -0700742 out->shm_perm.uid = tbuf_old.shm_perm.uid;
743 out->shm_perm.gid = tbuf_old.shm_perm.gid;
744 out->shm_perm.mode = tbuf_old.shm_perm.mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745
746 return 0;
747 }
748 default:
749 return -EINVAL;
750 }
751}
752
753static inline unsigned long copy_shminfo_to_user(void __user *buf, struct shminfo64 *in, int version)
754{
Manfred Spraul239521f2014-01-27 17:07:04 -0800755 switch (version) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 case IPC_64:
757 return copy_to_user(buf, in, sizeof(*in));
758 case IPC_OLD:
759 {
760 struct shminfo out;
761
Manfred Spraul239521f2014-01-27 17:07:04 -0800762 if (in->shmmax > INT_MAX)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 out.shmmax = INT_MAX;
764 else
765 out.shmmax = (int)in->shmmax;
766
767 out.shmmin = in->shmmin;
768 out.shmmni = in->shmmni;
769 out.shmseg = in->shmseg;
Paul McQuade46c0a8c2014-06-06 14:37:37 -0700770 out.shmall = in->shmall;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771
772 return copy_to_user(buf, &out, sizeof(out));
773 }
774 default:
775 return -EINVAL;
776 }
777}
778
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700779/*
Helge Dellerb7952182010-10-27 15:34:16 -0700780 * Calculate and add used RSS and swap pages of a shm.
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700781 * Called with shm_ids.rwsem held as a reader
Helge Dellerb7952182010-10-27 15:34:16 -0700782 */
783static void shm_add_rss_swap(struct shmid_kernel *shp,
784 unsigned long *rss_add, unsigned long *swp_add)
785{
786 struct inode *inode;
787
Al Viro496ad9a2013-01-23 17:07:38 -0500788 inode = file_inode(shp->shm_file);
Helge Dellerb7952182010-10-27 15:34:16 -0700789
790 if (is_file_hugepages(shp->shm_file)) {
791 struct address_space *mapping = inode->i_mapping;
792 struct hstate *h = hstate_file(shp->shm_file);
793 *rss_add += pages_per_huge_page(h) * mapping->nrpages;
794 } else {
795#ifdef CONFIG_SHMEM
796 struct shmem_inode_info *info = SHMEM_I(inode);
Shailesh Pandey63980c82016-12-14 15:06:10 -0800797
Kirill A. Shutemov4595ef82016-07-26 15:26:29 -0700798 spin_lock_irq(&info->lock);
Helge Dellerb7952182010-10-27 15:34:16 -0700799 *rss_add += inode->i_mapping->nrpages;
800 *swp_add += info->swapped;
Kirill A. Shutemov4595ef82016-07-26 15:26:29 -0700801 spin_unlock_irq(&info->lock);
Helge Dellerb7952182010-10-27 15:34:16 -0700802#else
803 *rss_add += inode->i_mapping->nrpages;
804#endif
805 }
806}
807
808/*
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700809 * Called with shm_ids.rwsem held as a reader
Nadia Derbeyf4566f02007-10-18 23:40:53 -0700810 */
Kirill Korotaev4e982312006-10-02 02:18:22 -0700811static void shm_get_stat(struct ipc_namespace *ns, unsigned long *rss,
812 unsigned long *swp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813{
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700814 int next_id;
815 int total, in_use;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
817 *rss = 0;
818 *swp = 0;
819
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700820 in_use = shm_ids(ns).in_use;
821
822 for (total = 0, next_id = 0; total < in_use; next_id++) {
Tony Battersbye562aeb2009-04-02 16:58:26 -0700823 struct kern_ipc_perm *ipc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 struct shmid_kernel *shp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
Tony Battersbye562aeb2009-04-02 16:58:26 -0700826 ipc = idr_find(&shm_ids(ns).ipcs_idr, next_id);
827 if (ipc == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 continue;
Tony Battersbye562aeb2009-04-02 16:58:26 -0700829 shp = container_of(ipc, struct shmid_kernel, shm_perm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
Helge Dellerb7952182010-10-27 15:34:16 -0700831 shm_add_rss_swap(shp, rss, swp);
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700832
833 total++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 }
835}
836
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -0700837/*
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700838 * This function handles some shmctl commands which require the rwsem
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -0700839 * to be held in write mode.
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700840 * NOTE: no locks must be held, the rwsem is taken inside this function.
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -0700841 */
842static int shmctl_down(struct ipc_namespace *ns, int shmid, int cmd,
Al Viro9ba720c2017-07-08 20:58:06 -0400843 struct shmid64_ds *shmid64)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844{
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -0700845 struct kern_ipc_perm *ipcp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 struct shmid_kernel *shp;
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -0700847 int err;
848
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700849 down_write(&shm_ids(ns).rwsem);
Davidlohr Bueso7b4cc5d2013-07-08 16:01:12 -0700850 rcu_read_lock();
851
Davidlohr Bueso79ccf0f2013-09-11 14:26:16 -0700852 ipcp = ipcctl_pre_down_nolock(ns, &shm_ids(ns), shmid, cmd,
Al Viro9ba720c2017-07-08 20:58:06 -0400853 &shmid64->shm_perm, 0);
Davidlohr Bueso7b4cc5d2013-07-08 16:01:12 -0700854 if (IS_ERR(ipcp)) {
855 err = PTR_ERR(ipcp);
Davidlohr Bueso7b4cc5d2013-07-08 16:01:12 -0700856 goto out_unlock1;
857 }
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -0700858
Pierre Peiffera5f75e72008-04-29 01:00:54 -0700859 shp = container_of(ipcp, struct shmid_kernel, shm_perm);
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -0700860
Eric W. Biederman7191adf2018-03-22 21:08:27 -0500861 err = security_shm_shmctl(&shp->shm_perm, cmd);
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -0700862 if (err)
Davidlohr Bueso79ccf0f2013-09-11 14:26:16 -0700863 goto out_unlock1;
Davidlohr Bueso7b4cc5d2013-07-08 16:01:12 -0700864
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -0700865 switch (cmd) {
866 case IPC_RMID:
Davidlohr Bueso79ccf0f2013-09-11 14:26:16 -0700867 ipc_lock_object(&shp->shm_perm);
Davidlohr Bueso7b4cc5d2013-07-08 16:01:12 -0700868 /* do_shm_rmid unlocks the ipc object and rcu */
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -0700869 do_shm_rmid(ns, ipcp);
870 goto out_up;
871 case IPC_SET:
Davidlohr Bueso79ccf0f2013-09-11 14:26:16 -0700872 ipc_lock_object(&shp->shm_perm);
Al Viro9ba720c2017-07-08 20:58:06 -0400873 err = ipc_update_perm(&shmid64->shm_perm, ipcp);
Eric W. Biederman1efdb692012-02-07 16:54:11 -0800874 if (err)
Davidlohr Bueso7b4cc5d2013-07-08 16:01:12 -0700875 goto out_unlock0;
Deepa Dinamani7ff28192017-08-02 19:51:14 -0700876 shp->shm_ctim = ktime_get_real_seconds();
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -0700877 break;
878 default:
879 err = -EINVAL;
Davidlohr Bueso79ccf0f2013-09-11 14:26:16 -0700880 goto out_unlock1;
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -0700881 }
Davidlohr Bueso7b4cc5d2013-07-08 16:01:12 -0700882
883out_unlock0:
884 ipc_unlock_object(&shp->shm_perm);
885out_unlock1:
886 rcu_read_unlock();
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -0700887out_up:
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700888 up_write(&shm_ids(ns).rwsem);
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -0700889 return err;
890}
891
Al Viro9ba720c2017-07-08 20:58:06 -0400892static int shmctl_ipc_info(struct ipc_namespace *ns,
893 struct shminfo64 *shminfo)
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -0700894{
Al Viro9ba720c2017-07-08 20:58:06 -0400895 int err = security_shm_shmctl(NULL, IPC_INFO);
896 if (!err) {
897 memset(shminfo, 0, sizeof(*shminfo));
898 shminfo->shmmni = shminfo->shmseg = ns->shm_ctlmni;
899 shminfo->shmmax = ns->shm_ctlmax;
900 shminfo->shmall = ns->shm_ctlall;
901 shminfo->shmmin = SHMMIN;
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700902 down_read(&shm_ids(ns).rwsem);
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700903 err = ipc_get_maxid(&shm_ids(ns));
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700904 up_read(&shm_ids(ns).rwsem);
Manfred Spraul239521f2014-01-27 17:07:04 -0800905 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 }
Al Viro9ba720c2017-07-08 20:58:06 -0400908 return err;
909}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910
Al Viro9ba720c2017-07-08 20:58:06 -0400911static int shmctl_shm_info(struct ipc_namespace *ns,
912 struct shm_info *shm_info)
913{
914 int err = security_shm_shmctl(NULL, SHM_INFO);
915 if (!err) {
916 memset(shm_info, 0, sizeof(*shm_info));
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700917 down_read(&shm_ids(ns).rwsem);
Al Viro9ba720c2017-07-08 20:58:06 -0400918 shm_info->used_ids = shm_ids(ns).in_use;
919 shm_get_stat(ns, &shm_info->shm_rss, &shm_info->shm_swp);
920 shm_info->shm_tot = ns->shm_tot;
921 shm_info->swap_attempts = 0;
922 shm_info->swap_successes = 0;
Nadia Derbey7ca7e562007-10-18 23:40:48 -0700923 err = ipc_get_maxid(&shm_ids(ns));
Davidlohr Buesod9a605e2013-09-11 14:26:24 -0700924 up_read(&shm_ids(ns).rwsem);
Al Viro9ba720c2017-07-08 20:58:06 -0400925 if (err < 0)
926 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 }
Al Viro9ba720c2017-07-08 20:58:06 -0400928 return err;
929}
Nadia Derbey023a5352007-10-18 23:40:51 -0700930
Al Viro9ba720c2017-07-08 20:58:06 -0400931static int shmctl_stat(struct ipc_namespace *ns, int shmid,
932 int cmd, struct shmid64_ds *tbuf)
933{
934 struct shmid_kernel *shp;
Philippe Mikoyan87ad4b02018-02-06 15:40:49 -0800935 int id = 0;
Al Viro9ba720c2017-07-08 20:58:06 -0400936 int err;
Davidlohr Buesoc97cb9c2013-09-11 14:26:20 -0700937
Philippe Mikoyan87ad4b02018-02-06 15:40:49 -0800938 memset(tbuf, 0, sizeof(*tbuf));
939
Al Viro9ba720c2017-07-08 20:58:06 -0400940 rcu_read_lock();
941 if (cmd == SHM_STAT) {
942 shp = shm_obtain_object(ns, shmid);
943 if (IS_ERR(shp)) {
944 err = PTR_ERR(shp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 goto out_unlock;
Al Viro9ba720c2017-07-08 20:58:06 -0400946 }
Philippe Mikoyan87ad4b02018-02-06 15:40:49 -0800947 id = shp->shm_perm.id;
Al Viro9ba720c2017-07-08 20:58:06 -0400948 } else {
949 shp = shm_obtain_object_check(ns, shmid);
950 if (IS_ERR(shp)) {
951 err = PTR_ERR(shp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 goto out_unlock;
Al Viro9ba720c2017-07-08 20:58:06 -0400953 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 }
Al Viro9ba720c2017-07-08 20:58:06 -0400955
956 err = -EACCES;
957 if (ipcperms(ns, &shp->shm_perm, S_IRUGO))
958 goto out_unlock;
959
Eric W. Biederman7191adf2018-03-22 21:08:27 -0500960 err = security_shm_shmctl(&shp->shm_perm, cmd);
Al Viro9ba720c2017-07-08 20:58:06 -0400961 if (err)
962 goto out_unlock;
963
Philippe Mikoyan87ad4b02018-02-06 15:40:49 -0800964 ipc_lock_object(&shp->shm_perm);
965
966 if (!ipc_valid_object(&shp->shm_perm)) {
967 ipc_unlock_object(&shp->shm_perm);
968 err = -EIDRM;
969 goto out_unlock;
970 }
971
Al Viro9ba720c2017-07-08 20:58:06 -0400972 kernel_to_ipc64_perm(&shp->shm_perm, &tbuf->shm_perm);
973 tbuf->shm_segsz = shp->shm_segsz;
974 tbuf->shm_atime = shp->shm_atim;
975 tbuf->shm_dtime = shp->shm_dtim;
976 tbuf->shm_ctime = shp->shm_ctim;
Eric W. Biederman98f929b12018-03-23 00:29:57 -0500977 tbuf->shm_cpid = pid_vnr(shp->shm_cprid);
978 tbuf->shm_lpid = pid_vnr(shp->shm_lprid);
Al Viro9ba720c2017-07-08 20:58:06 -0400979 tbuf->shm_nattch = shp->shm_nattch;
Philippe Mikoyan87ad4b02018-02-06 15:40:49 -0800980
981 ipc_unlock_object(&shp->shm_perm);
Al Viro9ba720c2017-07-08 20:58:06 -0400982 rcu_read_unlock();
Philippe Mikoyan87ad4b02018-02-06 15:40:49 -0800983 return id;
Davidlohr Bueso68eccc12013-09-11 14:26:18 -0700984
985out_unlock:
Davidlohr Buesoc97cb9c2013-09-11 14:26:20 -0700986 rcu_read_unlock();
Al Viro9ba720c2017-07-08 20:58:06 -0400987 return err;
988}
989
990static int shmctl_do_lock(struct ipc_namespace *ns, int shmid, int cmd)
991{
992 struct shmid_kernel *shp;
993 struct file *shm_file;
994 int err;
995
996 rcu_read_lock();
997 shp = shm_obtain_object_check(ns, shmid);
998 if (IS_ERR(shp)) {
999 err = PTR_ERR(shp);
1000 goto out_unlock1;
1001 }
1002
1003 audit_ipc_obj(&(shp->shm_perm));
Eric W. Biederman7191adf2018-03-22 21:08:27 -05001004 err = security_shm_shmctl(&shp->shm_perm, cmd);
Al Viro9ba720c2017-07-08 20:58:06 -04001005 if (err)
1006 goto out_unlock1;
1007
1008 ipc_lock_object(&shp->shm_perm);
1009
1010 /* check if shm_destroy() is tearing down shp */
1011 if (!ipc_valid_object(&shp->shm_perm)) {
1012 err = -EIDRM;
1013 goto out_unlock0;
1014 }
1015
1016 if (!ns_capable(ns->user_ns, CAP_IPC_LOCK)) {
1017 kuid_t euid = current_euid();
1018
1019 if (!uid_eq(euid, shp->shm_perm.uid) &&
1020 !uid_eq(euid, shp->shm_perm.cuid)) {
1021 err = -EPERM;
1022 goto out_unlock0;
1023 }
1024 if (cmd == SHM_LOCK && !rlimit(RLIMIT_MEMLOCK)) {
1025 err = -EPERM;
1026 goto out_unlock0;
1027 }
1028 }
1029
1030 shm_file = shp->shm_file;
1031 if (is_file_hugepages(shm_file))
1032 goto out_unlock0;
1033
1034 if (cmd == SHM_LOCK) {
1035 struct user_struct *user = current_user();
1036
1037 err = shmem_lock(shm_file, 1, user);
1038 if (!err && !(shp->shm_perm.mode & SHM_LOCKED)) {
1039 shp->shm_perm.mode |= SHM_LOCKED;
1040 shp->mlock_user = user;
1041 }
1042 goto out_unlock0;
1043 }
1044
1045 /* SHM_UNLOCK */
1046 if (!(shp->shm_perm.mode & SHM_LOCKED))
1047 goto out_unlock0;
1048 shmem_lock(shm_file, 0, shp->mlock_user);
1049 shp->shm_perm.mode &= ~SHM_LOCKED;
1050 shp->mlock_user = NULL;
1051 get_file(shm_file);
1052 ipc_unlock_object(&shp->shm_perm);
1053 rcu_read_unlock();
1054 shmem_unlock_mapping(shm_file->f_mapping);
1055
1056 fput(shm_file);
1057 return err;
1058
1059out_unlock0:
1060 ipc_unlock_object(&shp->shm_perm);
1061out_unlock1:
1062 rcu_read_unlock();
Davidlohr Bueso68eccc12013-09-11 14:26:18 -07001063 return err;
1064}
1065
1066SYSCALL_DEFINE3(shmctl, int, shmid, int, cmd, struct shmid_ds __user *, buf)
1067{
Davidlohr Bueso68eccc12013-09-11 14:26:18 -07001068 int err, version;
1069 struct ipc_namespace *ns;
Al Viro553f7702017-07-08 22:52:47 -04001070 struct shmid64_ds sem64;
Davidlohr Bueso68eccc12013-09-11 14:26:18 -07001071
Davidlohr Bueso2caacaa2013-09-11 14:26:21 -07001072 if (cmd < 0 || shmid < 0)
1073 return -EINVAL;
Davidlohr Bueso68eccc12013-09-11 14:26:18 -07001074
1075 version = ipc_parse_version(&cmd);
1076 ns = current->nsproxy->ipc_ns;
1077
1078 switch (cmd) {
Al Viro9ba720c2017-07-08 20:58:06 -04001079 case IPC_INFO: {
1080 struct shminfo64 shminfo;
1081 err = shmctl_ipc_info(ns, &shminfo);
1082 if (err < 0)
1083 return err;
1084 if (copy_shminfo_to_user(buf, &shminfo, version))
1085 err = -EFAULT;
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -07001086 return err;
Davidlohr Bueso2caacaa2013-09-11 14:26:21 -07001087 }
Al Viro9ba720c2017-07-08 20:58:06 -04001088 case SHM_INFO: {
1089 struct shm_info shm_info;
1090 err = shmctl_shm_info(ns, &shm_info);
1091 if (err < 0)
1092 return err;
1093 if (copy_to_user(buf, &shm_info, sizeof(shm_info)))
1094 err = -EFAULT;
1095 return err;
1096 }
1097 case SHM_STAT:
1098 case IPC_STAT: {
Al Viro553f7702017-07-08 22:52:47 -04001099 err = shmctl_stat(ns, shmid, cmd, &sem64);
Al Viro9ba720c2017-07-08 20:58:06 -04001100 if (err < 0)
1101 return err;
Al Viro553f7702017-07-08 22:52:47 -04001102 if (copy_shmid_to_user(buf, &sem64, version))
Al Viro9ba720c2017-07-08 20:58:06 -04001103 err = -EFAULT;
1104 return err;
1105 }
1106 case IPC_SET:
Al Viro553f7702017-07-08 22:52:47 -04001107 if (copy_shmid_from_user(&sem64, buf, version))
Al Viro9ba720c2017-07-08 20:58:06 -04001108 return -EFAULT;
Al Viro553f7702017-07-08 22:52:47 -04001109 /* fallthru */
Al Viro9ba720c2017-07-08 20:58:06 -04001110 case IPC_RMID:
Al Viro553f7702017-07-08 22:52:47 -04001111 return shmctl_down(ns, shmid, cmd, &sem64);
Al Viro9ba720c2017-07-08 20:58:06 -04001112 case SHM_LOCK:
1113 case SHM_UNLOCK:
1114 return shmctl_do_lock(ns, shmid, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 default:
Pierre Peiffer8d4cc8b2008-04-29 01:00:47 -07001116 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119
Al Viro553f7702017-07-08 22:52:47 -04001120#ifdef CONFIG_COMPAT
1121
1122struct compat_shmid_ds {
1123 struct compat_ipc_perm shm_perm;
1124 int shm_segsz;
1125 compat_time_t shm_atime;
1126 compat_time_t shm_dtime;
1127 compat_time_t shm_ctime;
1128 compat_ipc_pid_t shm_cpid;
1129 compat_ipc_pid_t shm_lpid;
1130 unsigned short shm_nattch;
1131 unsigned short shm_unused;
1132 compat_uptr_t shm_unused2;
1133 compat_uptr_t shm_unused3;
1134};
1135
1136struct compat_shminfo64 {
1137 compat_ulong_t shmmax;
1138 compat_ulong_t shmmin;
1139 compat_ulong_t shmmni;
1140 compat_ulong_t shmseg;
1141 compat_ulong_t shmall;
1142 compat_ulong_t __unused1;
1143 compat_ulong_t __unused2;
1144 compat_ulong_t __unused3;
1145 compat_ulong_t __unused4;
1146};
1147
1148struct compat_shm_info {
1149 compat_int_t used_ids;
1150 compat_ulong_t shm_tot, shm_rss, shm_swp;
1151 compat_ulong_t swap_attempts, swap_successes;
1152};
1153
1154static int copy_compat_shminfo_to_user(void __user *buf, struct shminfo64 *in,
1155 int version)
1156{
1157 if (in->shmmax > INT_MAX)
1158 in->shmmax = INT_MAX;
1159 if (version == IPC_64) {
1160 struct compat_shminfo64 info;
1161 memset(&info, 0, sizeof(info));
1162 info.shmmax = in->shmmax;
1163 info.shmmin = in->shmmin;
1164 info.shmmni = in->shmmni;
1165 info.shmseg = in->shmseg;
1166 info.shmall = in->shmall;
1167 return copy_to_user(buf, &info, sizeof(info));
1168 } else {
1169 struct shminfo info;
1170 memset(&info, 0, sizeof(info));
1171 info.shmmax = in->shmmax;
1172 info.shmmin = in->shmmin;
1173 info.shmmni = in->shmmni;
1174 info.shmseg = in->shmseg;
1175 info.shmall = in->shmall;
1176 return copy_to_user(buf, &info, sizeof(info));
1177 }
1178}
1179
1180static int put_compat_shm_info(struct shm_info *ip,
1181 struct compat_shm_info __user *uip)
1182{
1183 struct compat_shm_info info;
1184
1185 memset(&info, 0, sizeof(info));
1186 info.used_ids = ip->used_ids;
1187 info.shm_tot = ip->shm_tot;
1188 info.shm_rss = ip->shm_rss;
1189 info.shm_swp = ip->shm_swp;
1190 info.swap_attempts = ip->swap_attempts;
1191 info.swap_successes = ip->swap_successes;
Al Virob776e4b2017-09-25 20:38:45 -04001192 return copy_to_user(uip, &info, sizeof(info));
Al Viro553f7702017-07-08 22:52:47 -04001193}
1194
1195static int copy_compat_shmid_to_user(void __user *buf, struct shmid64_ds *in,
1196 int version)
1197{
1198 if (version == IPC_64) {
1199 struct compat_shmid64_ds v;
1200 memset(&v, 0, sizeof(v));
Al Viro28327fa2017-07-09 10:10:32 -04001201 to_compat_ipc64_perm(&v.shm_perm, &in->shm_perm);
Al Viro553f7702017-07-08 22:52:47 -04001202 v.shm_atime = in->shm_atime;
1203 v.shm_dtime = in->shm_dtime;
1204 v.shm_ctime = in->shm_ctime;
1205 v.shm_segsz = in->shm_segsz;
1206 v.shm_nattch = in->shm_nattch;
1207 v.shm_cpid = in->shm_cpid;
1208 v.shm_lpid = in->shm_lpid;
1209 return copy_to_user(buf, &v, sizeof(v));
1210 } else {
1211 struct compat_shmid_ds v;
1212 memset(&v, 0, sizeof(v));
Al Viro28327fa2017-07-09 10:10:32 -04001213 to_compat_ipc_perm(&v.shm_perm, &in->shm_perm);
Al Viro553f7702017-07-08 22:52:47 -04001214 v.shm_perm.key = in->shm_perm.key;
Al Viro553f7702017-07-08 22:52:47 -04001215 v.shm_atime = in->shm_atime;
1216 v.shm_dtime = in->shm_dtime;
1217 v.shm_ctime = in->shm_ctime;
1218 v.shm_segsz = in->shm_segsz;
1219 v.shm_nattch = in->shm_nattch;
1220 v.shm_cpid = in->shm_cpid;
1221 v.shm_lpid = in->shm_lpid;
1222 return copy_to_user(buf, &v, sizeof(v));
1223 }
1224}
1225
1226static int copy_compat_shmid_from_user(struct shmid64_ds *out, void __user *buf,
1227 int version)
1228{
1229 memset(out, 0, sizeof(*out));
1230 if (version == IPC_64) {
Linus Torvalds6aa211e2017-09-25 18:37:28 -07001231 struct compat_shmid64_ds __user *p = buf;
Al Viro28327fa2017-07-09 10:10:32 -04001232 return get_compat_ipc64_perm(&out->shm_perm, &p->shm_perm);
Al Viro553f7702017-07-08 22:52:47 -04001233 } else {
Linus Torvalds6aa211e2017-09-25 18:37:28 -07001234 struct compat_shmid_ds __user *p = buf;
Al Viro28327fa2017-07-09 10:10:32 -04001235 return get_compat_ipc_perm(&out->shm_perm, &p->shm_perm);
Al Viro553f7702017-07-08 22:52:47 -04001236 }
Al Viro553f7702017-07-08 22:52:47 -04001237}
1238
1239COMPAT_SYSCALL_DEFINE3(shmctl, int, shmid, int, cmd, void __user *, uptr)
1240{
1241 struct ipc_namespace *ns;
1242 struct shmid64_ds sem64;
1243 int version = compat_ipc_parse_version(&cmd);
1244 int err;
1245
1246 ns = current->nsproxy->ipc_ns;
1247
1248 if (cmd < 0 || shmid < 0)
1249 return -EINVAL;
1250
1251 switch (cmd) {
1252 case IPC_INFO: {
1253 struct shminfo64 shminfo;
1254 err = shmctl_ipc_info(ns, &shminfo);
1255 if (err < 0)
1256 return err;
1257 if (copy_compat_shminfo_to_user(uptr, &shminfo, version))
1258 err = -EFAULT;
1259 return err;
1260 }
1261 case SHM_INFO: {
1262 struct shm_info shm_info;
1263 err = shmctl_shm_info(ns, &shm_info);
1264 if (err < 0)
1265 return err;
1266 if (put_compat_shm_info(&shm_info, uptr))
1267 err = -EFAULT;
1268 return err;
1269 }
1270 case IPC_STAT:
1271 case SHM_STAT:
1272 err = shmctl_stat(ns, shmid, cmd, &sem64);
1273 if (err < 0)
1274 return err;
Will Deacon58aff0a2017-09-18 17:47:38 +01001275 if (copy_compat_shmid_to_user(uptr, &sem64, version))
Al Viro553f7702017-07-08 22:52:47 -04001276 err = -EFAULT;
1277 return err;
1278
1279 case IPC_SET:
1280 if (copy_compat_shmid_from_user(&sem64, uptr, version))
1281 return -EFAULT;
1282 /* fallthru */
1283 case IPC_RMID:
1284 return shmctl_down(ns, shmid, cmd, &sem64);
1285 case SHM_LOCK:
1286 case SHM_UNLOCK:
1287 return shmctl_do_lock(ns, shmid, cmd);
1288 break;
1289 default:
1290 return -EINVAL;
1291 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 return err;
1293}
Al Viro553f7702017-07-08 22:52:47 -04001294#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295
1296/*
1297 * Fix shmaddr, allocate descriptor, map shm, add attach descriptor to lists.
1298 *
1299 * NOTE! Despite the name, this is NOT a direct system call entrypoint. The
1300 * "raddr" thing points to kernel space, and there has to be a wrapper around
1301 * this.
1302 */
Davidlohr Bueso95e91b82017-02-27 14:28:24 -08001303long do_shmat(int shmid, char __user *shmaddr, int shmflg,
1304 ulong *raddr, unsigned long shmlba)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305{
1306 struct shmid_kernel *shp;
Davidlohr Buesof0cb8802017-05-08 15:57:03 -07001307 unsigned long addr = (unsigned long)shmaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 unsigned long size;
Manfred Spraul239521f2014-01-27 17:07:04 -08001309 struct file *file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 int err;
Davidlohr Buesof0cb8802017-05-08 15:57:03 -07001311 unsigned long flags = MAP_SHARED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 unsigned long prot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 int acc_mode;
Kirill Korotaev4e982312006-10-02 02:18:22 -07001314 struct ipc_namespace *ns;
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001315 struct shm_file_data *sfd;
1316 struct path path;
Al Viroaeb5d722008-09-02 15:28:45 -04001317 fmode_t f_mode;
Michel Lespinasse41badc12013-02-22 16:32:47 -08001318 unsigned long populate = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001320 err = -EINVAL;
1321 if (shmid < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 goto out;
Davidlohr Buesof0cb8802017-05-08 15:57:03 -07001323
1324 if (addr) {
Will Deacon079a96a2012-07-30 14:42:38 -07001325 if (addr & (shmlba - 1)) {
Davidlohr Bueso95e91b82017-02-27 14:28:24 -08001326 /*
1327 * Round down to the nearest multiple of shmlba.
1328 * For sane do_mmap_pgoff() parameters, avoid
1329 * round downs that trigger nil-page and MAP_FIXED.
1330 */
1331 if ((shmflg & SHM_RND) && addr >= shmlba)
1332 addr &= ~(shmlba - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 else
1334#ifndef __ARCH_FORCE_SHMLBA
1335 if (addr & ~PAGE_MASK)
1336#endif
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001337 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339
Davidlohr Buesof0cb8802017-05-08 15:57:03 -07001340 flags |= MAP_FIXED;
1341 } else if ((shmflg & SHM_REMAP))
1342 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343
1344 if (shmflg & SHM_RDONLY) {
1345 prot = PROT_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 acc_mode = S_IRUGO;
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001347 f_mode = FMODE_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 } else {
1349 prot = PROT_READ | PROT_WRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 acc_mode = S_IRUGO | S_IWUGO;
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001351 f_mode = FMODE_READ | FMODE_WRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 }
1353 if (shmflg & SHM_EXEC) {
1354 prot |= PROT_EXEC;
1355 acc_mode |= S_IXUGO;
1356 }
1357
1358 /*
1359 * We cannot rely on the fs check since SYSV IPC does have an
1360 * additional creator id...
1361 */
Kirill Korotaev4e982312006-10-02 02:18:22 -07001362 ns = current->nsproxy->ipc_ns;
Davidlohr Buesoc2c737a2013-09-11 14:26:23 -07001363 rcu_read_lock();
1364 shp = shm_obtain_object_check(ns, shmid);
Nadia Derbey023a5352007-10-18 23:40:51 -07001365 if (IS_ERR(shp)) {
1366 err = PTR_ERR(shp);
Davidlohr Buesoc2c737a2013-09-11 14:26:23 -07001367 goto out_unlock;
Nadia Derbey023a5352007-10-18 23:40:51 -07001368 }
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001369
1370 err = -EACCES;
Serge E. Hallynb0e77592011-03-23 16:43:24 -07001371 if (ipcperms(ns, &shp->shm_perm, acc_mode))
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001372 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373
Eric W. Biederman7191adf2018-03-22 21:08:27 -05001374 err = security_shm_shmat(&shp->shm_perm, shmaddr, shmflg);
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001375 if (err)
1376 goto out_unlock;
1377
Davidlohr Buesoc2c737a2013-09-11 14:26:23 -07001378 ipc_lock_object(&shp->shm_perm);
Greg Thelena399b292013-11-21 14:32:00 -08001379
1380 /* check if shm_destroy() is tearing down shp */
Rafael Aquini0f3d2b02014-01-27 17:07:01 -08001381 if (!ipc_valid_object(&shp->shm_perm)) {
Greg Thelena399b292013-11-21 14:32:00 -08001382 ipc_unlock_object(&shp->shm_perm);
1383 err = -EIDRM;
1384 goto out_unlock;
1385 }
1386
Al Viro2c48b9c2009-08-09 00:52:35 +04001387 path = shp->shm_file->f_path;
1388 path_get(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 shp->shm_nattch++;
David Howells75c3cfa2015-03-17 22:26:12 +00001390 size = i_size_read(d_inode(path.dentry));
Davidlohr Buesoc2c737a2013-09-11 14:26:23 -07001391 ipc_unlock_object(&shp->shm_perm);
1392 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001394 err = -ENOMEM;
1395 sfd = kzalloc(sizeof(*sfd), GFP_KERNEL);
Davidlohr Buesof42569b2013-09-11 14:26:22 -07001396 if (!sfd) {
1397 path_put(&path);
1398 goto out_nattch;
1399 }
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001400
Al Viro2c48b9c2009-08-09 00:52:35 +04001401 file = alloc_file(&path, f_mode,
1402 is_file_hugepages(shp->shm_file) ?
Al Viroc4caa772009-11-30 08:38:43 -05001403 &shm_file_operations_huge :
1404 &shm_file_operations);
Anatol Pomozov39b652522012-09-12 20:11:55 -07001405 err = PTR_ERR(file);
Davidlohr Buesof42569b2013-09-11 14:26:22 -07001406 if (IS_ERR(file)) {
1407 kfree(sfd);
1408 path_put(&path);
1409 goto out_nattch;
1410 }
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001411
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001412 file->private_data = sfd;
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001413 file->f_mapping = shp->shm_file->f_mapping;
Nadia Derbey7ca7e562007-10-18 23:40:48 -07001414 sfd->id = shp->shm_perm.id;
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001415 sfd->ns = get_ipc_ns(ns);
1416 sfd->file = shp->shm_file;
1417 sfd->vm_ops = NULL;
1418
Al Viro8b3ec682012-05-30 17:11:23 -04001419 err = security_mmap_file(file, prot, flags);
1420 if (err)
1421 goto out_fput;
1422
Michal Hocko91f4f942016-05-23 16:25:51 -07001423 if (down_write_killable(&current->mm->mmap_sem)) {
1424 err = -EINTR;
1425 goto out_fput;
1426 }
1427
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 if (addr && !(shmflg & SHM_REMAP)) {
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001429 err = -EINVAL;
Manfred Spraul247a8ce2014-06-06 14:37:38 -07001430 if (addr + size < addr)
1431 goto invalid;
1432
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 if (find_vma_intersection(current->mm, addr, addr + size))
1434 goto invalid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 }
Davidlohr Buesof42569b2013-09-11 14:26:22 -07001436
Mike Rapoport897ab3e2017-02-24 14:58:22 -08001437 addr = do_mmap_pgoff(file, addr, size, prot, flags, 0, &populate, NULL);
Michel Lespinassebebeb3d2013-02-22 16:32:37 -08001438 *raddr = addr;
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001439 err = 0;
Michel Lespinassebebeb3d2013-02-22 16:32:37 -08001440 if (IS_ERR_VALUE(addr))
1441 err = (long)addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442invalid:
1443 up_write(&current->mm->mmap_sem);
Michel Lespinassebebeb3d2013-02-22 16:32:37 -08001444 if (populate)
Michel Lespinasse41badc12013-02-22 16:32:47 -08001445 mm_populate(addr, populate);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446
Al Viro8b3ec682012-05-30 17:11:23 -04001447out_fput:
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001448 fput(file);
1449
1450out_nattch:
Davidlohr Buesod9a605e2013-09-11 14:26:24 -07001451 down_write(&shm_ids(ns).rwsem);
Nadia Derbey00c2bf82008-07-25 01:48:03 -07001452 shp = shm_lock(ns, shmid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 shp->shm_nattch--;
Vasiliy Kulikovb34a6b12011-07-26 16:08:48 -07001454 if (shm_may_destroy(ns, shp))
Kirill Korotaev4e982312006-10-02 02:18:22 -07001455 shm_destroy(ns, shp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 else
1457 shm_unlock(shp);
Davidlohr Buesod9a605e2013-09-11 14:26:24 -07001458 up_write(&shm_ids(ns).rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 return err;
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001460
1461out_unlock:
Davidlohr Buesoc2c737a2013-09-11 14:26:23 -07001462 rcu_read_unlock();
Davidlohr Buesof42569b2013-09-11 14:26:22 -07001463out:
1464 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465}
1466
Heiko Carstensd5460c92009-01-14 14:14:27 +01001467SYSCALL_DEFINE3(shmat, int, shmid, char __user *, shmaddr, int, shmflg)
Stephen Rothwell7d87e14c2005-05-01 08:59:12 -07001468{
1469 unsigned long ret;
1470 long err;
1471
Will Deacon079a96a2012-07-30 14:42:38 -07001472 err = do_shmat(shmid, shmaddr, shmflg, &ret, SHMLBA);
Stephen Rothwell7d87e14c2005-05-01 08:59:12 -07001473 if (err)
1474 return err;
1475 force_successful_syscall_return();
1476 return (long)ret;
1477}
1478
Al Viroa78ee9e2017-07-09 10:38:28 -04001479#ifdef CONFIG_COMPAT
1480
1481#ifndef COMPAT_SHMLBA
1482#define COMPAT_SHMLBA SHMLBA
1483#endif
1484
1485COMPAT_SYSCALL_DEFINE3(shmat, int, shmid, compat_uptr_t, shmaddr, int, shmflg)
1486{
1487 unsigned long ret;
1488 long err;
1489
1490 err = do_shmat(shmid, compat_ptr(shmaddr), shmflg, &ret, COMPAT_SHMLBA);
1491 if (err)
1492 return err;
1493 force_successful_syscall_return();
1494 return (long)ret;
1495}
1496#endif
1497
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498/*
1499 * detach and kill segment if marked destroyed.
1500 * The work is done in shm_close.
1501 */
Heiko Carstensd5460c92009-01-14 14:14:27 +01001502SYSCALL_DEFINE1(shmdt, char __user *, shmaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503{
1504 struct mm_struct *mm = current->mm;
Mike Frysinger586c7e62009-06-09 16:26:23 -07001505 struct vm_area_struct *vma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 unsigned long addr = (unsigned long)shmaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 int retval = -EINVAL;
Mike Frysinger586c7e62009-06-09 16:26:23 -07001508#ifdef CONFIG_MMU
1509 loff_t size = 0;
Dave Hansend3c97902014-12-12 16:58:19 -08001510 struct file *file;
Mike Frysinger586c7e62009-06-09 16:26:23 -07001511 struct vm_area_struct *next;
1512#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513
Hugh Dickinsdf1e2fb2006-03-24 03:18:06 -08001514 if (addr & ~PAGE_MASK)
1515 return retval;
1516
Michal Hocko91f4f942016-05-23 16:25:51 -07001517 if (down_write_killable(&mm->mmap_sem))
1518 return -EINTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519
1520 /*
1521 * This function tries to be smart and unmap shm segments that
1522 * were modified by partial mlock or munmap calls:
1523 * - It first determines the size of the shm segment that should be
1524 * unmapped: It searches for a vma that is backed by shm and that
1525 * started at address shmaddr. It records it's size and then unmaps
1526 * it.
1527 * - Then it unmaps all shm vmas that started at shmaddr and that
Dave Hansend3c97902014-12-12 16:58:19 -08001528 * are within the initially determined size and that are from the
1529 * same shm segment from which we determined the size.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 * Errors from do_munmap are ignored: the function only fails if
1531 * it's called with invalid parameters or if it's called to unmap
1532 * a part of a vma. Both calls in this function are for full vmas,
1533 * the parameters are directly copied from the vma itself and always
1534 * valid - therefore do_munmap cannot fail. (famous last words?)
1535 */
1536 /*
1537 * If it had been mremap()'d, the starting address would not
1538 * match the usual checks anyway. So assume all vma's are
1539 * above the starting address given.
1540 */
1541 vma = find_vma(mm, addr);
1542
David Howells8feae132009-01-08 12:04:47 +00001543#ifdef CONFIG_MMU
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 while (vma) {
1545 next = vma->vm_next;
1546
1547 /*
1548 * Check if the starting address would match, i.e. it's
1549 * a fragment created by mprotect() and/or munmap(), or it
1550 * otherwise it starts at this address with no hassles.
1551 */
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001552 if ((vma->vm_ops == &shm_vm_ops) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553 (vma->vm_start - addr)/PAGE_SIZE == vma->vm_pgoff) {
1554
Dave Hansend3c97902014-12-12 16:58:19 -08001555 /*
1556 * Record the file of the shm segment being
1557 * unmapped. With mremap(), someone could place
1558 * page from another segment but with equal offsets
1559 * in the range we are unmapping.
1560 */
1561 file = vma->vm_file;
Dave Hansen07a46ed2014-12-12 16:58:22 -08001562 size = i_size_read(file_inode(vma->vm_file));
Mike Rapoport897ab3e2017-02-24 14:58:22 -08001563 do_munmap(mm, vma->vm_start, vma->vm_end - vma->vm_start, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 /*
1565 * We discovered the size of the shm segment, so
1566 * break out of here and fall through to the next
1567 * loop that uses the size information to stop
1568 * searching for matching vma's.
1569 */
1570 retval = 0;
1571 vma = next;
1572 break;
1573 }
1574 vma = next;
1575 }
1576
1577 /*
1578 * We need look no further than the maximum address a fragment
1579 * could possibly have landed at. Also cast things to loff_t to
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001580 * prevent overflows and make comparisons vs. equal-width types.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 */
KAMEZAWA Hiroyuki8e367092006-02-10 01:51:12 -08001582 size = PAGE_ALIGN(size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 while (vma && (loff_t)(vma->vm_end - addr) <= size) {
1584 next = vma->vm_next;
1585
1586 /* finding a matching vma now does not alter retval */
Eric W. Biedermanbc56bba2007-02-20 13:57:53 -08001587 if ((vma->vm_ops == &shm_vm_ops) &&
Dave Hansend3c97902014-12-12 16:58:19 -08001588 ((vma->vm_start - addr)/PAGE_SIZE == vma->vm_pgoff) &&
1589 (vma->vm_file == file))
Mike Rapoport897ab3e2017-02-24 14:58:22 -08001590 do_munmap(mm, vma->vm_start, vma->vm_end - vma->vm_start, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 vma = next;
1592 }
1593
Shailesh Pandey63980c82016-12-14 15:06:10 -08001594#else /* CONFIG_MMU */
David Howells8feae132009-01-08 12:04:47 +00001595 /* under NOMMU conditions, the exact address to be destroyed must be
Shailesh Pandey63980c82016-12-14 15:06:10 -08001596 * given
1597 */
Davidlohr Bueso530fcd162013-09-11 14:26:28 -07001598 if (vma && vma->vm_start == addr && vma->vm_ops == &shm_vm_ops) {
Mike Rapoport897ab3e2017-02-24 14:58:22 -08001599 do_munmap(mm, vma->vm_start, vma->vm_end - vma->vm_start, NULL);
David Howells8feae132009-01-08 12:04:47 +00001600 retval = 0;
1601 }
1602
1603#endif
1604
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605 up_write(&mm->mmap_sem);
1606 return retval;
1607}
1608
1609#ifdef CONFIG_PROC_FS
Mike Waychison19b49462005-09-06 15:17:10 -07001610static int sysvipc_shm_proc_show(struct seq_file *s, void *it)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611{
Eric W. Biederman98f929b12018-03-23 00:29:57 -05001612 struct pid_namespace *pid_ns = ipc_seq_pid_ns(s);
Eric W. Biederman1efdb692012-02-07 16:54:11 -08001613 struct user_namespace *user_ns = seq_user_ns(s);
Kees Cookade9f912017-08-02 13:32:21 -07001614 struct kern_ipc_perm *ipcp = it;
1615 struct shmid_kernel *shp;
Helge Dellerb7952182010-10-27 15:34:16 -07001616 unsigned long rss = 0, swp = 0;
1617
Kees Cookade9f912017-08-02 13:32:21 -07001618 shp = container_of(ipcp, struct shmid_kernel, shm_perm);
Helge Dellerb7952182010-10-27 15:34:16 -07001619 shm_add_rss_swap(shp, &rss, &swp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620
Paul Menage6c826812008-06-12 15:21:49 -07001621#if BITS_PER_LONG <= 32
1622#define SIZE_SPEC "%10lu"
1623#else
1624#define SIZE_SPEC "%21lu"
1625#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626
Joe Perches7f032d62015-04-15 16:17:54 -07001627 seq_printf(s,
1628 "%10d %10d %4o " SIZE_SPEC " %5u %5u "
Deepa Dinamani7ff28192017-08-02 19:51:14 -07001629 "%5lu %5u %5u %5u %5u %10llu %10llu %10llu "
Joe Perches7f032d62015-04-15 16:17:54 -07001630 SIZE_SPEC " " SIZE_SPEC "\n",
1631 shp->shm_perm.key,
1632 shp->shm_perm.id,
1633 shp->shm_perm.mode,
1634 shp->shm_segsz,
Eric W. Biederman98f929b12018-03-23 00:29:57 -05001635 pid_nr_ns(shp->shm_cprid, pid_ns),
1636 pid_nr_ns(shp->shm_lprid, pid_ns),
Joe Perches7f032d62015-04-15 16:17:54 -07001637 shp->shm_nattch,
1638 from_kuid_munged(user_ns, shp->shm_perm.uid),
1639 from_kgid_munged(user_ns, shp->shm_perm.gid),
1640 from_kuid_munged(user_ns, shp->shm_perm.cuid),
1641 from_kgid_munged(user_ns, shp->shm_perm.cgid),
1642 shp->shm_atim,
1643 shp->shm_dtim,
1644 shp->shm_ctim,
1645 rss * PAGE_SIZE,
1646 swp * PAGE_SIZE);
1647
1648 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649}
1650#endif