// SPDX-License-Identifier: GPL-2.0-only #include "dev.h"#include "fuse_i.h" void fuse_end_polls(struct fuse_conn *fc){	struct rb_node *p; 	spin_lock(&fc->lock);	p = rb_first(&fc->polled_files); 	while (p) {		struct fuse_file *ff;		ff = rb_entry(p, struct fuse_file, polled_node);		wake_up_interruptible_all(&ff->poll_wait); 		p = rb_next(p);	}	spin_unlock(&fc->lock);} /* * All files which have been polled are linked to RB tree * fuse_conn->polled_files which is indexed by kh.  Walk the tree and * find the matching one. */static struct rb_node **fuse_find_polled_node(struct fuse_conn *fc, u64 kh,					      struct rb_node **parent_out){	struct rb_node **link = &fc->polled_files.rb_node;	struct rb_node *last = NULL; 	while (*link) {		struct fuse_file *ff; 		last = *link;		ff = rb_entry(last, struct fuse_file, polled_node); 		if (kh < ff->kh)			link = &last->rb_left;		else if (kh > ff->kh)			link = &last->rb_right;		else			return link;	} 	if (parent_out)		*parent_out = last;	return link;} /* * The file is about to be polled.  Make sure it's on the polled_files * RB tree.  Note that files once added to the polled_files tree are * not removed before the file is released.  This is because a file * polled once is likely to be polled again. */static void fuse_register_polled_file(struct fuse_conn *fc,				      struct fuse_file *ff){	spin_lock(&fc->lock);	if (RB_EMPTY_NODE(&ff->polled_node)) {		struct rb_node **link, *parent; 		link = fuse_find_polled_node(fc, ff->kh, &parent);		BUG_ON(*link);		rb_link_node(&ff->polled_node, parent, link);		rb_insert_color(&ff->polled_node, &fc->polled_files);	}	spin_unlock(&fc->lock);} __poll_t fuse_file_poll(struct file *file, poll_table *wait){	struct fuse_file *ff = file->private_data;	struct fuse_mount *fm = ff->fm;	struct fuse_poll_in inarg = { .fh = ff->fh, .kh = ff->kh };	struct fuse_poll_out outarg;	FUSE_ARGS(args);	int err; 	if (fm->fc->no_poll)		return DEFAULT_POLLMASK; 	poll_wait(file, &ff->poll_wait, wait);	inarg.events = mangle_poll(poll_requested_events(wait)); 	/*	 * Ask for notification iff there's someone waiting for it.	 * The client may ignore the flag and always notify.	 */	if (waitqueue_active(&ff->poll_wait)) {		inarg.flags |= FUSE_POLL_SCHEDULE_NOTIFY;		fuse_register_polled_file(fm->fc, ff);	} 	args.opcode = FUSE_POLL;	args.nodeid = ff->nodeid;	args.in_numargs = 1;	args.in_args[0].size = sizeof(inarg);	args.in_args[0].value = &inarg;	args.out_numargs = 1;	args.out_args[0].size = sizeof(outarg);	args.out_args[0].value = &outarg;	err = fuse_simple_request(fm, &args); 	if (!err)		return demangle_poll(outarg.revents);	if (err == -ENOSYS) {		fm->fc->no_poll = 1;		return DEFAULT_POLLMASK;	}	return EPOLLERR;}EXPORT_SYMBOL_GPL(fuse_file_poll); /* * This is called from fuse_handle_notify() on FUSE_NOTIFY_POLL and * wakes up the poll waiters. */int fuse_notify_poll_wakeup(struct fuse_conn *fc,			    struct fuse_notify_poll_wakeup_out *outarg){	u64 kh = outarg->kh;	struct rb_node **link; 	spin_lock(&fc->lock); 	link = fuse_find_polled_node(fc, kh, NULL);	if (*link) {		struct fuse_file *ff; 		ff = rb_entry(*link, struct fuse_file, polled_node);		wake_up_interruptible_sync(&ff->poll_wait);	} 	spin_unlock(&fc->lock);	return 0;}