This commit was manufactured by cvs2svn to create branch 'vserver'.

[linux-2.6.git] / fs / relayfs / buffers.c

diff --git a/fs/relayfs/buffers.c b/fs/relayfs/buffers.c
new file mode 100644 (file)
index 0000000..1018781
--- /dev/null
+++ b/fs/relayfs/buffers.c
@@ -0,0 +1,190 @@
+/*
+ * RelayFS buffer management code.
+ *
+ * Copyright (C) 2002-2005 - Tom Zanussi (zanussi@us.ibm.com), IBM Corp
+ * Copyright (C) 1999-2005 - Karim Yaghmour (karim@opersys.com)
+ *
+ * This file is released under the GPL.
+ */
+
+#include <linux/module.h>
+#include <linux/vmalloc.h>
+#include <linux/mm.h>
+#include <linux/relayfs_fs.h>
+#include "relay.h"
+#include "buffers.h"
+
+/*
+ * close() vm_op implementation for relayfs file mapping.
+ */
+static void relay_file_mmap_close(struct vm_area_struct *vma)
+{
+       struct rchan_buf *buf = vma->vm_private_data;
+       buf->chan->cb->buf_unmapped(buf, vma->vm_file);
+}
+
+/*
+ * nopage() vm_op implementation for relayfs file mapping.
+ */
+static struct page *relay_buf_nopage(struct vm_area_struct *vma,
+                                    unsigned long address,
+                                    int *type)
+{
+       struct page *page;
+       struct rchan_buf *buf = vma->vm_private_data;
+       unsigned long offset = address - vma->vm_start;
+
+       if (address > vma->vm_end)
+               return NOPAGE_SIGBUS; /* Disallow mremap */
+       if (!buf)
+               return NOPAGE_OOM;
+
+       page = vmalloc_to_page(buf->start + offset);
+       if (!page)
+               return NOPAGE_OOM;
+       get_page(page);
+
+       if (type)
+               *type = VM_FAULT_MINOR;
+
+       return page;
+}
+
+/*
+ * vm_ops for relay file mappings.
+ */
+static struct vm_operations_struct relay_file_mmap_ops = {
+       .nopage = relay_buf_nopage,
+       .close = relay_file_mmap_close,
+};
+
+/**
+ *     relay_mmap_buf: - mmap channel buffer to process address space
+ *     @buf: relay channel buffer
+ *     @vma: vm_area_struct describing memory to be mapped
+ *
+ *     Returns 0 if ok, negative on error
+ *
+ *     Caller should already have grabbed mmap_sem.
+ */
+int relay_mmap_buf(struct rchan_buf *buf, struct vm_area_struct *vma)
+{
+       unsigned long length = vma->vm_end - vma->vm_start;
+       struct file *filp = vma->vm_file;
+
+       if (!buf)
+               return -EBADF;
+
+       if (length != (unsigned long)buf->chan->alloc_size)
+               return -EINVAL;
+
+       vma->vm_ops = &relay_file_mmap_ops;
+       vma->vm_private_data = buf;
+       buf->chan->cb->buf_mapped(buf, filp);
+
+       return 0;
+}
+
+/**
+ *     relay_alloc_buf - allocate a channel buffer
+ *     @buf: the buffer struct
+ *     @size: total size of the buffer
+ *
+ *     Returns a pointer to the resulting buffer, NULL if unsuccessful
+ */
+static void *relay_alloc_buf(struct rchan_buf *buf, unsigned long size)
+{
+       void *mem;
+       unsigned int i, j, n_pages;
+
+       size = PAGE_ALIGN(size);
+       n_pages = size >> PAGE_SHIFT;
+
+       buf->page_array = kcalloc(n_pages, sizeof(struct page *), GFP_KERNEL);
+       if (!buf->page_array)
+               return NULL;
+
+       for (i = 0; i < n_pages; i++) {
+               buf->page_array[i] = alloc_page(GFP_KERNEL);
+               if (unlikely(!buf->page_array[i]))
+                       goto depopulate;
+       }
+       mem = vmap(buf->page_array, n_pages, VM_MAP, PAGE_KERNEL);
+       if (!mem)
+               goto depopulate;
+
+       memset(mem, 0, size);
+       buf->page_count = n_pages;
+       return mem;
+
+depopulate:
+       for (j = 0; j < i; j++)
+               __free_page(buf->page_array[j]);
+       kfree(buf->page_array);
+       return NULL;
+}
+
+/**
+ *     relay_create_buf - allocate and initialize a channel buffer
+ *     @alloc_size: size of the buffer to allocate
+ *     @n_subbufs: number of sub-buffers in the channel
+ *
+ *     Returns channel buffer if successful, NULL otherwise
+ */
+struct rchan_buf *relay_create_buf(struct rchan *chan)
+{
+       struct rchan_buf *buf = kcalloc(1, sizeof(struct rchan_buf), GFP_KERNEL);
+       if (!buf)
+               return NULL;
+
+       buf->padding = kmalloc(chan->n_subbufs * sizeof(size_t *), GFP_KERNEL);
+       if (!buf->padding)
+               goto free_buf;
+
+       buf->start = relay_alloc_buf(buf, chan->alloc_size);
+       if (!buf->start)
+               goto free_buf;
+
+       buf->chan = chan;
+       kref_get(&buf->chan->kref);
+       return buf;
+
+free_buf:
+       kfree(buf->padding);
+       kfree(buf);
+       return NULL;
+}
+
+/**
+ *     relay_destroy_buf - destroy an rchan_buf struct and associated buffer
+ *     @buf: the buffer struct
+ */
+void relay_destroy_buf(struct rchan_buf *buf)
+{
+       struct rchan *chan = buf->chan;
+       unsigned int i;
+
+       if (likely(buf->start)) {
+               vunmap(buf->start);
+               for (i = 0; i < buf->page_count; i++)
+                       __free_page(buf->page_array[i]);
+               kfree(buf->page_array);
+       }
+       kfree(buf->padding);
+       kfree(buf);
+       kref_put(&chan->kref, relay_destroy_channel);
+}
+
+/**
+ *     relay_remove_buf - remove a channel buffer
+ *
+ *     Removes the file from the relayfs fileystem, which also frees the
+ *     rchan_buf_struct and the channel buffer.  Should only be called from
+ *     kref_put().
+ */
+void relay_remove_buf(struct kref *kref)
+{
+       struct rchan_buf *buf = container_of(kref, struct rchan_buf, kref);
+       buf->chan->cb->remove_buf_file(buf->dentry);
+       relay_destroy_buf(buf);
+}