[PATCH] shm: make sysv ipc shared memory use stacked files

The current ipc shared memory code runs into several problems because it
does not quite use files like the rest of the kernel.  With the option of
backing ipc shared memory with either hugetlbfs or ordinary shared memory
the problems got worse.  With the added support for ipc namespaces things
behaved so unexpected that we now have several bad namespace reference
counting bugs when using what appears at first glance to be a reasonable
idiom.

So to attack these problems and hopefully make the code more maintainable
this patch simply uses the files provided by other parts of the kernel and
builds it's own files out of them.  The shm files are allocated in do_shmat
and freed when their reference count drops to zero with their last unmap.
The file and vm operations that we don't want to implement or we don't
implement completely we just delegate to the operations of our backing
file.

This means that we now get an accurate shm_nattch count for we have a
hugetlbfs inode for backing store, and the shm accounting of last attach
and last detach time work as well.

This means that getting a reference to the ipc namespace when we create the
file and dropping the referenece in the release method is now safe and
correct.

This means we no longer need a special case for clearing VM_MAYWRITE
as our file descriptor now only has write permissions when we have
requested write access when calling shmat.  Although VM_SHARED is now
cleared as well which I believe is harmless and is mostly likely a
minor bug fix.

By using the same set of operations for both the hugetlb case and regular
shared memory case shmdt is not simplified and made slightly more correct
as now the test "vma->vm_ops == &shm_vm_ops" is 100% accurate in spotting
all shared memory regions generated from sysvipc shared memory.

Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Cc: Michal Piotrowski <michal.k.k.piotrowski@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 155 insertions, 85 deletions

diff --git a/ipc/shm.c b/ipc/shm.c
index 5bb617f6306e..eb57e2254304 100644
--- a/ipc/shm.c
+++ b/ipc/shm.c
@@ -37,11 +37,21 @@
 #include <linux/seq_file.h>
 #include <linux/mutex.h>
 #include <linux/nsproxy.h>
+#include <linux/mount.h>
 
 #include <asm/uaccess.h>
 
 #include "util.h"
 
+struct shm_file_data {
+        int id;
+        struct ipc_namespace *ns;
+        struct file *file;
+        const struct vm_operations_struct *vm_ops;
+};
+
+#define shm_file_data(file) (*((struct shm_file_data **)&(file)->private_data))
+
 static const struct file_operations shm_file_operations;
 static struct vm_operations_struct shm_vm_ops;
 
@@ -60,8 +70,8 @@ static struct ipc_ids init_shm_ids;
 
 static int newseg (struct ipc_namespace *ns, key_t key,
                 int shmflg, size_t size);
-static void shm_open (struct vm_area_struct *shmd);
-static void shm_close (struct vm_area_struct *shmd);
+static void shm_open(struct vm_area_struct *vma);
+static void shm_close(struct vm_area_struct *vma);
 static void shm_destroy (struct ipc_namespace *ns, struct shmid_kernel *shp);
 #ifdef CONFIG_PROC_FS
 static int sysvipc_shm_proc_show(struct seq_file *s, void *it);
@@ -150,11 +160,14 @@ static inline int shm_addid(struct ipc_namespace *ns, struct shmid_kernel *shp)
 
 
 
-static inline void shm_inc(struct ipc_namespace *ns, int id)
+/* This is called by fork, once for every shm attach. */
+static void shm_open(struct vm_area_struct *vma)
 {
+        struct file *file = vma->vm_file;
+        struct shm_file_data *sfd = shm_file_data(file);
         struct shmid_kernel *shp;
 
-        shp = shm_lock(ns, id);
+        shp = shm_lock(sfd->ns, sfd->id);
         BUG_ON(!shp);
         shp->shm_atim = get_seconds();
         shp->shm_lprid = current->tgid;
@@ -162,15 +175,6 @@ static inline void shm_inc(struct ipc_namespace *ns, int id)
         shm_unlock(shp);
 }
 
