index : linux	frominto-error master
	Contrib clone of linux	matthias

summaryrefslogtreecommitdiffstats

log msg author committer range

path: root/mm/mmu_notifier.c

Age	Commit message (Expand)	Author
2019-09-07	mm, notifier: Catch sleeping/blocking for !blockable	Daniel Vetter
2019-09-07	mm/mmu_notifiers: prime lockdep	Daniel Vetter
2019-09-07	mm/mmu_notifiers: add a lockdep map for invalidate_range_start/end	Daniel Vetter
2019-08-28	mm/mmu_notifiers: remove the __mmu_notifier_invalidate_range_start/end exports	Christoph Hellwig
2019-08-21	mm/mmu_notifiers: remove unregister_no_release	Jason Gunthorpe
2019-08-20	mm/mmu_notifiers: check if mmu notifier callbacks are allowed to fail	Daniel Vetter
2019-08-16	mm/mmu_notifiers: add a get/put scheme for the registration	Jason Gunthorpe
2019-08-16	mm/mmu_notifiers: do not speculatively allocate a mmu_notifier_mm	Jason Gunthorpe
2019-08-16	mm/mmu_notifiers: hoist do_mmu_notifier_register down_write to the caller	Jason Gunthorpe
2019-07-12	mm/mmu_notifier: use hlist_add_head_rcu()	Jean-Philippe Brucker
2019-06-19	treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 499	Thomas Gleixner
2019-05-14	mm/mmu_notifier: mmu_notifier_range_update_to_read_only() helper	Jérôme Glisse
2019-05-14	mm/mmu_notifier: convert user range->blockable to helper function	Jérôme Glisse
2018-12-28	mm/mmu_notifier: use structure for invalidate_range_start/end calls v2	Jérôme Glisse
2018-12-28	mm/mmu_notifier: use structure for invalidate_range_start/end callback	Jérôme Glisse
2018-12-28	mm/mmu_notifier.c: remove mmu_notifier_synchronize()	Sean Christopherson
2018-10-26	Revert "mm, mmu_notifier: annotate mmu notifiers with blockable invalidate ca...	Michal Hocko
2018-08-22	mm, oom: distinguish blockable mode for mmu notifiers	Michal Hocko
2018-01-31	mm, mmu_notifier: annotate mmu notifiers with blockable invalidate callbacks	David Rientjes
2017-11-15	mm/mmu_notifier: avoid call to invalidate_range() in range_end()	Jérôme Glisse
2017-08-31	mm/mmu_notifier: kill invalidate_page	Jérôme Glisse
2017-04-18	mm: Use static initialization for "srcu"	Paul E. McKenney
2017-03-02	sched/headers: Prepare for new header dependencies before moving code to <lin...	Ingo Molnar
2017-02-27	mm: add new mmgrab() helper	Vegard Nossum
2016-03-17	fix Christoph's email addresses	Christoph Lameter
2015-09-10	mmu-notifier: add clear_young callback	Vladimir Davydov
2014-11-13	mmu_notifier: add the callback for mmu_notifier_invalidate_range()	Joerg Roedel
2014-09-24	kvm: Fix page ageing bugs	Andres Lagar-Cavilla
2014-08-06	mmu_notifier: add call_srcu and sync function for listener to delay call and ...	Peter Zijlstra
2014-01-23	mm: audit/fix non-modular users of module_init in core code	Paul Gortmaker
2013-06-28	treewide: relase -> release	Geert Uytterhoeven
2013-05-24	mm: mmu_notifier: re-fix freed page still mapped in secondary MMU	Xiao Guangrong
2013-02-27	hlist: drop the node parameter from iterators	Sasha Levin
2013-02-23	mm: export mmu notifier invalidates	Cliff Wickman
2013-02-23	mmu_notifier_unregister NULL Pointer deref and multiple ->release() callouts	Robin Holt
2012-10-25	mm/mmu_notifier: allocate mmu_notifier in advance	Gavin Shan
2012-10-09	mm: wrap calls to set_pte_at_notify with invalidate_range_start and invalidat...	Haggai Eran
2012-10-09	mm: mmu_notifier: make the mmu_notifier srcu static	Andrea Arcangeli
2012-10-09	mm/mmu_notifier: init notifier if necessary	Gavin Shan
2012-10-09	mm: mmu_notifier: have mmu_notifiers use a global SRCU so they may safely sch...	Sagi Grimberg
2012-07-31	mm: mmu_notifier: fix freed page still mapped in secondary MMU	Xiao Guangrong
2011-10-31	mm: Map most files to use export.h instead of module.h	Paul Gortmaker
2011-01-13	thp: mmu_notifier_test_young	Andrea Arcangeli
2010-03-30	include cleanup: Update gfp.h and slab.h includes to prepare for breaking imp...	Tejun Heo
2009-09-22	ksm: add mmu_notifier set_pte_at_notify()	Izik Eidus
2008-07-28	mmu-notifiers: core	Andrea Arcangeli

