[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Xen-devel] [RFC PATCH 31/60] hyper_dmabuf: built-in compilation option



From: Mateusz Polrola <mateuszx.potrola@xxxxxxxxx>

Enabled built-in compilation option of hyper_dmabuf driver.
Also, moved backend initialization into open() to remove
its dependencies on Kernel booting sequence.

hyper_dmabuf.h is now installed as one of standard header
files of Kernel.

This patch also addresses possible memory leaks in various
places.

Signed-off-by: Dongwon Kim <dongwon.kim@xxxxxxxxx>
---
 drivers/xen/hyper_dmabuf/Kconfig                   |   1 +
 drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c        |  17 ++--
 drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h        |   1 +
 drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c         |  14 +++
 drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c        |  13 ++-
 drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c      | 113 +++++++++++++++++----
 drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c       |  15 +++
 drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c        |  20 ++++
 .../xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c    |  32 +++++-
 .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c   |   6 ++
 .../hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c  |  15 +++
 .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c    |   6 ++
 include/uapi/xen/Kbuild                            |   6 ++
 13 files changed, 227 insertions(+), 32 deletions(-)
 create mode 100644 include/uapi/xen/Kbuild

diff --git a/drivers/xen/hyper_dmabuf/Kconfig b/drivers/xen/hyper_dmabuf/Kconfig
index 56633a2..185fdf8 100644
--- a/drivers/xen/hyper_dmabuf/Kconfig
+++ b/drivers/xen/hyper_dmabuf/Kconfig
@@ -14,6 +14,7 @@ config HYPER_DMABUF_XEN
 config HYPER_DMABUF_SYSFS
        bool "Enable sysfs information about hyper DMA buffers"
        default y
+       depends on HYPER_DMABUF
        help
          Expose information about imported and exported buffers using
          hyper_dmabuf driver
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c 
b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
index a12d4dc..92d710e 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
@@ -66,6 +66,15 @@ static int __init hyper_dmabuf_drv_init(void)
 #ifdef CONFIG_HYPER_DMABUF_XEN
        hyper_dmabuf_private.backend_ops = &xen_backend_ops;
 #endif
+       /*
+        * Defer backend setup to first open call.
+        * Due to fact that some hypervisors eg. Xen, may have dependencies
+        * to userspace daemons like xenstored, in that case all xenstore
+        * calls done from kernel will block until that deamon will be
+        * started, in case where module is built in that will block entire
+        * kernel initialization.
+        */
+       hyper_dmabuf_private.backend_initialized = false;
 
        dev_info(hyper_dmabuf_private.device,
                 "initializing database for imported/exported dmabufs\n");
@@ -73,7 +82,6 @@ static int __init hyper_dmabuf_drv_init(void)
        /* device structure initialization */
        /* currently only does work-queue initialization */
        hyper_dmabuf_private.work_queue = 
create_workqueue("hyper_dmabuf_wqueue");
-       hyper_dmabuf_private.domid = 
hyper_dmabuf_private.backend_ops->get_vm_id();
 
        ret = hyper_dmabuf_table_init();
        if (ret < 0) {
@@ -82,13 +90,6 @@ static int __init hyper_dmabuf_drv_init(void)
                return ret;
        }
 
