Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/fuse (e7989f97) · Commits · e / devices / android_kernel_fairphone_FP5

fs/fuse/cuse.c

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -90,7 +90,7 @@ static struct list_head *cuse_conntbl_head(dev_t devt)

	static ssize_t cuse_read_iter(struct kiocb kiocb, struct iov_iter to)		static ssize_t cuse_read_iter(struct kiocb kiocb, struct iov_iter to)
	{		{
	struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(kiocb->ki_filp);		struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(kiocb);
	loff_t pos = 0;		loff_t pos = 0;

	return fuse_direct_io(&io, to, &pos, FUSE_DIO_CUSE);		return fuse_direct_io(&io, to, &pos, FUSE_DIO_CUSE);
	@@ -98,7 +98,7 @@ static ssize_t cuse_read_iter(struct kiocb kiocb, struct iov_iter to)

	static ssize_t cuse_write_iter(struct kiocb kiocb, struct iov_iter from)		static ssize_t cuse_write_iter(struct kiocb kiocb, struct iov_iter from)
	{		{
	struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(kiocb->ki_filp);		struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(kiocb);
	loff_t pos = 0;		loff_t pos = 0;
	/*		/*
	* No locking or generic_write_checks(), the server is		* No locking or generic_write_checks(), the server is

fs/fuse/dev.c

+7 −6

Original line number	Original line	Diff line number	Diff line
	@@ -1222,9 +1222,6 @@ static ssize_t fuse_dev_do_read(struct fuse_dev fud, struct file file,
	struct fuse_in *in;		struct fuse_in *in;
	unsigned reqsize;		unsigned reqsize;

	if (task_active_pid_ns(current) != fc->pid_ns)
	return -EIO;

	restart:		restart:
	spin_lock(&fiq->waitq.lock);		spin_lock(&fiq->waitq.lock);
	err = -EAGAIN;		err = -EAGAIN;
	@@ -1262,6 +1259,13 @@ static ssize_t fuse_dev_do_read(struct fuse_dev fud, struct file file,

	in = &req->in;		in = &req->in;
	reqsize = in->h.len;		reqsize = in->h.len;

			if (task_active_pid_ns(current) != fc->pid_ns) {
			rcu_read_lock();
			in->h.pid = pid_vnr(find_pid_ns(in->h.pid, fc->pid_ns));
			rcu_read_unlock();
			}

	/* If request is too large, reply with an error and restart the read */		/* If request is too large, reply with an error and restart the read */
	if (nbytes < reqsize) {		if (nbytes < reqsize) {
	req->out.h.error = -EIO;		req->out.h.error = -EIO;
	@@ -1823,9 +1827,6 @@ static ssize_t fuse_dev_do_write(struct fuse_dev *fud,
	struct fuse_req *req;		struct fuse_req *req;
	struct fuse_out_header oh;		struct fuse_out_header oh;

	if (task_active_pid_ns(current) != fc->pid_ns)
	return -EIO;

	if (nbytes < sizeof(struct fuse_out_header))		if (nbytes < sizeof(struct fuse_out_header))
	return -EINVAL;		return -EINVAL;

fs/fuse/dir.c

+13 −17

Original line number	Original line	Diff line number	Diff line
	@@ -923,33 +923,29 @@ static int fuse_do_getattr(struct inode inode, struct kstat stat,
	return err;		return err;
	}		}

	int fuse_update_attributes(struct inode inode, struct kstat stat,		static int fuse_update_get_attr(struct inode inode, struct file file,
	struct file file, bool refreshed)		struct kstat *stat)
	{		{
	struct fuse_inode *fi = get_fuse_inode(inode);		struct fuse_inode *fi = get_fuse_inode(inode);
	int err;		int err = 0;
	bool r;

	if (time_before64(fi->i_time, get_jiffies_64())) {		if (time_before64(fi->i_time, get_jiffies_64())) {
	r = true;
	forget_all_cached_acls(inode);		forget_all_cached_acls(inode);
	err = fuse_do_getattr(inode, stat, file);		err = fuse_do_getattr(inode, stat, file);
	} else {		} else if (stat) {
	r = false;
	err = 0;
	if (stat) {
	generic_fillattr(inode, stat);		generic_fillattr(inode, stat);
	stat->mode = fi->orig_i_mode;		stat->mode = fi->orig_i_mode;
	stat->ino = fi->orig_ino;		stat->ino = fi->orig_ino;
	}		}
	}

	if (refreshed != NULL)
	*refreshed = r;

	return err;		return err;
	}		}

			int fuse_update_attributes(struct inode inode, struct file file)
			{
			return fuse_update_get_attr(inode, file, NULL);
			}

	int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,		int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
	u64 child_nodeid, struct qstr *name)		u64 child_nodeid, struct qstr *name)
	{		{
	@@ -1786,7 +1782,7 @@ static int fuse_getattr(const struct path path, struct kstat stat,
	if (!fuse_allow_current_process(fc))		if (!fuse_allow_current_process(fc))
	return -EACCES;		return -EACCES;

	return fuse_update_attributes(inode, stat, NULL, NULL);		return fuse_update_get_attr(inode, NULL, stat);
	}		}

	static const struct inode_operations fuse_dir_inode_operations = {		static const struct inode_operations fuse_dir_inode_operations = {

fs/fuse/file.c

+28 −24

Original line number	Original line	Diff line number	Diff line
	@@ -645,7 +645,7 @@ static size_t fuse_async_req_send(struct fuse_conn fc, struct fuse_req req,
	static size_t fuse_send_read(struct fuse_req req, struct fuse_io_priv io,		static size_t fuse_send_read(struct fuse_req req, struct fuse_io_priv io,
	loff_t pos, size_t count, fl_owner_t owner)		loff_t pos, size_t count, fl_owner_t owner)
	{		{
	struct file *file = io->file;		struct file *file = io->iocb->ki_filp;
	struct fuse_file *ff = file->private_data;		struct fuse_file *ff = file->private_data;
	struct fuse_conn *fc = ff->fc;		struct fuse_conn *fc = ff->fc;

	@@ -707,7 +707,8 @@ static void fuse_short_read(struct fuse_req req, struct inode inode,

	static int fuse_do_readpage(struct file file, struct page page)		static int fuse_do_readpage(struct file file, struct page page)
	{		{
	struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(file);		struct kiocb iocb;
			struct fuse_io_priv io;
	struct inode *inode = page->mapping->host;		struct inode *inode = page->mapping->host;
	struct fuse_conn *fc = get_fuse_conn(inode);		struct fuse_conn *fc = get_fuse_conn(inode);
	struct fuse_req *req;		struct fuse_req *req;
	@@ -735,6 +736,8 @@ static int fuse_do_readpage(struct file file, struct page page)
	req->num_pages = 1;		req->num_pages = 1;
	req->pages[0] = page;		req->pages[0] = page;
	req->page_descs[0].length = count;		req->page_descs[0].length = count;
			init_sync_kiocb(&iocb, file);
			io = (struct fuse_io_priv) FUSE_IO_PRIV_SYNC(&iocb);
	num_read = fuse_send_read(req, &io, pos, count, NULL);		num_read = fuse_send_read(req, &io, pos, count, NULL);
	err = req->out.h.error;		err = req->out.h.error;

	@@ -923,7 +926,7 @@ static ssize_t fuse_file_read_iter(struct kiocb iocb, struct iov_iter to)
	if (fc->auto_inval_data \|\|		if (fc->auto_inval_data \|\|
	(iocb->ki_pos + iov_iter_count(to) > i_size_read(inode))) {		(iocb->ki_pos + iov_iter_count(to) > i_size_read(inode))) {
	int err;		int err;
	err = fuse_update_attributes(inode, NULL, iocb->ki_filp, NULL);		err = fuse_update_attributes(inode, iocb->ki_filp);
	if (err)		if (err)
	return err;		return err;
	}		}
	@@ -957,13 +960,18 @@ static void fuse_write_fill(struct fuse_req req, struct fuse_file ff,
	static size_t fuse_send_write(struct fuse_req req, struct fuse_io_priv io,		static size_t fuse_send_write(struct fuse_req req, struct fuse_io_priv io,
	loff_t pos, size_t count, fl_owner_t owner)		loff_t pos, size_t count, fl_owner_t owner)
	{		{
	struct file *file = io->file;		struct kiocb *iocb = io->iocb;
			struct file *file = iocb->ki_filp;
	struct fuse_file *ff = file->private_data;		struct fuse_file *ff = file->private_data;
	struct fuse_conn *fc = ff->fc;		struct fuse_conn *fc = ff->fc;
	struct fuse_write_in *inarg = &req->misc.write.in;		struct fuse_write_in *inarg = &req->misc.write.in;

	fuse_write_fill(req, ff, pos, count);		fuse_write_fill(req, ff, pos, count);
	inarg->flags = file->f_flags;		inarg->flags = file->f_flags;
			if (iocb->ki_flags & IOCB_DSYNC)
			inarg->flags \|= O_DSYNC;
			if (iocb->ki_flags & IOCB_SYNC)
			inarg->flags \|= O_SYNC;
	if (owner != NULL) {		if (owner != NULL) {
	inarg->write_flags \|= FUSE_WRITE_LOCKOWNER;		inarg->write_flags \|= FUSE_WRITE_LOCKOWNER;
	inarg->lock_owner = fuse_lock_owner_id(fc, owner);		inarg->lock_owner = fuse_lock_owner_id(fc, owner);
	@@ -993,14 +1001,14 @@ bool fuse_write_update_size(struct inode *inode, loff_t pos)
	return ret;		return ret;
	}		}

	static size_t fuse_send_write_pages(struct fuse_req req, struct file file,		static size_t fuse_send_write_pages(struct fuse_req req, struct kiocb iocb,
	struct inode *inode, loff_t pos,		struct inode *inode, loff_t pos,
	size_t count)		size_t count)
	{		{
	size_t res;		size_t res;
	unsigned offset;		unsigned offset;
	unsigned i;		unsigned i;
	struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(file);		struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(iocb);

	for (i = 0; i < req->num_pages; i++)		for (i = 0; i < req->num_pages; i++)
	fuse_wait_on_page_writeback(inode, req->pages[i]->index);		fuse_wait_on_page_writeback(inode, req->pages[i]->index);
	@@ -1100,7 +1108,7 @@ static inline unsigned fuse_wr_pages(loff_t pos, size_t len)
	FUSE_MAX_PAGES_PER_REQ);		FUSE_MAX_PAGES_PER_REQ);
	}		}

	static ssize_t fuse_perform_write(struct file *file,		static ssize_t fuse_perform_write(struct kiocb *iocb,
	struct address_space *mapping,		struct address_space *mapping,
	struct iov_iter *ii, loff_t pos)		struct iov_iter *ii, loff_t pos)
	{		{
	@@ -1133,7 +1141,7 @@ static ssize_t fuse_perform_write(struct file *file,
	} else {		} else {
	size_t num_written;		size_t num_written;

	num_written = fuse_send_write_pages(req, file, inode,		num_written = fuse_send_write_pages(req, iocb, inode,
	pos, count);		pos, count);
	err = req->out.h.error;		err = req->out.h.error;
	if (!err) {		if (!err) {
	@@ -1169,7 +1177,7 @@ static ssize_t fuse_file_write_iter(struct kiocb iocb, struct iov_iter from)

	if (get_fuse_conn(inode)->writeback_cache) {		if (get_fuse_conn(inode)->writeback_cache) {
	/* Update size (EOF optimization) and mode (SUID clearing) */		/* Update size (EOF optimization) and mode (SUID clearing) */
	err = fuse_update_attributes(mapping->host, NULL, file, NULL);		err = fuse_update_attributes(mapping->host, file);
	if (err)		if (err)
	return err;		return err;

	@@ -1201,7 +1209,7 @@ static ssize_t fuse_file_write_iter(struct kiocb iocb, struct iov_iter from)

	pos += written;		pos += written;

	written_buffered = fuse_perform_write(file, mapping, from, pos);		written_buffered = fuse_perform_write(iocb, mapping, from, pos);
	if (written_buffered < 0) {		if (written_buffered < 0) {
	err = written_buffered;		err = written_buffered;
	goto out;		goto out;
	@@ -1220,13 +1228,15 @@ static ssize_t fuse_file_write_iter(struct kiocb iocb, struct iov_iter from)
	written += written_buffered;		written += written_buffered;
	iocb->ki_pos = pos + written_buffered;		iocb->ki_pos = pos + written_buffered;
	} else {		} else {
	written = fuse_perform_write(file, mapping, from, iocb->ki_pos);		written = fuse_perform_write(iocb, mapping, from, iocb->ki_pos);
	if (written >= 0)		if (written >= 0)
	iocb->ki_pos += written;		iocb->ki_pos += written;
	}		}
	out:		out:
	current->backing_dev_info = NULL;		current->backing_dev_info = NULL;
	inode_unlock(inode);		inode_unlock(inode);
			if (written > 0)
			written = generic_write_sync(iocb, written);

	return written ? written : err;		return written ? written : err;
	}		}
	@@ -1317,7 +1327,7 @@ ssize_t fuse_direct_io(struct fuse_io_priv io, struct iov_iter iter,
	{		{
	int write = flags & FUSE_DIO_WRITE;		int write = flags & FUSE_DIO_WRITE;
	int cuse = flags & FUSE_DIO_CUSE;		int cuse = flags & FUSE_DIO_CUSE;
	struct file *file = io->file;		struct file *file = io->iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;		struct inode *inode = file->f_mapping->host;
	struct fuse_file *ff = file->private_data;		struct fuse_file *ff = file->private_data;
	struct fuse_conn *fc = ff->fc;		struct fuse_conn *fc = ff->fc;
	@@ -1399,8 +1409,7 @@ static ssize_t __fuse_direct_read(struct fuse_io_priv *io,
	loff_t *ppos)		loff_t *ppos)
	{		{
	ssize_t res;		ssize_t res;
	struct file *file = io->file;		struct inode *inode = file_inode(io->iocb->ki_filp);
	struct inode *inode = file_inode(file);

	if (is_bad_inode(inode))		if (is_bad_inode(inode))
	return -EIO;		return -EIO;
	@@ -1414,15 +1423,14 @@ static ssize_t __fuse_direct_read(struct fuse_io_priv *io,

	static ssize_t fuse_direct_read_iter(struct kiocb iocb, struct iov_iter to)		static ssize_t fuse_direct_read_iter(struct kiocb iocb, struct iov_iter to)
	{		{
	struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(iocb->ki_filp);		struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(iocb);
	return __fuse_direct_read(&io, to, &iocb->ki_pos);		return __fuse_direct_read(&io, to, &iocb->ki_pos);
	}		}

	static ssize_t fuse_direct_write_iter(struct kiocb iocb, struct iov_iter from)		static ssize_t fuse_direct_write_iter(struct kiocb iocb, struct iov_iter from)
	{		{
	struct file *file = iocb->ki_filp;		struct inode *inode = file_inode(iocb->ki_filp);
	struct inode *inode = file_inode(file);		struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(iocb);
	struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(file);
	ssize_t res;		ssize_t res;

	if (is_bad_inode(inode))		if (is_bad_inode(inode))
	@@ -2181,9 +2189,6 @@ static int fuse_setlk(struct file file, struct file_lock fl, int flock)
	if ((fl->fl_flags & FL_CLOSE_POSIX) == FL_CLOSE_POSIX)		if ((fl->fl_flags & FL_CLOSE_POSIX) == FL_CLOSE_POSIX)
	return 0;		return 0;

	if (pid && pid_nr == 0)
	return -EOVERFLOW;

	fuse_lk_fill(&args, file, fl, opcode, pid_nr, flock, &inarg);		fuse_lk_fill(&args, file, fl, opcode, pid_nr, flock, &inarg);
	err = fuse_simple_request(fc, &args);		err = fuse_simple_request(fc, &args);

	@@ -2303,7 +2308,7 @@ static loff_t fuse_lseek(struct file *file, loff_t offset, int whence)
	return vfs_setpos(file, outarg.offset, inode->i_sb->s_maxbytes);		return vfs_setpos(file, outarg.offset, inode->i_sb->s_maxbytes);

	fallback:		fallback:
	err = fuse_update_attributes(inode, NULL, file, NULL);		err = fuse_update_attributes(inode, file);
	if (!err)		if (!err)
	return generic_file_llseek(file, offset, whence);		return generic_file_llseek(file, offset, whence);
	else		else
	@@ -2323,7 +2328,7 @@ static loff_t fuse_file_llseek(struct file *file, loff_t offset, int whence)
	break;		break;
	case SEEK_END:		case SEEK_END:
	inode_lock(inode);		inode_lock(inode);
	retval = fuse_update_attributes(inode, NULL, file, NULL);		retval = fuse_update_attributes(inode, file);
	if (!retval)		if (!retval)
	retval = generic_file_llseek(file, offset, whence);		retval = generic_file_llseek(file, offset, whence);
	inode_unlock(inode);		inode_unlock(inode);
	@@ -2874,7 +2879,6 @@ fuse_direct_IO(struct kiocb iocb, struct iov_iter iter)
	io->offset = offset;		io->offset = offset;
	io->write = (iov_iter_rw(iter) == WRITE);		io->write = (iov_iter_rw(iter) == WRITE);
	io->err = 0;		io->err = 0;
	io->file = file;
	/*		/*
	* By default, we want to optimize all I/Os with async request		* By default, we want to optimize all I/Os with async request
	* submission to the client filesystem if supported.		* submission to the client filesystem if supported.

fs/fuse/fuse_i.h

+3 −5

Original line number	Original line	Diff line number	Diff line
	@@ -252,16 +252,15 @@ struct fuse_io_priv {
	bool should_dirty;		bool should_dirty;
	int err;		int err;
	struct kiocb *iocb;		struct kiocb *iocb;
	struct file *file;
	struct completion *done;		struct completion *done;
	bool blocking;		bool blocking;
	};		};

	#define FUSE_IO_PRIV_SYNC(f) \		#define FUSE_IO_PRIV_SYNC(i) \
	{ \		{ \
	.refcnt = KREF_INIT(1), \		.refcnt = KREF_INIT(1), \
	.async = 0, \		.async = 0, \
	.file = f, \		.iocb = i, \
	}		}

	/**		/**
	@@ -905,8 +904,7 @@ u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id);

	void fuse_update_ctime(struct inode *inode);		void fuse_update_ctime(struct inode *inode);

	int fuse_update_attributes(struct inode inode, struct kstat stat,		int fuse_update_attributes(struct inode inode, struct file file);
	struct file file, bool refreshed);

	void fuse_flush_writepages(struct inode *inode);		void fuse_flush_writepages(struct inode *inode);