-#define shm_file_ns(file) (*((struct ipc_namespace **)&(file)->private_data))
-
-/* This is called by fork, once for every shm attach. */
-static void shm_open(struct vm_area_struct *shmd)
-{
-        shm_inc(shm_file_ns(shmd->vm_file),
-                        shmd->vm_file->f_path.dentry->d_inode->i_ino);
-}
-
 /*
  * shm_destroy - free the struct shmid_kernel
  *
@@ -195,23 +199,21 @@ static void shm_destroy(struct ipc_namespace *ns, struct shmid_kernel *shp)
 }
 
 /*
- * remove the attach descriptor shmd.
+ * remove the attach descriptor vma.
  * free memory for segment if it is marked destroyed.
  * The descriptor has already been removed from the current->mm->mmap list
  * and will later be kfree()d.
  */
-static void shm_close (struct vm_area_struct *shmd)
+static void shm_close(struct vm_area_struct *vma)
 {
-        struct file * file = shmd->vm_file;
-        int id = file->f_path.dentry->d_inode->i_ino;
+        struct file * file = vma->vm_file;
+        struct shm_file_data *sfd = shm_file_data(file);
         struct shmid_kernel *shp;
-        struct ipc_namespace *ns;
-
-        ns = shm_file_ns(file);
+        struct ipc_namespace *ns = sfd->ns;
 
         mutex_lock(&shm_ids(ns).mutex);
         /* remove from the list of attaches of the shm segment */
-        shp = shm_lock(ns, id);
+        shp = shm_lock(ns, sfd->id);
         BUG_ON(!shp);
         shp->shm_lprid = current->tgid;
         shp->shm_dtim = get_seconds();
@@ -224,46 +226,91 @@ static void shm_close (struct vm_area_struct *shmd)
         mutex_unlock(&shm_ids(ns).mutex);
 }
 
+struct page *shm_nopage(struct vm_area_struct *vma, unsigned long address,
+                        int *type)
+{
+        struct file *file = vma->vm_file;
+        struct shm_file_data *sfd = shm_file_data(file);
+
+        return sfd->vm_ops->nopage(vma, address, type);
+}
+
+#ifdef CONFIG_NUMA
+int shm_set_policy(struct vm_area_struct *vma, struct mempolicy *new)
+{
+        struct file *file = vma->vm_file;
+        struct shm_file_data *sfd = shm_file_data(file);
+        int err = 0;
+        if (sfd->vm_ops->set_policy)
+                err = sfd->vm_ops->set_policy(vma, new);
+        return err;
+}
+
+struct mempolicy *shm_get_policy(struct vm_area_struct *vma, unsigned long addr)
+{
+        struct file *file = vma->vm_file;
+        struct shm_file_data *sfd = shm_file_data(file);
+        struct mempolicy *pol = NULL;
+
+        if (sfd->vm_ops->get_policy)
+                pol = sfd->vm_ops->get_policy(vma, addr);
+        else
+                pol = vma->vm_policy;
+        return pol;
+}
+#endif
+
 static int shm_mmap(struct file * file, struct vm_area_struct * vma)
 {
+        struct shm_file_data *sfd = shm_file_data(file);
         int ret;
 
-        ret = shmem_mmap(file, vma);
-        if (ret == 0) {
-                vma->vm_ops = &shm_vm_ops;
-                if (!(vma->vm_flags & VM_WRITE))
-                        vma->vm_flags &= ~VM_MAYWRITE;
-                shm_inc(shm_file_ns(file), file->f_path.dentry->d_inode->i_ino);
-        }
+        ret = sfd->file->f_op->mmap(sfd->file, vma);
+        if (ret != 0)
+                return ret;
+        sfd->vm_ops = vma->vm_ops;
+        vma->vm_ops = &shm_vm_ops;
+        shm_open(vma);
 
         return ret;
 }
 
 static int shm_release(struct inode *ino, struct file *file)
 {
-        struct ipc_namespace *ns;
+        struct shm_file_data *sfd = shm_file_data(file);
 
-        ns = shm_file_ns(file);
-        put_ipc_ns(ns);
-        shm_file_ns(file) = NULL;
+        put_ipc_ns(sfd->ns);
+        shm_file_data(file) = NULL;
+        kfree(sfd);
         return 0;
 }
 
+#ifndef CONFIG_MMU
+static unsigned long shm_get_unmapped_area(struct file *file,
+        unsigned long addr, unsigned long len, unsigned long pgoff,
+        unsigned long flags)
+{