generated by cgit v1.2.3 (git 2.25.1) at 2024-08-06 16:40:39 +0000

// SPDX-License-Identifier: GPL-2.0
/*
 * linux/ipc/util.c
 * Copyright (C) 1992 Krishna Balasubramanian
 *
 * Sep 1997 - Call suser() last after "normal" permission checks so we
 *            get BSD style process accounting right.
 *            Occurs in several places in the IPC code.
 *            Chris Evans, <chris@ferret.lmh.ox.ac.uk>
 * Nov 1999 - ipc helper functions, unified SMP locking
 *	      Manfred Spraul <manfred@colorfullife.com>
 * Oct 2002 - One lock per IPC id. RCU ipc_free for lock-free grow_ary().
 *            Mingming Cao <cmm@us.ibm.com>
 * Mar 2006 - support for audit of ipc object properties
 *            Dustin Kirkland <dustin.kirkland@us.ibm.com>
 * Jun 2006 - namespaces ssupport
 *            OpenVZ, SWsoft Inc.
 *            Pavel Emelianov <xemul@openvz.org>
 *
 * General sysv ipc locking scheme:
 *	rcu_read_lock()
 *          obtain the ipc object (kern_ipc_perm) by looking up the id in an idr
 *	    tree.
 *	    - perform initial checks (capabilities, auditing and permission,
 *	      etc).
 *	    - perform read-only operations, such as INFO command, that
 *	      do not demand atomicity
 *	      acquire the ipc lock (kern_ipc_perm.lock) through
 *	      ipc_lock_object()
 *		- perform read-only operations that demand atomicity,
 *		  such as STAT command.
 *		- perform data updates, such as SET, RMID commands and
 *		  mechanism-specific operations (semop/semtimedop,
 *		  msgsnd/msgrcv, shmat/shmdt).
 *	    drop the ipc lock, through ipc_unlock_object().
 *	rcu_read_unlock()
 *
 *  The ids->rwsem must be taken when:
 *	- creating, removing and iterating the existing entries in ipc
 *	  identifier sets.
 *	- iterating through files under /proc/sysvipc/
 *
 *  Note that sems have a special fast path that avoids kern_ipc_perm.lock -
 *  see sem_lock().
 */

#include <linux/mm.h>
#include <linux/shm.h>
#include <linux/init.h>
#include <linux/msg.h>
#include <linux/vmalloc.h>
#include <linux/slab.h>
#include <linux/notifier.h>
#include <linux/capability.h>
#include <linux/highuid.h>
#include <linux/security.h>
#include <linux/rcupdate.h>
#include <linux/workqueue.h>
#include <linux/seq_file.h>
#include <linux/proc_fs.h>
#include <linux/audit.h>
#include <linux/nsproxy.h>
#include <linux/rwsem.h>
#include <linux/memory.h>
#include <linux/ipc_namespace.h>
#include <linux/rhashtable.h>

#include <asm/unistd.h>

#include "util.h"

struct ipc_proc_iface {
	const char *path;
	const char *header;
	int ids;
	int (*show)(struct seq_file *, void *);
};

/**
 * ipc_init - initialise ipc subsystem
 *
 * The various sysv ipc resources (semaphores, messages and shared
 * memory) are initialised.
 *
 * A callback routine is registered into the memory hotplug notifier
 * chain: since msgmni scales to lowmem this callback routine will be
 * called upon successful memory add / remove to recompute msmgni.
 */
static int __init ipc_init(void)
{
	proc_mkdir("sysvipc", NULL);
	sem_init();
	msg_init();
	shm_init();

	return 0;
}
device_initcall(ipc_init);

static const struct rhashtable_params ipc_kht_params = {
	.head_offset		= offsetof(struct kern_ipc_perm, khtnode),
	.key_offset		= offsetof(struct kern_ipc_perm, key),
	.key_len		= FIELD_SIZEOF(struct kern_ipc_perm, key),
	.automatic_shrinking	= true,
};

