Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cb9bad16 authored by Jack Pham's avatar Jack Pham Committed by Hemant Kumar
Browse files

usb: gadget: f_fs: Add support for ipc logging 



Log function entry and exit and dump relevant values
into ipc log buffer. This allows to debug various
race conditions and stability issues.

Change-Id: I15011d79fc2f054e64f8bbd1f8f5db8944b46ada
Signed-off-by: default avatarHemant Kumar <hemantk@codeaurora.org>
Signed-off-by: default avatarMayank Rana <mrana@codeaurora.org>
Signed-off-by: default avatarJack Pham <jackp@codeaurora.org>
parent ef02a3d3

drivers/usb/gadget/function/f_fs.c

+297 −22
Original line number Diff line number Diff line
@@ -38,6 +38,18 @@ 


#define FUNCTIONFS_MAGIC	0xa647361 /* Chosen by a honest dice roll ;) */



#define NUM_PAGES	10 /* # of pages for ipc logging */



#ifdef CONFIG_DYNAMIC_DEBUG

#define ffs_log(fmt, ...) do { \

	ipc_log_string(ffs->ipc_log, "%s: " fmt,  __func__, ##__VA_ARGS__); \

	dynamic_pr_debug("%s: " fmt, __func__, ##__VA_ARGS__); \

} while (0)

#else

#define ffs_log(fmt, ...) \

	ipc_log_string(ffs->ipc_log, "%s: " fmt,  __func__, ##__VA_ARGS__)

#endif



/* Reference counter handling */

static void ffs_data_get(struct ffs_data *ffs);

static void ffs_data_put(struct ffs_data *ffs);
@@ -275,6 +287,9 @@ static int __ffs_ep0_queue_wait(struct ffs_data *ffs, char *data, size_t len) 


	spin_unlock_irq(&ffs->ev.waitq.lock);



	ffs_log("enter: state %d setup_state %d flags %lu", ffs->state,

		ffs->setup_state, ffs->flags);



	req->buf      = data;

	req->length   = len;
@@ -299,11 +314,18 @@ static int __ffs_ep0_queue_wait(struct ffs_data *ffs, char *data, size_t len) 
	}



	ffs->setup_state = FFS_NO_SETUP;



	ffs_log("exit: state %d setup_state %d flags %lu", ffs->state,

		ffs->setup_state, ffs->flags);



	return req->status ? req->status : req->actual;

}



static int __ffs_ep0_stall(struct ffs_data *ffs)

