8 files changed, 44 insertions, 275 deletions

diff --git a/ipc/Makefile b/ipc/Makefile
index 9075e172e52c..86c7300ecdf5 100644
--- a/ipc/Makefile
+++ b/ipc/Makefile
@@ -3,7 +3,7 @@
 #
 
 obj-$(CONFIG_SYSVIPC_COMPAT) += compat.o
-obj-$(CONFIG_SYSVIPC) += util.o msgutil.o msg.o sem.o shm.o ipcns_notifier.o syscall.o
+obj-$(CONFIG_SYSVIPC) += util.o msgutil.o msg.o sem.o shm.o syscall.o
 obj-$(CONFIG_SYSVIPC_SYSCTL) += ipc_sysctl.o
 obj_mq-$(CONFIG_COMPAT) += compat_mq.o
 obj-$(CONFIG_POSIX_MQUEUE) += mqueue.o msgutil.o $(obj_mq-y)
diff --git a/ipc/ipc_sysctl.c b/ipc/ipc_sysctl.c
index e8075b247497..8ad93c29f511 100644
--- a/ipc/ipc_sysctl.c
+++ b/ipc/ipc_sysctl.c
@@ -62,29 +62,6 @@ static int proc_ipc_dointvec_minmax_orphans(struct ctl_table *table, int write,
         return err;
 }
 
-static int proc_ipc_callback_dointvec_minmax(struct ctl_table *table, int write,
-        void __user *buffer, size_t *lenp, loff_t *ppos)
-{
-        struct ctl_table ipc_table;
-        size_t lenp_bef = *lenp;
-        int rc;
-
-        memcpy(&ipc_table, table, sizeof(ipc_table));
-        ipc_table.data = get_ipc(table);
-
-        rc = proc_dointvec_minmax(&ipc_table, write, buffer, lenp, ppos);
-
-        if (write && !rc && lenp_bef == *lenp)
-                /*
-                 * Tunable has successfully been changed by hand. Disable its
-                 * automatic adjustment. This simply requires unregistering
-                 * the notifiers that trigger recalculation.
-                 */
-                unregister_ipcns_notifier(current->nsproxy->ipc_ns);
-
-        return rc;
-}
-
 static int proc_ipc_doulongvec_minmax(struct ctl_table *table, int write,
         void __user *buffer, size_t *lenp, loff_t *ppos)
 {
@@ -96,54 +73,19 @@ static int proc_ipc_doulongvec_minmax(struct ctl_table *table, int write,
                                         lenp, ppos);
 }
 
