Home
Reading
Searching
Subscribe
Sponsors
Statistics
Posting
Contact
Spam
Lists
Links
About
Hosting
Filtering
Features Download
Marketing
Archives
FAQ
Blog
 
Gmane
From: Markus Rechberger <mrechberger-Re5JQEeQqe8AvxtiuMwx3w <at> public.gmane.org>
Subject: [PATCH] memory mapping for usbfs (v0.4)
Newsgroups: gmane.linux.usb.general
Date: Sunday 29th September 2013 14:02:56 UTC (over 4 years ago)
This patch adds memory mapping support to USBFS for isochronous and bulk
data transfers, it allows to pre-allocate usb transfer buffers.

The CPU usage decreases 1-2% on my 1.3ghz U7300 notebook
The CPU usage decreases 6-8% on an Intel Atom n270 when
transferring 20mbyte/sec (isochronous), it should be more interesting to
see those
statistics on embedded systems where copying data is more expensive.

Usage from userspace:
allocation:
       rv = ioctl(priv->usbfd, USBDEVFS_ALLOC_MEMORY, &mem);
        if (rv == 0)
                buffer = mmap(NULL, size, PROT_READ|PROT_WRITE,
MAP_SHARED, priv->usbfd, mem.offset);
     use the mapped buffer with urb->buffer.
release:
                rv = munmap(buffer, size);
                memset(&mem, 0x0, sizeof(struct usbdevfs_memory));
                mem.buffer = buffer;
                rv = ioctl(priv->usbfd, USBDEVFS_RELEASE_MEMORY, &mem);

non freed memory buffers are collected and will be released when closing
the node.

I tested this patch with Bulk and Isochronous, with and without memory
mapping (applications which don't use mmap will just fall back to the
legacy mechanism).

Version 0.3:
* Removed comment
* Renamed USBDEVFS_FREE_MEMORY to USBDEVFS_RELEASE_MEMORY
* Clearing allocated memory

Version 0.4:
* overriding SG transfers once memory mapped buffers are allocated for
BULK 
* adding pgprot_noncached to ensure that the IO memory is not cached
(thanks to Ming Lei for mentioning that)

http://sundtek.de/support/devio_mmap_v0.4.diff

Signed-off-by: Markus Rechberger



diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 737e3c1..a32fb70 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -69,6 +69,7 @@ struct dev_state {
 	spinlock_t lock;            /* protects the async urb lists */
 	struct list_head async_pending;
 	struct list_head async_completed;
+	struct list_head memory_list;
 	wait_queue_head_t wait;     /* wake up if a request completed */
 	unsigned int discsignr;
 	struct pid *disc_pid;
@@ -96,6 +97,16 @@ struct async {
 	u8 bulk_status;
 };
 
+struct usb_memory {
+	struct list_head memlist;
+	int vma_use_count;
+	int usb_use_count;
+	u32 offset;
+	u32 size;
+	void *mem;
+	unsigned long vm_start;
+};
+
 static bool usbfs_snoop;
 module_param(usbfs_snoop, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(usbfs_snoop, "true to log all usbfs traffic");
@@ -288,6 +299,9 @@ static struct async *alloc_async(unsigned int
numisoframes)
 
 static void free_async(struct async *as)
 {
+	struct usb_memory *usbm = NULL, *usbm_iter;
+	unsigned long flags;
+	struct dev_state *ps = as->ps;
 	int i;
 
 	put_pid(as->pid);
@@ -297,8 +311,22 @@ static void free_async(struct async *as)
 		if (sg_page(&as->urb->sg[i]))
 			kfree(sg_virt(&as->urb->sg[i]));
 	}
+
+	spin_lock_irqsave(&ps->lock, flags);
+	list_for_each_entry(usbm_iter, &ps->memory_list, memlist) {
+		if (usbm_iter->mem == as->urb->transfer_buffer) {
+			usbm = usbm_iter;
+			break;
+		}
+	}
+	spin_unlock_irqrestore(&ps->lock, flags);
+
 	kfree(as->urb->sg);
-	kfree(as->urb->transfer_buffer);
+	if (usbm == NULL)
+		kfree(as->urb->transfer_buffer);
+	else
+		usbm->usb_use_count--;
+
 	kfree(as->urb->setup_packet);
 	usb_free_urb(as->urb);
 	usbfs_decrease_memory_usage(as->mem_usage);
@@ -811,6 +839,7 @@ static int usbdev_open(struct inode *inode, struct file
*file)
 	INIT_LIST_HEAD(&ps->list);
 	INIT_LIST_HEAD(&ps->async_pending);
 	INIT_LIST_HEAD(&ps->async_completed);
+	INIT_LIST_HEAD(&ps->memory_list);
 	init_waitqueue_head(&ps->wait);
 	ps->discsignr = 0;
 	ps->disc_pid = get_pid(task_pid(current));
@@ -839,6 +868,8 @@ static int usbdev_release(struct inode *inode, struct
file *file)
 	struct dev_state *ps = file->private_data;
 	struct usb_device *dev = ps->dev;
 	unsigned int ifnum;
+	struct list_head *p, *q;
+	struct usb_memory *tmp;
 	struct async *as;
 
 	usb_lock_device(dev);
@@ -863,6 +894,14 @@ static int usbdev_release(struct inode *inode, struct
file *file)
 		free_async(as);
 		as = async_getcompleted(ps);
 	}
+
+	list_for_each_safe(p, q, &ps->memory_list) {
+		tmp = list_entry(p, struct usb_memory, memlist);
+		list_del(p);
+		if (tmp->mem)
+			free_pages_exact(tmp->mem, tmp->size);
+		kfree(tmp);
+	}
 	kfree(ps);
 	return 0;
 }