{

	ffs_log("state %d setup_state %d flags %lu can_stall %d", ffs->state,

		ffs->setup_state, ffs->flags, ffs->ev.can_stall);



	if (ffs->ev.can_stall) {

		pr_vdebug("ep0 stall\n");

		usb_ep_set_halt(ffs->gadget->ep0);
@@ -324,6 +346,9 @@ static ssize_t ffs_ep0_write(struct file *file, const char __user *buf, 


	ENTER();



	ffs_log("enter:len %zu state %d setup_state %d flags %lu", len,

		ffs->state, ffs->setup_state, ffs->flags);



	/* Fast check if setup was canceled */

	if (ffs_setup_state_clear_cancelled(ffs) == FFS_SETUP_CANCELLED)

		return -EIDRM;
@@ -452,6 +477,9 @@ static ssize_t ffs_ep0_write(struct file *file, const char __user *buf, 
		break;

	}



	ffs_log("exit:ret %zd state %d setup_state %d flags %lu", ret,

		ffs->state, ffs->setup_state, ffs->flags);



	mutex_unlock(&ffs->mutex);

	return ret;

}
@@ -486,6 +514,10 @@ static ssize_t __ffs_ep0_read_events(struct ffs_data *ffs, char __user *buf, 
			ffs->ev.count * sizeof *ffs->ev.types);



	spin_unlock_irq(&ffs->ev.waitq.lock);



	ffs_log("state %d setup_state %d flags %lu #evt %zu", ffs->state,

		ffs->setup_state, ffs->flags, n);



	mutex_unlock(&ffs->mutex);



	return unlikely(copy_to_user(buf, events, size)) ? -EFAULT : size;
@@ -501,6 +533,9 @@ static ssize_t ffs_ep0_read(struct file *file, char __user *buf, 


	ENTER();



	ffs_log("enter:len %zu state %d setup_state %d flags %lu", len,

		ffs->state, ffs->setup_state, ffs->flags);



	/* Fast check if setup was canceled */

	if (ffs_setup_state_clear_cancelled(ffs) == FFS_SETUP_CANCELLED)

		return -EIDRM;
@@ -590,8 +625,12 @@ static ssize_t ffs_ep0_read(struct file *file, char __user *buf, 


	spin_unlock_irq(&ffs->ev.waitq.lock);

done_mutex:

	ffs_log("exit:ret %d state %d setup_state %d flags %lu", ret,

		ffs->state, ffs->setup_state, ffs->flags);



	mutex_unlock(&ffs->mutex);

	kfree(data);



	return ret;

}
@@ -601,6 +640,9 @@ static int ffs_ep0_open(struct inode *inode, struct file *file) 


	ENTER();



	ffs_log("state %d setup_state %d flags %lu opened %d", ffs->state,

		ffs->setup_state, ffs->flags, atomic_read(&ffs->opened));



	if (unlikely(ffs->state == FFS_CLOSING))

		return -EBUSY;
@@ -616,6 +658,9 @@ static int ffs_ep0_release(struct inode *inode, struct file *file) 


	ENTER();



	ffs_log("state %d setup_state %d flags %lu opened %d", ffs->state,

		ffs->setup_state, ffs->flags, atomic_read(&ffs->opened));



	ffs_data_closed(ffs);



	return 0;
@@ -629,6 +674,9 @@ static long ffs_ep0_ioctl(struct file *file, unsigned code, unsigned long value) 


	ENTER();



	ffs_log("state %d setup_state %d flags %lu opened %d", ffs->state,

		ffs->setup_state, ffs->flags, atomic_read(&ffs->opened));



	if (code == FUNCTIONFS_INTERFACE_REVMAP) {

		struct ffs_function *func = ffs->func;

		ret = func ? ffs_func_revmap_intf(func, value) : -ENODEV;
@@ -647,6 +695,9 @@ static __poll_t ffs_ep0_poll(struct file *file, poll_table *wait) 
	__poll_t mask = EPOLLWRNORM;

	int ret;



	ffs_log("enter:state %d setup_state %d flags %lu opened %d", ffs->state,

		ffs->setup_state, ffs->flags, atomic_read(&ffs->opened));



	poll_wait(file, &ffs->ev.waitq, wait);



	ret = ffs_mutex_lock(&ffs->mutex, file->f_flags & O_NONBLOCK);
@@ -677,6 +728,8 @@ static __poll_t ffs_ep0_poll(struct file *file, poll_table *wait) 
		break;

	}



	ffs_log("exit: mask %u", mask);



	mutex_unlock(&ffs->mutex);



	return mask;
@@ -753,10 +806,13 @@ static void ffs_user_copy_worker(struct work_struct *work) 
{

	struct ffs_io_data *io_data = container_of(work, struct ffs_io_data,

						   work);

	struct ffs_data *ffs = io_data->ffs;

	int ret = io_data->req->status ? io_data->req->status :

					 io_data->req->actual;

	bool kiocb_has_eventfd = io_data->kiocb->ki_flags & IOCB_EVENTFD;



	ffs_log("enter: ret %d for %s", ret, io_data->read ? "read" : "write");



	if (io_data->read && ret > 0) {

		mm_segment_t oldfs = get_fs();
@@ -778,6 +834,8 @@ static void ffs_user_copy_worker(struct work_struct *work) 
		kfree(io_data->to_free);

	kfree(io_data->buf);

	kfree(io_data);



	ffs_log("exit");

}



static void ffs_epfile_async_io_complete(struct usb_ep *_ep,
@@ -788,6 +846,8 @@ static void ffs_epfile_async_io_complete(struct usb_ep *_ep, 


	ENTER();



	ffs_log("enter");



	INIT_WORK(&io_data->work, ffs_user_copy_worker);

	queue_work(ffs->io_completion_wq, &io_data->work);

}
@@ -877,12 +937,15 @@ static ssize_t __ffs_epfile_read_data(struct ffs_epfile *epfile, 
static ssize_t ffs_epfile_io(struct file *file, struct ffs_io_data *io_data)

{

	struct ffs_epfile *epfile = file->private_data;

	struct ffs_data *ffs = epfile->ffs;

	struct usb_request *req;

	struct ffs_ep *ep;

	char *data = NULL;

	ssize_t ret, data_len = -EINVAL;

	int halt;



	ffs_log("enter: %s", epfile->name);



	/* Are we still active? */

	if (WARN_ON(epfile->ffs->state != FFS_ACTIVE))

		return -ENODEV;
@@ -1000,6 +1063,8 @@ static ssize_t ffs_epfile_io(struct file *file, struct ffs_io_data *io_data) 


		spin_unlock_irq(&epfile->ffs->eps_lock);



		ffs_log("queued %d bytes on %s", data_len, epfile->name);



		if (unlikely(wait_for_completion_interruptible(&done))) {

			/*

			 * To avoid race condition with ffs_epfile_io_complete,
@@ -1011,6 +1076,9 @@ static ssize_t ffs_epfile_io(struct file *file, struct ffs_io_data *io_data) 
			interrupted = ep->status < 0;

		}



		ffs_log("%s:ep status %d for req %pK", epfile->name, ep->status,

				req);



		if (interrupted)

			ret = -EINTR;

		else if (io_data->read && ep->status > 0)
@@ -1039,6 +1107,8 @@ static ssize_t ffs_epfile_io(struct file *file, struct ffs_io_data *io_data) 
			goto error_lock;

		}



		ffs_log("queued %d bytes on %s", data_len, epfile->name);



		ret = -EIOCBQUEUED;

		/*

		 * Do not kfree the buffer in this function.  It will be freed
@@ -1053,6 +1123,9 @@ static ssize_t ffs_epfile_io(struct file *file, struct ffs_io_data *io_data) 
	mutex_unlock(&epfile->mutex);

error:

	kfree(data);



	ffs_log("exit: %s ret %zd", epfile->name, ret);



	return ret;

}
@@ -1060,9 +1133,14 @@ static int 
ffs_epfile_open(struct inode *inode, struct file *file)

{

	struct ffs_epfile *epfile = inode->i_private;

	struct ffs_data *ffs = epfile->ffs;



	ENTER();



	ffs_log("%s: state %d setup_state %d flag %lu", epfile->name,

		epfile->ffs->state, epfile->ffs->setup_state,

		epfile->ffs->flags);



	if (WARN_ON(epfile->ffs->state != FFS_ACTIVE))

		return -ENODEV;
@@ -1076,10 +1154,14 @@ static int ffs_aio_cancel(struct kiocb *kiocb) 
{

	struct ffs_io_data *io_data = kiocb->private;

	struct ffs_epfile *epfile = kiocb->ki_filp->private_data;

	struct ffs_data *ffs = epfile->ffs;

	int value;



	ENTER();



	ffs_log("enter:state %d setup_state %d flag %lu", epfile->ffs->state,

		epfile->ffs->setup_state, epfile->ffs->flags);



	spin_lock_irq(&epfile->ffs->eps_lock);



	if (likely(io_data && io_data->ep && io_data->req))
@@ -1089,16 +1171,22 @@ static int ffs_aio_cancel(struct kiocb *kiocb) 


	spin_unlock_irq(&epfile->ffs->eps_lock);



	ffs_log("exit: value %d", value);



	return value;

}



static ssize_t ffs_epfile_write_iter(struct kiocb *kiocb, struct iov_iter *from)

{

	struct ffs_epfile *epfile = kiocb->ki_filp->private_data;

	struct ffs_data *ffs = epfile->ffs;

	struct ffs_io_data io_data, *p = &io_data;

	ssize_t res;



	ENTER();



	ffs_log("enter");



	if (!is_sync_kiocb(kiocb)) {

		p = kmalloc(sizeof(io_data), GFP_KERNEL);

		if (unlikely(!p))
@@ -1125,16 +1213,23 @@ static ssize_t ffs_epfile_write_iter(struct kiocb *kiocb, struct iov_iter *from) 
		kfree(p);

	else

		*from = p->data;



	ffs_log("exit: ret %zd", res);



	return res;

}



static ssize_t ffs_epfile_read_iter(struct kiocb *kiocb, struct iov_iter *to)

{

	struct ffs_epfile *epfile = kiocb->ki_filp->private_data;

	struct ffs_data *ffs = epfile->ffs;

	struct ffs_io_data io_data, *p = &io_data;

	ssize_t res;



	ENTER();



	ffs_log("enter");



	if (!is_sync_kiocb(kiocb)) {

		p = kmalloc(sizeof(io_data), GFP_KERNEL);

		if (unlikely(!p))
@@ -1173,6 +1268,9 @@ static ssize_t ffs_epfile_read_iter(struct kiocb *kiocb, struct iov_iter *to) 
	} else {

		*to = p->data;

	}



	ffs_log("exit: ret %zd", res);



	return res;

}
@@ -1180,10 +1278,15 @@ static int 
ffs_epfile_release(struct inode *inode, struct file *file)

{

	struct ffs_epfile *epfile = inode->i_private;

	struct ffs_data *ffs = epfile->ffs;



	ENTER();



	__ffs_epfile_read_buffer_free(epfile);

	ffs_log("%s: state %d setup_state %d flag %lu", epfile->name,

			epfile->ffs->state, epfile->ffs->setup_state,

			epfile->ffs->flags);



	ffs_data_closed(epfile->ffs);



	return 0;
@@ -1193,11 +1296,16 @@ static long ffs_epfile_ioctl(struct file *file, unsigned code, 
			     unsigned long value)

{

	struct ffs_epfile *epfile = file->private_data;

	struct ffs_data *ffs = epfile->ffs;

	struct ffs_ep *ep;

	int ret;



	ENTER();



	ffs_log("%s: code 0x%08x value %#lx state %d setup_state %d flag %lu",

		epfile->name, code, value, epfile->ffs->state,

		epfile->ffs->setup_state, epfile->ffs->flags);



	if (WARN_ON(epfile->ffs->state != FFS_ACTIVE))

		return -ENODEV;
@@ -1263,6 +1371,8 @@ static long ffs_epfile_ioctl(struct file *file, unsigned code, 
	}

	spin_unlock_irq(&epfile->ffs->eps_lock);



	ffs_log("exit: %s: ret %d\n", epfile->name, ret);



	return ret;

}
@@ -1301,10 +1411,13 @@ ffs_sb_make_inode(struct super_block *sb, void *data, 
		  const struct inode_operations *iops,

		  struct ffs_file_perms *perms)

{

	struct ffs_data	*ffs = sb->s_fs_info;

	struct inode *inode;



	ENTER();



	ffs_log("enter");



	inode = new_inode(sb);



	if (likely(inode)) {
@@ -1338,6 +1451,8 @@ static struct dentry *ffs_sb_create_file(struct super_block *sb, 


	ENTER();



	ffs_log("enter");



	dentry = d_alloc_name(sb->s_root, name);

	if (unlikely(!dentry))

		return NULL;
@@ -1349,6 +1464,7 @@ static struct dentry *ffs_sb_create_file(struct super_block *sb, 
	}



	d_add(dentry, inode);



	return dentry;

}
@@ -1374,6 +1490,8 @@ static int ffs_sb_fill(struct super_block *sb, void *_data, int silent) 


	ENTER();



	ffs_log("enter");



	ffs->sb              = sb;

	data->ffs_data       = NULL;

	sb->s_fs_info        = ffs;
@@ -1541,6 +1659,7 @@ ffs_fs_mount(struct file_system_type *t, int flags, 
		ffs_release_dev(data.ffs_data);

		ffs_data_put(data.ffs_data);

	}



	return rv;

}
@@ -1600,6 +1719,8 @@ static void ffs_data_get(struct ffs_data *ffs) 
{

	ENTER();



	ffs_log("ref %u", refcount_read(&ffs->ref));



	refcount_inc(&ffs->ref);

}
@@ -1607,6 +1728,10 @@ static void ffs_data_opened(struct ffs_data *ffs) 
{

	ENTER();



	ffs_log("enter: state %d setup_state %d flag %lu opened %d ref %d",

		ffs->state, ffs->setup_state, ffs->flags,

		atomic_read(&ffs->opened), refcount_read(&ffs->ref));



	refcount_inc(&ffs->ref);

	if (atomic_add_return(1, &ffs->opened) == 1 &&

			ffs->state == FFS_DEACTIVATED) {
@@ -1619,6 +1744,8 @@ static void ffs_data_put(struct ffs_data *ffs) 
{

	ENTER();



	ffs_log("ref %u", refcount_read(&ffs->ref));



	if (unlikely(refcount_dec_and_test(&ffs->ref))) {

		pr_info("%s(): freeing\n", __func__);

		ffs_data_clear(ffs);
@@ -1626,6 +1753,7 @@ static void ffs_data_put(struct ffs_data *ffs) 
		       waitqueue_active(&ffs->ep0req_completion.wait) ||

		       waitqueue_active(&ffs->wait));

		destroy_workqueue(ffs->io_completion_wq);

		ipc_log_context_destroy(ffs->ipc_log);

		kfree(ffs->dev_name);

		kfree(ffs);

	}
@@ -1635,6 +1763,9 @@ static void ffs_data_closed(struct ffs_data *ffs) 
{

	ENTER();



	ffs_log("state %d setup_state %d flag %lu opened %d", ffs->state,

		ffs->setup_state, ffs->flags, atomic_read(&ffs->opened));



	if (atomic_dec_and_test(&ffs->opened)) {

		if (ffs->no_disconnect) {

			ffs->state = FFS_DEACTIVATED;
@@ -1660,6 +1791,7 @@ static void ffs_data_closed(struct ffs_data *ffs) 


static struct ffs_data *ffs_data_new(const char *dev_name)

{

	char ipcname[24] = "usb_ffs_";

	struct ffs_data *ffs = kzalloc(sizeof *ffs, GFP_KERNEL);

	if (unlikely(!ffs))

		return NULL;
@@ -1684,6 +1816,11 @@ static struct ffs_data *ffs_data_new(const char *dev_name) 
	/* XXX REVISIT need to update it in some places, or do we? */

	ffs->ev.can_stall = 1;



	strlcat(ipcname, dev_name, sizeof(ipcname));

	ffs->ipc_log = ipc_log_context_create(NUM_PAGES, ipcname, 0);

	if (IS_ERR_OR_NULL(ffs->ipc_log))

		ffs->ipc_log =  NULL;



	return ffs;

}
@@ -1691,6 +1828,11 @@ static void ffs_data_clear(struct ffs_data *ffs) 
{

	ENTER();



	ffs_log("enter: state %d setup_state %d flag %lu", ffs->state,

		ffs->setup_state, ffs->flags);



	pr_debug("%s: ffs->gadget= %pK, ffs->flags= %lu\n",

				__func__, ffs->gadget, ffs->flags);

	ffs_closed(ffs);



	BUG_ON(ffs->gadget);
@@ -1710,6 +1852,9 @@ static void ffs_data_reset(struct ffs_data *ffs) 
{

	ENTER();



	ffs_log("enter: state %d setup_state %d flag %lu", ffs->state,

		ffs->setup_state, ffs->flags);



	ffs_data_clear(ffs);



	ffs->epfiles = NULL;
@@ -1742,6 +1887,9 @@ static int functionfs_bind(struct ffs_data *ffs, struct usb_composite_dev *cdev) 


	ENTER();



	ffs_log("enter: state %d setup_state %d flag %lu", ffs->state,

		ffs->setup_state, ffs->flags);



	if (WARN_ON(ffs->state != FFS_ACTIVE

		 || test_and_set_bit(FFS_FL_BOUND, &ffs->flags)))

		return -EBADFD;
@@ -1767,6 +1915,7 @@ static int functionfs_bind(struct ffs_data *ffs, struct usb_composite_dev *cdev) 
	}



	ffs->gadget = cdev->gadget;



	ffs_data_get(ffs);

	return 0;

}
@@ -1780,6 +1929,8 @@ static void functionfs_unbind(struct ffs_data *ffs) 
		ffs->ep0req = NULL;

		ffs->gadget = NULL;

		clear_bit(FFS_FL_BOUND, &ffs->flags);

		ffs_log("state %d setup_state %d flag %lu gadget %pK\n",

			ffs->state, ffs->setup_state, ffs->flags, ffs->gadget);

		ffs_data_put(ffs);

	}

}
@@ -1791,6 +1942,9 @@ static int ffs_epfiles_create(struct ffs_data *ffs) 


	ENTER();



	ffs_log("enter: eps_count %u state %d setup_state %d flag %lu",

		ffs->eps_count, ffs->state, ffs->setup_state, ffs->flags);



	count = ffs->eps_count;

	epfiles = kcalloc(count, sizeof(*epfiles), GFP_KERNEL);

	if (!epfiles)
@@ -1814,15 +1968,19 @@ static int ffs_epfiles_create(struct ffs_data *ffs) 
	}



	ffs->epfiles = epfiles;



	return 0;

}



static void ffs_epfiles_destroy(struct ffs_epfile *epfiles, unsigned count)

{

	struct ffs_epfile *epfile = epfiles;

	struct ffs_data *ffs = epfiles->ffs;



	ENTER();



	ffs_log("enter: count %u", count);



	for (; count; --count, ++epfile) {

		BUG_ON(mutex_is_locked(&epfile->mutex));

		if (epfile->dentry) {
@@ -1838,10 +1996,14 @@ static void ffs_epfiles_destroy(struct ffs_epfile *epfiles, unsigned count) 
static void ffs_func_eps_disable(struct ffs_function *func)

{

	struct ffs_ep *ep         = func->eps;

	struct ffs_data *ffs      = func->ffs;

	struct ffs_epfile *epfile = func->ffs->epfiles;

	unsigned count            = func->ffs->eps_count;

	unsigned long flags;



	ffs_log("enter: state %d setup_state %d flag %lu", func->ffs->state,

		func->ffs->setup_state, func->ffs->flags);



	spin_lock_irqsave(&func->ffs->eps_lock, flags);

	while (count--) {

		/* pending requests get nuked */
@@ -1867,6 +2029,9 @@ static int ffs_func_eps_enable(struct ffs_function *func) 
	unsigned long flags;

	int ret = 0;



	ffs_log("enter: state %d setup_state %d flag %lu", func->ffs->state,

		func->ffs->setup_state, func->ffs->flags);



	spin_lock_irqsave(&func->ffs->eps_lock, flags);

	while(count--) {

		ep->ep->driver_data = ep;
@@ -1883,7 +2048,9 @@ static int ffs_func_eps_enable(struct ffs_function *func) 
			epfile->ep = ep;

			epfile->in = usb_endpoint_dir_in(ep->ep->desc);

			epfile->isoc = usb_endpoint_xfer_isoc(ep->ep->desc);

			ffs_log("usb_ep_enable %s", ep->ep->name);

		} else {

			ffs_log("usb_ep_enable %s ret %d", ep->ep->name, ret);

			break;

		}
@@ -1924,7 +2091,8 @@ typedef int (*ffs_os_desc_callback)(enum ffs_os_desc_type entity, 
				    struct usb_os_desc_header *h, void *data,

				    unsigned len, void *priv);



static int __must_check ffs_do_single_desc(char *data, unsigned len,

static int __must_check ffs_do_single_desc(struct ffs_data *ffs,

					   char *data, unsigned int len,

					   ffs_entity_callback entity,

					   void *priv)

{
@@ -1934,6 +2102,8 @@ static int __must_check ffs_do_single_desc(char *data, unsigned len, 


	ENTER();



	ffs_log("enter: len %u", len);



	/* At least two bytes are required: length and type */

	if (len < 2) {

		pr_vdebug("descriptor too short\n");
@@ -2050,10 +2220,13 @@ static int __must_check ffs_do_single_desc(char *data, unsigned len, 
#undef __entity_check_STRING

#undef __entity_check_ENDPOINT



	ffs_log("exit: desc type %d length %d", _ds->bDescriptorType, length);



	return length;

}



static int __must_check ffs_do_descs(unsigned count, char *data, unsigned len,

static int __must_check ffs_do_descs(struct ffs_data *ffs, unsigned int count,

				     char *data, unsigned int len,

				     ffs_entity_callback entity, void *priv)

{

	const unsigned _len = len;
@@ -2061,6 +2234,8 @@ static int __must_check ffs_do_descs(unsigned count, char *data, unsigned len, 


	ENTER();



	ffs_log("enter: len %u", len);



	for (;;) {

		int ret;
@@ -2078,7 +2253,7 @@ static int __must_check ffs_do_descs(unsigned count, char *data, unsigned len, 
		if (!data)

			return _len - len;



		ret = ffs_do_single_desc(data, len, entity, priv);

		ret = ffs_do_single_desc(ffs, data, len, entity, priv);

		if (unlikely(ret < 0)) {

			pr_debug("%s returns %d\n", __func__, ret);

			return ret;
@@ -2095,10 +2270,13 @@ static int __ffs_data_do_entity(enum ffs_entity_type type, 
				void *priv)

{

	struct ffs_desc_helper *helper = priv;

	struct ffs_data *ffs = helper->ffs;

	struct usb_endpoint_descriptor *d;



	ENTER();



	ffs_log("enter: type %u", type);



	switch (type) {

	case FFS_DESCRIPTOR:

		break;
@@ -2140,12 +2318,15 @@ static int __ffs_data_do_entity(enum ffs_entity_type type, 
	return 0;

}



static int __ffs_do_os_desc_header(enum ffs_os_desc_type *next_type,

static int __ffs_do_os_desc_header(struct ffs_data *ffs,

				   enum ffs_os_desc_type *next_type,

				   struct usb_os_desc_header *desc)

{

	u16 bcd_version = le16_to_cpu(desc->bcdVersion);

	u16 w_index = le16_to_cpu(desc->wIndex);



	ffs_log("enter: bcd:%x w_index:%d", bcd_version, w_index);



	if (bcd_version != 1) {

		pr_vdebug("unsupported os descriptors version: %d",

			  bcd_version);
@@ -2170,7 +2351,8 @@ static int __ffs_do_os_desc_header(enum ffs_os_desc_type *next_type, 
 * Process all extended compatibility/extended property descriptors

 * of a feature descriptor

 */

static int __must_check ffs_do_single_os_desc(char *data, unsigned len,

static int __must_check ffs_do_single_os_desc(struct ffs_data *ffs,

					      char *data, unsigned int len,

					      enum ffs_os_desc_type type,

					      u16 feature_count,

					      ffs_os_desc_callback entity,
@@ -2182,22 +2364,27 @@ static int __must_check ffs_do_single_os_desc(char *data, unsigned len, 


	ENTER();



	ffs_log("enter: len %u os desc type %d", len, type);



	/* loop over all ext compat/ext prop descriptors */

	while (feature_count--) {

		ret = entity(type, h, data, len, priv);

		if (unlikely(ret < 0)) {

			pr_debug("bad OS descriptor, type: %d\n", type);

			ffs_log("bad OS descriptor, type: %d\n", type);

			return ret;

		}

		data += ret;

		len -= ret;

	}





	return _len - len;

}



/* Process a number of complete Feature Descriptors (Ext Compat or Ext Prop) */

static int __must_check ffs_do_os_descs(unsigned count,

					char *data, unsigned len,

static int __must_check ffs_do_os_descs(struct ffs_data *ffs,

					unsigned int count, char *data,

					unsigned int len,

					ffs_os_desc_callback entity, void *priv)

{

	const unsigned _len = len;
@@ -2205,6 +2392,8 @@ static int __must_check ffs_do_os_descs(unsigned count, 


	ENTER();



	ffs_log("enter: len %u", len);



	for (num = 0; num < count; ++num) {

		int ret;

		enum ffs_os_desc_type type;
@@ -2224,9 +2413,9 @@ static int __must_check ffs_do_os_descs(unsigned count, 
		if (le32_to_cpu(desc->dwLength) > len)

			return -EINVAL;



		ret = __ffs_do_os_desc_header(&type, desc);

		ret = __ffs_do_os_desc_header(ffs, &type, desc);

		if (unlikely(ret < 0)) {

			pr_debug("entity OS_DESCRIPTOR(%02lx); ret = %d\n",

			ffs_log("entity OS_DESCRIPTOR(%02lx); ret = %d\n",

				 num, ret);

			return ret;

		}
@@ -2244,16 +2433,17 @@ static int __must_check ffs_do_os_descs(unsigned count, 
		 * Process all function/property descriptors

		 * of this Feature Descriptor

		 */

		ret = ffs_do_single_os_desc(data, len, type,

		ret = ffs_do_single_os_desc(ffs, data, len, type,

					    feature_count, entity, priv, desc);

		if (unlikely(ret < 0)) {

			pr_debug("%s returns %d\n", __func__, ret);

			ffs_log("%s returns %d\n", __func__, ret);

			return ret;

		}



		len -= ret;

		data += ret;

	}



	return _len - len;

}
@@ -2269,6 +2459,8 @@ static int __ffs_data_do_os_desc(enum ffs_os_desc_type type, 


	ENTER();



	ffs_log("enter: type %d len %u", type, len);



	switch (type) {

	case FFS_OS_DESC_EXT_COMPAT: {

		struct usb_ext_compat_desc *d = data;
@@ -2333,6 +2525,7 @@ static int __ffs_data_do_os_desc(enum ffs_os_desc_type type, 
		pr_vdebug("unknown descriptor: %d\n", type);

		return -EINVAL;

	}



	return length;

}
@@ -2346,6 +2539,8 @@ static int __ffs_data_got_descs(struct ffs_data *ffs, 


	ENTER();



	ffs_log("enter: len %zu", len);



	if (get_unaligned_le32(data + 4) != len)

		goto error;
@@ -2419,7 +2614,7 @@ static int __ffs_data_got_descs(struct ffs_data *ffs, 
			continue;

		helper.interfaces_count = 0;

		helper.eps_count = 0;

		ret = ffs_do_descs(counts[i], data, len,

		ret = ffs_do_descs(ffs, counts[i], data, len,

				   __ffs_data_do_entity, &helper);

		if (ret < 0)

			goto error;
@@ -2440,7 +2635,7 @@ static int __ffs_data_got_descs(struct ffs_data *ffs, 
		len  -= ret;

	}

	if (os_descs_count) {

		ret = ffs_do_os_descs(os_descs_count, data, len,

		ret = ffs_do_os_descs(ffs, os_descs_count, data, len,

				      __ffs_data_do_os_desc, ffs);

		if (ret < 0)

			goto error;
@@ -2478,6 +2673,8 @@ static int __ffs_data_got_strings(struct ffs_data *ffs, 


	ENTER();



	ffs_log("enter: len %zu", len);



	if (unlikely(len < 16 ||

		     get_unaligned_le32(data) != FUNCTIONFS_STRINGS_MAGIC ||

		     get_unaligned_le32(data + 4) != len))
@@ -2610,6 +2807,9 @@ static void __ffs_event_add(struct ffs_data *ffs, 
	enum usb_functionfs_event_type rem_type1, rem_type2 = type;

	int neg = 0;



	ffs_log("enter: type %d state %d setup_state %d flag %lu", type,

		ffs->state, ffs->setup_state, ffs->flags);



	/*

	 * Abort any unhandled setup

	 *
@@ -2698,11 +2898,14 @@ static int __ffs_func_bind_do_descs(enum ffs_entity_type type, u8 *valuep, 
{

	struct usb_endpoint_descriptor *ds = (void *)desc;

	struct ffs_function *func = priv;

	struct ffs_data *ffs = func->ffs;

	struct ffs_ep *ffs_ep;

	unsigned ep_desc_id;

	int idx;

	static const char *speed_names[] = { "full", "high", "super" };



	ffs_log("enter");



	if (type != FFS_DESCRIPTOR)

		return 0;
@@ -2786,9 +2989,12 @@ static int __ffs_func_bind_do_nums(enum ffs_entity_type type, u8 *valuep, 
				   void *priv)

{

	struct ffs_function *func = priv;

	struct ffs_data *ffs = func->ffs;

	unsigned idx;

	u8 newValue;



	ffs_log("enter: type %d", type);



	switch (type) {

	default:

	case FFS_DESCRIPTOR:
@@ -2833,6 +3039,9 @@ static int __ffs_func_bind_do_nums(enum ffs_entity_type type, u8 *valuep, 


	pr_vdebug("%02x -> %02x\n", *valuep, newValue);

	*valuep = newValue;



	ffs_log("exit: newValue %d", newValue);



	return 0;

}
@@ -2841,8 +3050,11 @@ static int __ffs_func_bind_do_os_desc(enum ffs_os_desc_type type, 
				      unsigned len, void *priv)

{

	struct ffs_function *func = priv;

	struct ffs_data *ffs = func->ffs;

	u8 length = 0;



	ffs_log("enter: type %d", type);



	switch (type) {

	case FFS_OS_DESC_EXT_COMPAT: {

		struct usb_ext_compat_desc *desc = data;
@@ -2921,6 +3133,7 @@ static inline struct f_fs_opts *ffs_do_functionfs_bind(struct usb_function *f, 
	struct ffs_function *func = ffs_func_from_usb(f);

	struct f_fs_opts *ffs_opts =

		container_of(f->fi, struct f_fs_opts, func_inst);

	struct ffs_data *ffs = ffs_opts->dev->ffs_data;

	int ret;



	ENTER();
@@ -2953,9 +3166,11 @@ static inline struct f_fs_opts *ffs_do_functionfs_bind(struct usb_function *f, 
	 */

	if (!ffs_opts->refcnt) {

		ret = functionfs_bind(func->ffs, c->cdev);

		if (ret)

		if (ret) {

			ffs_log("functionfs_bind returned %d", ret);

			return ERR_PTR(ret);

		}

	}

	ffs_opts->refcnt++;

	func->function.strings = func->ffs->stringtabs;
@@ -3002,6 +3217,9 @@ static int _ffs_func_bind(struct usb_configuration *c, 


	ENTER();



	ffs_log("enter: state %d setup_state %d flag %lu", ffs->state,

		ffs->setup_state, ffs->flags);



	/* Has descriptors only for speeds gadget does not support */

	if (unlikely(!(full | high | super)))

		return -ENOTSUPP;
@@ -3039,7 +3257,7 @@ static int _ffs_func_bind(struct usb_configuration *c, 
	 */

	if (likely(full)) {

		func->function.fs_descriptors = vla_ptr(vlabuf, d, fs_descs);

		fs_len = ffs_do_descs(ffs->fs_descs_count,

		fs_len = ffs_do_descs(ffs, ffs->fs_descs_count,

				      vla_ptr(vlabuf, d, raw_descs),

				      d_raw_descs__sz,

				      __ffs_func_bind_do_descs, func);
@@ -3053,7 +3271,7 @@ static int _ffs_func_bind(struct usb_configuration *c, 


	if (likely(high)) {

		func->function.hs_descriptors = vla_ptr(vlabuf, d, hs_descs);

		hs_len = ffs_do_descs(ffs->hs_descs_count,

		hs_len = ffs_do_descs(ffs, ffs->hs_descs_count,

				      vla_ptr(vlabuf, d, raw_descs) + fs_len,

				      d_raw_descs__sz - fs_len,

				      __ffs_func_bind_do_descs, func);
@@ -3067,7 +3285,7 @@ static int _ffs_func_bind(struct usb_configuration *c, 


	if (likely(super)) {

		func->function.ss_descriptors = vla_ptr(vlabuf, d, ss_descs);

		ss_len = ffs_do_descs(ffs->ss_descs_count,

		ss_len = ffs_do_descs(ffs, ffs->ss_descs_count,

				vla_ptr(vlabuf, d, raw_descs) + fs_len + hs_len,

				d_raw_descs__sz - fs_len - hs_len,

				__ffs_func_bind_do_descs, func);
@@ -3085,7 +3303,7 @@ static int _ffs_func_bind(struct usb_configuration *c, 
	 * endpoint numbers rewriting.  We can do that in one go

	 * now.

	 */

	ret = ffs_do_descs(ffs->fs_descs_count +

	ret = ffs_do_descs(ffs, ffs->fs_descs_count +

			   (high ? ffs->hs_descs_count : 0) +

			   (super ? ffs->ss_descs_count : 0),

			   vla_ptr(vlabuf, d, raw_descs), d_raw_descs__sz,
@@ -3105,7 +3323,7 @@ static int _ffs_func_bind(struct usb_configuration *c, 
				vla_ptr(vlabuf, d, ext_compat) + i * 16;

			INIT_LIST_HEAD(&desc->ext_prop);

		}

		ret = ffs_do_os_descs(ffs->ms_os_descs_count,

		ret = ffs_do_os_descs(ffs, ffs->ms_os_descs_count,

				      vla_ptr(vlabuf, d, raw_descs) +

				      fs_len + hs_len + ss_len,

				      d_raw_descs__sz - fs_len - hs_len -
@@ -3119,10 +3337,12 @@ static int _ffs_func_bind(struct usb_configuration *c, 


	/* And we're done */

	ffs_event_add(ffs, FUNCTIONFS_BIND);



	return 0;



error:

	/* XXX Do we need to release all claimed endpoints here? */

	ffs_log("exit: ret %d", ret);

	return ret;

}
@@ -3131,11 +3351,14 @@ static int ffs_func_bind(struct usb_configuration *c, 
{

	struct f_fs_opts *ffs_opts = ffs_do_functionfs_bind(f, c);

	struct ffs_function *func = ffs_func_from_usb(f);

	struct ffs_data *ffs = func->ffs;

	int ret;



	if (IS_ERR(ffs_opts))

		return PTR_ERR(ffs_opts);



	ffs_log("enter");



	ret = _ffs_func_bind(c, f);

	if (ret && !--ffs_opts->refcnt)

		functionfs_unbind(func->ffs);
@@ -3150,6 +3373,9 @@ static void ffs_reset_work(struct work_struct *work) 
{

	struct ffs_data *ffs = container_of(work,

		struct ffs_data, reset_work);



	ffs_log("enter");



	ffs_data_reset(ffs);

}
@@ -3160,6 +3386,8 @@ static int ffs_func_set_alt(struct usb_function *f, 
	struct ffs_data *ffs = func->ffs;

	int ret = 0, intf;



	ffs_log("enter: alt %d", (int)alt);



	if (alt != (unsigned)-1) {

		intf = ffs_func_revmap_intf(func, interface);

		if (unlikely(intf < 0))
@@ -3189,11 +3417,16 @@ static int ffs_func_set_alt(struct usb_function *f, 
	ret = ffs_func_eps_enable(func);

	if (likely(ret >= 0))

		ffs_event_add(ffs, FUNCTIONFS_ENABLE);



	return ret;

}



static void ffs_func_disable(struct usb_function *f)

{

	struct ffs_function *func = ffs_func_from_usb(f);

	struct ffs_data *ffs = func->ffs;



	ffs_log("enter");

	ffs_func_set_alt(f, 0, (unsigned)-1);

}
@@ -3213,6 +3446,11 @@ static int ffs_func_setup(struct usb_function *f, 
	pr_vdebug("creq->wIndex       = %04x\n", le16_to_cpu(creq->wIndex));

	pr_vdebug("creq->wLength      = %04x\n", le16_to_cpu(creq->wLength));



	ffs_log("enter: state %d reqtype=%02x req=%02x wv=%04x wi=%04x wl=%04x",

			ffs->state, creq->bRequestType, creq->bRequest,

			le16_to_cpu(creq->wValue), le16_to_cpu(creq->wIndex),

			le16_to_cpu(creq->wLength));



	/*

	 * Most requests directed to interface go through here

	 * (notable exceptions are set/get interface) so we need to
@@ -3281,13 +3519,23 @@ static bool ffs_func_req_match(struct usb_function *f, 


static void ffs_func_suspend(struct usb_function *f)

{

	struct ffs_data *ffs = ffs_func_from_usb(f)->ffs;



	ENTER();



	ffs_log("enter");



	ffs_event_add(ffs_func_from_usb(f)->ffs, FUNCTIONFS_SUSPEND);

}



static void ffs_func_resume(struct usb_function *f)

{

	struct ffs_data *ffs = ffs_func_from_usb(f)->ffs;



	ENTER();



	ffs_log("enter");



	ffs_event_add(ffs_func_from_usb(f)->ffs, FUNCTIONFS_RESUME);

}
@@ -3360,7 +3608,9 @@ static struct ffs_dev *_ffs_find_dev(const char *name) 
	if (dev)

		return dev;



	return _ffs_do_find_dev(name);

	dev = _ffs_do_find_dev(name);



	return dev;

}



/* Configfs support *********************************************************/
@@ -3451,6 +3701,10 @@ static void ffs_func_unbind(struct usb_configuration *c, 
	unsigned long flags;



	ENTER();



	ffs_log("enter: state %d setup_state %d flag %lu", ffs->state,

		ffs->setup_state, ffs->flags);



	if (ffs->func == func) {

		ffs_func_eps_disable(func);

		ffs->func = NULL;
@@ -3481,6 +3735,9 @@ static void ffs_func_unbind(struct usb_configuration *c, 
	func->interfaces_nums = NULL;



	ffs_event_add(ffs, FUNCTIONFS_UNBIND);



	ffs_log("exit: state %d setup_state %d flag %lu", ffs->state,

		ffs->setup_state, ffs->flags);

}



static struct usb_function *ffs_alloc(struct usb_function_instance *fi)
@@ -3568,6 +3825,7 @@ int ffs_single_dev(struct ffs_dev *dev) 
		dev->single = true;



	ffs_dev_unlock();



	return ret;

}

EXPORT_SYMBOL_GPL(ffs_single_dev);
@@ -3593,6 +3851,7 @@ static void *ffs_acquire_dev(const char *dev_name) 
	struct ffs_dev *ffs_dev;



	ENTER();



	ffs_dev_lock();



	ffs_dev = _ffs_find_dev(dev_name);
@@ -3607,6 +3866,7 @@ static void *ffs_acquire_dev(const char *dev_name) 
		ffs_dev->mounted = true;



	ffs_dev_unlock();



	return ffs_dev;

}
@@ -3615,6 +3875,7 @@ static void ffs_release_dev(struct ffs_data *ffs_data) 
	struct ffs_dev *ffs_dev;



	ENTER();



	ffs_dev_lock();



	ffs_dev = ffs_data->private_data;
@@ -3634,6 +3895,9 @@ static int ffs_ready(struct ffs_data *ffs) 
	int ret = 0;



	ENTER();



	ffs_log("enter");



	ffs_dev_lock();



	ffs_obj = ffs->private_data;
@@ -3658,6 +3922,9 @@ static int ffs_ready(struct ffs_data *ffs) 
	set_bit(FFS_FL_CALL_CLOSED_CALLBACK, &ffs->flags);

done:

	ffs_dev_unlock();



	ffs_log("exit: ret %d", ret);



	return ret;

}
@@ -3668,6 +3935,9 @@ static void ffs_closed(struct ffs_data *ffs) 
	struct config_item *ci;



	ENTER();



	ffs_log("enter");



	ffs_dev_lock();



	ffs_obj = ffs->private_data;
@@ -3693,11 +3963,16 @@ static void ffs_closed(struct ffs_data *ffs) 
	ci = opts->func_inst.group.cg_item.ci_parent->ci_parent;

	ffs_dev_unlock();



	if (test_bit(FFS_FL_BOUND, &ffs->flags))

	if (test_bit(FFS_FL_BOUND, &ffs->flags)) {

		unregister_gadget_item(ci);

		ffs_log("unreg gadget done");

	}



	return;

done:

	ffs_dev_unlock();



	ffs_log("exit error");

}



/* Misc helper functions ****************************************************/

drivers/usb/gadget/function/u_fs.h

+3 −0

File changed.

Preview size limit exceeded, changes collapsed.