CVE-2013-4483 (C, published 2013-11-04T15:55Z)
Description: value: The ipc_rcu_putref function in ipc/util.c in the Linux kernel before 3.10 does not properly manage a reference count, which allows local users to cause a denial of service (memory consumption or system crash) via a crafted application.
Severity: MEDIUM (CVSS v3 base score: )
Weakness: CWE-189 \u2014 Numeric Errors
Weaknesses in this category are related to improper calculation or conversion of numbers.
Repository: https://github.com/torvalds/linux
Files changed:
ipc/msg.c
ipc/sem.c
ipc/util.c
ipc/util.h
Commit message: ipc,sem: fine grained locking for semtimedop

Introduce finer grained locking for semtimedop, to handle the common case
of a program wanting to manipulate one semaphore from an array with
multiple semaphores.

If the call is a semop manipulating just one semaphore in an array with
multiple semaphores, only take the lock for that semaphore itself.

If the call needs to manipulate multiple semaphores, or another caller is
in a transaction that manipulates multiple semaphores, the sem_array lock
is taken, as well as all the locks for the individual semaphores.

On a 24 CPU system, performance numbers with the semop-multi
test with N threads and N semaphores, look like this:

	vanilla		Davidlohr's	Davidlohr's +	Davidlohr's +
threads			patches		rwlock patches	v3 patches
10	610652		726325		1783589		2142206
20	341570		365699		1520453		1977878
30	288102		307037		1498167		2037995
40	290714		305955		1612665		2256484
50	288620		312890		1733453		2650292
60	289987		306043		1649360		2388008
70	291298		306347		1723167		2717486
80	290948		305662		1729545		2763582
90	290996		306680		1736021		2757524
100	292243		306700		1773700		3059159

[davidlohr.bueso@hp.com: do not call sem_lock when bogus sma]
[davidlohr.bueso@hp.com: make refcounter atomic]
Signed-off-by: Rik van Riel <riel@redhat.com>
Suggested-by: Linus Torvalds <torvalds@linux-foundation.org>
Acked-by: Davidlohr Bueso <davidlohr.bueso@hp.com>
Cc: Chegu Vinod <chegu_vinod@hp.com>
Cc: Jason Low <jason.low2@hp.com>
Reviewed-by: Michel Lespinasse <walken@google.com>
Cc: Peter Hurley <peter@hurleysoftware.com>
Cc: Stanislav Kinsbursky <skinsbursky@parallels.com>
Tested-by: Emmanuel Benisty <benisty.e@gmail.com>
Tested-by: Sedat Dilek <sedat.dilek@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>


Vulnerable code:
		ipc_rcu_getref(msq);
#define sem_unlock(sma)		ipc_unlock(&(sma)->sem_perm)
static inline struct sem_array *sem_obtain_lock(struct ipc_namespace *ns, int id)
	spin_lock(&ipcp->lock);
	spin_unlock(&ipcp->lock);
static inline struct sem_array *sem_lock_check(struct ipc_namespace *ns,
						int id)
{
	struct kern_ipc_perm *ipcp = ipc_lock_check(&sem_ids(ns), id);

	if (IS_ERR(ipcp))
		return ERR_CAST(ipcp);

	return container_of(ipcp, struct sem_array, sem_perm);
}

	ipc_lock_by_ptr(&sma->sem_perm);
	ipc_rcu_getref(sma);
	ipc_unlock(&(sma)->sem_perm);
	ipc_lock_by_ptr(&sma->sem_perm);
	ipc_rcu_putref(sma);
	ipc_unlock(&(sma)->sem_perm);
	spin_lock(&(sma)->sem_perm.lock);
	ipc_rcu_getref(sma);
	ipc_unlock(&(sma)->sem_perm);
	for (i = 0; i < nsems; i++)
	sem_unlock(sma);
	sem_unlock(sma);
	int nsems;
	sma = sem_lock_check(ns, semid);
	if (IS_ERR(sma))
		return PTR_ERR(sma);
	nsems = sma->sem_nsems;
	err = -EACCES;
	if (ipcperms(ns, &sma->sem_perm, S_IWUGO))
		goto out_unlock;
	if (err)
		goto out_unlock;
	err = -EINVAL;
	if(semnum < 0 || semnum >= nsems)
		goto out_unlock;
	err = -ERANGE;
	if (val > SEMVMX || val < 0)
		goto out_unlock;

	err = 0;
