/* * 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> */ #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/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 <asm/unistd.h> #include "util.h" struct ipc_proc_iface {	const char *path;	const char *header;	int ids;	int (*show)(struct seq_file *, void *);}; #ifdef CONFIG_MEMORY_HOTPLUG static void ipc_memory_notifier(struct work_struct *work){	ipcns_notify(IPCNS_MEMCHANGED);} static DECLARE_WORK(ipc_memory_wq, ipc_memory_notifier);  static int ipc_memory_callback(struct notifier_block *self,				unsigned long action, void *arg){	switch (action) {	case MEM_ONLINE:    /* memory successfully brought online */	case MEM_OFFLINE:   /* or offline: it's time to recompute msgmni */		/*		 * This is done by invoking the ipcns notifier chain with the		 * IPC_MEMCHANGED event.		 * In order not to keep the lock on the hotplug memory chain		 * for too long, queue a work item that will, when waken up,		 * activate the ipcns notification chain.		 * No need to keep several ipc work items on the queue.		 */		if (!work_pending(&ipc_memory_wq))			schedule_work(&ipc_memory_wq);		break;	case MEM_GOING_ONLINE:	case MEM_GOING_OFFLINE:	case MEM_CANCEL_ONLINE:	case MEM_CANCEL_OFFLINE:	default:		break;	} 	return NOTIFY_OK;} #endif /* CONFIG_MEMORY_HOTPLUG */ /** *	ipc_init	-	initialise IPC subsystem * *	The various system5 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){	sem_init();	msg_init();	shm_init();	hotplug_memory_notifier(ipc_memory_callback, IPC_CALLBACK_PRI);	register_ipcns_notifier(&init_ipc_ns);	return 0;}__initcall(ipc_init); /** *	ipc_init_ids		-	initialise IPC identifiers *	@ids: Identifier set * *	Set up the sequence range to use for the ipc identifier range (limited *	below IPCMNI) then initialise the ids idr. */ void ipc_init_ids(struct ipc_ids *ids){	init_rwsem(&ids->rw_mutex); 	ids->in_use = 0;	ids->seq = 0;	{		int seq_limit = INT_MAX/SEQ_MULTIPLIER;		if (seq_limit > USHRT_MAX)			ids->seq_max = USHRT_MAX;		 else		 	ids->seq_max = seq_limit;	} 	idr_init(&ids->ipcs_idr);} #ifdef CONFIG_PROC_FSstatic 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: Identifier set *	@key: The key to find *	 *	Requires ipc_ids.rw_mutex locked. *	Returns the LOCKED pointer to the ipc structure if found or NULL *	if not. *	If key is found ipc points to the owning ipc structure */ static struct kern_ipc_perm *ipc_findkey(struct ipc_ids *ids, key_t key){	struct kern_ipc_perm *ipc;	int next_id;	int total; 	for (total = 0, next_id = 0; total < ids->in_use; next_id++) {		ipc = idr_find(&ids->ipcs_idr, next_id); 		if (ipc == NULL)			continue; 		if (ipc->key != key) {			total++;			continue;		} 		ipc_lock_by_ptr(ipc);		return ipc;	} 	return NULL;} /** *	ipc_get_maxid 	-	get the last assigned id *	@ids: IPC identifier set * *	Called with ipc_ids.rw_mutex held. */ int ipc_get_maxid(struct ipc_ids *ids){	struct kern_ipc_perm *ipc;	int max_id = -1;	int total, id; 	if (ids->in_use == 0)		return -1; 	if (ids->in_use == IPCMNI)		return IPCMNI - 1; 	/* Look for the last assigned id */	total = 0;	for (id = 0; id < IPCMNI && total < ids->in_use; id++) {		ipc = idr_find(&ids->ipcs_idr, id);		if (ipc != NULL) {			max_id = id;			total++;		}	}	return max_id;} /** *	ipc_addid 	-	add an IPC identifier *	@ids: IPC identifier set *	@new: new IPC permission set *	@size: limit for the number of used ids * *	Add an entry 'new' to the IPC ids idr. The permissions object is *	initialised and the first free entry is set up and the id assigned *	is returned. The 'new' entry is returned in a locked state on success. *	On failure the entry is not locked and a negative err-code is returned. * *	Called with ipc_ids.rw_mutex held as a writer. */ int ipc_addid(struct ipc_ids* ids, struct kern_ipc_perm* new, int size){	uid_t euid;	gid_t egid;	int id, err; 	if (size > IPCMNI)		size = IPCMNI; 	if (ids->in_use >= size)		return -ENOSPC; 	spin_lock_init(&new->lock);	new->deleted = 0;	rcu_read_lock();	spin_lock(&new->lock); 	err = idr_get_new(&ids->ipcs_idr, new, &id);	if (err) {		spin_unlock(&new->lock);		rcu_read_unlock();		return err;	} 	ids->in_use++; 	current_euid_egid(&euid, &egid);	new->cuid = new->uid = euid;	new->gid = new->cgid = egid; 	new->seq = ids->seq++;	if(ids->seq > ids->seq_max)		ids->seq = 0; 	new->id = ipc_buildid(id, new->seq);	return id;} /** *	ipcget_new	-	create a new ipc object *	@ns: namespace *	@ids: IPC identifer set *	@ops: the actual creation routine to call *	@params: its parameters * *	This routine is called by sys_msgget, sys_semget() and sys_shmget() *	when the key is IPC_PRIVATE. */static int ipcget_new(struct ipc_namespace *ns, struct ipc_ids *ids,		struct ipc_ops *ops, struct ipc_params *params){	int err;retry:	err = idr_pre_get(&ids->ipcs_idr, GFP_KERNEL); 	if (!err)		return -ENOMEM; 	down_write(&ids->rw_mutex);	err = ops->getnew(ns, params);	up_write(&ids->rw_mutex); 	if (err == -EAGAIN)		goto retry; 	return err;} /** *	ipc_check_perms	-	check security and permissions for an IPC *	@ns: IPC namespace *	@ipcp: ipc permission set *	@ops: the actual security routine to call *	@params: its parameters * *	This routine is called by sys_msgget(), sys_semget() and sys_shmget() *      when the key is not IPC_PRIVATE and that key already exists in the *      ids IDR. * *	On success, the IPC id is returned. * *	It is called with ipc_ids.rw_mutex and ipcp->lock held. */static int ipc_check_perms(struct ipc_namespace *ns,			   struct kern_ipc_perm *ipcp,			   struct ipc_ops *ops,			   struct ipc_params *params){	int err; 	if (ipcperms(ns, ipcp, params->flg))		err = -EACCES;	else {		err = ops->associate(ipcp, params->flg);		if (!err)			err = ipcp->id;	} 	return err;} /** *	ipcget_public	-	get an ipc object or create a new one *	@ns: namespace *	@ids: IPC identifer set *	@ops: the actual creation routine to call *	@params: its parameters * *	This routine is called by sys_msgget, sys_semget() and sys_shmget() *	when the key is not IPC_PRIVATE. *	It adds a new entry if the key is not found and does some permission *      / security checkings if the key is found. * *	On success, the ipc id is returned. */static int ipcget_public(struct ipc_namespace *ns, struct ipc_ids *ids,		struct ipc_ops *ops, struct ipc_params *params){	struct kern_ipc_perm *ipcp;	int flg = params->flg;	int err;retry:	err = idr_pre_get(&ids->ipcs_idr, GFP_KERNEL); 	/*	 * Take the lock as a writer since we are potentially going to add	 * a new entry + read locks are not "upgradable"	 */	down_write(&ids->rw_mutex);	ipcp = ipc_findkey(ids, params->key);	if (ipcp == NULL) {		/* key not used */		if (!(flg & IPC_CREAT))			err = -ENOENT;		else if (!err)			err = -ENOMEM;		else			err = ops->getnew(ns, params);	} else {		/* ipc object has been locked by ipc_findkey() */ 		if (flg & IPC_CREAT && flg & IPC_EXCL)			err = -EEXIST;		else {			err = 0;			if (ops->more_checks)				err = ops->more_checks(ipcp, params);			if (!err)				/*				 * ipc_check_perms returns the IPC id on				 * success				 */				err = ipc_check_perms(ns, ipcp, ops, params);		}		ipc_unlock(ipcp);	}	up_write(&ids->rw_mutex); 	if (err == -EAGAIN)		goto retry; 	return err;}  /** *	ipc_rmid	-	remove an IPC identifier *	@ids: IPC identifier set *	@ipcp: ipc perm structure containing the identifier to remove * *	ipc_ids.rw_mutex (as a writer) and the spinlock for this ID are held *	before this function is called, and remain locked on the exit. */ void ipc_rmid(struct ipc_ids *ids, struct kern_ipc_perm *ipcp){	int lid = ipcid_to_idx(ipcp->id); 	idr_remove(&ids->ipcs_idr, lid); 	ids->in_use--; 	ipcp->deleted = 1; 	return;} /** *	ipc_alloc	-	allocate ipc space *	@size: size desired * *	Allocate memory from the appropriate pools and return a pointer to it. *	NULL is returned if the allocation fails */ void* ipc_alloc(int size){	void* out;	if(size > PAGE_SIZE)		out = vmalloc(size);	else		out = kmalloc(size, GFP_KERNEL);	return out;} /** *	ipc_free        -       free ipc space *	@ptr: pointer returned by ipc_alloc *	@size: size of block * *	Free a block created with ipc_alloc(). The caller must know the size *	used in the allocation call. */ void ipc_free(void* ptr, int size){	if(size > PAGE_SIZE)		vfree(ptr);	else		kfree(ptr);} /* * rcu allocations: * There are three headers that are prepended to the actual allocation: * - during use: ipc_rcu_hdr. * - during the rcu grace period: ipc_rcu_grace. * - [only if vmalloc]: ipc_rcu_sched. * Their lifetime doesn't overlap, thus the headers share the same memory. * Unlike a normal union, they are right-aligned, thus some container_of * forward/backward casting is necessary: */struct ipc_rcu_hdr{	int refcount;	int is_vmalloc;	void *data[0];};  struct ipc_rcu_grace{	struct rcu_head rcu;	/* "void *" makes sure alignment of following data is sane. */	void *data[0];}; struct ipc_rcu_sched{	struct work_struct work;	/* "void *" makes sure alignment of following data is sane. */

Lines 1–500 of 1001. Load more