fuse: convert ioctl to simple api (093f38a2) · Commits · e / devices / android_kernel_fairphone_FP5

fs/fuse/dev.c

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -590,8 +590,8 @@ ssize_t fuse_simple_request(struct fuse_conn fc, struct fuse_args args)
	__fuse_request_send(fc, req);		__fuse_request_send(fc, req);
	ret = req->out.h.error;		ret = req->out.h.error;
	if (!ret && args->out_argvar) {		if (!ret && args->out_argvar) {
	BUG_ON(args->out_numargs != 1);		BUG_ON(args->out_numargs == 0);
	ret = req->out.args[0].size;		ret = req->out.args[args->out_numargs - 1].size;
	}		}
	fuse_put_request(fc, req);		fuse_put_request(fc, req);

fs/fuse/file.c

+43 −54

Original line number	Original line	Diff line number	Diff line
	@@ -1267,14 +1267,14 @@ static ssize_t fuse_cache_write_iter(struct kiocb iocb, struct iov_iter from)
	return written ? written : err;		return written ? written : err;
	}		}

	static inline void fuse_page_descs_length_init(struct fuse_req *req,		static inline void fuse_page_descs_length_init(struct fuse_page_desc *descs,
	unsigned index, unsigned nr_pages)		unsigned int index,
			unsigned int nr_pages)
	{		{
	int i;		int i;

	for (i = index; i < index + nr_pages; i++)		for (i = index; i < index + nr_pages; i++)
	req->page_descs[i].length = PAGE_SIZE -		descs[i].length = PAGE_SIZE - descs[i].offset;
	req->page_descs[i].offset;
	}		}

	static inline unsigned long fuse_get_user_addr(const struct iov_iter *ii)		static inline unsigned long fuse_get_user_addr(const struct iov_iter *ii)
	@@ -1326,7 +1326,8 @@ static int fuse_get_user_pages(struct fuse_req req, struct iov_iter ii,
	npages = (ret + PAGE_SIZE - 1) / PAGE_SIZE;		npages = (ret + PAGE_SIZE - 1) / PAGE_SIZE;

	req->page_descs[req->num_pages].offset = start;		req->page_descs[req->num_pages].offset = start;
	fuse_page_descs_length_init(req, req->num_pages, npages);		fuse_page_descs_length_init(req->page_descs, req->num_pages,
			npages);

	req->num_pages += npages;		req->num_pages += npages;
	req->page_descs[req->num_pages - 1].length -=		req->page_descs[req->num_pages - 1].length -=
	@@ -2582,14 +2583,14 @@ long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
	.flags = flags		.flags = flags
	};		};
	struct fuse_ioctl_out outarg;		struct fuse_ioctl_out outarg;
	struct fuse_req *req = NULL;
	struct page **pages = NULL;
	struct iovec *iov_page = NULL;		struct iovec *iov_page = NULL;
	struct iovec in_iov = NULL, out_iov = NULL;		struct iovec in_iov = NULL, out_iov = NULL;
	unsigned int in_iovs = 0, out_iovs = 0, num_pages = 0, max_pages;		unsigned int in_iovs = 0, out_iovs = 0, max_pages;
	size_t in_size, out_size, transferred, c;		size_t in_size, out_size, c;
			ssize_t transferred;
	int err, i;		int err, i;
	struct iov_iter ii;		struct iov_iter ii;
			struct fuse_args_pages ap = {};

	#if BITS_PER_LONG == 32		#if BITS_PER_LONG == 32
	inarg.flags \|= FUSE_IOCTL_32BIT;		inarg.flags \|= FUSE_IOCTL_32BIT;
	@@ -2607,11 +2608,13 @@ long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
	BUILD_BUG_ON(sizeof(struct fuse_ioctl_iovec) * FUSE_IOCTL_MAX_IOV > PAGE_SIZE);		BUILD_BUG_ON(sizeof(struct fuse_ioctl_iovec) * FUSE_IOCTL_MAX_IOV > PAGE_SIZE);

	err = -ENOMEM;		err = -ENOMEM;
	pages = kcalloc(fc->max_pages, sizeof(pages[0]), GFP_KERNEL);		ap.pages = fuse_pages_alloc(fc->max_pages, GFP_KERNEL, &ap.descs);
	iov_page = (struct iovec *) __get_free_page(GFP_KERNEL);		iov_page = (struct iovec *) __get_free_page(GFP_KERNEL);
	if (!pages \|\| !iov_page)		if (!ap.pages \|\| !iov_page)
	goto out;		goto out;

			fuse_page_descs_length_init(ap.descs, 0, fc->max_pages);

	/*		/*
	* If restricted, initialize IO parameters as encoded in @cmd.		* If restricted, initialize IO parameters as encoded in @cmd.
	* RETRY from server is not allowed.		* RETRY from server is not allowed.
	@@ -2648,56 +2651,44 @@ long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
	err = -ENOMEM;		err = -ENOMEM;
	if (max_pages > fc->max_pages)		if (max_pages > fc->max_pages)
	goto out;		goto out;
	while (num_pages < max_pages) {		while (ap.num_pages < max_pages) {
	pages[num_pages] = alloc_page(GFP_KERNEL \| __GFP_HIGHMEM);		ap.pages[ap.num_pages] = alloc_page(GFP_KERNEL \| __GFP_HIGHMEM);
	if (!pages[num_pages])		if (!ap.pages[ap.num_pages])
	goto out;		goto out;
	num_pages++;		ap.num_pages++;
	}		}

	req = fuse_get_req(fc, num_pages);
	if (IS_ERR(req)) {
	err = PTR_ERR(req);
	req = NULL;
	goto out;
	}
	memcpy(req->pages, pages, sizeof(req->pages[0]) * num_pages);
	req->num_pages = num_pages;
	fuse_page_descs_length_init(req, 0, req->num_pages);

	/* okay, let's send it to the client */		/* okay, let's send it to the client */
	req->in.h.opcode = FUSE_IOCTL;		ap.args.opcode = FUSE_IOCTL;
	req->in.h.nodeid = ff->nodeid;		ap.args.nodeid = ff->nodeid;
	req->in.numargs = 1;		ap.args.in_numargs = 1;
	req->in.args[0].size = sizeof(inarg);		ap.args.in_args[0].size = sizeof(inarg);
	req->in.args[0].value = &inarg;		ap.args.in_args[0].value = &inarg;
	if (in_size) {		if (in_size) {
	req->in.numargs++;		ap.args.in_numargs++;
	req->in.args[1].size = in_size;		ap.args.in_args[1].size = in_size;
	req->in.argpages = 1;		ap.args.in_pages = true;

	err = -EFAULT;		err = -EFAULT;
	iov_iter_init(&ii, WRITE, in_iov, in_iovs, in_size);		iov_iter_init(&ii, WRITE, in_iov, in_iovs, in_size);
	for (i = 0; iov_iter_count(&ii) && !WARN_ON(i >= num_pages); i++) {		for (i = 0; iov_iter_count(&ii) && !WARN_ON(i >= ap.num_pages); i++) {
	c = copy_page_from_iter(pages[i], 0, PAGE_SIZE, &ii);		c = copy_page_from_iter(ap.pages[i], 0, PAGE_SIZE, &ii);
	if (c != PAGE_SIZE && iov_iter_count(&ii))		if (c != PAGE_SIZE && iov_iter_count(&ii))
	goto out;		goto out;
	}		}
	}		}

	req->out.numargs = 2;		ap.args.out_numargs = 2;
	req->out.args[0].size = sizeof(outarg);		ap.args.out_args[0].size = sizeof(outarg);
	req->out.args[0].value = &outarg;		ap.args.out_args[0].value = &outarg;
	req->out.args[1].size = out_size;		ap.args.out_args[1].size = out_size;
	req->out.argpages = 1;		ap.args.out_pages = true;
	req->out.argvar = 1;		ap.args.out_argvar = true;

	fuse_request_send(fc, req);		transferred = fuse_simple_request(fc, &ap.args);
	err = req->out.h.error;		err = transferred;
	transferred = req->out.args[1].size;		if (transferred < 0)
	fuse_put_request(fc, req);
	req = NULL;
	if (err)
	goto out;		goto out;

	/* did it ask for retry? */		/* did it ask for retry? */
	@@ -2722,7 +2713,7 @@ long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
	in_iovs + out_iovs > FUSE_IOCTL_MAX_IOV)		in_iovs + out_iovs > FUSE_IOCTL_MAX_IOV)
	goto out;		goto out;

	vaddr = kmap_atomic(pages[0]);		vaddr = kmap_atomic(ap.pages[0]);
	err = fuse_copy_ioctl_iovec(fc, iov_page, vaddr,		err = fuse_copy_ioctl_iovec(fc, iov_page, vaddr,
	transferred, in_iovs + out_iovs,		transferred, in_iovs + out_iovs,
	(flags & FUSE_IOCTL_COMPAT) != 0);		(flags & FUSE_IOCTL_COMPAT) != 0);
	@@ -2750,19 +2741,17 @@ long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,

	err = -EFAULT;		err = -EFAULT;
	iov_iter_init(&ii, READ, out_iov, out_iovs, transferred);		iov_iter_init(&ii, READ, out_iov, out_iovs, transferred);
	for (i = 0; iov_iter_count(&ii) && !WARN_ON(i >= num_pages); i++) {		for (i = 0; iov_iter_count(&ii) && !WARN_ON(i >= ap.num_pages); i++) {
	c = copy_page_to_iter(pages[i], 0, PAGE_SIZE, &ii);		c = copy_page_to_iter(ap.pages[i], 0, PAGE_SIZE, &ii);
	if (c != PAGE_SIZE && iov_iter_count(&ii))		if (c != PAGE_SIZE && iov_iter_count(&ii))
	goto out;		goto out;
	}		}
	err = 0;		err = 0;
	out:		out:
	if (req)
	fuse_put_request(fc, req);
	free_page((unsigned long) iov_page);		free_page((unsigned long) iov_page);
	while (num_pages)		while (ap.num_pages)
	__free_page(pages[--num_pages]);		__free_page(ap.pages[--ap.num_pages]);
	kfree(pages);		kfree(ap.pages);

	return err ? err : outarg.result;		return err ? err : outarg.result;
	}		}