out_unlock:
	sem_unlock(sma);
	return err;
				sem_unlock(sma);
		}
		spin_lock(&sma->sem_perm.lock);
		sem_unlock(sma);
		ipc_rcu_getref(sma);
			sem_unlock(sma);
	spin_lock(&sma->sem_perm.lock);
	sem_unlock(sma);
		ipc_lock_object(&sma->sem_perm);
		ipc_lock_object(&sma->sem_perm);
	sem_unlock(sma);
	int nsems;
	int error;
	ipc_rcu_getref(sma);
		sem_unlock(sma);
	sem_unlock(sma);
	int undos = 0, alter = 0, max;
	} else
	INIT_LIST_HEAD(&tasks);

	rcu_read_lock();
		if (un)
			rcu_read_unlock();
	ipc_lock_object(&sma->sem_perm);
	if (un) {
		if (un->semid == -1) {
			rcu_read_unlock();
			goto out_unlock_free;
		} else {
			/*
			 * rcu lock can be released, "un" cannot disappear:
			 * - sem_lock is acquired, thus IPC_RMID is
			 *   impossible.
			 * - exit_sem is impossible, it always operates on
			 *   current (or a dead task).
			 */

			rcu_read_unlock();
		}
	}
	sem_unlock(sma);
	sma = sem_obtain_lock(ns, semid);
	sem_unlock(sma);
		int semid;
		int i;
		rcu_read_unlock();
		if (semid == -1)
		sma = sem_lock_check(tsk->nsproxy->ipc_ns, un->semid);

		if (IS_ERR(sma))
			sem_unlock(sma);
		sem_unlock(sma);
void* ipc_alloc(int size)
	void* out;
	int refcount;
 *	Returns the pointer to the object.
 *	NULL is returned if the allocation fails. 
 
void* ipc_rcu_alloc(int size)
	void* out;
	/* 
	 * workqueue if necessary (for vmalloc). 
		if (out) {
			out += HDRLEN_VMALLOC;
			container_of(out, struct ipc_rcu_hdr, data)->is_vmalloc = 1;
			container_of(out, struct ipc_rcu_hdr, data)->refcount = 1;
		}
		if (out) {
			out += HDRLEN_KMALLOC;
			container_of(out, struct ipc_rcu_hdr, data)->is_vmalloc = 0;
			container_of(out, struct ipc_rcu_hdr, data)->refcount = 1;
		}
void ipc_rcu_getref(void *ptr)
	container_of(ptr, struct ipc_rcu_hdr, data)->refcount++;
	if (--container_of(ptr, struct ipc_rcu_hdr, data)->refcount > 0)
void ipc_rcu_getref(void *ptr);

Fixed code:

		if (!ipc_rcu_getref(msq)) {
			err = -EIDRM;
			goto out_unlock_free;
		}

	spinlock_t	lock;	/* spinlock for fine-grained semtimedop */
/*
 * If the request contains only one semaphore operation, and there are
 * no complex transactions pending, lock only the semaphore involved.
 * Otherwise, lock the entire semaphore array, since we either have
 * multiple semaphores in our own semops, or we need to look at
 * semaphores from other pending complex operations.
 *
 * Carefully guard against sma->complex_count changing between zero
 * and non-zero while we are spinning for the lock. The value of
 * sma->complex_count cannot change while we are holding the lock,
 * so sem_unlock should be fine.
 *
 * The global lock path checks that all the local locks have been released,
 * checking each local lock once. This means that the local lock paths
 * cannot start their critical sections while the global lock is held.
 */
static inline int sem_lock(struct sem_array *sma, struct sembuf *sops,
			      int nsops)
{
	int locknum;
 again:
	if (nsops == 1 && !sma->complex_count) {
		struct sem *sem = sma->sem_base + sops->sem_num;

		/* Lock just the semaphore we are interested in. */
		spin_lock(&sem->lock);

		/*
		 * If sma->complex_count was set while we were spinning,
		 * we may need to look at things we did not lock here.
		 */
		if (unlikely(sma->complex_count)) {
			spin_unlock(&sem->lock);
			goto lock_array;
		}

		/*
		 * Another process is holding the global lock on the
		 * sem_array; we cannot enter our critical section,
		 * but have to wait for the global lock to be released.
		 */
		if (unlikely(spin_is_locked(&sma->sem_perm.lock))) {
			spin_unlock(&sem->lock);
			spin_unlock_wait(&sma->sem_perm.lock);
			goto again;
		}

		locknum = sops->sem_num;
	} else {
		int i;
		/*
		 * Lock the semaphore array, and wait for all of the
		 * individual semaphore locks to go away.  The code
		 * above ensures no new single-lock holders will enter
		 * their critical section while the array lock is held.
		 */
 lock_array:
		spin_lock(&sma->sem_perm.lock);
		for (i = 0; i < sma->sem_nsems; i++) {
			struct sem *sem = sma->sem_base + i;
			spin_unlock_wait(&sem->lock);
		}
		locknum = -1;
	}
	return locknum;
}