-       ret = hyper_dmabuf_private.backend_ops->init_comm_env();
-       if (ret < 0) {
-               dev_err(hyper_dmabuf_private.device,
-                       "failed to initiailize hypervisor-specific comm env\n");
-               return ret;
-       }
-
 #ifdef CONFIG_HYPER_DMABUF_SYSFS
        ret = hyper_dmabuf_register_sysfs(hyper_dmabuf_private.device);
        if (ret < 0) {
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h 
b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
index 8445416..91fda04 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
@@ -77,6 +77,7 @@ struct hyper_dmabuf_private {
        /* backend ops - hypervisor specific */
        struct hyper_dmabuf_backend_ops *backend_ops;
        struct mutex lock;
+       bool backend_initialized;
 };
 
 #endif /* __LINUX_PUBLIC_HYPER_DMABUF_DRV_H__ */
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c 
b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
index 35bfdfb..fe95091 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
@@ -40,6 +40,13 @@ void store_reusable_id(int id)
        struct list_reusable_id *new_reusable;
 
        new_reusable = kmalloc(sizeof(*new_reusable), GFP_KERNEL);
+
+       if (!new_reusable) {
+               dev_err(hyper_dmabuf_private.device,
+                       "No memory left to be allocated\n");
+               return;
+       }
+
        new_reusable->id = id;
 
        list_add(&new_reusable->list, &reusable_head->list);
@@ -94,6 +101,13 @@ int hyper_dmabuf_get_id(void)
        /* first cla to hyper_dmabuf_get_id */
        if (id == 0) {
                reusable_head = kmalloc(sizeof(*reusable_head), GFP_KERNEL);
+
+               if (!reusable_head) {
+                       dev_err(hyper_dmabuf_private.device,
+                               "No memory left to be allocated\n");
+                       return -ENOMEM;
+               }
+
                reusable_head->id = -1; /* list head have invalid id */
                INIT_LIST_HEAD(&reusable_head->list);
                hyper_dmabuf_private.id_queue = reusable_head;
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c 
b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c
index 5a034ffb..34dfa18 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c
@@ -270,6 +270,12 @@ inline int hyper_dmabuf_sync_request(int id, int 
dmabuf_ops)
 
        req = kcalloc(1, sizeof(*req), GFP_KERNEL);
 
+       if (!req) {
+               dev_err(hyper_dmabuf_private.device,
+                       "No memory left to be allocated\n");
+               return -ENOMEM;
+       }
+
        hyper_dmabuf_create_request(req, HYPER_DMABUF_OPS_TO_SOURCE, 
&operands[0]);
 
        /* send request and wait for a response */
@@ -366,8 +372,11 @@ static struct sg_table* hyper_dmabuf_ops_map(struct 
dma_buf_attachment *attachme
        return st;
 
 err_free_sg:
-       sg_free_table(st);
-       kfree(st);
+       if (st) {
+               sg_free_table(st);
+               kfree(st);
+       }
+
        return NULL;
 }
 
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c 
b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
index fa700f2..c0048d9 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
@@ -115,22 +115,24 @@ static int hyper_dmabuf_export_remote(struct file *filp, 
void *data)
         */
        ret = hyper_dmabuf_find_id_exported(dma_buf, 
export_remote_attr->remote_domain);
        sgt_info = hyper_dmabuf_find_exported(ret);
-       if (ret != -ENOENT && sgt_info->valid) {
-               /*
-                * Check if unexport is already scheduled for that buffer,
-                * if so try to cancel it. If that will fail, buffer needs
-                * to be reexport once again.
-                */
-               if (sgt_info->unexport_scheduled) {
-                       if 
(!cancel_delayed_work_sync(&sgt_info->unexport_work)) {
-                               dma_buf_put(dma_buf);
-                               goto reexport;
+       if (ret != -ENOENT && sgt_info != NULL) {
+               if (sgt_info->valid) {
+                       /*
+                        * Check if unexport is already scheduled for that 
buffer,
+                        * if so try to cancel it. If that will fail, buffer 
needs
+                        * to be reexport once again.
+                        */
+                       if (sgt_info->unexport_scheduled) {
+                               if 
(!cancel_delayed_work_sync(&sgt_info->unexport_work)) {
+                                       dma_buf_put(dma_buf);
+                                       goto reexport;
+                               }
+                               sgt_info->unexport_scheduled = 0;
                        }
-                       sgt_info->unexport_scheduled = 0;
+                       dma_buf_put(dma_buf);
+                       export_remote_attr->hyper_dmabuf_id = ret;
+                       return 0;
                }
-               dma_buf_put(dma_buf);
-               export_remote_attr->hyper_dmabuf_id = ret;
-               return 0;
        }
 
 reexport:
@@ -162,9 +164,32 @@ static int hyper_dmabuf_export_remote(struct file *filp, 
void *data)
        sgt_info->valid = 1;
 
        sgt_info->active_sgts = kmalloc(sizeof(struct sgt_list), GFP_KERNEL);
+       if (!sgt_info->active_sgts) {
+               dev_err(hyper_dmabuf_private.device, "no more space left\n");
+               ret = -ENOMEM;
+               goto fail_map_active_sgts;
+       }
+
        sgt_info->active_attached = kmalloc(sizeof(struct attachment_list), 
GFP_KERNEL);
+       if (!sgt_info->active_attached) {
+               dev_err(hyper_dmabuf_private.device, "no more space left\n");
+               ret = -ENOMEM;
+               goto fail_map_active_attached;
+       }
+
        sgt_info->va_kmapped = kmalloc(sizeof(struct kmap_vaddr_list), 
GFP_KERNEL);
+       if (!sgt_info->va_kmapped) {
+               dev_err(hyper_dmabuf_private.device, "no more space left\n");
+               ret = -ENOMEM;
+               goto fail_map_va_kmapped;
+       }
+
        sgt_info->va_vmapped = kmalloc(sizeof(struct vmap_vaddr_list), 
GFP_KERNEL);
+       if (!sgt_info->va_vmapped) {
+               dev_err(hyper_dmabuf_private.device, "no more space left\n");
+               ret = -ENOMEM;
+               goto fail_map_va_vmapped;
+       }
 
        sgt_info->active_sgts->sgt = sgt;
        sgt_info->active_attached->attach = attachment;
@@ -211,6 +236,11 @@ static int hyper_dmabuf_export_remote(struct file *filp, 
void *data)
 
        req = kcalloc(1, sizeof(*req), GFP_KERNEL);
 
+       if(!req) {
+               dev_err(hyper_dmabuf_private.device, "no more space left\n");
+               goto fail_map_req;
+       }
+
        /* composing a message to the importer */
        hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT, &operands[0]);
 
@@ -233,6 +263,8 @@ static int hyper_dmabuf_export_remote(struct file *filp, 
void *data)
 
 fail_send_request:
        kfree(req);
+
+fail_map_req:
        hyper_dmabuf_remove_exported(sgt_info->hyper_dmabuf_id);
 
 fail_export:
@@ -242,10 +274,14 @@ static int hyper_dmabuf_export_remote(struct file *filp, 
void *data)
        dma_buf_detach(sgt_info->dma_buf, sgt_info->active_attached->attach);
        dma_buf_put(sgt_info->dma_buf);
 
-       kfree(sgt_info->active_attached);
-       kfree(sgt_info->active_sgts);
-       kfree(sgt_info->va_kmapped);
        kfree(sgt_info->va_vmapped);
+fail_map_va_vmapped:
+       kfree(sgt_info->va_kmapped);
+fail_map_va_kmapped:
+       kfree(sgt_info->active_sgts);
+fail_map_active_sgts:
+       kfree(sgt_info->active_attached);
+fail_map_active_attached:
 
        return ret;
 }
@@ -288,6 +324,13 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, 
void *data)
        dev_dbg(hyper_dmabuf_private.device, "Exporting fd of buffer %d\n", 
operand);
 
        req = kcalloc(1, sizeof(*req), GFP_KERNEL);
+
+       if (!req) {
+               dev_err(hyper_dmabuf_private.device,
+                       "No memory left to be allocated\n");
+               return -ENOMEM;
+       }
+
        hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT_FD, &operand);
 
        ret = ops->send_req(HYPER_DMABUF_DOM_ID(operand), req, true);
@@ -381,6 +424,12 @@ static void hyper_dmabuf_delayed_unexport(struct 
work_struct *work)
 
        req = kcalloc(1, sizeof(*req), GFP_KERNEL);
 
+       if (!req) {
+               dev_err(hyper_dmabuf_private.device,
+                       "No memory left to be allocated\n");
+               return;
+       }
+
        hyper_dmabuf_create_request(req, HYPER_DMABUF_NOTIFY_UNEXPORT, 
&hyper_dmabuf_id);
 
        /* Now send unexport request to remote domain, marking that buffer 
should not be used anymore */
@@ -540,6 +589,11 @@ static long hyper_dmabuf_ioctl(struct file *filp,
        hyper_dmabuf_ioctl_t func;
        char *kdata;
 
+       if (nr > ARRAY_SIZE(hyper_dmabuf_ioctls)) {
+               dev_err(hyper_dmabuf_private.device, "invalid ioctl\n");
+               return -EINVAL;
+       }
+
        ioctl = &hyper_dmabuf_ioctls[nr];
 
        func = ioctl->func;
@@ -574,11 +628,34 @@ static long hyper_dmabuf_ioctl(struct file *filp,
 
 int hyper_dmabuf_open(struct inode *inode, struct file *filp)
 {
+       int ret = 0;
+
        /* Do not allow exclusive open */
        if (filp->f_flags & O_EXCL)
                return -EBUSY;
 
-       return 0;
+       /*
+        * Initialize backend if neededm,
+        * use mutex to prevent race conditions when
+        * two userspace apps will open device at the same time
+        */
+       mutex_lock(&hyper_dmabuf_private.lock);
+
+       if (!hyper_dmabuf_private.backend_initialized) {
+               hyper_dmabuf_private.domid = 
hyper_dmabuf_private.backend_ops->get_vm_id();
+
+               ret = hyper_dmabuf_private.backend_ops->init_comm_env();
+               if (ret < 0) {
+                       dev_err(hyper_dmabuf_private.device,
+                               "failed to initiailize hypervisor-specific comm 
env\n");
+               } else {
+                       hyper_dmabuf_private.backend_initialized = true;
+               }
+       }
+
+       mutex_unlock(&hyper_dmabuf_private.lock);
+
+       return ret;
 }
 
 static void hyper_dmabuf_emergency_release(struct hyper_dmabuf_sgt_info* 
sgt_info,
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c 
b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c
index c1285eb..90c8c56 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c
@@ -34,8 +34,11 @@
 #include <asm/uaccess.h>
 #include <linux/hashtable.h>
 #include <linux/dma-buf.h>
+#include "hyper_dmabuf_drv.h"
 #include "hyper_dmabuf_list.h"
 
+extern struct hyper_dmabuf_private hyper_dmabuf_private;
+
 DECLARE_HASHTABLE(hyper_dmabuf_hash_imported, MAX_ENTRY_IMPORTED);
 DECLARE_HASHTABLE(hyper_dmabuf_hash_exported, MAX_ENTRY_EXPORTED);
 
@@ -132,6 +135,12 @@ int hyper_dmabuf_register_exported(struct 
hyper_dmabuf_sgt_info *info)
 
        info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);
 
+       if (!info_entry) {
+               dev_err(hyper_dmabuf_private.device,
+                        "No memory left to be allocated\n");
+               return -ENOMEM;
+       }
+
        info_entry->info = info;
 
        hash_add(hyper_dmabuf_hash_exported, &info_entry->node,
@@ -146,6 +155,12 @@ int hyper_dmabuf_register_imported(struct 
hyper_dmabuf_imported_sgt_info* info)
 
        info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);
 
+       if (!info_entry) {
+               dev_err(hyper_dmabuf_private.device,
+                        "No memory left to be allocated\n");
+               return -ENOMEM;
+       }
+
        info_entry->info = info;
 
        hash_add(hyper_dmabuf_hash_imported, &info_entry->node,
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c 
b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
index 3111cdc..5f64261 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
@@ -134,6 +134,13 @@ void cmd_process_work(struct work_struct *work)
                 * operands5~8 : Driver-specific private data (e.g. graphic 
buffer's meta info)
                 */
                imported_sgt_info = kcalloc(1, sizeof(*imported_sgt_info), 
GFP_KERNEL);
+
+               if (!imported_sgt_info) {
+                       dev_err(hyper_dmabuf_private.device,
+                               "No memory left to be allocated\n");
+                       break;
+               }
+
                imported_sgt_info->hyper_dmabuf_id = req->operands[0];
                imported_sgt_info->frst_ofst = req->operands[2];
                imported_sgt_info->last_len = req->operands[3];
@@ -288,9 +295,22 @@ int hyper_dmabuf_msg_parse(int domid, struct 
hyper_dmabuf_req *req)
                "%s: putting request to workqueue\n", __func__);
        temp_req = kmalloc(sizeof(*temp_req), GFP_KERNEL);
 
+       if (!temp_req) {
+               dev_err(hyper_dmabuf_private.device,
+                       "No memory left to be allocated\n");
+               return -ENOMEM;
+       }
+
        memcpy(temp_req, req, sizeof(*temp_req));
 
        proc = kcalloc(1, sizeof(struct cmd_process), GFP_KERNEL);
+
+       if (!proc) {
+               dev_err(hyper_dmabuf_private.device,
+                       "No memory left to be allocated\n");
+               return -ENOMEM;
+       }
+
        proc->rq = temp_req;
        proc->domid = domid;
 
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c 
b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
index 0eded61..2dab833 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
@@ -78,6 +78,12 @@ int hyper_dmabuf_remote_sync(int id, int ops)
        case HYPER_DMABUF_OPS_ATTACH:
                attachl = kcalloc(1, sizeof(*attachl), GFP_KERNEL);
 
+               if (!attachl) {
+                       dev_err(hyper_dmabuf_private.device,
+                               "dmabuf remote sync::error while processing 
HYPER_DMABUF_OPS_ATTACH\n");
+                       return -ENOMEM;
+               }
+
                attachl->attach = dma_buf_attach(sgt_info->dma_buf,
                                                 hyper_dmabuf_private.device);
 
@@ -85,7 +91,7 @@ int hyper_dmabuf_remote_sync(int id, int ops)
                        kfree(attachl);
                        dev_err(hyper_dmabuf_private.device,
                                "dmabuf remote sync::error while processing 
HYPER_DMABUF_OPS_ATTACH\n");
-                       return PTR_ERR(attachl->attach);
+                       return -ENOMEM;
                }
 
                list_add(&attachl->list, &sgt_info->active_attached->list);
@@ -121,12 +127,19 @@ int hyper_dmabuf_remote_sync(int id, int ops)
                                           struct attachment_list, list);
 
                sgtl = kcalloc(1, sizeof(*sgtl), GFP_KERNEL);
+
+               if (!sgtl) {
+                       dev_err(hyper_dmabuf_private.device,
+                               "dmabuf remote sync::error while processing 
HYPER_DMABUF_OPS_MAP\n");
+                       return -ENOMEM;
+               }
+
                sgtl->sgt = dma_buf_map_attachment(attachl->attach, 
DMA_BIDIRECTIONAL);
                if (!sgtl->sgt) {
                        kfree(sgtl);
                        dev_err(hyper_dmabuf_private.device,
                                "dmabuf remote sync::error while processing 
HYPER_DMABUF_OPS_MAP\n");
-                       return PTR_ERR(sgtl->sgt);
+                       return -ENOMEM;
                }
                list_add(&sgtl->list, &sgt_info->active_sgts->list);
                break;
@@ -201,6 +214,11 @@ int hyper_dmabuf_remote_sync(int id, int ops)
        case HYPER_DMABUF_OPS_KMAP_ATOMIC:
        case HYPER_DMABUF_OPS_KMAP:
                va_kmapl = kcalloc(1, sizeof(*va_kmapl), GFP_KERNEL);
+               if (!va_kmapl) {
+                       dev_err(hyper_dmabuf_private.device,
+                               "dmabuf remote sync::error while processing 
HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
+                       return -ENOMEM;
+               }
 
                /* dummy kmapping of 1 page */
                if (ops == HYPER_DMABUF_OPS_KMAP_ATOMIC)
@@ -212,7 +230,7 @@ int hyper_dmabuf_remote_sync(int id, int ops)
                        kfree(va_kmapl);
                        dev_err(hyper_dmabuf_private.device,
                                "dmabuf remote sync::error while processing 
HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
-                       return PTR_ERR(va_kmapl->vaddr);
+                       return -ENOMEM;
                }
                list_add(&va_kmapl->list, &sgt_info->va_kmapped->list);
                break;
@@ -255,6 +273,12 @@ int hyper_dmabuf_remote_sync(int id, int ops)
        case HYPER_DMABUF_OPS_VMAP:
                va_vmapl = kcalloc(1, sizeof(*va_vmapl), GFP_KERNEL);
 
+               if (!va_vmapl) {
+                       dev_err(hyper_dmabuf_private.device,
+                               "dmabuf remote sync::error while processing 
HYPER_DMABUF_OPS_VMAP\n");
+                       return -ENOMEM;
+               }
+
                /* dummy vmapping */
                va_vmapl->vaddr = dma_buf_vmap(sgt_info->dma_buf);
 
@@ -262,7 +286,7 @@ int hyper_dmabuf_remote_sync(int id, int ops)
                        kfree(va_vmapl);
                        dev_err(hyper_dmabuf_private.device,
                                "dmabuf remote sync::error while processing 
HYPER_DMABUF_OPS_VMAP\n");
-                       return PTR_ERR(va_vmapl->vaddr);
+                       return -ENOMEM;
                }
                list_add(&va_vmapl->list, &sgt_info->va_vmapped->list);
                break;
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c 
b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
index ce9862a..43dd3b6 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
@@ -381,6 +381,12 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
 
        ring_info = kmalloc(sizeof(*ring_info), GFP_KERNEL);
 
+       if (!ring_info) {
+               dev_err(hyper_dmabuf_private.device,
+                       "No memory left to be allocated\n");
+               return -ENOMEM;
+       }
+
        ring_info->sdomain = domid;
        ring_info->evtchn = rx_port;
 
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c 
b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c
index 2f469da..4708b49 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c
@@ -34,9 +34,12 @@
 #include <asm/uaccess.h>
 #include <linux/hashtable.h>
 #include <xen/grant_table.h>
+#include "../hyper_dmabuf_drv.h"
 #include "hyper_dmabuf_xen_comm.h"
 #include "hyper_dmabuf_xen_comm_list.h"
 
+extern struct hyper_dmabuf_private hyper_dmabuf_private;
+
 DECLARE_HASHTABLE(xen_comm_tx_ring_hash, MAX_ENTRY_TX_RING);
 DECLARE_HASHTABLE(xen_comm_rx_ring_hash, MAX_ENTRY_RX_RING);
 
@@ -52,6 +55,12 @@ int xen_comm_add_tx_ring(struct xen_comm_tx_ring_info 
*ring_info)
 
        info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);
 
+       if (!info_entry) {
+               dev_err(hyper_dmabuf_private.device,
+                       "No memory left to be allocated\n");
+               return -ENOMEM;
+       }
+
        info_entry->info = ring_info;
 
        hash_add(xen_comm_tx_ring_hash, &info_entry->node,
@@ -66,6 +75,12 @@ int xen_comm_add_rx_ring(struct xen_comm_rx_ring_info 
*ring_info)
 
        info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);
 
+       if (!info_entry) {
+               dev_err(hyper_dmabuf_private.device,
+                       "No memory left to be allocated\n");
+               return -ENOMEM;
+       }
+
        info_entry->info = ring_info;
 
        hash_add(xen_comm_rx_ring_hash, &info_entry->node,
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c 
b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
index 524f75c..c6a2993 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
@@ -96,6 +96,12 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int 
domid, int nents,
        lvl2_table = (grant_ref_t *)__get_free_pages(GFP_KERNEL, n_lvl2_grefs);
 
        sh_pages_info = kmalloc(sizeof(*sh_pages_info), GFP_KERNEL);
+
+       if (!sh_pages_info) {
+               dev_err(hyper_dmabuf_private.device, "No more space left\n");
+               return -ENOMEM;
+       }
+
        *refs_info = (void *)sh_pages_info;
 
        /* share data pages in rw mode*/
diff --git a/include/uapi/xen/Kbuild b/include/uapi/xen/Kbuild
new file mode 100644
index 0000000..bf81f42
--- /dev/null
+++ b/include/uapi/xen/Kbuild
@@ -0,0 +1,6 @@
+# UAPI Header export list
+header-y += evtchn.h
+header-y += gntalloc.h
+header-y += gntdev.h
+header-y += privcmd.h
+header-y += hyper_dmabuf.h
-- 
2.7.4


_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxxx
https://lists.xenproject.org/mailman/listinfo/xen-devel

 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.