/**
 * ipc_init_ids	- initialise ipc identifiers
 * @ids: ipc identifier set
 *
 * Set up the sequence range to use for the ipc identifier range (limited
 * below ipc_mni) then initialise the keys hashtable and ids idr.
 */
void ipc_init_ids(struct ipc_ids *ids)
{
	ids->in_use = 0;
	ids->seq = 0;
	init_rwsem(&ids->rwsem);
	rhashtable_init(&ids->key_ht, &ipc_kht_params);
	idr_init(&ids->ipcs_idr);
	ids->max_idx = -1;
	ids->last_idx = -1;
#ifdef CONFIG_CHECKPOINT_RESTORE
	ids->next_id = -1;
#endif
}

#ifdef CONFIG_PROC_FS
static const struct file_operations sysvipc_proc_fops;
/**
 * ipc_init_proc_interface -  create a proc interface for sysipc types using a seq_file interface.
 * @path: Path in procfs
 * @header: Banner to be printed at the beginning of the file.
 * @ids: ipc id table to iterate.
 * @show: show routine.
 */
void __init ipc_init_proc_interface(const char *path, const char *header,
		int ids, int (*show)(struct seq_file *, void *))
{
	struct proc_dir_entry *pde;
	struct ipc_proc_iface *iface;

	iface = kmalloc(sizeof(*iface), GFP_KERNEL);
	if (!iface)
		return;
	iface->path	= path;
	iface->header	= header;
	iface->ids	= ids;
	iface->show	= show;

	pde = proc_create_data(path,
			       S_IRUGO,        /* world readable */
			       NULL,           /* parent dir */
			       &sysvipc_proc_fops,
			       iface);
	if (!pde)
		kfree(iface);
}
#endif

/**
 * ipc_findkey	- find a key in an ipc identifier set
 * @ids: ipc identifier set
 * @key: key to find
 *
 * Returns the locked pointer to the ipc structure if found or NULL
 * otherwise. If key is found ipc points to the owning ipc structure
 *
 * Called with writer ipc_ids.rwsem held.
 */
static struct kern_ipc_perm *ipc_findkey(struct ipc_ids *ids, key_t key)
{
	struct kern_ipc_perm *ipcp;

	ipcp = rhashtable_lookup_fast(&ids->key_ht, &key,
					      ipc_kht_params);
	if (!ipcp)
		return NULL;

	rcu_read_lock();
	ipc_lock_object(ipcp);
	return ipcp;
}

/*
 * Insert new IPC object into idr tree, and set sequence number and id
 * in the correct order.
 * Especially:
 * - the sequence number must be set before inserting the object into the idr,
 *   because the sequence number is accessed without a lock.
 * - the id can/must be set after inserting the object into the idr.
 *   All accesses must be done after getting kern_ipc_perm.lock.
 *
 * The caller must own kern_ipc_perm.lock.of the new object.
 * On error, the function returns a (negative) error code.
 *
 * To conserve sequence number space, especially with extended ipc_mni,
 * the sequence number is incremented only when the returned ID is less than
 * the last one.
 */
static inline int ipc_idr_alloc(struct ipc_ids *ids, struct kern_ipc_perm *new)
{
	int idx, next_id = -1;

#ifdef CONFIG_CHECKPOINT_RESTORE
	next_id = ids->next_id;
	ids->next_id = -1;
#endif

	/*
	 * As soon as a new object is inserted into the idr,
	 * ipc_obtain_object_idr() or ipc_obtain_object_check() can find it,
	 * and the lockless preparations for ipc operations can start.
	 * This means especially: permission checks, audit calls, allocation
	 * of undo structures, ...
	 *
	 * Thus the object must be fully initialized, and if something fails,
	 * then the full tear-down sequence must be followed.
	 * (i.e.: set new->deleted, reduce refcount, call_rcu())
	 */

	if (next_id < 0) { /* !CHECKPOINT_RESTORE or next_id is unset */
		int max_idx;

		max_idx = max(ids->in_use*3/2, ipc_min_cycle);
		max_idx = min(max_idx, ipc_mni);

		/* allocate the idx, with a NULL struct kern_ipc_perm */
		idx = idr_alloc_cyclic(&ids->ipcs_idr, NULL, 0, max_idx,
					GFP_NOWAIT);

		if (idx >= 0) {
			/*
			 * idx got allocated successfully.
			 * Now calculate the sequence number and set the
			 * pointer for real.
			 */
			if (idx <= ids->last_idx) {
				ids->seq++;
				if (ids->seq >= ipcid_seq_max