static inline void sem_unlock(struct sem_array *sma, int locknum)
{
	if (locknum == -1) {
		spin_unlock(&sma->sem_perm.lock);
	} else {
		struct sem *sem = sma->sem_base + locknum;
		spin_unlock(&sem->lock);
	}
	rcu_read_unlock();
}

static inline struct sem_array *sem_obtain_lock(struct ipc_namespace *ns,
			int id, struct sembuf *sops, int nsops, int *locknum)
	sma = container_of(ipcp, struct sem_array, sem_perm);
	*locknum = sem_lock(sma, sops, nsops);
	sem_unlock(sma, *locknum);
	rcu_read_lock();
	sem_lock(sma, NULL, -1);
	WARN_ON_ONCE(!ipc_rcu_getref(sma));
	sem_unlock(sma, -1);
	sem_lock_and_putref(sma);
	sem_unlock(sma, -1);
	sem_lock(sma, NULL, -1);
	WARN_ON_ONCE(!ipc_rcu_getref(sma));
	sem_unlock(sma, -1);
	for (i = 0; i < nsems; i++) {
		spin_lock_init(&sma->sem_base[i].lock);
	}
	sem_unlock(sma, -1);
	sem_unlock(sma, -1);
	if (val > SEMVMX || val < 0)
		return -ERANGE;
	rcu_read_lock();
	sma = sem_obtain_object_check(ns, semid);
	if (IS_ERR(sma)) {
		rcu_read_unlock();
		return PTR_ERR(sma);
	}

	if (semnum < 0 || semnum >= sma->sem_nsems) {
		rcu_read_unlock();
		return -EINVAL;
	}


	if (ipcperms(ns, &sma->sem_perm, S_IWUGO)) {
		rcu_read_unlock();
		return -EACCES;
	}
	if (err) {
		rcu_read_unlock();
		return -EACCES;
	}
	sem_lock(sma, NULL, -1);
	sem_unlock(sma, -1);
	return 0;
				sem_unlock(sma, -1);
		} else
			sem_lock(sma, NULL, -1);
		sem_unlock(sma, -1);
		if (!ipc_rcu_getref(sma)) {
			rcu_read_unlock();
			return -EIDRM;
		}
			sem_unlock(sma, -1);
	sem_lock(sma, NULL, -1);
	sem_unlock(sma, -1);
		sem_lock(sma, NULL, -1);
		sem_lock(sma, NULL, -1);
	sem_unlock(sma, -1);
	int nsems, error;
	if (!ipc_rcu_getref(sma)) {
		rcu_read_unlock();
		un = ERR_PTR(-EIDRM);
		goto out;
	}
		sem_unlock(sma, -1);
	sem_unlock(sma, -1);
	int undos = 0, alter = 0, max, locknum;
	INIT_LIST_HEAD(&tasks);

		/* On success, find_alloc_undo takes the rcu_read_lock */
	} else {
		rcu_read_lock();
	}
		rcu_read_unlock();
	locknum = sem_lock(sma, sops, nsops);
	if (un && un->semid == -1)
		goto out_unlock_free;
	sem_unlock(sma, locknum);
	sma = sem_obtain_lock(ns, semid, sops, nsops, &locknum);
	sem_unlock(sma, locknum);
		int semid, i;
		if (semid == -1) {
			rcu_read_unlock();
		}
		sma = sem_obtain_object_check(tsk->nsproxy->ipc_ns, un->semid);
		if (IS_ERR(sma)) {
			rcu_read_unlock();
		}
		sem_lock(sma, NULL, -1);
			sem_unlock(sma, -1);
		sem_unlock(sma, -1);
void *ipc_alloc(int size)
	void *out;
	atomic_t refcount;
 *	Returns the pointer to the object or NULL upon failure.
void *ipc_rcu_alloc(int size)
	void *out;

	/*
	 * workqueue if necessary (for vmalloc).
		if (!out)
			goto done;

		out += HDRLEN_VMALLOC;
		container_of(out, struct ipc_rcu_hdr, data)->is_vmalloc = 1;
		if (!out)
			goto done;

		out += HDRLEN_KMALLOC;
		container_of(out, struct ipc_rcu_hdr, data)->is_vmalloc = 0;
	/* set reference counter no matter what kind of allocation was done */
	atomic_set(&container_of(out, struct ipc_rcu_hdr, data)->refcount, 1);
done:
int ipc_rcu_getref(void *ptr)
	return atomic_inc_not_zero(&container_of(ptr, struct ipc_rcu_hdr, data)->refcount);
	if (!atomic_dec_and_test(&container_of(ptr, struct ipc_rcu_hdr, data)->refcount))
int ipc_rcu_getref(void *ptr);