| Message ID | 20230523065802.2253926-1-aloktiagi@gmail.com (mailing list archive) |
|---|---|
| State | Superseded, archived |
| Headers | show |
| Series | [RFC,v6,1/2] epoll: Implement eventpoll_replace_file() | expand |
On Tue, May 23, 2023 at 06:58:01AM +0000, aloktiagi wrote: > Introduce a mechanism to replace a file linked in the epoll interface with a new > file. > > eventpoll_replace() finds all instances of the file to be replaced and replaces > them with the new file and the interested events. > > Signed-off-by: aloktiagi <aloktiagi@gmail.com> > --- > Changes in v6: > - incorporate latest changes that get rid of the global epmutex lock. > > Changes in v5: > - address review comments and move the call to replace old file in each > subsystem (epoll, io_uring, etc.) outside the fdtable helpers like > replace_fd(). > > Changes in v4: > - address review comment to remove the redundant eventpoll_replace() function. > - removed an extra empty line introduced in include/linux/file.h > > Changes in v3: > - address review comment and iterate over the file table while holding the > spin_lock(&files->file_lock). > - address review comment and call filp_close() outside the > spin_lock(&files->file_lock). > --- > fs/eventpoll.c | 76 +++++++++++++++++++++++++++++++++++++++ > include/linux/eventpoll.h | 8 +++++ > 2 files changed, 84 insertions(+) > > diff --git a/fs/eventpoll.c b/fs/eventpoll.c > index 980483455cc0..9c7bffa8401b 100644 > --- a/fs/eventpoll.c > +++ b/fs/eventpoll.c > @@ -973,6 +973,82 @@ void eventpoll_release_file(struct file *file) > spin_unlock(&file->f_lock); > } > > +static int ep_insert(struct eventpoll *ep, const struct epoll_event *event, > + struct file *tfile, int fd, int full_check); > + > +/* > + * This is called from eventpoll_replace() to replace a linked file in the epoll > + * interface with a new file received from another process. This is useful in > + * cases where a process is trying to install a new file for an existing one > + * that is linked in the epoll interface > + */ > +int eventpoll_replace_file(struct file *toreplace, struct file *file, int tfd) > +{ > + struct file *to_remove = toreplace; > + struct epoll_event event; > + struct hlist_node *next; > + struct eventpoll *ep; > + struct epitem *epi; > + int error = 0; > + bool dispose; > + int fd; > + > + if (!file_can_poll(file)) > + return 0; > + > + spin_lock(&toreplace->f_lock); > + if (unlikely(!toreplace->f_ep)) { > + spin_unlock(&toreplace->f_lock); > + return 0; > + } > + hlist_for_each_entry_safe(epi, next, toreplace->f_ep, fllink) { > + ep = epi->ep; > + mutex_lock(&ep->mtx); Afaict, you're under a spinlock and you're acquiring a mutex. The spinlock can't sleep (on non-rt kernels at least) but the mutex can. > + fd = epi->ffd.fd; > + if (fd != tfd) { > + mutex_unlock(&ep->mtx); > + continue; > + } > + event = epi->event; > + error = ep_insert(ep, &event, file, fd, 1); > + mutex_unlock(&ep->mtx); > + if (error != 0) { > + break; > + } nit: we don't do { } around single lines.
On Tue, May 23, 2023 at 06:58:01AM +0000, aloktiagi wrote: > +/* > + * This is called from eventpoll_replace() to replace a linked file in the epoll > + * interface with a new file received from another process. This is useful in > + * cases where a process is trying to install a new file for an existing one > + * that is linked in the epoll interface > + */ > +int eventpoll_replace_file(struct file *toreplace, struct file *file, int tfd) Functions do not control where they are called from. Just take that clause out: /* * Replace a linked file in the epoll interface with a new file received * from another process. This allows a process to * install a new file for an existing one that is linked in the epoll * interface */ But, erm, aren't those two sentences basically saying the same thing? So simplify again: /* * Replace a linked file in the epoll interface with a new file */ > diff --git a/include/linux/eventpoll.h b/include/linux/eventpoll.h > index 3337745d81bd..2a6c8f52f272 100644 > --- a/include/linux/eventpoll.h > +++ b/include/linux/eventpoll.h > @@ -25,6 +25,14 @@ struct file *get_epoll_tfile_raw_ptr(struct file *file, int tfd, unsigned long t > /* Used to release the epoll bits inside the "struct file" */ > void eventpoll_release_file(struct file *file); > > +/* > + * This is called from fs/file.c:do_replace() to replace a linked file in the > + * epoll interface with a new file received from another process. This is useful > + * in cases where a process is trying to install a new file for an existing one > + * that is linked in the epoll interface > + */ > +int eventpoll_replace_file(struct file *toreplace, struct file *file, int tfd); No need to repeat the comment again. Just delete it here.
On Tue, May 23, 2023 at 02:32:06PM +0200, Christian Brauner wrote: > On Tue, May 23, 2023 at 06:58:01AM +0000, aloktiagi wrote: > > Introduce a mechanism to replace a file linked in the epoll interface with a new > > file. > > > > eventpoll_replace() finds all instances of the file to be replaced and replaces > > them with the new file and the interested events. > > > > Signed-off-by: aloktiagi <aloktiagi@gmail.com> > > --- > > Changes in v6: > > - incorporate latest changes that get rid of the global epmutex lock. > > > > Changes in v5: > > - address review comments and move the call to replace old file in each > > subsystem (epoll, io_uring, etc.) outside the fdtable helpers like > > replace_fd(). > > > > Changes in v4: > > - address review comment to remove the redundant eventpoll_replace() function. > > - removed an extra empty line introduced in include/linux/file.h > > > > Changes in v3: > > - address review comment and iterate over the file table while holding the > > spin_lock(&files->file_lock). > > - address review comment and call filp_close() outside the > > spin_lock(&files->file_lock). > > --- > > fs/eventpoll.c | 76 +++++++++++++++++++++++++++++++++++++++ > > include/linux/eventpoll.h | 8 +++++ > > 2 files changed, 84 insertions(+) > > > > diff --git a/fs/eventpoll.c b/fs/eventpoll.c > > index 980483455cc0..9c7bffa8401b 100644 > > --- a/fs/eventpoll.c > > +++ b/fs/eventpoll.c > > @@ -973,6 +973,82 @@ void eventpoll_release_file(struct file *file) > > spin_unlock(&file->f_lock); > > } > > > > +static int ep_insert(struct eventpoll *ep, const struct epoll_event *event, > > + struct file *tfile, int fd, int full_check); > > + > > +/* > > + * This is called from eventpoll_replace() to replace a linked file in the epoll > > + * interface with a new file received from another process. This is useful in > > + * cases where a process is trying to install a new file for an existing one > > + * that is linked in the epoll interface > > + */ > > +int eventpoll_replace_file(struct file *toreplace, struct file *file, int tfd) > > +{ > > + struct file *to_remove = toreplace; > > + struct epoll_event event; > > + struct hlist_node *next; > > + struct eventpoll *ep; > > + struct epitem *epi; > > + int error = 0; > > + bool dispose; > > + int fd; > > + > > + if (!file_can_poll(file)) > > + return 0; > > + > > + spin_lock(&toreplace->f_lock); > > + if (unlikely(!toreplace->f_ep)) { > > + spin_unlock(&toreplace->f_lock); > > + return 0; > > + } > > + hlist_for_each_entry_safe(epi, next, toreplace->f_ep, fllink) { > > + ep = epi->ep; > > + mutex_lock(&ep->mtx); > > Afaict, you're under a spinlock and you're acquiring a mutex. The > spinlock can't sleep (on non-rt kernels at least) but the mutex can. > thank you. I'll address this in another way in the next patch series. Please let me know of your opinion on how it can be achieved differently. > > + fd = epi->ffd.fd; > > + if (fd != tfd) { > > + mutex_unlock(&ep->mtx); > > + continue; > > + } > > + event = epi->event; > > + error = ep_insert(ep, &event, file, fd, 1); > > + mutex_unlock(&ep->mtx); > > + if (error != 0) { > > + break; > > + } > > nit: we don't do { } around single lines. will fix this in the next series.
On Tue, May 23, 2023 at 02:31:58PM +0100, Matthew Wilcox wrote: > On Tue, May 23, 2023 at 06:58:01AM +0000, aloktiagi wrote: > > +/* > > + * This is called from eventpoll_replace() to replace a linked file in the epoll > > + * interface with a new file received from another process. This is useful in > > + * cases where a process is trying to install a new file for an existing one > > + * that is linked in the epoll interface > > + */ > > +int eventpoll_replace_file(struct file *toreplace, struct file *file, int tfd) > > Functions do not control where they are called from. Just take that > clause out: > > /* > * Replace a linked file in the epoll interface with a new file received > * from another process. This allows a process to > * install a new file for an existing one that is linked in the epoll > * interface > */ > > But, erm, aren't those two sentences basically saying the same thing? > So simplify again: > > /* > * Replace a linked file in the epoll interface with a new file > */ > thank you for pointing this out. I'll address this in the next version. > > diff --git a/include/linux/eventpoll.h b/include/linux/eventpoll.h > > index 3337745d81bd..2a6c8f52f272 100644 > > --- a/include/linux/eventpoll.h > > +++ b/include/linux/eventpoll.h > > @@ -25,6 +25,14 @@ struct file *get_epoll_tfile_raw_ptr(struct file *file, int tfd, unsigned long t > > /* Used to release the epoll bits inside the "struct file" */ > > void eventpoll_release_file(struct file *file); > > > > +/* > > + * This is called from fs/file.c:do_replace() to replace a linked file in the > > + * epoll interface with a new file received from another process. This is useful > > + * in cases where a process is trying to install a new file for an existing one > > + * that is linked in the epoll interface > > + */ > > +int eventpoll_replace_file(struct file *toreplace, struct file *file, int tfd); > > No need to repeat the comment again. Just delete it here. thank you. I'll update this in the next version.
diff --git a/fs/eventpoll.c b/fs/eventpoll.c index 980483455cc0..9c7bffa8401b 100644 --- a/fs/eventpoll.c +++ b/fs/eventpoll.c @@ -973,6 +973,82 @@ void eventpoll_release_file(struct file *file) spin_unlock(&file->f_lock); } +static int ep_insert(struct eventpoll *ep, const struct epoll_event *event, + struct file *tfile, int fd, int full_check); + +/* + * This is called from eventpoll_replace() to replace a linked file in the epoll + * interface with a new file received from another process. This is useful in + * cases where a process is trying to install a new file for an existing one + * that is linked in the epoll interface + */ +int eventpoll_replace_file(struct file *toreplace, struct file *file, int tfd) +{ + struct file *to_remove = toreplace; + struct epoll_event event; + struct hlist_node *next; + struct eventpoll *ep; + struct epitem *epi; + int error = 0; + bool dispose; + int fd; + + if (!file_can_poll(file)) + return 0; + + spin_lock(&toreplace->f_lock); + if (unlikely(!toreplace->f_ep)) { + spin_unlock(&toreplace->f_lock); + return 0; + } + hlist_for_each_entry_safe(epi, next, toreplace->f_ep, fllink) { + ep = epi->ep; + mutex_lock(&ep->mtx); + fd = epi->ffd.fd; + if (fd != tfd) { + mutex_unlock(&ep->mtx); + continue; + } + event = epi->event; + error = ep_insert(ep, &event, file, fd, 1); + mutex_unlock(&ep->mtx); + if (error != 0) { + break; + } + } + spin_unlock(&toreplace->f_lock); + /* + * In case of an error remove all instances of the new file in the epoll + * interface. If no error, remove all instances of the original file. + */ + if (error != 0) + to_remove = file; + +again: + spin_lock(&to_remove->f_lock); + if (to_remove->f_ep && to_remove->f_ep->first) { + epi = hlist_entry(to_remove->f_ep->first, struct epitem, fllink); + fd = epi->ffd.fd; + if (fd != tfd) { + spin_unlock(&to_remove->f_lock); + goto again; + } + epi->dying = true; + spin_unlock(&to_remove->f_lock); + + ep = epi->ep; + mutex_lock(&ep->mtx); + dispose = __ep_remove(ep, epi, true); + mutex_unlock(&ep->mtx); + + if (dispose) + ep_free(ep); + goto again; + } + spin_unlock(&to_remove->f_lock); + return error; +} + static int ep_alloc(struct eventpoll **pep) { int error; diff --git a/include/linux/eventpoll.h b/include/linux/eventpoll.h index 3337745d81bd..2a6c8f52f272 100644 --- a/include/linux/eventpoll.h +++ b/include/linux/eventpoll.h @@ -25,6 +25,14 @@ struct file *get_epoll_tfile_raw_ptr(struct file *file, int tfd, unsigned long t /* Used to release the epoll bits inside the "struct file" */ void eventpoll_release_file(struct file *file); +/* + * This is called from fs/file.c:do_replace() to replace a linked file in the + * epoll interface with a new file received from another process. This is useful + * in cases where a process is trying to install a new file for an existing one + * that is linked in the epoll interface + */ +int eventpoll_replace_file(struct file *toreplace, struct file *file, int tfd); + /* * This is called from inside fs/file_table.c:__fput() to unlink files * from the eventpoll interface. We need to have this facility to cleanup
Introduce a mechanism to replace a file linked in the epoll interface with a new file. eventpoll_replace() finds all instances of the file to be replaced and replaces them with the new file and the interested events. Signed-off-by: aloktiagi <aloktiagi@gmail.com> --- Changes in v6: - incorporate latest changes that get rid of the global epmutex lock. Changes in v5: - address review comments and move the call to replace old file in each subsystem (epoll, io_uring, etc.) outside the fdtable helpers like replace_fd(). Changes in v4: - address review comment to remove the redundant eventpoll_replace() function. - removed an extra empty line introduced in include/linux/file.h Changes in v3: - address review comment and iterate over the file table while holding the spin_lock(&files->file_lock). - address review comment and call filp_close() outside the spin_lock(&files->file_lock). --- fs/eventpoll.c | 76 +++++++++++++++++++++++++++++++++++++++ include/linux/eventpoll.h | 8 +++++ 2 files changed, 84 insertions(+)