-/*
- * Routine that is called when the file "auto_msgmni" has successfully been
- * written.
- * Two values are allowed:
- * 0: unregister msgmni's callback routine from the ipc namespace notifier
- *    chain. This means that msgmni won't be recomputed anymore upon memory
- *    add/remove or ipc namespace creation/removal.
- * 1: register back the callback routine.
- */
-static void ipc_auto_callback(int val)
-{
-        if (!val)
-                unregister_ipcns_notifier(current->nsproxy->ipc_ns);
-        else {
-                /*
-                 * Re-enable automatic recomputing only if not already
-                 * enabled.
-                 */
-                recompute_msgmni(current->nsproxy->ipc_ns);
-                cond_register_ipcns_notifier(current->nsproxy->ipc_ns);
-        }
-}
-
-static int proc_ipcauto_dointvec_minmax(struct ctl_table *table, int write,
+static int proc_ipc_auto_msgmni(struct ctl_table *table, int write,
         void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         struct ctl_table ipc_table;
-        int oldval;
-        int rc;
+        int dummy = 0;
 
         memcpy(&ipc_table, table, sizeof(ipc_table));
-        ipc_table.data = get_ipc(table);
-        oldval = *((int *)(ipc_table.data));
+        ipc_table.data = &dummy;
 
-        rc = proc_dointvec_minmax(&ipc_table, write, buffer, lenp, ppos);
+        if (write)
+                pr_info_once("writing to auto_msgmni has no effect");
 
-        if (write && !rc) {
-                int newval = *((int *)(ipc_table.data));
-                /*
-                 * The file "auto_msgmni" has correctly been set.
-                 * React by (un)registering the corresponding tunable, if the
-                 * value has changed.
-                 */
-                if (newval != oldval)
-                        ipc_auto_callback(newval);
-        }
-
-        return rc;
+        return proc_dointvec_minmax(&ipc_table, write, buffer, lenp, ppos);
 }
 
 #else
@@ -151,8 +93,7 @@ static int proc_ipcauto_dointvec_minmax(struct ctl_table *table, int write,
 #define proc_ipc_dointvec          NULL
 #define proc_ipc_dointvec_minmax   NULL
 #define proc_ipc_dointvec_minmax_orphans   NULL
-#define proc_ipc_callback_dointvec_minmax  NULL
-#define proc_ipcauto_dointvec_minmax NULL
+#define proc_ipc_auto_msgmni       NULL
 #endif
 
 static int zero;
@@ -204,11 +145,20 @@ static struct ctl_table ipc_kern_table[] = {
                 .data           = &init_ipc_ns.msg_ctlmni,
                 .maxlen         = sizeof(init_ipc_ns.msg_ctlmni),
                 .mode           = 0644,
-                .proc_handler   = proc_ipc_callback_dointvec_minmax,
+                .proc_handler   = proc_ipc_dointvec_minmax,
                 .extra1         = &zero,
                 .extra2         = &int_max,
         },
         {
+                .procname       = "auto_msgmni",
+                .data           = NULL,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = proc_ipc_auto_msgmni,
+                .extra1         = &zero,
+                .extra2         = &one,
+        },
+        {
                 .procname       =  "msgmnb",
                 .data           = &init_ipc_ns.msg_ctlmnb,
                 .maxlen         = sizeof(init_ipc_ns.msg_ctlmnb),
@@ -224,15 +174,6 @@ static struct ctl_table ipc_kern_table[] = {
                 .mode           = 0644,
                 .proc_handler   = proc_ipc_dointvec,
         },
-        {
-                .procname       = "auto_msgmni",
-                .data           = &init_ipc_ns.auto_msgmni,
-                .maxlen         = sizeof(int),
-                .mode           = 0644,
-                .proc_handler   = proc_ipcauto_dointvec_minmax,
-                .extra1         = &zero,
-                .extra2         = &one,
-        },
 #ifdef CONFIG_CHECKPOINT_RESTORE
         {
                 .procname       = "sem_next_id",
diff --git a/ipc/ipcns_notifier.c b/ipc/ipcns_notifier.c
deleted file mode 100644
index b9b31a4f77e1..000000000000
--- a/ipc/ipcns_notifier.c
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * linux/ipc/ipcns_notifier.c
- * Copyright (C) 2007 BULL SA. Nadia Derbey
- *
- * Notification mechanism for ipc namespaces:
- * The callback routine registered in the memory chain invokes the ipcns
- * notifier chain with the IPCNS_MEMCHANGED event.
- * Each callback routine registered in the ipcns namespace recomputes msgmni
- * for the owning namespace.
- */
-
-#include <linux/msg.h>
-#include <linux/rcupdate.h>
-#include <linux/notifier.h>
-#include <linux/nsproxy.h>
-#include <linux/ipc_namespace.h>
-
-#include "util.h"
-
-
-
-static BLOCKING_NOTIFIER_HEAD(ipcns_chain);
-
-
-static int ipcns_callback(struct notifier_block *self,
-                                unsigned long action, void *arg)
-{
-        struct ipc_namespace *ns;
-
-        switch (action) {
-        case IPCNS_MEMCHANGED:   /* amount of lowmem has changed */
-        case IPCNS_CREATED:
-        case IPCNS_REMOVED:
-                /*
-                 * It's time to recompute msgmni
-                 */
-                ns = container_of(self, struct ipc_namespace, ipcns_nb);
-                /*
-                 * No need to get a reference on the ns: the 1st job of
-                 * free_ipc_ns() is to unregister the callback routine.
-                 * blocking_notifier_chain_unregister takes the wr lock to do
-                 * it.
-                 * When this callback routine is called the rd lock is held by
-                 * blocking_notifier_call_chain.
-                 * So the ipc ns cannot be freed while we are here.
-                 */
-                recompute_msgmni(ns);
-                break;
-        default:
-                break;
-        }
-
-        return NOTIFY_OK;
-}
-
-int register_ipcns_notifier(struct ipc_namespace *ns)
-{
-        int rc;
-
-        memset(&ns->ipcns_nb, 0, sizeof(ns->ipcns_nb));
-        ns->ipcns_nb.notifier_call = ipcns_callback;
-        ns->ipcns_nb.priority = IPCNS_CALLBACK_PRI;
-        rc = blocking_notifier_chain_register(&ipcns_chain, &ns->ipcns_nb);
-        if (!rc)
-                ns->auto_msgmni = 1;
-        return rc;
-}
-
-int cond_register_ipcns_notifier(struct ipc_namespace *ns)
-{
-        int rc;
-
-        memset(&ns->ipcns_nb, 0, sizeof(ns->ipcns_nb));
-        ns->ipcns_nb.notifier_call = ipcns_callback;
-        ns->ipcns_nb.priority = IPCNS_CALLBACK_PRI;
-        rc = blocking_notifier_chain_cond_register(&ipcns_chain,
-                                                        &ns->ipcns_nb);
-        if (!rc)
-                ns->auto_msgmni = 1;
-        return rc;
-}
-
-void unregister_ipcns_notifier(struct ipc_namespace *ns)
-{
-        blocking_notifier_chain_unregister(&ipcns_chain, &ns->ipcns_nb);
-        ns->auto_msgmni = 0;
-}
-
-int ipcns_notify(unsigned long val)
-{
-        return blocking_notifier_call_chain(&ipcns_chain, val, NULL);
-}
diff --git a/ipc/msg.c b/ipc/msg.c
index c5d8e3749985..a7261d5cbc89 100644
--- a/ipc/msg.c
+++ b/ipc/msg.c
@@ -989,43 +989,12 @@ SYSCALL_DEFINE5(msgrcv, int, msqid, struct msgbuf __user *, msgp, size_t, msgsz,
         return do_msgrcv(msqid, msgp, msgsz, msgtyp, msgflg, do_msg_fill);
 }
 
-/*
- * Scale msgmni with the available lowmem size: the memory dedicated to msg
- * queues should occupy at most 1/MSG_MEM_SCALE of lowmem.
- * Also take into account the number of nsproxies created so far.
- * This should be done staying within the (MSGMNI , IPCMNI/nr_ipc_ns) range.
- */
-void recompute_msgmni(struct ipc_namespace *ns)
-{
-        struct sysinfo i;
-        unsigned long allowed;
-        int nb_ns;
-
-        si_meminfo(&i);
-        allowed = (((i.totalram - i.totalhigh) / MSG_MEM_SCALE) * i.mem_unit)
-                / MSGMNB;
-        nb_ns = atomic_read(&nr_ipc_ns);
-        allowed /= nb_ns;
-
-        if (allowed < MSGMNI) {
-                ns->msg_ctlmni = MSGMNI;
-                return;
-        }
-
-        if (allowed > IPCMNI / nb_ns) {
-                ns->msg_ctlmni = IPCMNI / nb_ns;
-                return;
-        }
-
-        ns->msg_ctlmni = allowed;
-}
 
 void msg_init_ns(struct ipc_namespace *ns)
 {
         ns->msg_ctlmax = MSGMAX;
         ns->msg_ctlmnb = MSGMNB;
-
-        recompute_msgmni(ns);
+        ns->msg_ctlmni = MSGMNI;
 
         atomic_set(&ns->msg_bytes, 0);
         atomic_set(&ns->msg_hdrs, 0);
@@ -1069,9 +1038,6 @@ void __init msg_init(void)
 {
         msg_init_ns(&init_ipc_ns);
 
-        printk(KERN_INFO "msgmni has been set to %d\n",
-                init_ipc_ns.msg_ctlmni);
-
         ipc_init_proc_interface("sysvipc/msg",
                                 "       key      msqid perms      cbytes       qnum lspid lrpid   uid   gid  cuid  cgid      stime      rtime      ctime\n",
                                 IPC_MSG_IDS, sysvipc_msg_proc_show);
diff --git a/ipc/namespace.c b/ipc/namespace.c
index b54468e48e32..1a3ffd40356e 100644
--- a/ipc/namespace.c
+++ b/ipc/namespace.c
@@ -45,14 +45,6 @@ static struct ipc_namespace *create_ipc_ns(struct user_namespace *user_ns,
         msg_init_ns(ns);
         shm_init_ns(ns);
 
-        /*
-         * msgmni has already been computed for the new ipc ns.
-         * Thus, do the ipcns creation notification before registering that
-         * new ipcns in the chain.
-         */
-        ipcns_notify(IPCNS_CREATED);
-        register_ipcns_notifier(ns);
-
         ns->user_ns = get_user_ns(user_ns);
 
         return ns;
@@ -99,25 +91,11 @@ void free_ipcs(struct ipc_namespace *ns, struct ipc_ids *ids,
 
 static void free_ipc_ns(struct ipc_namespace *ns)
 {
-        /*
-         * Unregistering the hotplug notifier at the beginning guarantees
-         * that the ipc namespace won't be freed while we are inside the
-         * callback routine. Since the blocking_notifier_chain_XXX routines
-         * hold a rw lock on the notifier list, unregister_ipcns_notifier()
-         * won't take the rw lock before blocking_notifier_call_chain() has
-         * released the rd lock.
-         */
-        unregister_ipcns_notifier(ns);
         sem_exit_ns(ns);
         msg_exit_ns(ns);
         shm_exit_ns(ns);
         atomic_dec(&nr_ipc_ns);
 
-        /*
-         * Do the ipcns removal notification after decrementing nr_ipc_ns in
-         * order to have a correct value when recomputing msgmni.
-         */
-        ipcns_notify(IPCNS_REMOVED);
         put_user_ns(ns->user_ns);
         proc_free_inum(ns->proc_inum);
         kfree(ns);
diff --git a/ipc/sem.c b/ipc/sem.c
index 53c3310f41c6..6115146563f9 100644
--- a/ipc/sem.c
+++ b/ipc/sem.c
@@ -326,10 +326,17 @@ static inline int sem_lock(struct sem_array *sma, struct sembuf *sops,
 
                 /* Then check that the global lock is free */
                 if (!spin_is_locked(&sma->sem_perm.lock)) {
-                        /* spin_is_locked() is not a memory barrier */
-                        smp_mb();
+                        /*
+                         * The ipc object lock check must be visible on all
+                         * cores before rechecking the complex count.  Otherwise
+                         * we can race with  another thread that does:
+                         *      complex_count++;
+                         *      spin_unlock(sem_perm.lock);
+                         */
+                        smp_rmb();
 
-                        /* Now repeat the test of complex_count:
+                        /*
+                         * Now repeat the test of complex_count:
                          * It can't change anymore until we drop sem->lock.
                          * Thus: if is now 0, then it will stay 0.
                          */
diff --git a/ipc/shm.c b/ipc/shm.c
index 01454796ba3c..19633b4a2350 100644
--- a/ipc/shm.c
+++ b/ipc/shm.c
@@ -219,7 +219,8 @@ static void shm_destroy(struct ipc_namespace *ns, struct shmid_kernel *shp)
         if (!is_file_hugepages(shm_file))
                 shmem_lock(shm_file, 0, shp->mlock_user);
         else if (shp->mlock_user)
-                user_shm_unlock(file_inode(shm_file)->i_size, shp->mlock_user);
+                user_shm_unlock(i_size_read(file_inode(shm_file)),
+                                shp->mlock_user);
         fput(shm_file);
         ipc_rcu_putref(shp, shm_rcu_free);
 }
@@ -1229,6 +1230,7 @@ SYSCALL_DEFINE1(shmdt, char __user *, shmaddr)
         int retval = -EINVAL;
 #ifdef CONFIG_MMU
         loff_t size = 0;
+        struct file *file;
         struct vm_area_struct *next;
 #endif
 
@@ -1245,7 +1247,8 @@ SYSCALL_DEFINE1(shmdt, char __user *, shmaddr)
          *   started at address shmaddr. It records it's size and then unmaps
          *   it.
          * - Then it unmaps all shm vmas that started at shmaddr and that
-         *   are within the initially determined size.
+         *   are within the initially determined size and that are from the
+         *   same shm segment from which we determined the size.
          * Errors from do_munmap are ignored: the function only fails if
          * it's called with invalid parameters or if it's called to unmap
          * a part of a vma. Both calls in this function are for full vmas,
@@ -1271,8 +1274,14 @@ SYSCALL_DEFINE1(shmdt, char __user *, shmaddr)
                 if ((vma->vm_ops == &shm_vm_ops) &&
                         (vma->vm_start - addr)/PAGE_SIZE == vma->vm_pgoff) {
 
-
-                        size = file_inode(vma->vm_file)->i_size;
+                        /*
+                         * Record the file of the shm segment being
+                         * unmapped.  With mremap(), someone could place
+                         * page from another segment but with equal offsets
+                         * in the range we are unmapping.
+                         */
+                        file = vma->vm_file;
+                        size = i_size_read(file_inode(vma->vm_file));
                         do_munmap(mm, vma->vm_start, vma->vm_end - vma->vm_start);
                         /*
                          * We discovered the size of the shm segment, so
@@ -1298,8 +1307,8 @@ SYSCALL_DEFINE1(shmdt, char __user *, shmaddr)
 
                 /* finding a matching vma now does not alter retval */
                 if ((vma->vm_ops == &shm_vm_ops) &&
-                        (vma->vm_start - addr)/PAGE_SIZE == vma->vm_pgoff)
-
+                    ((vma->vm_start - addr)/PAGE_SIZE == vma->vm_pgoff) &&
+                    (vma->vm_file == file))
                         do_munmap(mm, vma->vm_start, vma->vm_end - vma->vm_start);
                 vma = next;
         }
diff --git a/ipc/util.c b/ipc/util.c
index 88adc329888c..106bed0378ab 100644
--- a/ipc/util.c
+++ b/ipc/util.c
@@ -71,44 +71,6 @@ struct ipc_proc_iface {
         int (*show)(struct seq_file *, void *);
 };
 
-static void ipc_memory_notifier(struct work_struct *work)
-{
-        ipcns_notify(IPCNS_MEMCHANGED);
-}
-
-static int ipc_memory_callback(struct notifier_block *self,
-                                unsigned long action, void *arg)
-{
-        static DECLARE_WORK(ipc_memory_wq, ipc_memory_notifier);
-
-        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.
-                 */
-                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;
-}
-
-static struct notifier_block ipc_memory_nb = {
-        .notifier_call = ipc_memory_callback,
-        .priority = IPC_CALLBACK_PRI,
-};
-
 /**
  * ipc_init - initialise ipc subsystem
  *
@@ -124,8 +86,6 @@ static int __init ipc_init(void)
         sem_init();
         msg_init();
         shm_init();
-        register_hotmemory_notifier(&ipc_memory_nb);
-        register_ipcns_notifier(&init_ipc_ns);
         return 0;
 }
 device_initcall(ipc_init);