2019-05-19 12:08:55 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* linux/fs/file_table.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
|
|
* Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/file.h>
|
2008-04-24 11:44:08 +00:00
|
|
|
#include <linux/fdtable.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/security.h>
|
2017-02-02 16:54:15 +00:00
|
|
|
#include <linux/cred.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/eventpoll.h>
|
2005-09-09 20:04:13 +00:00
|
|
|
#include <linux/rcupdate.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/mount.h>
|
2006-01-11 20:17:46 +00:00
|
|
|
#include <linux/capability.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/cdev.h>
|
[PATCH] inotify
inotify is intended to correct the deficiencies of dnotify, particularly
its inability to scale and its terrible user interface:
* dnotify requires the opening of one fd per each directory
that you intend to watch. This quickly results in too many
open files and pins removable media, preventing unmount.
* dnotify is directory-based. You only learn about changes to
directories. Sure, a change to a file in a directory affects
the directory, but you are then forced to keep a cache of
stat structures.
* dnotify's interface to user-space is awful. Signals?
inotify provides a more usable, simple, powerful solution to file change
notification:
* inotify's interface is a system call that returns a fd, not SIGIO.
You get a single fd, which is select()-able.
* inotify has an event that says "the filesystem that the item
you were watching is on was unmounted."
* inotify can watch directories or files.
Inotify is currently used by Beagle (a desktop search infrastructure),
Gamin (a FAM replacement), and other projects.
See Documentation/filesystems/inotify.txt.
Signed-off-by: Robert Love <rml@novell.com>
Cc: John McCutchan <ttb@tentacle.dhs.org>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-12 21:06:03 +00:00
|
|
|
#include <linux/fsnotify.h>
|
2006-03-08 05:55:35 +00:00
|
|
|
#include <linux/sysctl.h>
|
|
|
|
#include <linux/percpu_counter.h>
|
fs: scale files_lock
fs: scale files_lock
Improve scalability of files_lock by adding per-cpu, per-sb files lists,
protected with an lglock. The lglock provides fast access to the per-cpu lists
to add and remove files. It also provides a snapshot of all the per-cpu lists
(although this is very slow).
One difficulty with this approach is that a file can be removed from the list
by another CPU. We must track which per-cpu list the file is on with a new
variale in the file struct (packed into a hole on 64-bit archs). Scalability
could suffer if files are frequently removed from different cpu's list.
However loads with frequent removal of files imply short interval between
adding and removing the files, and the scheduler attempts to avoid moving
processes too far away. Also, even in the case of cross-CPU removal, the
hardware has much more opportunity to parallelise cacheline transfers with N
cachelines than with 1.
A worst-case test of 1 CPU allocating files subsequently being freed by N CPUs
degenerates to contending on a single lock, which is no worse than before. When
more than one CPU are allocating files, even if they are always freed by
different CPUs, there will be more parallelism than the single-lock case.
Testing results:
On a 2 socket, 8 core opteron, I measure the number of times the lock is taken
to remove the file, the number of times it is removed by the same CPU that
added it, and the number of times it is removed by the same node that added it.
Booting: locks= 25049 cpu-hits= 23174 (92.5%) node-hits= 23945 (95.6%)
kbuild -j16 locks=2281913 cpu-hits=2208126 (96.8%) node-hits=2252674 (98.7%)
dbench 64 locks=4306582 cpu-hits=4287247 (99.6%) node-hits=4299527 (99.8%)
So a file is removed from the same CPU it was added by over 90% of the time.
It remains within the same node 95% of the time.
Tim Chen ran some numbers for a 64 thread Nehalem system performing a compile.
throughput
2.6.34-rc2 24.5
+patch 24.9
us sys idle IO wait (in %)
2.6.34-rc2 51.25 28.25 17.25 3.25
+patch 53.75 18.5 19 8.75
So significantly less CPU time spent in kernel code, higher idle time and
slightly higher throughput.
Single threaded performance difference was within the noise of microbenchmarks.
That is not to say penalty does not exist, the code is larger and more memory
accesses required so it will be slightly slower.
Cc: linux-kernel@vger.kernel.org
Cc: Tim Chen <tim.c.chen@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2010-08-17 18:37:38 +00:00
|
|
|
#include <linux/percpu.h>
|
2012-06-24 05:56:45 +00:00
|
|
|
#include <linux/task_work.h>
|
2009-12-16 09:53:03 +00:00
|
|
|
#include <linux/ima.h>
|
2015-08-06 22:46:20 +00:00
|
|
|
#include <linux/swap.h>
|
2006-03-08 05:55:35 +00:00
|
|
|
|
2011-07-26 23:09:06 +00:00
|
|
|
#include <linux/atomic.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-12-04 20:47:36 +00:00
|
|
|
#include "internal.h"
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* sysctl tunables... */
|
|
|
|
struct files_stat_struct files_stat = {
|
|
|
|
.max_files = NR_FILE
|
|
|
|
};
|
|
|
|
|
2008-12-10 17:35:45 +00:00
|
|
|
/* SLAB cache for file structures */
|
|
|
|
static struct kmem_cache *filp_cachep __read_mostly;
|
|
|
|
|
2006-03-08 05:55:35 +00:00
|
|
|
static struct percpu_counter nr_files __cacheline_aligned_in_smp;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-07-20 19:05:59 +00:00
|
|
|
static void file_free_rcu(struct rcu_head *head)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-11-13 23:39:25 +00:00
|
|
|
struct file *f = container_of(head, struct file, f_u.fu_rcuhead);
|
|
|
|
|
|
|
|
put_cred(f->f_cred);
|
2006-03-08 05:55:35 +00:00
|
|
|
kmem_cache_free(filp_cachep, f);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-03-08 05:55:35 +00:00
|
|
|
static inline void file_free(struct file *f)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2018-07-09 15:24:21 +00:00
|
|
|
security_file_free(f);
|
2018-07-18 13:44:40 +00:00
|
|
|
if (!(f->f_mode & FMODE_NOACCOUNT))
|
|
|
|
percpu_counter_dec(&nr_files);
|
2006-03-08 05:55:35 +00:00
|
|
|
call_rcu(&f->f_u.fu_rcuhead, file_free_rcu);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-03-08 05:55:35 +00:00
|
|
|
/*
|
|
|
|
* Return the total number of open files in the system
|
|
|
|
*/
|
2010-10-26 21:22:44 +00:00
|
|
|
static long get_nr_files(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-03-08 05:55:35 +00:00
|
|
|
return percpu_counter_read_positive(&nr_files);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-03-08 05:55:35 +00:00
|
|
|
/*
|
|
|
|
* Return the maximum number of open files in the system
|
|
|
|
*/
|
2010-10-26 21:22:44 +00:00
|
|
|
unsigned long get_max_files(void)
|
2005-09-09 20:04:13 +00:00
|
|
|
{
|
2006-03-08 05:55:35 +00:00
|
|
|
return files_stat.max_files;
|
2005-09-09 20:04:13 +00:00
|
|
|
}
|
2006-03-08 05:55:35 +00:00
|
|
|
EXPORT_SYMBOL_GPL(get_max_files);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle nr_files sysctl
|
|
|
|
*/
|
|
|
|
#if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS)
|
2014-06-06 21:38:05 +00:00
|
|
|
int proc_nr_files(struct ctl_table *table, int write,
|
2020-04-24 06:43:38 +00:00
|
|
|
void *buffer, size_t *lenp, loff_t *ppos)
|
2006-03-08 05:55:35 +00:00
|
|
|
{
|
|
|
|
files_stat.nr_files = get_nr_files();
|
2010-10-26 21:22:44 +00:00
|
|
|
return proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
|
2006-03-08 05:55:35 +00:00
|
|
|
}
|
|
|
|
#else
|
2014-06-06 21:38:05 +00:00
|
|
|
int proc_nr_files(struct ctl_table *table, int write,
|
2020-04-24 06:43:38 +00:00
|
|
|
void *buffer, size_t *lenp, loff_t *ppos)
|
2006-03-08 05:55:35 +00:00
|
|
|
{
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
|
|
|
#endif
|
2005-09-09 20:04:13 +00:00
|
|
|
|
2018-07-18 13:44:40 +00:00
|
|
|
static struct file *__alloc_file(int flags, const struct cred *cred)
|
|
|
|
{
|
|
|
|
struct file *f;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
f = kmem_cache_zalloc(filp_cachep, GFP_KERNEL);
|
|
|
|
if (unlikely(!f))
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
f->f_cred = get_cred(cred);
|
|
|
|
error = security_file_alloc(f);
|
|
|
|
if (unlikely(error)) {
|
|
|
|
file_free_rcu(&f->f_u.fu_rcuhead);
|
|
|
|
return ERR_PTR(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
atomic_long_set(&f->f_count, 1);
|
|
|
|
rwlock_init(&f->f_owner.lock);
|
|
|
|
spin_lock_init(&f->f_lock);
|
|
|
|
mutex_init(&f->f_pos_lock);
|
|
|
|
eventpoll_init_file(f);
|
|
|
|
f->f_flags = flags;
|
|
|
|
f->f_mode = OPEN_FMODE(flags);
|
|
|
|
/* f->f_version: 0 */
|
|
|
|
|
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Find an unused file structure and return a pointer to it.
|
2013-02-15 01:41:04 +00:00
|
|
|
* Returns an error pointer if some error happend e.g. we over file
|
|
|
|
* structures limit, run out of memory or operation is not permitted.
|
2008-02-15 22:37:26 +00:00
|
|
|
*
|
|
|
|
* Be very careful using this. You are responsible for
|
|
|
|
* getting write access to any mount that you might assign
|
|
|
|
* to this filp, if it is opened for write. If this is not
|
|
|
|
* done, you will imbalance int the mount's writer count
|
|
|
|
* and a warning at __fput() time.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2018-07-11 19:00:04 +00:00
|
|
|
struct file *alloc_empty_file(int flags, const struct cred *cred)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2010-10-26 21:22:44 +00:00
|
|
|
static long old_max;
|
2013-02-15 01:41:04 +00:00
|
|
|
struct file *f;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Privileged users can go above max_files
|
|
|
|
*/
|
2006-03-08 05:55:35 +00:00
|
|
|
if (get_nr_files() >= files_stat.max_files && !capable(CAP_SYS_ADMIN)) {
|
|
|
|
/*
|
|
|
|
* percpu_counters are inaccurate. Do an expensive check before
|
|
|
|
* we go and fail.
|
|
|
|
*/
|
2007-10-17 06:25:44 +00:00
|
|
|
if (percpu_counter_sum_positive(&nr_files) >= files_stat.max_files)
|
2006-03-08 05:55:35 +00:00
|
|
|
goto over;
|
|
|
|
}
|
2005-06-23 07:09:50 +00:00
|
|
|
|
2018-07-18 13:44:40 +00:00
|
|
|
f = __alloc_file(flags, cred);
|
|
|
|
if (!IS_ERR(f))
|
|
|
|
percpu_counter_inc(&nr_files);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-06-23 07:09:50 +00:00
|
|
|
return f;
|
|
|
|
|
|
|
|
over:
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Ran out of filps - report that */
|
2006-03-08 05:55:35 +00:00
|
|
|
if (get_nr_files() > old_max) {
|
2010-10-26 21:22:44 +00:00
|
|
|
pr_info("VFS: file-max limit %lu reached\n", get_max_files());
|
2006-03-08 05:55:35 +00:00
|
|
|
old_max = get_nr_files();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2013-02-15 01:41:04 +00:00
|
|
|
return ERR_PTR(-ENFILE);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2018-07-18 13:44:40 +00:00
|
|
|
/*
|
|
|
|
* Variant of alloc_empty_file() that doesn't check and modify nr_files.
|
|
|
|
*
|
|
|
|
* Should not be used unless there's a very good reason to do so.
|
|
|
|
*/
|
|
|
|
struct file *alloc_empty_file_noaccount(int flags, const struct cred *cred)
|
|
|
|
{
|
|
|
|
struct file *f = __alloc_file(flags, cred);
|
|
|
|
|
|
|
|
if (!IS_ERR(f))
|
|
|
|
f->f_mode |= FMODE_NOACCOUNT;
|
|
|
|
|
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
2007-10-17 06:31:13 +00:00
|
|
|
/**
|
|
|
|
* alloc_file - allocate and initialize a 'struct file'
|
2014-10-12 19:29:29 +00:00
|
|
|
*
|
|
|
|
* @path: the (dentry, vfsmount) pair for the new file
|
2018-07-11 18:19:04 +00:00
|
|
|
* @flags: O_... flags with which the new file will be opened
|
2007-10-17 06:31:13 +00:00
|
|
|
* @fop: the 'struct file_operations' for the new file
|
|
|
|
*/
|
2018-06-17 18:21:27 +00:00
|
|
|
static struct file *alloc_file(const struct path *path, int flags,
|
2009-08-08 20:52:35 +00:00
|
|
|
const struct file_operations *fop)
|
2007-10-17 06:31:13 +00:00
|
|
|
{
|
|
|
|
struct file *file;
|
|
|
|
|
2018-07-11 19:00:04 +00:00
|
|
|
file = alloc_empty_file(flags, current_cred());
|
2013-02-15 01:41:04 +00:00
|
|
|
if (IS_ERR(file))
|
2012-09-13 03:11:55 +00:00
|
|
|
return file;
|
2007-10-17 06:31:13 +00:00
|
|
|
|
2009-08-08 20:52:35 +00:00
|
|
|
file->f_path = *path;
|
2013-03-02 00:48:30 +00:00
|
|
|
file->f_inode = path->dentry->d_inode;
|
2009-08-08 20:52:35 +00:00
|
|
|
file->f_mapping = path->dentry->d_inode->i_mapping;
|
fs: new infrastructure for writeback error handling and reporting
Most filesystems currently use mapping_set_error and
filemap_check_errors for setting and reporting/clearing writeback errors
at the mapping level. filemap_check_errors is indirectly called from
most of the filemap_fdatawait_* functions and from
filemap_write_and_wait*. These functions are called from all sorts of
contexts to wait on writeback to finish -- e.g. mostly in fsync, but
also in truncate calls, getattr, etc.
The non-fsync callers are problematic. We should be reporting writeback
errors during fsync, but many places spread over the tree clear out
errors before they can be properly reported, or report errors at
nonsensical times.
If I get -EIO on a stat() call, there is no reason for me to assume that
it is because some previous writeback failed. The fact that it also
clears out the error such that a subsequent fsync returns 0 is a bug,
and a nasty one since that's potentially silent data corruption.
This patch adds a small bit of new infrastructure for setting and
reporting errors during address_space writeback. While the above was my
original impetus for adding this, I think it's also the case that
current fsync semantics are just problematic for userland. Most
applications that call fsync do so to ensure that the data they wrote
has hit the backing store.
In the case where there are multiple writers to the file at the same
time, this is really hard to determine. The first one to call fsync will
see any stored error, and the rest get back 0. The processes with open
fds may not be associated with one another in any way. They could even
be in different containers, so ensuring coordination between all fsync
callers is not really an option.
One way to remedy this would be to track what file descriptor was used
to dirty the file, but that's rather cumbersome and would likely be
slow. However, there is a simpler way to improve the semantics here
without incurring too much overhead.
This set adds an errseq_t to struct address_space, and a corresponding
one is added to struct file. Writeback errors are recorded in the
mapping's errseq_t, and the one in struct file is used as the "since"
value.
This changes the semantics of the Linux fsync implementation such that
applications can now use it to determine whether there were any
writeback errors since fsync(fd) was last called (or since the file was
opened in the case of fsync having never been called).
Note that those writeback errors may have occurred when writing data
that was dirtied via an entirely different fd, but that's the case now
with the current mapping_set_error/filemap_check_error infrastructure.
This will at least prevent you from getting a false report of success.
The new behavior is still consistent with the POSIX spec, and is more
reliable for application developers. This patch just adds some basic
infrastructure for doing this, and ensures that the f_wb_err "cursor"
is properly set when a file is opened. Later patches will change the
existing code to use this new infrastructure for reporting errors at
fsync time.
Signed-off-by: Jeff Layton <jlayton@redhat.com>
Reviewed-by: Jan Kara <jack@suse.cz>
2017-07-06 11:02:25 +00:00
|
|
|
file->f_wb_err = filemap_sample_wb_err(file->f_mapping);
|
vfs: track per-sb writeback errors and report them to syncfs
Patch series "vfs: have syncfs() return error when there are writeback
errors", v6.
Currently, syncfs does not return errors when one of the inodes fails to
be written back. It will return errors based on the legacy AS_EIO and
AS_ENOSPC flags when syncing out the block device fails, but that's not
particularly helpful for filesystems that aren't backed by a blockdev.
It's also possible for a stray sync to lose those errors.
The basic idea in this set is to track writeback errors at the
superblock level, so that we can quickly and easily check whether
something bad happened without having to fsync each file individually.
syncfs is then changed to reliably report writeback errors after they
occur, much in the same fashion as fsync does now.
This patch (of 2):
Usually we suggest that applications call fsync when they want to ensure
that all data written to the file has made it to the backing store, but
that can be inefficient when there are a lot of open files.
Calling syncfs on the filesystem can be more efficient in some
situations, but the error reporting doesn't currently work the way most
people expect. If a single inode on a filesystem reports a writeback
error, syncfs won't necessarily return an error. syncfs only returns an
error if __sync_blockdev fails, and on some filesystems that's a no-op.
It would be better if syncfs reported an error if there were any
writeback failures. Then applications could call syncfs to see if there
are any errors on any open files, and could then call fsync on all of
the other descriptors to figure out which one failed.
This patch adds a new errseq_t to struct super_block, and has
mapping_set_error also record writeback errors there.
To report those errors, we also need to keep an errseq_t in struct file
to act as a cursor. This patch adds a dedicated field for that purpose,
which slots nicely into 4 bytes of padding at the end of struct file on
x86_64.
An earlier version of this patch used an O_PATH file descriptor to cue
the kernel that the open file should track the superblock error and not
the inode's writeback error.
I think that API is just too weird though. This is simpler and should
make syncfs error reporting "just work" even if someone is multiplexing
fsync and syncfs on the same fds.
Signed-off-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Reviewed-by: Jan Kara <jack@suse.cz>
Cc: Andres Freund <andres@anarazel.de>
Cc: Matthew Wilcox <willy@infradead.org>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Dave Chinner <david@fromorbit.com>
Cc: David Howells <dhowells@redhat.com>
Link: http://lkml.kernel.org/r/20200428135155.19223-1-jlayton@kernel.org
Link: http://lkml.kernel.org/r/20200428135155.19223-2-jlayton@kernel.org
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2020-06-02 04:45:36 +00:00
|
|
|
file->f_sb_err = file_sample_sb_err(file);
|
2018-07-11 18:19:04 +00:00
|
|
|
if ((file->f_mode & FMODE_READ) &&
|
2015-04-04 05:14:53 +00:00
|
|
|
likely(fop->read || fop->read_iter))
|
2018-07-11 18:19:04 +00:00
|
|
|
file->f_mode |= FMODE_CAN_READ;
|
|
|
|
if ((file->f_mode & FMODE_WRITE) &&
|
2015-04-04 05:14:53 +00:00
|
|
|
likely(fop->write || fop->write_iter))
|
2018-07-11 18:19:04 +00:00
|
|
|
file->f_mode |= FMODE_CAN_WRITE;
|
2018-07-09 06:35:08 +00:00
|
|
|
file->f_mode |= FMODE_OPENED;
|
2007-10-17 06:31:13 +00:00
|
|
|
file->f_op = fop;
|
2018-07-11 18:19:04 +00:00
|
|
|
if ((file->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
|
2010-11-02 14:13:07 +00:00
|
|
|
i_readcount_inc(path->dentry->d_inode);
|
2009-08-08 19:56:29 +00:00
|
|
|
return file;
|
2007-10-17 06:31:13 +00:00
|
|
|
}
|
|
|
|
|
2018-06-09 13:40:05 +00:00
|
|
|
struct file *alloc_file_pseudo(struct inode *inode, struct vfsmount *mnt,
|
|
|
|
const char *name, int flags,
|
|
|
|
const struct file_operations *fops)
|
|
|
|
{
|
|
|
|
static const struct dentry_operations anon_ops = {
|
|
|
|
.d_dname = simple_dname
|
|
|
|
};
|
|
|
|
struct qstr this = QSTR_INIT(name, strlen(name));
|
|
|
|
struct path path;
|
|
|
|
struct file *file;
|
|
|
|
|
|
|
|
path.dentry = d_alloc_pseudo(mnt->mnt_sb, &this);
|
|
|
|
if (!path.dentry)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
if (!mnt->mnt_sb->s_d_op)
|
|
|
|
d_set_d_op(path.dentry, &anon_ops);
|
|
|
|
path.mnt = mntget(mnt);
|
|
|
|
d_instantiate(path.dentry, inode);
|
fs: Do not check if there is a fsnotify watcher on pseudo inodes
The kernel uses internal mounts created by kern_mount() and populated
with files with no lookup path by alloc_file_pseudo() for a variety of
reasons. An example of such a mount is for anonymous pipes. For pipes,
every vfs_write() regardless of filesystem, calls fsnotify_modify()
to notify of any changes which incurs a small amount of overhead in
fsnotify even when there are no watchers. It can also trigger for reads
and readv and writev, it was simply vfs_write() that was noticed first.
A patch is pending that reduces, but does not eliminate, the overhead of
fsnotify but for files that cannot be looked up via a path, even that
small overhead is unnecessary. The user API for all notification
subsystems (inotify, fanotify, ...) is based on the pathname and a dirfd
and proc entries appear to be the only visible representation of the
files. Proc does not have the same pathname as the internal entry and
the proc inode is not the same as the internal inode so even if fanotify
is used on a file under /proc/XX/fd, no useful events are notified.
This patch changes alloc_file_pseudo() to always opt out of fsnotify by
setting FMODE_NONOTIFY flag so that no check is made for fsnotify
watchers on pseudo files. This should be safe as the underlying helper
for the dentry is d_alloc_pseudo() which explicitly states that no
lookups are ever performed meaning that fanotify should have nothing
useful to attach to.
The test motivating this was "perf bench sched messaging --pipe". On
a single-socket machine using threads the difference of the patch was
as follows.
5.7.0 5.7.0
vanilla nofsnotify-v1r1
Amean 1 1.3837 ( 0.00%) 1.3547 ( 2.10%)
Amean 3 3.7360 ( 0.00%) 3.6543 ( 2.19%)
Amean 5 5.8130 ( 0.00%) 5.7233 * 1.54%*
Amean 7 8.1490 ( 0.00%) 7.9730 * 2.16%*
Amean 12 14.6843 ( 0.00%) 14.1820 ( 3.42%)
Amean 18 21.8840 ( 0.00%) 21.7460 ( 0.63%)
Amean 24 28.8697 ( 0.00%) 29.1680 ( -1.03%)
Amean 30 36.0787 ( 0.00%) 35.2640 * 2.26%*
Amean 32 38.0527 ( 0.00%) 38.1223 ( -0.18%)
The difference is small but in some cases it's outside the noise so
while marginal, there is still some small benefit to ignoring fsnotify
for files allocated via alloc_file_pseudo() in some cases.
Link: https://lore.kernel.org/r/20200615121358.GF3183@techsingularity.net
Signed-off-by: Mel Gorman <mgorman@techsingularity.net>
Reviewed-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Jan Kara <jack@suse.cz>
2020-06-15 12:13:58 +00:00
|
|
|
file = alloc_file(&path, flags | FMODE_NONOTIFY, fops);
|
2018-06-09 13:40:05 +00:00
|
|
|
if (IS_ERR(file)) {
|
|
|
|
ihold(inode);
|
|
|
|
path_put(&path);
|
|
|
|
}
|
|
|
|
return file;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(alloc_file_pseudo);
|
|
|
|
|
2018-06-17 18:15:10 +00:00
|
|
|
struct file *alloc_file_clone(struct file *base, int flags,
|
|
|
|
const struct file_operations *fops)
|
|
|
|
{
|
|
|
|
struct file *f = alloc_file(&base->f_path, flags, fops);
|
|
|
|
if (!IS_ERR(f)) {
|
|
|
|
path_get(&f->f_path);
|
|
|
|
f->f_mapping = base->f_mapping;
|
|
|
|
}
|
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
2010-05-26 19:13:55 +00:00
|
|
|
/* the real guts of fput() - releasing the last reference to file
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2010-05-26 19:13:55 +00:00
|
|
|
static void __fput(struct file *file)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-12-08 10:36:35 +00:00
|
|
|
struct dentry *dentry = file->f_path.dentry;
|
|
|
|
struct vfsmount *mnt = file->f_path.mnt;
|
2013-06-13 22:37:49 +00:00
|
|
|
struct inode *inode = file->f_inode;
|
2018-11-05 17:40:30 +00:00
|
|
|
fmode_t mode = file->f_mode;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-07-09 15:14:39 +00:00
|
|
|
if (unlikely(!(file->f_mode & FMODE_OPENED)))
|
|
|
|
goto out;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
might_sleep();
|
[PATCH] inotify
inotify is intended to correct the deficiencies of dnotify, particularly
its inability to scale and its terrible user interface:
* dnotify requires the opening of one fd per each directory
that you intend to watch. This quickly results in too many
open files and pins removable media, preventing unmount.
* dnotify is directory-based. You only learn about changes to
directories. Sure, a change to a file in a directory affects
the directory, but you are then forced to keep a cache of
stat structures.
* dnotify's interface to user-space is awful. Signals?
inotify provides a more usable, simple, powerful solution to file change
notification:
* inotify's interface is a system call that returns a fd, not SIGIO.
You get a single fd, which is select()-able.
* inotify has an event that says "the filesystem that the item
you were watching is on was unmounted."
* inotify can watch directories or files.
Inotify is currently used by Beagle (a desktop search infrastructure),
Gamin (a FAM replacement), and other projects.
See Documentation/filesystems/inotify.txt.
Signed-off-by: Robert Love <rml@novell.com>
Cc: John McCutchan <ttb@tentacle.dhs.org>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-12 21:06:03 +00:00
|
|
|
|
|
|
|
fsnotify_close(file);
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* The function eventpoll_release() should be the first called
|
|
|
|
* in the file cleanup chain.
|
|
|
|
*/
|
|
|
|
eventpoll_release(file);
|
2014-02-03 17:13:08 +00:00
|
|
|
locks_remove_file(file);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-06-22 01:13:18 +00:00
|
|
|
ima_file_free(file);
|
2008-10-31 23:28:30 +00:00
|
|
|
if (unlikely(file->f_flags & FASYNC)) {
|
2013-09-22 20:27:52 +00:00
|
|
|
if (file->f_op->fasync)
|
2008-10-31 23:28:30 +00:00
|
|
|
file->f_op->fasync(-1, file, 0);
|
|
|
|
}
|
2013-09-22 20:27:52 +00:00
|
|
|
if (file->f_op->release)
|
2005-04-16 22:20:36 +00:00
|
|
|
file->f_op->release(inode, file);
|
2011-03-16 17:17:54 +00:00
|
|
|
if (unlikely(S_ISCHR(inode->i_mode) && inode->i_cdev != NULL &&
|
2018-11-05 17:40:30 +00:00
|
|
|
!(mode & FMODE_PATH))) {
|
2005-04-16 22:20:36 +00:00
|
|
|
cdev_put(inode->i_cdev);
|
2011-03-16 17:17:54 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
fops_put(file->f_op);
|
2006-10-02 09:17:15 +00:00
|
|
|
put_pid(file->f_owner.pid);
|
2018-11-05 17:40:30 +00:00
|
|
|
if ((mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
|
2010-11-02 14:13:07 +00:00
|
|
|
i_readcount_dec(inode);
|
2018-11-05 17:40:30 +00:00
|
|
|
if (mode & FMODE_WRITER) {
|
2014-03-14 16:02:47 +00:00
|
|
|
put_write_access(inode);
|
|
|
|
__mnt_drop_write(mnt);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
dput(dentry);
|
2018-11-05 17:40:30 +00:00
|
|
|
if (unlikely(mode & FMODE_NEED_UNMOUNT))
|
|
|
|
dissolve_on_fput(mnt);
|
2005-04-16 22:20:36 +00:00
|
|
|
mntput(mnt);
|
2018-07-09 15:14:39 +00:00
|
|
|
out:
|
|
|
|
file_free(file);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-07-08 21:24:16 +00:00
|
|
|
static LLIST_HEAD(delayed_fput_list);
|
2012-06-24 05:56:45 +00:00
|
|
|
static void delayed_fput(struct work_struct *unused)
|
|
|
|
{
|
2013-07-08 21:24:16 +00:00
|
|
|
struct llist_node *node = llist_del_all(&delayed_fput_list);
|
2017-08-07 08:45:39 +00:00
|
|
|
struct file *f, *t;
|
2013-07-08 21:24:16 +00:00
|
|
|
|
2017-08-07 08:45:39 +00:00
|
|
|
llist_for_each_entry_safe(f, t, node, f_u.fu_llist)
|
|
|
|
__fput(f);
|
2012-06-24 05:56:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ____fput(struct callback_head *work)
|
|
|
|
{
|
|
|
|
__fput(container_of(work, struct file, f_u.fu_rcuhead));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If kernel thread really needs to have the final fput() it has done
|
|
|
|
* to complete, call this. The only user right now is the boot - we
|
|
|
|
* *do* need to make sure our writes to binaries on initramfs has
|
|
|
|
* not left us with opened struct file waiting for __fput() - execve()
|
|
|
|
* won't work without that. Please, don't add more callers without
|
|
|
|
* very good reasons; in particular, never call that with locks
|
|
|
|
* held and never call that from a thread that might need to do
|
|
|
|
* some work on any kind of umount.
|
|
|
|
*/
|
|
|
|
void flush_delayed_fput(void)
|
|
|
|
{
|
|
|
|
delayed_fput(NULL);
|
|
|
|
}
|
2019-08-18 18:18:47 +00:00
|
|
|
EXPORT_SYMBOL_GPL(flush_delayed_fput);
|
2012-06-24 05:56:45 +00:00
|
|
|
|
2013-10-20 12:44:39 +00:00
|
|
|
static DECLARE_DELAYED_WORK(delayed_fput_work, delayed_fput);
|
2012-06-24 05:56:45 +00:00
|
|
|
|
2018-11-21 17:32:39 +00:00
|
|
|
void fput_many(struct file *file, unsigned int refs)
|
2010-05-26 19:13:55 +00:00
|
|
|
{
|
2018-11-21 17:32:39 +00:00
|
|
|
if (atomic_long_sub_and_test(refs, &file->f_count)) {
|
2012-06-24 05:56:45 +00:00
|
|
|
struct task_struct *task = current;
|
2013-06-14 19:09:47 +00:00
|
|
|
|
|
|
|
if (likely(!in_interrupt() && !(task->flags & PF_KTHREAD))) {
|
|
|
|
init_task_work(&file->f_u.fu_rcuhead, ____fput);
|
|
|
|
if (!task_work_add(task, &file->f_u.fu_rcuhead, true))
|
|
|
|
return;
|
2013-07-08 21:24:15 +00:00
|
|
|
/*
|
|
|
|
* After this task has run exit_task_work(),
|
2013-09-11 21:24:34 +00:00
|
|
|
* task_work_add() will fail. Fall through to delayed
|
2013-07-08 21:24:15 +00:00
|
|
|
* fput to avoid leaking *file.
|
|
|
|
*/
|
2012-06-24 05:56:45 +00:00
|
|
|
}
|
2013-07-08 21:24:16 +00:00
|
|
|
|
|
|
|
if (llist_add(&file->f_u.fu_llist, &delayed_fput_list))
|
2013-10-20 12:44:39 +00:00
|
|
|
schedule_delayed_work(&delayed_fput_work, 1);
|
2012-06-24 05:56:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-21 17:32:39 +00:00
|
|
|
void fput(struct file *file)
|
|
|
|
{
|
|
|
|
fput_many(file, 1);
|
|
|
|
}
|
|
|
|
|
2012-06-24 05:56:45 +00:00
|
|
|
/*
|
|
|
|
* synchronous analog of fput(); for kernel threads that might be needed
|
|
|
|
* in some umount() (and thus can't use flush_delayed_fput() without
|
|
|
|
* risking deadlocks), need to wait for completion of __fput() and know
|
|
|
|
* for this specific struct file it won't involve anything that would
|
|
|
|
* need them. Use only if you really need it - at the very least,
|
|
|
|
* don't blindly convert fput() by kernel thread to that.
|
|
|
|
*/
|
|
|
|
void __fput_sync(struct file *file)
|
|
|
|
{
|
|
|
|
if (atomic_long_dec_and_test(&file->f_count)) {
|
|
|
|
struct task_struct *task = current;
|
|
|
|
BUG_ON(!(task->flags & PF_KTHREAD));
|
2010-05-26 19:13:55 +00:00
|
|
|
__fput(file);
|
2012-06-24 05:56:45 +00:00
|
|
|
}
|
2010-05-26 19:13:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(fput);
|
|
|
|
|
2015-08-06 22:46:20 +00:00
|
|
|
void __init files_init(void)
|
2017-08-07 08:45:39 +00:00
|
|
|
{
|
2008-12-10 17:35:45 +00:00
|
|
|
filp_cachep = kmem_cache_create("filp", sizeof(struct file), 0,
|
2017-11-16 01:35:44 +00:00
|
|
|
SLAB_HWCACHE_ALIGN | SLAB_PANIC | SLAB_ACCOUNT, NULL);
|
2015-08-06 22:46:20 +00:00
|
|
|
percpu_counter_init(&nr_files, 0, GFP_KERNEL);
|
|
|
|
}
|
2008-12-10 17:35:45 +00:00
|
|
|
|
2015-08-06 22:46:20 +00:00
|
|
|
/*
|
|
|
|
* One file with associated inode and dcache is very roughly 1K. Per default
|
|
|
|
* do not use more than 10% of our memory for files.
|
|
|
|
*/
|
|
|
|
void __init files_maxfiles_init(void)
|
|
|
|
{
|
|
|
|
unsigned long n;
|
2018-12-28 08:34:29 +00:00
|
|
|
unsigned long nr_pages = totalram_pages();
|
2018-12-28 08:34:20 +00:00
|
|
|
unsigned long memreserve = (nr_pages - nr_free_pages()) * 3/2;
|
2015-08-06 22:46:20 +00:00
|
|
|
|
2018-12-28 08:34:20 +00:00
|
|
|
memreserve = min(memreserve, nr_pages - 1);
|
|
|
|
n = ((nr_pages - memreserve) * (PAGE_SIZE / 1024)) / 10;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-10-26 21:22:44 +00:00
|
|
|
files_stat.max_files = max_t(unsigned long, n, NR_FILE);
|
2017-08-07 08:45:39 +00:00
|
|
|
}
|