@@ -1173,6 +1212,7 @@ static int proc_do_submiturb(struct dev_state *ps,
struct usbdevfs_urb *uurb,
 	struct usb_host_endpoint *ep;
 	struct async *as = NULL;
 	struct usb_ctrlrequest *dr = NULL;
+	struct usb_memory *usbm = NULL, *iter = NULL;
 	unsigned int u, totlen, isofrmlen;
 	int i, ret, is_in, num_sgs = 0, ifnum = -1;
 	void *buf;
@@ -1259,9 +1299,13 @@ static int proc_do_submiturb(struct dev_state *ps,
struct usbdevfs_urb *uurb,
 			goto interrupt_urb;
 		}
 		uurb->number_of_packets = 0;
-		num_sgs = DIV_ROUND_UP(uurb->buffer_length, USB_SG_SIZE);
-		if (num_sgs == 1 || num_sgs > ps->dev->bus->sg_tablesize)
-			num_sgs = 0;
+
+		/* do not use SG buffers when memory mapped segments are allocated */
+		if (list_empty(&ps->memory_list)) {
+			num_sgs = DIV_ROUND_UP(uurb->buffer_length, USB_SG_SIZE);
+			if (num_sgs == 1 || num_sgs > ps->dev->bus->sg_tablesize)
+				num_sgs = 0;
+		}
 		break;
 
 	case USBDEVFS_URB_TYPE_INTERRUPT:
@@ -1323,6 +1367,8 @@ static int proc_do_submiturb(struct dev_state *ps,
struct usbdevfs_urb *uurb,
 		goto error;
 	}
 
+	as->ps = ps;
+
 	u += sizeof(struct async) + sizeof(struct urb) + uurb->buffer_length +
 	     num_sgs * sizeof(struct scatterlist);
 	ret = usbfs_increase_memory_usage(u);
@@ -1360,21 +1406,47 @@ static int proc_do_submiturb(struct dev_state *ps,
struct usbdevfs_urb *uurb,
 			totlen -= u;
 		}
 	} else if (uurb->buffer_length > 0) {
-		as->urb->transfer_buffer = kmalloc(uurb->buffer_length,
-				GFP_KERNEL);
-		if (!as->urb->transfer_buffer) {
-			ret = -ENOMEM;
-			goto error;
+		if (!list_empty(&ps->memory_list)) {
+			unsigned long flags;
+			usbm=NULL;
+			as->urb->transfer_buffer = NULL;
+			spin_lock_irqsave(&ps->lock, flags);
+			list_for_each_entry(iter, &ps->memory_list, memlist) {
+				if (iter->vm_start == (unsigned long)uurb->buffer &&
iter->usb_use_count == 0 && 
+						(PAGE_SIZE<size)) >= uurb->buffer_length) {
+					usbm = iter;
+					usbm->usb_use_count++;
+					break;
+				}
+			}
+			spin_unlock_irqrestore(&ps->lock, flags);
+			if (usbm) {
+				as->urb->transfer_buffer = usbm->mem;
+			} else {
+				ret = -ENOMEM;
+				goto error;
+			}
+			if (as->urb->transfer_buffer == NULL) {
+				ret = -ENOMEM;
+				goto error;
+			}
+		} else {
+			as->urb->transfer_buffer = kmalloc(uurb->buffer_length,
+					GFP_KERNEL);
+			if (!as->urb->transfer_buffer) {
+				ret = -ENOMEM;
+				goto error;
+			}
 		}
 
-		if (!is_in) {
+		if (!is_in && usbm == NULL) {
 			if (copy_from_user(as->urb->transfer_buffer,
 					   uurb->buffer,
 					   uurb->buffer_length)) {
 				ret = -EFAULT;
 				goto error;
 			}
-		} else if (uurb->type == USBDEVFS_URB_TYPE_ISO) {
+		} else if (uurb->type == USBDEVFS_URB_TYPE_ISO && usbm == NULL) {
 			/*
 			 * Isochronous input data may end up being
 			 * discontiguous if some of the packets are short.
@@ -1426,7 +1498,6 @@ static int proc_do_submiturb(struct dev_state *ps,
struct usbdevfs_urb *uurb,
 	}
 	kfree(isopkt);
 	isopkt = NULL;
-	as->ps = ps;
 	as->userurb = arg;
 	if (is_in && uurb->buffer_length > 0)
 		as->userbuffer = uurb->buffer;
@@ -1487,6 +1558,8 @@ static int proc_do_submiturb(struct dev_state *ps,
struct usbdevfs_urb *uurb,
 	return 0;
 
  error:
+ 	if (usbm)
+		usbm->usb_use_count--;
 	kfree(isopkt);
 	kfree(dr);
 	if (as)
@@ -1969,6 +2042,64 @@ static int proc_disconnect_claim(struct dev_state
*ps, void __user *arg)
 	return claimintf(ps, dc.interface);
 }
 
+static int proc_release_memory(struct dev_state *ps, void __user *arg)
+{
+	struct usbdevfs_memory m;
+	struct usb_memory *usbm;
+	unsigned long flags;
+
+	if (copy_from_user(&m, arg, sizeof(m)))
+		return -EFAULT;
+
+	spin_lock_irqsave(&ps->lock, flags);
+	list_for_each_entry(usbm, &ps->memory_list, memlist) {
+		if ((usbm->vm_start == (unsigned long)m.buffer || usbm->offset ==
m.offset) &&
+			usbm->usb_use_count == 0 && usbm->vma_use_count == 0) {
+
+			list_del_init(&usbm->memlist);
+			spin_unlock_irqrestore(&ps->lock, flags);
+			free_pages_exact(usbm->mem, usbm->size);
+			kfree(usbm);
+			return 0;
+		}
+	}
+	spin_unlock_irqrestore(&ps->lock, flags);
+	return -EBUSY;
+}
+
+static int proc_alloc_memory(struct dev_state *ps, void __user *arg)
+{
+	struct usbdevfs_memory m;
+	struct usb_memory *usbmem;
+	void *mem;
+	unsigned long flags;
+
+	if (copy_from_user(&m, arg, sizeof(m)))
+		return -EFAULT;
+
+	mem = alloc_pages_exact(m.size, GFP_KERNEL | GFP_DMA32);
+	if (!mem)
+		return -ENOMEM;
+	
+	usbmem = kzalloc(sizeof(struct usb_memory), GFP_KERNEL);
+	if (!usbmem) {
+		free_pages_exact(mem, m.size);
+		return -ENOMEM;
+	}
+	memset(mem, 0x0, (PAGE_SIZE<mem = mem;
+	m.offset = usbmem->offset = virt_to_phys(mem);
+	usbmem->size = m.size;
+	spin_lock_irqsave(&ps->lock, flags);
+	list_add_tail(&usbmem->memlist, &ps->memory_list);
+	spin_unlock_irqrestore(&ps->lock, flags);
+
+	if (copy_to_user(arg, &m, sizeof(m)))
+		return -EFAULT;
+
+	return 0;
+}
+
 /*
  * NOTE:  All requests here that have interface numbers as parameters
  * are assuming that somehow the configuration has been prevented from
@@ -2145,7 +2276,16 @@ static long usbdev_do_ioctl(struct file *file,
unsigned int cmd,
 	case USBDEVFS_DISCONNECT_CLAIM:
 		ret = proc_disconnect_claim(ps, p);
 		break;
+	case USBDEVFS_ALLOC_MEMORY:
+		snoop(&dev->dev, "%s: ALLOC_MEMORY\n", __func__);
+		ret = proc_alloc_memory(ps, p);
+		break;
+	case USBDEVFS_RELEASE_MEMORY:
+		snoop(&dev->dev, "%s: RELEASE_MEMORY\n", __func__);
+		ret = proc_release_memory(ps, p);
+		break;
 	}
+
 	usb_unlock_device(dev);
 	if (ret >= 0)
 		inode->i_atime = CURRENT_TIME;
@@ -2162,6 +2302,60 @@ static long usbdev_ioctl(struct file *file, unsigned
int cmd,
 	return ret;
 }
 
+static void usbdev_vm_open(struct vm_area_struct *vma)
+{
+	struct usb_memory *usbm = vma->vm_private_data;
+	usbm->vma_use_count++;
+}
+
+static void usbdev_vm_close(struct vm_area_struct *vma)
+{
+	struct usb_memory *usbm = vma->vm_private_data;
+	usbm->vma_use_count--;
+}
+
+
+struct vm_operations_struct usbdev_vm_ops = {
+	.open = usbdev_vm_open,
+	.close = usbdev_vm_close
+};
+
+static int usbdev_mmap(struct file *file, struct vm_area_struct *vma) 
+{
+	struct usb_memory *usbm = NULL, *usbm_iter = NULL;
+	struct dev_state *ps = file->private_data;
+	int size = vma->vm_end - vma->vm_start;
+	unsigned long flags;
+	spin_lock_irqsave(&ps->lock, flags);
+	list_for_each_entry(usbm_iter, &ps->memory_list, memlist) {
+
+		if (usbm_iter->offset == (vma->vm_pgoff<size))) {
+			usbm = usbm_iter;
+			usbm->vm_start = vma->vm_start;
+			break;
+		}
+	}
+	spin_unlock_irqrestore(&ps->lock, flags);
+
+	if (usbm == NULL)
+		return -EINVAL;
+
+	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+
+	if (remap_pfn_range(vma, vma->vm_start, virt_to_phys(usbm->mem) >>
PAGE_SHIFT,
+		size,
+		vma->vm_page_prot) < 0)
+		return -EAGAIN;
+	
+	vma->vm_flags |= VM_IO;
+	vma->vm_flags |= (VM_DONTEXPAND | VM_DONTDUMP);
+	vma->vm_ops = &usbdev_vm_ops;
+	vma->vm_private_data = usbm;
+	usbdev_vm_open(vma);
+	return 0;
+}
+
 #ifdef CONFIG_COMPAT
 static long usbdev_compat_ioctl(struct file *file, unsigned int cmd,
 			unsigned long arg)
@@ -2198,6 +2392,7 @@ const struct file_operations usbdev_file_operations =
{
 #ifdef CONFIG_COMPAT
 	.compat_ioctl =   usbdev_compat_ioctl,
 #endif
+	.mmap =           usbdev_mmap,
 	.open =		  usbdev_open,
 	.release =	  usbdev_release,
 };
diff --git a/include/uapi/linux/usbdevice_fs.h
b/include/uapi/linux/usbdevice_fs.h
index 0c65e4b..1e63eec 100644
--- a/include/uapi/linux/usbdevice_fs.h
+++ b/include/uapi/linux/usbdevice_fs.h
@@ -144,6 +144,11 @@ struct usbdevfs_disconnect_claim {
 	char driver[USBDEVFS_MAXDRIVERNAME + 1];
 };
 
+struct usbdevfs_memory {
+	u32 size;
+	u32 offset;
+	void __user *buffer;
+};
 
 #define USBDEVFS_CONTROL           _IOWR('U', 0, struct
usbdevfs_ctrltransfer)
 #define USBDEVFS_CONTROL32           _IOWR('U', 0, struct
usbdevfs_ctrltransfer32)
@@ -176,5 +181,7 @@ struct usbdevfs_disconnect_claim {
 #define USBDEVFS_RELEASE_PORT      _IOR('U', 25, unsigned int)
 #define USBDEVFS_GET_CAPABILITIES  _IOR('U', 26, __u32)
 #define USBDEVFS_DISCONNECT_CLAIM  _IOR('U', 27, struct
usbdevfs_disconnect_claim)
+#define USBDEVFS_ALLOC_MEMORY      _IOWR('U', 28, struct usbdevfs_memory)
+#define USBDEVFS_RELEASE_MEMORY       _IOW('U', 29, struct
usbdevfs_memory)
 
 #endif /* _UAPI_LINUX_USBDEVICE_FS_H */



--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to [email protected]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
 
CD: 4ms