2019-05-19 15:08:55 +03:00
// SPDX-License-Identifier: GPL-2.0-only
2005-04-17 02:20:36 +04:00
/*
* linux / fs / locks . c
*
2021-10-19 20:38:35 +03:00
* We implement four types of file locks : BSD locks , posix locks , open
* file description locks , and leases . For details about BSD locks ,
* see the flock ( 2 ) man page ; for details about the other three , see
* fcntl ( 2 ) .
2005-04-17 02:20:36 +04:00
*
fs/locks: create a tree of dependent requests.
When we find an existing lock which conflicts with a request,
and the request wants to wait, we currently add the request
to a list. When the lock is removed, the whole list is woken.
This can cause the thundering-herd problem.
To reduce the problem, we make use of the (new) fact that
a pending request can itself have a list of blocked requests.
When we find a conflict, we look through the existing blocked requests.
If any one of them blocks the new request, the new request is attached
below that request, otherwise it is added to the list of blocked
requests, which are now known to be mutually non-conflicting.
This way, when the lock is released, only a set of non-conflicting
locks will be woken, the rest can stay asleep.
If the lock request cannot be granted and the request needs to be
requeued, all the other requests it blocks will then be woken
To make this more concrete:
If you have a many-core machine, and have many threads all wanting to
briefly lock a give file (udev is known to do this), you can get quite
poor performance.
When one thread releases a lock, it wakes up all other threads that
are waiting (classic thundering-herd) - one will get the lock and the
others go to sleep.
When you have few cores, this is not very noticeable: by the time the
4th or 5th thread gets enough CPU time to try to claim the lock, the
earlier threads have claimed it, done what was needed, and released.
So with few cores, many of the threads don't end up contending.
With 50+ cores, lost of threads can get the CPU at the same time,
and the contention can easily be measured.
This patchset creates a tree of pending lock requests in which siblings
don't conflict and each lock request does conflict with its parent.
When a lock is released, only requests which don't conflict with each
other a woken.
Testing shows that lock-acquisitions-per-second is now fairly stable
even as the number of contending process goes to 1000. Without this
patch, locks-per-second drops off steeply after a few 10s of
processes.
There is a small cost to this extra complexity.
At 20 processes running a particular test on 72 cores, the lock
acquisitions per second drops from 1.8 million to 1.4 million with
this patch. For 100 processes, this patch still provides 1.4 million
while without this patch there are about 700,000.
Reported-and-tested-by: Martin Wilck <mwilck@suse.de>
Signed-off-by: NeilBrown <neilb@suse.com>
Reviewed-by: J. Bruce Fields <bfields@redhat.com>
Signed-off-by: Jeff Layton <jlayton@kernel.org>
2018-11-30 02:04:08 +03:00
*
* Locking conflicts and dependencies :
* If multiple threads attempt to lock the same byte ( or flock the same file )
* only one can be granted the lock , and other must wait their turn .
* The first lock has been " applied " or " granted " , the others are " waiting "
* and are " blocked " by the " applied " lock . .
*
* Waiting and applied locks are all kept in trees whose properties are :
*
* - the root of a tree may be an applied or waiting lock .
* - every other node in the tree is a waiting lock that
* conflicts with every ancestor of that node .
*
* Every such tree begins life as a waiting singleton which obviously
* satisfies the above properties .
*
* The only ways we modify trees preserve these properties :
*
* 1. We may add a new leaf node , but only after first verifying that it
* conflicts with all of its ancestors .
* 2. We may remove the root of a tree , creating a new singleton
* tree from the root and N new trees rooted in the immediate
* children .
* 3. If the root of a tree is not currently an applied lock , we may
* apply it ( if possible ) .
* 4. We may upgrade the root of the tree ( either extend its range ,
* or upgrade its entire range from read to write ) .
*
* When an applied lock is modified in a way that reduces or downgrades any
* part of its range , we remove all its children ( 2 above ) . This particularly
* happens when a lock is unlocked .
*
* For each of those child trees we " wake up " the thread which is
* waiting for the lock so it can continue handling as follows : if the
* root of the tree applies , we do so ( 3 ) . If it doesn ' t , it must
* conflict with some applied lock . We remove ( wake up ) all of its children
* ( 2 ) , and add it is a new leaf to the tree rooted in the applied
* lock ( 1 ) . We then repeat the process recursively with those
* children .
*
2005-04-17 02:20:36 +04:00
*/
# include <linux/capability.h>
# include <linux/file.h>
2008-04-24 15:44:08 +04:00
# include <linux/fdtable.h>
2005-04-17 02:20:36 +04:00
# include <linux/fs.h>
# include <linux/init.h>
# include <linux/security.h>
# include <linux/slab.h>
# include <linux/syscalls.h>
# include <linux/time.h>
2005-09-17 06:28:13 +04:00
# include <linux/rcupdate.h>
2008-01-17 03:07:08 +03:00
# include <linux/pid_namespace.h>
2013-06-21 16:58:18 +04:00
# include <linux/hashtable.h>
2013-06-21 16:58:22 +04:00
# include <linux/percpu.h>
2022-01-22 09:13:10 +03:00
# include <linux/sysctl.h>
2005-04-17 02:20:36 +04:00
2014-05-09 22:13:05 +04:00
# define CREATE_TRACE_POINTS
# include <trace/events/filelock.h>
2016-12-24 22:46:01 +03:00
# include <linux/uaccess.h>
2005-04-17 02:20:36 +04:00
# define IS_POSIX(fl) (fl->fl_flags & FL_POSIX)
# define IS_FLOCK(fl) (fl->fl_flags & FL_FLOCK)
2015-01-21 21:17:03 +03:00
# define IS_LEASE(fl) (fl->fl_flags & (FL_LEASE|FL_DELEG|FL_LAYOUT))
2014-04-22 16:24:32 +04:00
# define IS_OFDLCK(fl) (fl->fl_flags & FL_OFDLCK)
fs/locks: Remove fl_nspid and use fs-specific l_pid for remote locks
Since commit c69899a17ca4 "NFSv4: Update of VFS byte range lock must be
atomic with the stateid update", NFSv4 has been inserting locks in rpciod
worker context. The result is that the file_lock's fl_nspid is the
kworker's pid instead of the original userspace pid.
The fl_nspid is only used to represent the namespaced virtual pid number
when displaying locks or returning from F_GETLK. There's no reason to set
it for every inserted lock, since we can usually just look it up from
fl_pid. So, instead of looking up and holding struct pid for every lock,
let's just look up the virtual pid number from fl_pid when it is needed.
That means we can remove fl_nspid entirely.
The translaton and presentation of fl_pid should handle the following four
cases:
1 - F_GETLK on a remote file with a remote lock:
In this case, the filesystem should determine the l_pid to return here.
Filesystems should indicate that the fl_pid represents a non-local pid
value that should not be translated by returning an fl_pid <= 0.
2 - F_GETLK on a local file with a remote lock:
This should be the l_pid of the lock manager process, and translated.
3 - F_GETLK on a remote file with a local lock, and
4 - F_GETLK on a local file with a local lock:
These should be the translated l_pid of the local locking process.
Fuse was already doing the correct thing by translating the pid into the
caller's namespace. With this change we must update fuse to translate
to init's pid namespace, so that the locks API can then translate from
init's pid namespace into the pid namespace of the caller.
With this change, the locks API will expect that if a filesystem returns
a remote pid as opposed to a local pid for F_GETLK, that remote pid will
be <= 0. This signifies that the pid is remote, and the locks API will
forego translating that pid into the pid namespace of the local calling
process.
Finally, we convert remote filesystems to present remote pids using
negative numbers. Have lustre, 9p, ceph, cifs, and dlm negate the remote
pid returned for F_GETLK lock requests.
Since local pids will never be larger than PID_MAX_LIMIT (which is
currently defined as <= 4 million), but pid_t is an unsigned int, we
should have plenty of room to represent remote pids with negative
numbers if we assume that remote pid numbers are similarly limited.
If this is not the case, then we run the risk of having a remote pid
returned for which there is also a corresponding local pid. This is a
problem we have now, but this patch should reduce the chances of that
occurring, while also returning those remote pid numbers, for whatever
that may be worth.
Signed-off-by: Benjamin Coddington <bcodding@redhat.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
2017-07-16 17:28:22 +03:00
# define IS_REMOTELCK(fl) (fl->fl_pid <= 0)
2005-04-17 02:20:36 +04:00
2011-07-27 04:10:51 +04:00
static bool lease_breaking ( struct file_lock * fl )
{
2011-07-27 02:25:49 +04:00
return fl - > fl_flags & ( FL_UNLOCK_PENDING | FL_DOWNGRADE_PENDING ) ;
}
static int target_leasetype ( struct file_lock * fl )
{
if ( fl - > fl_flags & FL_UNLOCK_PENDING )
return F_UNLCK ;
if ( fl - > fl_flags & FL_DOWNGRADE_PENDING )
return F_RDLCK ;
return fl - > fl_type ;
2011-07-27 04:10:51 +04:00
}
2022-01-22 09:13:10 +03:00
static int leases_enable = 1 ;
static int lease_break_time = 45 ;
# ifdef CONFIG_SYSCTL
static struct ctl_table locks_sysctls [ ] = {
{
. procname = " leases-enable " ,
. data = & leases_enable ,
. maxlen = sizeof ( int ) ,
. mode = 0644 ,
. proc_handler = proc_dointvec ,
} ,
# ifdef CONFIG_MMU
{
. procname = " lease-break-time " ,
. data = & lease_break_time ,
. maxlen = sizeof ( int ) ,
. mode = 0644 ,
. proc_handler = proc_dointvec ,
} ,
# endif /* CONFIG_MMU */
{ }
} ;
static int __init init_fs_locks_sysctls ( void )
{
register_sysctl_init ( " fs " , locks_sysctls ) ;
return 0 ;
}
early_initcall ( init_fs_locks_sysctls ) ;
# endif /* CONFIG_SYSCTL */
2005-04-17 02:20:36 +04:00
2013-06-21 16:58:15 +04:00
/*
2013-06-21 16:58:22 +04:00
* The global file_lock_list is only used for displaying / proc / locks , so we
2015-06-22 15:16:34 +03:00
* keep a list on each CPU , with each list protected by its own spinlock .
* Global serialization is done using file_rwsem .
*
* Note that alterations to the list also require that the relevant flc_lock is
* held .
2013-06-21 16:58:15 +04:00
*/
2015-06-22 15:16:34 +03:00
struct file_lock_list_struct {
spinlock_t lock ;
struct hlist_head hlist ;
} ;
static DEFINE_PER_CPU ( struct file_lock_list_struct , file_lock_list ) ;
2015-06-22 15:16:33 +03:00
DEFINE_STATIC_PERCPU_RWSEM ( file_rwsem ) ;
2013-06-21 16:58:14 +04:00
2019-08-18 21:18:53 +03:00
2013-06-21 16:58:15 +04:00
/*
2013-06-21 16:58:18 +04:00
* The blocked_hash is used to find POSIX lock loops for deadlock detection .
2013-06-21 16:58:20 +04:00
* It is protected by blocked_lock_lock .
2013-06-21 16:58:18 +04:00
*
* We hash locks by lockowner in order to optimize searching for the lock a
* particular lockowner is waiting on .
*
* FIXME : make this value scale via some heuristic ? We generally will want more
* buckets when we have more lockowners holding locks , but that ' s a little
* difficult to determine without knowing what the workload will look like .
2013-06-21 16:58:15 +04:00
*/
2013-06-21 16:58:18 +04:00
# define BLOCKED_HASH_BITS 7
static DEFINE_HASHTABLE ( blocked_hash , BLOCKED_HASH_BITS ) ;
2013-06-21 16:58:14 +04:00
2013-06-21 16:58:15 +04:00
/*
2013-06-21 16:58:20 +04:00
* This lock protects the blocked_hash . Generally , if you ' re accessing it , you
* want to be holding this lock .
2013-06-21 16:58:15 +04:00
*
2018-11-30 02:04:08 +03:00
* In addition , it also protects the fl - > fl_blocked_requests list , and the
* fl - > fl_blocker pointer for file_lock structures that are acting as lock
* requests ( in contrast to those that are acting as records of acquired locks ) .
2013-06-21 16:58:15 +04:00
*
* Note that when we acquire this lock in order to change the above fields ,
2015-01-16 23:05:57 +03:00
* we often hold the flc_lock as well . In certain cases , when reading the fields
2013-06-21 16:58:15 +04:00
* protected by this lock , we can skip acquiring it iff we already hold the
2015-01-16 23:05:57 +03:00
* flc_lock .
2013-06-21 16:58:15 +04:00
*/
2013-06-21 16:58:20 +04:00
static DEFINE_SPINLOCK ( blocked_lock_lock ) ;
2005-04-17 02:20:36 +04:00
2015-01-16 23:05:54 +03:00
static struct kmem_cache * flctx_cache __read_mostly ;
2006-12-07 07:33:20 +03:00
static struct kmem_cache * filelock_cache __read_mostly ;
2005-04-17 02:20:36 +04:00
2015-01-16 23:05:54 +03:00
static struct file_lock_context *
2015-04-03 16:04:03 +03:00
locks_get_lock_context ( struct inode * inode , int type )
2015-01-16 23:05:54 +03:00
{
2015-09-21 10:43:06 +03:00
struct file_lock_context * ctx ;
2015-01-16 23:05:54 +03:00
2015-09-21 10:43:06 +03:00
/* paired with cmpxchg() below */
ctx = smp_load_acquire ( & inode - > i_flctx ) ;
if ( likely ( ctx ) | | type = = F_UNLCK )
2015-01-16 23:05:54 +03:00
goto out ;
2015-09-21 10:43:06 +03:00
ctx = kmem_cache_alloc ( flctx_cache , GFP_KERNEL ) ;
if ( ! ctx )
2015-01-16 23:05:54 +03:00
goto out ;
2015-09-21 10:43:06 +03:00
spin_lock_init ( & ctx - > flc_lock ) ;
INIT_LIST_HEAD ( & ctx - > flc_flock ) ;
INIT_LIST_HEAD ( & ctx - > flc_posix ) ;
INIT_LIST_HEAD ( & ctx - > flc_lease ) ;
2015-01-16 23:05:54 +03:00
/*
* Assign the pointer if it ' s not already assigned . If it is , then
* free the context we just allocated .
*/
2015-09-21 10:43:06 +03:00
if ( cmpxchg ( & inode - > i_flctx , NULL , ctx ) ) {
kmem_cache_free ( flctx_cache , ctx ) ;
ctx = smp_load_acquire ( & inode - > i_flctx ) ;
}
2015-01-16 23:05:54 +03:00
out :
2016-01-07 05:26:10 +03:00
trace_locks_get_lock_context ( inode , type , ctx ) ;
2015-09-21 10:43:06 +03:00
return ctx ;
2015-01-16 23:05:54 +03:00
}
2016-01-07 05:28:41 +03:00
static void
locks_dump_ctx_list ( struct list_head * list , char * list_type )
{
struct file_lock * fl ;
list_for_each_entry ( fl , list , fl_list ) {
pr_warn ( " %s: fl_owner=%p fl_flags=0x%x fl_type=0x%x fl_pid=%u \n " , list_type , fl - > fl_owner , fl - > fl_flags , fl - > fl_type , fl - > fl_pid ) ;
}
}
static void
locks_check_ctx_lists ( struct inode * inode )
{
struct file_lock_context * ctx = inode - > i_flctx ;
if ( unlikely ( ! list_empty ( & ctx - > flc_flock ) | |
! list_empty ( & ctx - > flc_posix ) | |
! list_empty ( & ctx - > flc_lease ) ) ) {
pr_warn ( " Leaked locks on dev=0x%x:0x%x ino=0x%lx: \n " ,
MAJOR ( inode - > i_sb - > s_dev ) , MINOR ( inode - > i_sb - > s_dev ) ,
inode - > i_ino ) ;
locks_dump_ctx_list ( & ctx - > flc_flock , " FLOCK " ) ;
locks_dump_ctx_list ( & ctx - > flc_posix , " POSIX " ) ;
locks_dump_ctx_list ( & ctx - > flc_lease , " LEASE " ) ;
}
}
2017-07-21 20:36:25 +03:00
static void
locks_check_ctx_file_list ( struct file * filp , struct list_head * list ,
char * list_type )
{
struct file_lock * fl ;
struct inode * inode = locks_inode ( filp ) ;
list_for_each_entry ( fl , list , fl_list )
if ( fl - > fl_file = = filp )
pr_warn ( " Leaked %s lock on dev=0x%x:0x%x ino=0x%lx "
" fl_owner=%p fl_flags=0x%x fl_type=0x%x fl_pid=%u \n " ,
list_type , MAJOR ( inode - > i_sb - > s_dev ) ,
MINOR ( inode - > i_sb - > s_dev ) , inode - > i_ino ,
fl - > fl_owner , fl - > fl_flags , fl - > fl_type , fl - > fl_pid ) ;
}
2015-01-16 23:05:54 +03:00
void
2016-01-07 23:08:51 +03:00
locks_free_lock_context ( struct inode * inode )
2015-01-16 23:05:54 +03:00
{
2016-01-07 23:08:51 +03:00
struct file_lock_context * ctx = inode - > i_flctx ;
2016-01-07 05:28:41 +03:00
if ( unlikely ( ctx ) ) {
locks_check_ctx_lists ( inode ) ;
2015-01-16 23:05:54 +03:00
kmem_cache_free ( flctx_cache , ctx ) ;
}
}
2011-07-07 15:06:09 +04:00
static void locks_init_lock_heads ( struct file_lock * fl )
2011-07-06 14:33:55 +04:00
{
2013-06-21 16:58:17 +04:00
INIT_HLIST_NODE ( & fl - > fl_link ) ;
2015-01-16 23:05:54 +03:00
INIT_LIST_HEAD ( & fl - > fl_list ) ;
2018-11-30 02:04:08 +03:00
INIT_LIST_HEAD ( & fl - > fl_blocked_requests ) ;
INIT_LIST_HEAD ( & fl - > fl_blocked_member ) ;
2011-07-07 15:06:09 +04:00
init_waitqueue_head ( & fl - > fl_wait ) ;
2011-07-06 14:33:55 +04:00
}
2005-04-17 02:20:36 +04:00
/* Allocate an empty lock structure. */
2010-10-27 17:46:08 +04:00
struct file_lock * locks_alloc_lock ( void )
2005-04-17 02:20:36 +04:00
{
2011-07-07 15:06:09 +04:00
struct file_lock * fl = kmem_cache_zalloc ( filelock_cache , GFP_KERNEL ) ;
2011-07-06 14:33:55 +04:00
if ( fl )
2011-07-07 15:06:09 +04:00
locks_init_lock_heads ( fl ) ;
2011-07-06 14:33:55 +04:00
return fl ;
2005-04-17 02:20:36 +04:00
}
2010-10-27 17:46:08 +04:00
EXPORT_SYMBOL_GPL ( locks_alloc_lock ) ;
2005-04-17 02:20:36 +04:00
2009-04-01 00:12:56 +04:00
void locks_release_private ( struct file_lock * fl )
2006-03-20 21:44:05 +03:00
{
2019-04-24 05:00:08 +03:00
BUG_ON ( waitqueue_active ( & fl - > fl_wait ) ) ;
BUG_ON ( ! list_empty ( & fl - > fl_list ) ) ;
BUG_ON ( ! list_empty ( & fl - > fl_blocked_requests ) ) ;
BUG_ON ( ! list_empty ( & fl - > fl_blocked_member ) ) ;
BUG_ON ( ! hlist_unhashed ( & fl - > fl_link ) ) ;
2006-03-20 21:44:05 +03:00
if ( fl - > fl_ops ) {
if ( fl - > fl_ops - > fl_release_private )
fl - > fl_ops - > fl_release_private ( fl ) ;
fl - > fl_ops = NULL ;
}
2014-08-22 18:18:43 +04:00
if ( fl - > fl_lmops ) {
2015-04-03 16:04:04 +03:00
if ( fl - > fl_lmops - > lm_put_owner ) {
fl - > fl_lmops - > lm_put_owner ( fl - > fl_owner ) ;
fl - > fl_owner = NULL ;
}
2014-08-22 18:18:43 +04:00
fl - > fl_lmops = NULL ;
}
2006-03-20 21:44:05 +03:00
}
2009-04-01 00:12:56 +04:00
EXPORT_SYMBOL_GPL ( locks_release_private ) ;
2006-03-20 21:44:05 +03:00
2022-05-03 00:19:24 +03:00
/**
* locks_owner_has_blockers - Check for blocking lock requests
* @ flctx : file lock context
* @ owner : lock owner
*
* Return values :
* % true : @ owner has at least one blocker
* % false : @ owner has no blockers
*/
bool locks_owner_has_blockers ( struct file_lock_context * flctx ,
fl_owner_t owner )
{
struct file_lock * fl ;
spin_lock ( & flctx - > flc_lock ) ;
list_for_each_entry ( fl , & flctx - > flc_posix , fl_list ) {
if ( fl - > fl_owner ! = owner )
continue ;
if ( ! list_empty ( & fl - > fl_blocked_requests ) ) {
spin_unlock ( & flctx - > flc_lock ) ;
return true ;
}
}
spin_unlock ( & flctx - > flc_lock ) ;
return false ;
}
EXPORT_SYMBOL_GPL ( locks_owner_has_blockers ) ;
2005-04-17 02:20:36 +04:00
/* Free a lock which is not in use. */
2010-10-31 01:31:15 +04:00
void locks_free_lock ( struct file_lock * fl )
2005-04-17 02:20:36 +04:00
{
2006-03-20 21:44:05 +03:00
locks_release_private ( fl ) ;
2005-04-17 02:20:36 +04:00
kmem_cache_free ( filelock_cache , fl ) ;
}
2010-10-31 01:31:15 +04:00
EXPORT_SYMBOL ( locks_free_lock ) ;
2005-04-17 02:20:36 +04:00
2014-08-11 22:20:31 +04:00
static void
locks_dispose_list ( struct list_head * dispose )
{
struct file_lock * fl ;
while ( ! list_empty ( dispose ) ) {
2015-01-16 23:05:54 +03:00
fl = list_first_entry ( dispose , struct file_lock , fl_list ) ;
list_del_init ( & fl - > fl_list ) ;
2014-08-11 22:20:31 +04:00
locks_free_lock ( fl ) ;
}
}
2005-04-17 02:20:36 +04:00
void locks_init_lock ( struct file_lock * fl )
{
2011-07-07 15:06:09 +04:00
memset ( fl , 0 , sizeof ( struct file_lock ) ) ;
locks_init_lock_heads ( fl ) ;
2005-04-17 02:20:36 +04:00
}
EXPORT_SYMBOL ( locks_init_lock ) ;
/*
* Initialize a new lock from an existing file_lock structure .
*/
2014-08-22 18:18:42 +04:00
void locks_copy_conflock ( struct file_lock * new , struct file_lock * fl )
2005-04-17 02:20:36 +04:00
{
new - > fl_owner = fl - > fl_owner ;
new - > fl_pid = fl - > fl_pid ;
2006-03-20 21:44:38 +03:00
new - > fl_file = NULL ;
2005-04-17 02:20:36 +04:00
new - > fl_flags = fl - > fl_flags ;
new - > fl_type = fl - > fl_type ;
new - > fl_start = fl - > fl_start ;
new - > fl_end = fl - > fl_end ;
2014-08-22 18:18:43 +04:00
new - > fl_lmops = fl - > fl_lmops ;
2006-03-20 21:44:38 +03:00
new - > fl_ops = NULL ;
2014-08-22 18:18:43 +04:00
if ( fl - > fl_lmops ) {
if ( fl - > fl_lmops - > lm_get_owner )
2015-04-03 16:04:04 +03:00
fl - > fl_lmops - > lm_get_owner ( fl - > fl_owner ) ;
2014-08-22 18:18:43 +04:00
}
2006-03-20 21:44:38 +03:00
}
2014-08-22 18:18:42 +04:00
EXPORT_SYMBOL ( locks_copy_conflock ) ;
2006-03-20 21:44:38 +03:00
void locks_copy_lock ( struct file_lock * new , struct file_lock * fl )
{
2014-08-11 22:09:35 +04:00
/* "new" must be a freshly-initialized lock */
WARN_ON_ONCE ( new - > fl_ops ) ;
2006-03-20 21:44:38 +03:00
2014-08-22 18:18:42 +04:00
locks_copy_conflock ( new , fl ) ;
2014-08-22 18:18:43 +04:00
2006-03-20 21:44:38 +03:00
new - > fl_file = fl - > fl_file ;
2005-04-17 02:20:36 +04:00
new - > fl_ops = fl - > fl_ops ;
2006-03-20 21:44:05 +03:00
2014-08-22 18:18:43 +04:00
if ( fl - > fl_ops ) {
if ( fl - > fl_ops - > fl_copy_lock )
fl - > fl_ops - > fl_copy_lock ( new , fl ) ;
}
2005-04-17 02:20:36 +04:00
}
EXPORT_SYMBOL ( locks_copy_lock ) ;
2018-11-30 02:04:08 +03:00
static void locks_move_blocks ( struct file_lock * new , struct file_lock * fl )
{
struct file_lock * f ;
/*
* As ctx - > flc_lock is held , new requests cannot be added to
* - > fl_blocked_requests , so we don ' t need a lock to check if it
* is empty .
*/
if ( list_empty ( & fl - > fl_blocked_requests ) )
return ;
spin_lock ( & blocked_lock_lock ) ;
list_splice_init ( & fl - > fl_blocked_requests , & new - > fl_blocked_requests ) ;
2019-01-03 03:04:08 +03:00
list_for_each_entry ( f , & new - > fl_blocked_requests , fl_blocked_member )
2018-11-30 02:04:08 +03:00
f - > fl_blocker = new ;
spin_unlock ( & blocked_lock_lock ) ;
}
2005-04-17 02:20:36 +04:00
static inline int flock_translate_cmd ( int cmd ) {
switch ( cmd ) {
case LOCK_SH :
return F_RDLCK ;
case LOCK_EX :
return F_WRLCK ;
case LOCK_UN :
return F_UNLCK ;
}
return - EINVAL ;
}
/* Fill in a file_lock structure with an appropriate FLOCK lock. */
2014-09-04 18:25:06 +04:00
static struct file_lock *
2018-11-30 02:04:08 +03:00
flock_make_lock ( struct file * filp , unsigned int cmd , struct file_lock * fl )
2005-04-17 02:20:36 +04:00
{
int type = flock_translate_cmd ( cmd ) ;
2014-09-04 18:25:06 +04:00
2005-04-17 02:20:36 +04:00
if ( type < 0 )
2014-09-04 18:25:06 +04:00
return ERR_PTR ( type ) ;
2018-11-30 02:04:08 +03:00
2018-11-30 02:04:08 +03:00
if ( fl = = NULL ) {
fl = locks_alloc_lock ( ) ;
if ( fl = = NULL )
return ERR_PTR ( - ENOMEM ) ;
} else {
locks_init_lock ( fl ) ;
}
2005-04-17 02:20:36 +04:00
fl - > fl_file = filp ;
2014-07-13 19:00:38 +04:00
fl - > fl_owner = filp ;
2005-04-17 02:20:36 +04:00
fl - > fl_pid = current - > tgid ;
fl - > fl_flags = FL_FLOCK ;
fl - > fl_type = type ;
fl - > fl_end = OFFSET_MAX ;
2018-11-30 02:04:08 +03:00
2014-09-04 18:25:06 +04:00
return fl ;
2005-04-17 02:20:36 +04:00
}
2012-07-23 23:17:17 +04:00
static int assign_type ( struct file_lock * fl , long type )
2005-04-17 02:20:36 +04:00
{
switch ( type ) {
case F_RDLCK :
case F_WRLCK :
case F_UNLCK :
fl - > fl_type = type ;
break ;
default :
return - EINVAL ;
}
return 0 ;
}
2014-02-03 21:13:08 +04:00
static int flock64_to_posix_lock ( struct file * filp , struct file_lock * fl ,
struct flock64 * l )
2005-04-17 02:20:36 +04:00
{
switch ( l - > l_whence ) {
2006-10-01 10:27:35 +04:00
case SEEK_SET :
2014-02-03 21:13:08 +04:00
fl - > fl_start = 0 ;
2005-04-17 02:20:36 +04:00
break ;
2006-10-01 10:27:35 +04:00
case SEEK_CUR :
2014-02-03 21:13:08 +04:00
fl - > fl_start = filp - > f_pos ;
2005-04-17 02:20:36 +04:00
break ;
2006-10-01 10:27:35 +04:00
case SEEK_END :
2014-02-03 21:13:08 +04:00
fl - > fl_start = i_size_read ( file_inode ( filp ) ) ;
2005-04-17 02:20:36 +04:00
break ;
default :
return - EINVAL ;
}
2014-02-03 21:13:08 +04:00
if ( l - > l_start > OFFSET_MAX - fl - > fl_start )
return - EOVERFLOW ;
fl - > fl_start + = l - > l_start ;
if ( fl - > fl_start < 0 )
return - EINVAL ;
2005-04-17 02:20:36 +04:00
/* POSIX-1996 leaves the case l->l_len < 0 undefined;
POSIX - 2001 defines it . */
2005-10-19 01:20:21 +04:00
if ( l - > l_len > 0 ) {
2014-02-03 21:13:08 +04:00
if ( l - > l_len - 1 > OFFSET_MAX - fl - > fl_start )
return - EOVERFLOW ;
2020-10-23 09:20:05 +03:00
fl - > fl_end = fl - > fl_start + ( l - > l_len - 1 ) ;
2014-02-03 21:13:08 +04:00
2005-10-19 01:20:21 +04:00
} else if ( l - > l_len < 0 ) {
2014-02-03 21:13:08 +04:00
if ( fl - > fl_start + l - > l_len < 0 )
2005-10-19 01:20:21 +04:00
return - EINVAL ;
2014-02-03 21:13:08 +04:00
fl - > fl_end = fl - > fl_start - 1 ;
fl - > fl_start + = l - > l_len ;
} else
fl - > fl_end = OFFSET_MAX ;
2005-04-17 02:20:36 +04:00
fl - > fl_owner = current - > files ;
fl - > fl_pid = current - > tgid ;
fl - > fl_file = filp ;
fl - > fl_flags = FL_POSIX ;
fl - > fl_ops = NULL ;
fl - > fl_lmops = NULL ;
return assign_type ( fl , l - > l_type ) ;
}
2014-02-03 21:13:08 +04:00
/* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX
* style lock .
*/
static int flock_to_posix_lock ( struct file * filp , struct file_lock * fl ,
struct flock * l )
2005-04-17 02:20:36 +04:00
{
2014-02-03 21:13:08 +04:00
struct flock64 ll = {
. l_type = l - > l_type ,
. l_whence = l - > l_whence ,
. l_start = l - > l_start ,
. l_len = l - > l_len ,
} ;
return flock64_to_posix_lock ( filp , fl , & ll ) ;
2005-04-17 02:20:36 +04:00
}
/* default lease lock manager operations */
2014-09-01 23:06:54 +04:00
static bool
lease_break_callback ( struct file_lock * fl )
2005-04-17 02:20:36 +04:00
{
kill_fasync ( & fl - > fl_fasync , SIGIO , POLL_MSG ) ;
2014-09-01 23:06:54 +04:00
return false ;
2005-04-17 02:20:36 +04:00
}
2014-08-22 18:55:47 +04:00
static void
lease_setup ( struct file_lock * fl , void * * priv )
{
struct file * filp = fl - > fl_file ;
struct fasync_struct * fa = * priv ;
/*
* fasync_insert_entry ( ) returns the old entry if any . If there was no
* old entry , then it used " priv " and inserted it into the fasync list .
* Clear the pointer to indicate that it shouldn ' t be freed .
*/
if ( ! fasync_insert_entry ( fa - > fa_fd , filp , & fl - > fl_fasync , fa ) )
* priv = NULL ;
2017-07-17 06:05:57 +03:00
__f_setown ( filp , task_pid ( current ) , PIDTYPE_TGID , 0 ) ;
2014-08-22 18:55:47 +04:00
}
2009-09-22 04:01:12 +04:00
static const struct lock_manager_operations lease_manager_ops = {
2011-07-21 04:21:59 +04:00
. lm_break = lease_break_callback ,
. lm_change = lease_modify ,
2014-08-22 18:55:47 +04:00
. lm_setup = lease_setup ,
2005-04-17 02:20:36 +04:00
} ;
/*
* Initialize a lease , use the default lock manager operations
*/
2012-07-23 23:17:17 +04:00
static int lease_init ( struct file * filp , long type , struct file_lock * fl )
2018-03-22 01:09:32 +03:00
{
2006-05-08 07:02:42 +04:00
if ( assign_type ( fl , type ) ! = 0 )
return - EINVAL ;
2014-09-02 03:04:48 +04:00
fl - > fl_owner = filp ;
2005-04-17 02:20:36 +04:00
fl - > fl_pid = current - > tgid ;
fl - > fl_file = filp ;
fl - > fl_flags = FL_LEASE ;
fl - > fl_start = 0 ;
fl - > fl_end = OFFSET_MAX ;
fl - > fl_ops = NULL ;
fl - > fl_lmops = & lease_manager_ops ;
return 0 ;
}
/* Allocate a file_lock initialised to this type of lease */
2012-07-23 23:17:17 +04:00
static struct file_lock * lease_alloc ( struct file * filp , long type )
2005-04-17 02:20:36 +04:00
{
struct file_lock * fl = locks_alloc_lock ( ) ;
2006-05-08 07:02:42 +04:00
int error = - ENOMEM ;
2005-04-17 02:20:36 +04:00
if ( fl = = NULL )
2007-03-01 22:34:35 +03:00
return ERR_PTR ( error ) ;
2005-04-17 02:20:36 +04:00
error = lease_init ( filp , type , fl ) ;
2006-05-08 07:02:42 +04:00
if ( error ) {
locks_free_lock ( fl ) ;
2007-03-01 22:34:35 +03:00
return ERR_PTR ( error ) ;
2006-05-08 07:02:42 +04:00
}
2007-03-01 22:34:35 +03:00
return fl ;
2005-04-17 02:20:36 +04:00
}
/* Check if two locks overlap each other.
*/
static inline int locks_overlap ( struct file_lock * fl1 , struct file_lock * fl2 )
{
return ( ( fl1 - > fl_end > = fl2 - > fl_start ) & &
( fl2 - > fl_end > = fl1 - > fl_start ) ) ;
}
/*
* Check whether two locks have the same owner .
*/
2006-01-08 12:05:22 +03:00
static int posix_same_owner ( struct file_lock * fl1 , struct file_lock * fl2 )
2005-04-17 02:20:36 +04:00
{
return fl1 - > fl_owner = = fl2 - > fl_owner ;
}
2015-01-16 23:05:57 +03:00
/* Must be called with the flc_lock held! */
2014-02-03 21:13:07 +04:00
static void locks_insert_global_locks ( struct file_lock * fl )
2013-06-21 16:58:14 +04:00
{
2015-06-22 15:16:34 +03:00
struct file_lock_list_struct * fll = this_cpu_ptr ( & file_lock_list ) ;
2015-06-22 15:16:33 +03:00
percpu_rwsem_assert_held ( & file_rwsem ) ;
2015-06-22 15:16:34 +03:00
spin_lock ( & fll - > lock ) ;
2013-06-21 16:58:22 +04:00
fl - > fl_link_cpu = smp_processor_id ( ) ;
2015-06-22 15:16:34 +03:00
hlist_add_head ( & fl - > fl_link , & fll - > hlist ) ;
spin_unlock ( & fll - > lock ) ;
2013-06-21 16:58:14 +04:00
}
2015-01-16 23:05:57 +03:00
/* Must be called with the flc_lock held! */
2014-02-03 21:13:07 +04:00
static void locks_delete_global_locks ( struct file_lock * fl )
2013-06-21 16:58:14 +04:00
{
2015-06-22 15:16:34 +03:00
struct file_lock_list_struct * fll ;
2015-06-22 15:16:33 +03:00
percpu_rwsem_assert_held ( & file_rwsem ) ;
2013-06-21 16:58:22 +04:00
/*
* Avoid taking lock if already unhashed . This is safe since this check
2015-01-16 23:05:57 +03:00
* is done while holding the flc_lock , and new insertions into the list
2013-06-21 16:58:22 +04:00
* also require that it be held .
*/
if ( hlist_unhashed ( & fl - > fl_link ) )
return ;
2015-06-22 15:16:34 +03:00
fll = per_cpu_ptr ( & file_lock_list , fl - > fl_link_cpu ) ;
spin_lock ( & fll - > lock ) ;
2013-06-21 16:58:17 +04:00
hlist_del_init ( & fl - > fl_link ) ;
2015-06-22 15:16:34 +03:00
spin_unlock ( & fll - > lock ) ;
2013-06-21 16:58:14 +04:00
}
2013-06-21 16:58:19 +04:00
static unsigned long
posix_owner_key ( struct file_lock * fl )
{
return ( unsigned long ) fl - > fl_owner ;
}
2014-02-03 21:13:07 +04:00
static void locks_insert_global_blocked ( struct file_lock * waiter )
2013-06-21 16:58:14 +04:00
{
2015-04-03 16:04:03 +03:00
lockdep_assert_held ( & blocked_lock_lock ) ;
2013-06-21 16:58:19 +04:00
hash_add ( blocked_hash , & waiter - > fl_link , posix_owner_key ( waiter ) ) ;
2013-06-21 16:58:14 +04:00
}
2014-02-03 21:13:07 +04:00
static void locks_delete_global_blocked ( struct file_lock * waiter )
2013-06-21 16:58:14 +04:00
{
2015-04-03 16:04:03 +03:00
lockdep_assert_held ( & blocked_lock_lock ) ;
2013-06-21 16:58:18 +04:00
hash_del ( & waiter - > fl_link ) ;
2013-06-21 16:58:14 +04:00
}
2005-04-17 02:20:36 +04:00
/* Remove waiter from blocker's block list.
* When blocker ends up pointing to itself then the list is empty .
2013-06-21 16:58:15 +04:00
*
2013-06-21 16:58:20 +04:00
* Must be called with blocked_lock_lock held .
2005-04-17 02:20:36 +04:00
*/
2006-01-08 12:05:22 +03:00
static void __locks_delete_block ( struct file_lock * waiter )
2005-04-17 02:20:36 +04:00
{
2013-06-21 16:58:14 +04:00
locks_delete_global_blocked ( waiter ) ;
2018-11-30 02:04:08 +03:00
list_del_init ( & waiter - > fl_blocked_member ) ;
2005-04-17 02:20:36 +04:00
}
2018-11-30 02:04:08 +03:00
static void __locks_wake_up_blocks ( struct file_lock * blocker )
{
while ( ! list_empty ( & blocker - > fl_blocked_requests ) ) {
struct file_lock * waiter ;
waiter = list_first_entry ( & blocker - > fl_blocked_requests ,
struct file_lock , fl_blocked_member ) ;
__locks_delete_block ( waiter ) ;
if ( waiter - > fl_lmops & & waiter - > fl_lmops - > lm_notify )
waiter - > fl_lmops - > lm_notify ( waiter ) ;
else
wake_up ( & waiter - > fl_wait ) ;
2020-03-18 14:52:21 +03:00
/*
* The setting of fl_blocker to NULL marks the " done "
* point in deleting a block . Paired with acquire at the top
* of locks_delete_block ( ) .
*/
smp_store_release ( & waiter - > fl_blocker , NULL ) ;
2018-11-30 02:04:08 +03:00
}
}
2018-11-30 02:04:08 +03:00
/**
2020-10-23 19:33:23 +03:00
* locks_delete_block - stop waiting for a file lock
2018-11-30 02:04:08 +03:00
* @ waiter : the lock which was waiting
*
* lockd / nfsd need to disconnect the lock while working on it .
*/
int locks_delete_block ( struct file_lock * waiter )
2005-04-17 02:20:36 +04:00
{
2018-11-30 02:04:08 +03:00
int status = - ENOENT ;
2020-03-18 14:52:21 +03:00
/*
* If fl_blocker is NULL , it won ' t be set again as this thread " owns "
* the lock and is the only one that might try to claim the lock .
*
* We use acquire / release to manage fl_blocker so that we can
* optimize away taking the blocked_lock_lock in many cases .
*
* The smp_load_acquire guarantees two things :
*
* 1 / that fl_blocked_requests can be tested locklessly . If something
* was recently added to that list it must have been in a locked region
* * before * the locked region when fl_blocker was set to NULL .
*
* 2 / that no other thread is accessing ' waiter ' , so it is safe to free
* it . __locks_wake_up_blocks is careful not to touch waiter after
* fl_blocker is released .
*
* If a lockless check of fl_blocker shows it to be NULL , we know that
* no new locks can be inserted into its fl_blocked_requests list , and
* can avoid doing anything further if the list is empty .
*/
if ( ! smp_load_acquire ( & waiter - > fl_blocker ) & &
list_empty ( & waiter - > fl_blocked_requests ) )
return status ;
2013-06-21 16:58:20 +04:00
spin_lock ( & blocked_lock_lock ) ;
2018-11-30 02:04:08 +03:00
if ( waiter - > fl_blocker )
status = 0 ;
2018-11-30 02:04:08 +03:00
__locks_wake_up_blocks ( waiter ) ;
2005-04-17 02:20:36 +04:00
__locks_delete_block ( waiter ) ;
2020-03-18 14:52:21 +03:00
/*
* The setting of fl_blocker to NULL marks the " done " point in deleting
* a block . Paired with acquire at the top of this function .
*/
smp_store_release ( & waiter - > fl_blocker , NULL ) ;
2013-06-21 16:58:20 +04:00
spin_unlock ( & blocked_lock_lock ) ;
2018-11-30 02:04:08 +03:00
return status ;
2005-04-17 02:20:36 +04:00
}
2018-11-30 02:04:08 +03:00
EXPORT_SYMBOL ( locks_delete_block ) ;
2005-04-17 02:20:36 +04:00
/* Insert waiter into blocker's block list.
* We use a circular list so that processes can be easily woken up in
* the order they blocked . The documentation doesn ' t require this but
* it seems like the reasonable thing to do .
2013-06-21 16:58:15 +04:00
*
2015-01-16 23:05:57 +03:00
* Must be called with both the flc_lock and blocked_lock_lock held . The
2018-11-30 02:04:08 +03:00
* fl_blocked_requests list itself is protected by the blocked_lock_lock ,
* but by ensuring that the flc_lock is also held on insertions we can avoid
* taking the blocked_lock_lock in some cases when we see that the
* fl_blocked_requests list is empty .
fs/locks: create a tree of dependent requests.
When we find an existing lock which conflicts with a request,
and the request wants to wait, we currently add the request
to a list. When the lock is removed, the whole list is woken.
This can cause the thundering-herd problem.
To reduce the problem, we make use of the (new) fact that
a pending request can itself have a list of blocked requests.
When we find a conflict, we look through the existing blocked requests.
If any one of them blocks the new request, the new request is attached
below that request, otherwise it is added to the list of blocked
requests, which are now known to be mutually non-conflicting.
This way, when the lock is released, only a set of non-conflicting
locks will be woken, the rest can stay asleep.
If the lock request cannot be granted and the request needs to be
requeued, all the other requests it blocks will then be woken
To make this more concrete:
If you have a many-core machine, and have many threads all wanting to
briefly lock a give file (udev is known to do this), you can get quite
poor performance.
When one thread releases a lock, it wakes up all other threads that
are waiting (classic thundering-herd) - one will get the lock and the
others go to sleep.
When you have few cores, this is not very noticeable: by the time the
4th or 5th thread gets enough CPU time to try to claim the lock, the
earlier threads have claimed it, done what was needed, and released.
So with few cores, many of the threads don't end up contending.
With 50+ cores, lost of threads can get the CPU at the same time,
and the contention can easily be measured.
This patchset creates a tree of pending lock requests in which siblings
don't conflict and each lock request does conflict with its parent.
When a lock is released, only requests which don't conflict with each
other a woken.
Testing shows that lock-acquisitions-per-second is now fairly stable
even as the number of contending process goes to 1000. Without this
patch, locks-per-second drops off steeply after a few 10s of
processes.
There is a small cost to this extra complexity.
At 20 processes running a particular test on 72 cores, the lock
acquisitions per second drops from 1.8 million to 1.4 million with
this patch. For 100 processes, this patch still provides 1.4 million
while without this patch there are about 700,000.
Reported-and-tested-by: Martin Wilck <mwilck@suse.de>
Signed-off-by: NeilBrown <neilb@suse.com>
Reviewed-by: J. Bruce Fields <bfields@redhat.com>
Signed-off-by: Jeff Layton <jlayton@kernel.org>
2018-11-30 02:04:08 +03:00
*
* Rather than just adding to the list , we check for conflicts with any existing
* waiters , and add beneath any waiter that blocks the new waiter .
* Thus wakeups don ' t happen until needed .
2005-04-17 02:20:36 +04:00
*/
2013-06-21 16:58:15 +04:00
static void __locks_insert_block ( struct file_lock * blocker ,
fs/locks: create a tree of dependent requests.
When we find an existing lock which conflicts with a request,
and the request wants to wait, we currently add the request
to a list. When the lock is removed, the whole list is woken.
This can cause the thundering-herd problem.
To reduce the problem, we make use of the (new) fact that
a pending request can itself have a list of blocked requests.
When we find a conflict, we look through the existing blocked requests.
If any one of them blocks the new request, the new request is attached
below that request, otherwise it is added to the list of blocked
requests, which are now known to be mutually non-conflicting.
This way, when the lock is released, only a set of non-conflicting
locks will be woken, the rest can stay asleep.
If the lock request cannot be granted and the request needs to be
requeued, all the other requests it blocks will then be woken
To make this more concrete:
If you have a many-core machine, and have many threads all wanting to
briefly lock a give file (udev is known to do this), you can get quite
poor performance.
When one thread releases a lock, it wakes up all other threads that
are waiting (classic thundering-herd) - one will get the lock and the
others go to sleep.
When you have few cores, this is not very noticeable: by the time the
4th or 5th thread gets enough CPU time to try to claim the lock, the
earlier threads have claimed it, done what was needed, and released.
So with few cores, many of the threads don't end up contending.
With 50+ cores, lost of threads can get the CPU at the same time,
and the contention can easily be measured.
This patchset creates a tree of pending lock requests in which siblings
don't conflict and each lock request does conflict with its parent.
When a lock is released, only requests which don't conflict with each
other a woken.
Testing shows that lock-acquisitions-per-second is now fairly stable
even as the number of contending process goes to 1000. Without this
patch, locks-per-second drops off steeply after a few 10s of
processes.
There is a small cost to this extra complexity.
At 20 processes running a particular test on 72 cores, the lock
acquisitions per second drops from 1.8 million to 1.4 million with
this patch. For 100 processes, this patch still provides 1.4 million
while without this patch there are about 700,000.
Reported-and-tested-by: Martin Wilck <mwilck@suse.de>
Signed-off-by: NeilBrown <neilb@suse.com>
Reviewed-by: J. Bruce Fields <bfields@redhat.com>
Signed-off-by: Jeff Layton <jlayton@kernel.org>
2018-11-30 02:04:08 +03:00
struct file_lock * waiter ,
bool conflict ( struct file_lock * ,
struct file_lock * ) )
2005-04-17 02:20:36 +04:00
{
fs/locks: create a tree of dependent requests.
When we find an existing lock which conflicts with a request,
and the request wants to wait, we currently add the request
to a list. When the lock is removed, the whole list is woken.
This can cause the thundering-herd problem.
To reduce the problem, we make use of the (new) fact that
a pending request can itself have a list of blocked requests.
When we find a conflict, we look through the existing blocked requests.
If any one of them blocks the new request, the new request is attached
below that request, otherwise it is added to the list of blocked
requests, which are now known to be mutually non-conflicting.
This way, when the lock is released, only a set of non-conflicting
locks will be woken, the rest can stay asleep.
If the lock request cannot be granted and the request needs to be
requeued, all the other requests it blocks will then be woken
To make this more concrete:
If you have a many-core machine, and have many threads all wanting to
briefly lock a give file (udev is known to do this), you can get quite
poor performance.
When one thread releases a lock, it wakes up all other threads that
are waiting (classic thundering-herd) - one will get the lock and the
others go to sleep.
When you have few cores, this is not very noticeable: by the time the
4th or 5th thread gets enough CPU time to try to claim the lock, the
earlier threads have claimed it, done what was needed, and released.
So with few cores, many of the threads don't end up contending.
With 50+ cores, lost of threads can get the CPU at the same time,
and the contention can easily be measured.
This patchset creates a tree of pending lock requests in which siblings
don't conflict and each lock request does conflict with its parent.
When a lock is released, only requests which don't conflict with each
other a woken.
Testing shows that lock-acquisitions-per-second is now fairly stable
even as the number of contending process goes to 1000. Without this
patch, locks-per-second drops off steeply after a few 10s of
processes.
There is a small cost to this extra complexity.
At 20 processes running a particular test on 72 cores, the lock
acquisitions per second drops from 1.8 million to 1.4 million with
this patch. For 100 processes, this patch still provides 1.4 million
while without this patch there are about 700,000.
Reported-and-tested-by: Martin Wilck <mwilck@suse.de>
Signed-off-by: NeilBrown <neilb@suse.com>
Reviewed-by: J. Bruce Fields <bfields@redhat.com>
Signed-off-by: Jeff Layton <jlayton@kernel.org>
2018-11-30 02:04:08 +03:00
struct file_lock * fl ;
2018-11-30 02:04:08 +03:00
BUG_ON ( ! list_empty ( & waiter - > fl_blocked_member ) ) ;
fs/locks: create a tree of dependent requests.
When we find an existing lock which conflicts with a request,
and the request wants to wait, we currently add the request
to a list. When the lock is removed, the whole list is woken.
This can cause the thundering-herd problem.
To reduce the problem, we make use of the (new) fact that
a pending request can itself have a list of blocked requests.
When we find a conflict, we look through the existing blocked requests.
If any one of them blocks the new request, the new request is attached
below that request, otherwise it is added to the list of blocked
requests, which are now known to be mutually non-conflicting.
This way, when the lock is released, only a set of non-conflicting
locks will be woken, the rest can stay asleep.
If the lock request cannot be granted and the request needs to be
requeued, all the other requests it blocks will then be woken
To make this more concrete:
If you have a many-core machine, and have many threads all wanting to
briefly lock a give file (udev is known to do this), you can get quite
poor performance.
When one thread releases a lock, it wakes up all other threads that
are waiting (classic thundering-herd) - one will get the lock and the
others go to sleep.
When you have few cores, this is not very noticeable: by the time the
4th or 5th thread gets enough CPU time to try to claim the lock, the
earlier threads have claimed it, done what was needed, and released.
So with few cores, many of the threads don't end up contending.
With 50+ cores, lost of threads can get the CPU at the same time,
and the contention can easily be measured.
This patchset creates a tree of pending lock requests in which siblings
don't conflict and each lock request does conflict with its parent.
When a lock is released, only requests which don't conflict with each
other a woken.
Testing shows that lock-acquisitions-per-second is now fairly stable
even as the number of contending process goes to 1000. Without this
patch, locks-per-second drops off steeply after a few 10s of
processes.
There is a small cost to this extra complexity.
At 20 processes running a particular test on 72 cores, the lock
acquisitions per second drops from 1.8 million to 1.4 million with
this patch. For 100 processes, this patch still provides 1.4 million
while without this patch there are about 700,000.
Reported-and-tested-by: Martin Wilck <mwilck@suse.de>
Signed-off-by: NeilBrown <neilb@suse.com>
Reviewed-by: J. Bruce Fields <bfields@redhat.com>
Signed-off-by: Jeff Layton <jlayton@kernel.org>
2018-11-30 02:04:08 +03:00
new_blocker :
list_for_each_entry ( fl , & blocker - > fl_blocked_requests , fl_blocked_member )
if ( conflict ( fl , waiter ) ) {
blocker = fl ;
goto new_blocker ;
}
2018-11-30 02:04:08 +03:00
waiter - > fl_blocker = blocker ;
list_add_tail ( & waiter - > fl_blocked_member , & blocker - > fl_blocked_requests ) ;
2014-04-22 16:24:32 +04:00
if ( IS_POSIX ( blocker ) & & ! IS_OFDLCK ( blocker ) )
2013-06-21 16:58:15 +04:00
locks_insert_global_blocked ( waiter ) ;
2018-11-30 02:04:08 +03:00
/* The requests in waiter->fl_blocked are known to conflict with
* waiter , but might not conflict with blocker , or the requests
* and lock which block it . So they all need to be woken .
*/
__locks_wake_up_blocks ( waiter ) ;
2013-06-21 16:58:15 +04:00
}
2015-01-16 23:05:57 +03:00
/* Must be called with flc_lock held. */
2013-06-21 16:58:15 +04:00
static void locks_insert_block ( struct file_lock * blocker ,
fs/locks: create a tree of dependent requests.
When we find an existing lock which conflicts with a request,
and the request wants to wait, we currently add the request
to a list. When the lock is removed, the whole list is woken.
This can cause the thundering-herd problem.
To reduce the problem, we make use of the (new) fact that
a pending request can itself have a list of blocked requests.
When we find a conflict, we look through the existing blocked requests.
If any one of them blocks the new request, the new request is attached
below that request, otherwise it is added to the list of blocked
requests, which are now known to be mutually non-conflicting.
This way, when the lock is released, only a set of non-conflicting
locks will be woken, the rest can stay asleep.
If the lock request cannot be granted and the request needs to be
requeued, all the other requests it blocks will then be woken
To make this more concrete:
If you have a many-core machine, and have many threads all wanting to
briefly lock a give file (udev is known to do this), you can get quite
poor performance.
When one thread releases a lock, it wakes up all other threads that
are waiting (classic thundering-herd) - one will get the lock and the
others go to sleep.
When you have few cores, this is not very noticeable: by the time the
4th or 5th thread gets enough CPU time to try to claim the lock, the
earlier threads have claimed it, done what was needed, and released.
So with few cores, many of the threads don't end up contending.
With 50+ cores, lost of threads can get the CPU at the same time,
and the contention can easily be measured.
This patchset creates a tree of pending lock requests in which siblings
don't conflict and each lock request does conflict with its parent.
When a lock is released, only requests which don't conflict with each
other a woken.
Testing shows that lock-acquisitions-per-second is now fairly stable
even as the number of contending process goes to 1000. Without this
patch, locks-per-second drops off steeply after a few 10s of
processes.
There is a small cost to this extra complexity.
At 20 processes running a particular test on 72 cores, the lock
acquisitions per second drops from 1.8 million to 1.4 million with
this patch. For 100 processes, this patch still provides 1.4 million
while without this patch there are about 700,000.
Reported-and-tested-by: Martin Wilck <mwilck@suse.de>
Signed-off-by: NeilBrown <neilb@suse.com>
Reviewed-by: J. Bruce Fields <bfields@redhat.com>
Signed-off-by: Jeff Layton <jlayton@kernel.org>
2018-11-30 02:04:08 +03:00
struct file_lock * waiter ,
bool conflict ( struct file_lock * ,
struct file_lock * ) )
2013-06-21 16:58:15 +04:00
{
2013-06-21 16:58:20 +04:00
spin_lock ( & blocked_lock_lock ) ;
fs/locks: create a tree of dependent requests.
When we find an existing lock which conflicts with a request,
and the request wants to wait, we currently add the request
to a list. When the lock is removed, the whole list is woken.
This can cause the thundering-herd problem.
To reduce the problem, we make use of the (new) fact that
a pending request can itself have a list of blocked requests.
When we find a conflict, we look through the existing blocked requests.
If any one of them blocks the new request, the new request is attached
below that request, otherwise it is added to the list of blocked
requests, which are now known to be mutually non-conflicting.
This way, when the lock is released, only a set of non-conflicting
locks will be woken, the rest can stay asleep.
If the lock request cannot be granted and the request needs to be
requeued, all the other requests it blocks will then be woken
To make this more concrete:
If you have a many-core machine, and have many threads all wanting to
briefly lock a give file (udev is known to do this), you can get quite
poor performance.
When one thread releases a lock, it wakes up all other threads that
are waiting (classic thundering-herd) - one will get the lock and the
others go to sleep.
When you have few cores, this is not very noticeable: by the time the
4th or 5th thread gets enough CPU time to try to claim the lock, the
earlier threads have claimed it, done what was needed, and released.
So with few cores, many of the threads don't end up contending.
With 50+ cores, lost of threads can get the CPU at the same time,
and the contention can easily be measured.
This patchset creates a tree of pending lock requests in which siblings
don't conflict and each lock request does conflict with its parent.
When a lock is released, only requests which don't conflict with each
other a woken.
Testing shows that lock-acquisitions-per-second is now fairly stable
even as the number of contending process goes to 1000. Without this
patch, locks-per-second drops off steeply after a few 10s of
processes.
There is a small cost to this extra complexity.
At 20 processes running a particular test on 72 cores, the lock
acquisitions per second drops from 1.8 million to 1.4 million with
this patch. For 100 processes, this patch still provides 1.4 million
while without this patch there are about 700,000.
Reported-and-tested-by: Martin Wilck <mwilck@suse.de>
Signed-off-by: NeilBrown <neilb@suse.com>
Reviewed-by: J. Bruce Fields <bfields@redhat.com>
Signed-off-by: Jeff Layton <jlayton@kernel.org>
2018-11-30 02:04:08 +03:00
__locks_insert_block ( blocker , waiter , conflict ) ;
2013-06-21 16:58:20 +04:00
spin_unlock ( & blocked_lock_lock ) ;
2005-04-17 02:20:36 +04:00
}
2013-06-21 16:58:12 +04:00
/*
* Wake up processes blocked waiting for blocker .
*
2015-01-16 23:05:57 +03:00
* Must be called with the inode - > flc_lock held !
2005-04-17 02:20:36 +04:00
*/
static void locks_wake_up_blocks ( struct file_lock * blocker )
{
2013-06-21 16:58:16 +04:00
/*
* Avoid taking global lock if list is empty . This is safe since new
2015-01-16 23:05:57 +03:00
* blocked requests are only added to the list under the flc_lock , and
2018-11-30 02:04:08 +03:00
* the flc_lock is always held here . Note that removal from the
* fl_blocked_requests list does not require the flc_lock , so we must
* recheck list_empty ( ) after acquiring the blocked_lock_lock .
2013-06-21 16:58:16 +04:00
*/
2018-11-30 02:04:08 +03:00
if ( list_empty ( & blocker - > fl_blocked_requests ) )
2013-06-21 16:58:16 +04:00
return ;
2013-06-21 16:58:20 +04:00
spin_lock ( & blocked_lock_lock ) ;
2018-11-30 02:04:08 +03:00
__locks_wake_up_blocks ( blocker ) ;
2013-06-21 16:58:20 +04:00
spin_unlock ( & blocked_lock_lock ) ;
2005-04-17 02:20:36 +04:00
}
2015-01-16 23:05:55 +03:00
static void
2015-02-16 22:32:03 +03:00
locks_insert_lock_ctx ( struct file_lock * fl , struct list_head * before )
2015-01-16 23:05:55 +03:00
{
list_add_tail ( & fl - > fl_list , before ) ;
locks_insert_global_locks ( fl ) ;
}
2015-01-16 23:05:55 +03:00
static void
2015-02-16 22:32:03 +03:00
locks_unlink_lock_ctx ( struct file_lock * fl )
2005-04-17 02:20:36 +04:00
{
2013-06-21 16:58:14 +04:00
locks_delete_global_locks ( fl ) ;
2015-01-16 23:05:55 +03:00
list_del_init ( & fl - > fl_list ) ;
2005-04-17 02:20:36 +04:00
locks_wake_up_blocks ( fl ) ;
2014-02-03 21:13:06 +04:00
}
2015-01-16 23:05:55 +03:00
static void
2015-02-16 22:32:03 +03:00
locks_delete_lock_ctx ( struct file_lock * fl , struct list_head * dispose )
2014-02-03 21:13:06 +04:00
{
2015-02-16 22:32:03 +03:00
locks_unlink_lock_ctx ( fl ) ;
2014-08-11 22:20:31 +04:00
if ( dispose )
2015-01-16 23:05:54 +03:00
list_add ( & fl - > fl_list , dispose ) ;
2014-08-11 22:20:31 +04:00
else
locks_free_lock ( fl ) ;
2005-04-17 02:20:36 +04:00
}
/* Determine if lock sys_fl blocks lock caller_fl. Common functionality
* checks for shared / exclusive status of overlapping locks .
*/
2018-11-30 02:04:08 +03:00
static bool locks_conflict ( struct file_lock * caller_fl ,
struct file_lock * sys_fl )
2005-04-17 02:20:36 +04:00
{
if ( sys_fl - > fl_type = = F_WRLCK )
2018-11-30 02:04:08 +03:00
return true ;
2005-04-17 02:20:36 +04:00
if ( caller_fl - > fl_type = = F_WRLCK )
2018-11-30 02:04:08 +03:00
return true ;
return false ;
2005-04-17 02:20:36 +04:00
}
/* Determine if lock sys_fl blocks lock caller_fl. POSIX specific
* checking before calling the locks_conflict ( ) .
*/
2018-11-30 02:04:08 +03:00
static bool posix_locks_conflict ( struct file_lock * caller_fl ,
struct file_lock * sys_fl )
2005-04-17 02:20:36 +04:00
{
/* POSIX locks owned by the same process do not conflict with
* each other .
*/
2015-04-03 16:04:02 +03:00
if ( posix_same_owner ( caller_fl , sys_fl ) )
2018-11-30 02:04:08 +03:00
return false ;
2005-04-17 02:20:36 +04:00
/* Check whether they overlap */
if ( ! locks_overlap ( caller_fl , sys_fl ) )
2018-11-30 02:04:08 +03:00
return false ;
2005-04-17 02:20:36 +04:00
2018-11-30 02:04:08 +03:00
return locks_conflict ( caller_fl , sys_fl ) ;
2005-04-17 02:20:36 +04:00
}
/* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific
* checking before calling the locks_conflict ( ) .
*/
2018-11-30 02:04:08 +03:00
static bool flock_locks_conflict ( struct file_lock * caller_fl ,
struct file_lock * sys_fl )
2005-04-17 02:20:36 +04:00
{
/* FLOCK locks referring to the same filp do not conflict with
* each other .
*/
2015-04-03 16:04:02 +03:00
if ( caller_fl - > fl_file = = sys_fl - > fl_file )
2018-11-30 02:04:08 +03:00
return false ;
2005-04-17 02:20:36 +04:00
2018-11-30 02:04:08 +03:00
return locks_conflict ( caller_fl , sys_fl ) ;
2005-04-17 02:20:36 +04:00
}
2007-05-12 00:09:32 +04:00
void
2007-02-21 08:55:18 +03:00
posix_test_lock ( struct file * filp , struct file_lock * fl )
2005-04-17 02:20:36 +04:00
{
struct file_lock * cfl ;
2015-01-16 23:05:55 +03:00
struct file_lock_context * ctx ;
2016-09-16 13:44:20 +03:00
struct inode * inode = locks_inode ( filp ) ;
2022-05-03 00:19:25 +03:00
void * owner ;
void ( * func ) ( void ) ;
2005-04-17 02:20:36 +04:00
2015-09-21 10:43:06 +03:00
ctx = smp_load_acquire ( & inode - > i_flctx ) ;
2015-01-16 23:05:55 +03:00
if ( ! ctx | | list_empty_careful ( & ctx - > flc_posix ) ) {
fl - > fl_type = F_UNLCK ;
return ;
}
2022-05-03 00:19:25 +03:00
retry :
2015-01-16 23:05:57 +03:00
spin_lock ( & ctx - > flc_lock ) ;
2015-01-16 23:05:55 +03:00
list_for_each_entry ( cfl , & ctx - > flc_posix , fl_list ) {
2022-05-03 00:19:25 +03:00
if ( ! posix_locks_conflict ( fl , cfl ) )
continue ;
if ( cfl - > fl_lmops & & cfl - > fl_lmops - > lm_lock_expirable
& & ( * cfl - > fl_lmops - > lm_lock_expirable ) ( cfl ) ) {
owner = cfl - > fl_lmops - > lm_mod_owner ;
func = cfl - > fl_lmops - > lm_expire_lock ;
__module_get ( owner ) ;
spin_unlock ( & ctx - > flc_lock ) ;
( * func ) ( ) ;
module_put ( owner ) ;
goto retry ;
2015-01-16 23:05:55 +03:00
}
2022-05-03 00:19:25 +03:00
locks_copy_conflock ( fl , cfl ) ;
goto out ;
2005-04-17 02:20:36 +04:00
}
2015-01-16 23:05:55 +03:00
fl - > fl_type = F_UNLCK ;
out :
2015-01-16 23:05:57 +03:00
spin_unlock ( & ctx - > flc_lock ) ;
2007-05-12 00:09:32 +04:00
return ;
2005-04-17 02:20:36 +04:00
}
EXPORT_SYMBOL ( posix_test_lock ) ;
2007-10-27 02:05:40 +04:00
/*
* Deadlock detection :
*
* We attempt to detect deadlocks that are due purely to posix file
* locks .
2005-04-17 02:20:36 +04:00
*
2007-10-27 02:05:40 +04:00
* We assume that a task can be waiting for at most one lock at a time .
* So for any acquired lock , the process holding that lock may be
* waiting on at most one other lock . That lock in turns may be held by
* someone waiting for at most one other lock . Given a requested lock
* caller_fl which is about to wait for a conflicting lock block_fl , we
* follow this chain of waiters to ensure we are not about to create a
* cycle .
2005-04-17 02:20:36 +04:00
*
2007-10-27 02:05:40 +04:00
* Since we do this before we ever put a process to sleep on a lock , we
* are ensured that there is never a cycle ; that is what guarantees that
* the while ( ) loop in posix_locks_deadlock ( ) eventually completes .
2007-10-30 18:20:02 +03:00
*
2007-10-27 02:05:40 +04:00
* Note : the above assumption may not be true when handling lock
* requests from a broken NFS client . It may also fail in the presence
* of tasks ( such as posix threads ) sharing the same open file table .
* To handle those cases , we just bail out after a few iterations .
2014-02-03 21:13:09 +04:00
*
2014-04-22 16:24:32 +04:00
* For FL_OFDLCK locks , the owner is the filp , not the files_struct .
2014-02-03 21:13:09 +04:00
* Because the owner is not even nominally tied to a thread of
* execution , the deadlock detection below can ' t reasonably work well . Just
* skip it for those .
*
2014-04-22 16:24:32 +04:00
* In principle , we could do a more limited deadlock detection on FL_OFDLCK
2014-02-03 21:13:09 +04:00
* locks that just checks for the case where two tasks are attempting to
* upgrade from read to write locks on the same inode .
2005-04-17 02:20:36 +04:00
*/
2007-10-30 18:20:02 +03:00
# define MAX_DEADLK_ITERATIONS 10
2007-10-27 02:05:40 +04:00
/* Find a lock that the owner of the given block_fl is blocking on. */
static struct file_lock * what_owner_is_waiting_for ( struct file_lock * block_fl )
{
struct file_lock * fl ;
2013-06-21 16:58:19 +04:00
hash_for_each_possible ( blocked_hash , fl , fl_link , posix_owner_key ( block_fl ) ) {
2018-11-30 02:04:08 +03:00
if ( posix_same_owner ( fl , block_fl ) ) {
while ( fl - > fl_blocker )
fl = fl - > fl_blocker ;
return fl ;
}
2007-10-27 02:05:40 +04:00
}
return NULL ;
}
2013-06-21 16:58:20 +04:00
/* Must be called with the blocked_lock_lock held! */
2006-06-23 13:05:13 +04:00
static int posix_locks_deadlock ( struct file_lock * caller_fl ,
2005-04-17 02:20:36 +04:00
struct file_lock * block_fl )
{
2007-10-30 18:20:02 +03:00
int i = 0 ;
2005-04-17 02:20:36 +04:00
2015-04-03 16:04:03 +03:00
lockdep_assert_held ( & blocked_lock_lock ) ;
2014-02-03 21:13:09 +04:00
/*
* This deadlock detector can ' t reasonably detect deadlocks with
2014-04-22 16:24:32 +04:00
* FL_OFDLCK locks , since they aren ' t owned by a process , per - se .
2014-02-03 21:13:09 +04:00
*/
2014-04-22 16:24:32 +04:00
if ( IS_OFDLCK ( caller_fl ) )
2014-02-03 21:13:09 +04:00
return 0 ;
2007-10-27 02:05:40 +04:00
while ( ( block_fl = what_owner_is_waiting_for ( block_fl ) ) ) {
if ( i + + > MAX_DEADLK_ITERATIONS )
return 0 ;
if ( posix_same_owner ( caller_fl , block_fl ) )
return 1 ;
2005-04-17 02:20:36 +04:00
}
return 0 ;
}
/* Try to create a FLOCK lock on filp. We always insert new FLOCK locks
2007-09-12 23:45:07 +04:00
* after any leases , but before any posix locks .
2006-06-30 00:38:32 +04:00
*
* Note that if called with an FL_EXISTS argument , the caller may determine
* whether or not a lock was successfully freed by testing the return
* value for - ENOENT .
2005-04-17 02:20:36 +04:00
*/
2015-07-11 13:43:02 +03:00
static int flock_lock_inode ( struct inode * inode , struct file_lock * request )
2005-04-17 02:20:36 +04:00
{
2006-03-31 14:30:55 +04:00
struct file_lock * new_fl = NULL ;
2015-01-16 23:05:55 +03:00
struct file_lock * fl ;
struct file_lock_context * ctx ;
2005-04-17 02:20:36 +04:00
int error = 0 ;
2015-01-16 23:05:55 +03:00
bool found = false ;
2014-08-11 22:20:31 +04:00
LIST_HEAD ( dispose ) ;
2005-04-17 02:20:36 +04:00
2015-04-03 16:04:03 +03:00
ctx = locks_get_lock_context ( inode , request - > fl_type ) ;
if ( ! ctx ) {
if ( request - > fl_type ! = F_UNLCK )
return - ENOMEM ;
return ( request - > fl_flags & FL_EXISTS ) ? - ENOENT : 0 ;
}
2015-01-16 23:05:55 +03:00
2010-09-18 17:09:31 +04:00
if ( ! ( request - > fl_flags & FL_ACCESS ) & & ( request - > fl_type ! = F_UNLCK ) ) {
2007-09-11 16:38:13 +04:00
new_fl = locks_alloc_lock ( ) ;
2010-09-18 17:09:31 +04:00
if ( ! new_fl )
return - ENOMEM ;
2007-09-11 16:38:13 +04:00
}
2019-02-21 17:38:40 +03:00
percpu_down_read ( & file_rwsem ) ;
2015-01-16 23:05:57 +03:00
spin_lock ( & ctx - > flc_lock ) ;
2010-09-18 17:09:31 +04:00
if ( request - > fl_flags & FL_ACCESS )
goto find_conflict ;
2015-01-16 23:05:55 +03:00
list_for_each_entry ( fl , & ctx - > flc_flock , fl_list ) {
2015-07-11 13:43:02 +03:00
if ( request - > fl_file ! = fl - > fl_file )
2005-04-17 02:20:36 +04:00
continue ;
2006-03-31 14:30:55 +04:00
if ( request - > fl_type = = fl - > fl_type )
2005-04-17 02:20:36 +04:00
goto out ;
2015-01-16 23:05:55 +03:00
found = true ;
2015-02-16 22:32:03 +03:00
locks_delete_lock_ctx ( fl , & dispose ) ;
2005-04-17 02:20:36 +04:00
break ;
}
2006-06-30 00:38:32 +04:00
if ( request - > fl_type = = F_UNLCK ) {
if ( ( request - > fl_flags & FL_EXISTS ) & & ! found )
error = - ENOENT ;
2006-03-31 14:30:55 +04:00
goto out ;
2006-06-30 00:38:32 +04:00
}
2005-04-17 02:20:36 +04:00
2006-06-30 00:38:37 +04:00
find_conflict :
2015-01-16 23:05:55 +03:00
list_for_each_entry ( fl , & ctx - > flc_flock , fl_list ) {
2006-03-31 14:30:55 +04:00
if ( ! flock_locks_conflict ( request , fl ) )
2005-04-17 02:20:36 +04:00
continue ;
error = - EAGAIN ;
2008-07-25 12:48:57 +04:00
if ( ! ( request - > fl_flags & FL_SLEEP ) )
goto out ;
error = FILE_LOCK_DEFERRED ;
fs/locks: create a tree of dependent requests.
When we find an existing lock which conflicts with a request,
and the request wants to wait, we currently add the request
to a list. When the lock is removed, the whole list is woken.
This can cause the thundering-herd problem.
To reduce the problem, we make use of the (new) fact that
a pending request can itself have a list of blocked requests.
When we find a conflict, we look through the existing blocked requests.
If any one of them blocks the new request, the new request is attached
below that request, otherwise it is added to the list of blocked
requests, which are now known to be mutually non-conflicting.
This way, when the lock is released, only a set of non-conflicting
locks will be woken, the rest can stay asleep.
If the lock request cannot be granted and the request needs to be
requeued, all the other requests it blocks will then be woken
To make this more concrete:
If you have a many-core machine, and have many threads all wanting to
briefly lock a give file (udev is known to do this), you can get quite
poor performance.
When one thread releases a lock, it wakes up all other threads that
are waiting (classic thundering-herd) - one will get the lock and the
others go to sleep.
When you have few cores, this is not very noticeable: by the time the
4th or 5th thread gets enough CPU time to try to claim the lock, the
earlier threads have claimed it, done what was needed, and released.
So with few cores, many of the threads don't end up contending.
With 50+ cores, lost of threads can get the CPU at the same time,
and the contention can easily be measured.
This patchset creates a tree of pending lock requests in which siblings
don't conflict and each lock request does conflict with its parent.
When a lock is released, only requests which don't conflict with each
other a woken.
Testing shows that lock-acquisitions-per-second is now fairly stable
even as the number of contending process goes to 1000. Without this
patch, locks-per-second drops off steeply after a few 10s of
processes.
There is a small cost to this extra complexity.
At 20 processes running a particular test on 72 cores, the lock
acquisitions per second drops from 1.8 million to 1.4 million with
this patch. For 100 processes, this patch still provides 1.4 million
while without this patch there are about 700,000.
Reported-and-tested-by: Martin Wilck <mwilck@suse.de>
Signed-off-by: NeilBrown <neilb@suse.com>
Reviewed-by: J. Bruce Fields <bfields@redhat.com>
Signed-off-by: Jeff Layton <jlayton@kernel.org>
2018-11-30 02:04:08 +03:00
locks_insert_block ( fl , request , flock_locks_conflict ) ;
2005-04-17 02:20:36 +04:00
goto out ;
}
2006-06-30 00:38:37 +04:00
if ( request - > fl_flags & FL_ACCESS )
goto out ;
2006-03-31 14:30:55 +04:00
locks_copy_lock ( new_fl , request ) ;
2018-11-30 02:04:08 +03:00
locks_move_blocks ( new_fl , request ) ;
2015-02-16 22:32:03 +03:00
locks_insert_lock_ctx ( new_fl , & ctx - > flc_flock ) ;
2006-03-31 14:30:55 +04:00
new_fl = NULL ;
2006-06-14 17:59:35 +04:00
error = 0 ;
2005-04-17 02:20:36 +04:00
out :
2015-01-16 23:05:57 +03:00
spin_unlock ( & ctx - > flc_lock ) ;
2019-02-21 17:38:40 +03:00
percpu_up_read ( & file_rwsem ) ;
2006-03-31 14:30:55 +04:00
if ( new_fl )
locks_free_lock ( new_fl ) ;
2014-08-11 22:20:31 +04:00
locks_dispose_list ( & dispose ) ;
2018-07-30 14:54:56 +03:00
trace_flock_lock_inode ( inode , request , error ) ;
2005-04-17 02:20:36 +04:00
return error ;
}
2016-01-08 02:27:42 +03:00
static int posix_lock_inode ( struct inode * inode , struct file_lock * request ,
struct file_lock * conflock )
2005-04-17 02:20:36 +04:00
{
2015-01-16 23:05:55 +03:00
struct file_lock * fl , * tmp ;
2006-06-23 13:05:10 +04:00
struct file_lock * new_fl = NULL ;
struct file_lock * new_fl2 = NULL ;
2005-04-17 02:20:36 +04:00
struct file_lock * left = NULL ;
struct file_lock * right = NULL ;
2015-01-16 23:05:55 +03:00
struct file_lock_context * ctx ;
2013-06-21 16:58:13 +04:00
int error ;
bool added = false ;
2014-08-11 22:20:31 +04:00
LIST_HEAD ( dispose ) ;
2022-05-03 00:19:25 +03:00
void * owner ;
void ( * func ) ( void ) ;
2005-04-17 02:20:36 +04:00
2015-04-03 16:04:03 +03:00
ctx = locks_get_lock_context ( inode , request - > fl_type ) ;
2015-01-16 23:05:55 +03:00
if ( ! ctx )
2015-04-03 16:04:03 +03:00
return ( request - > fl_type = = F_UNLCK ) ? 0 : - ENOMEM ;
2015-01-16 23:05:55 +03:00
2005-04-17 02:20:36 +04:00
/*
* We may need two file_lock structures for this operation ,
* so we get them in advance to avoid races .
2006-06-23 13:05:10 +04:00
*
* In some cases we can be sure , that no new locks will be needed
2005-04-17 02:20:36 +04:00
*/
2006-06-23 13:05:10 +04:00
if ( ! ( request - > fl_flags & FL_ACCESS ) & &
( request - > fl_type ! = F_UNLCK | |
request - > fl_start ! = 0 | | request - > fl_end ! = OFFSET_MAX ) ) {
new_fl = locks_alloc_lock ( ) ;
new_fl2 = locks_alloc_lock ( ) ;
}
2005-04-17 02:20:36 +04:00
2022-05-03 00:19:25 +03:00
retry :
2019-02-21 17:38:40 +03:00
percpu_down_read ( & file_rwsem ) ;
2015-01-16 23:05:57 +03:00
spin_lock ( & ctx - > flc_lock ) ;
2013-06-21 16:58:12 +04:00
/*
* New lock request . Walk all POSIX locks and look for conflicts . If
* there are any , either return error or put the request on the
2013-06-21 16:58:18 +04:00
* blocker ' s list of waiters and the global blocked_hash .
2013-06-21 16:58:12 +04:00
*/
2005-04-17 02:20:36 +04:00
if ( request - > fl_type ! = F_UNLCK ) {
2015-01-16 23:05:55 +03:00
list_for_each_entry ( fl , & ctx - > flc_posix , fl_list ) {
2005-04-17 02:20:36 +04:00
if ( ! posix_locks_conflict ( request , fl ) )
continue ;
2022-05-03 00:19:25 +03:00
if ( fl - > fl_lmops & & fl - > fl_lmops - > lm_lock_expirable
& & ( * fl - > fl_lmops - > lm_lock_expirable ) ( fl ) ) {
owner = fl - > fl_lmops - > lm_mod_owner ;
func = fl - > fl_lmops - > lm_expire_lock ;
__module_get ( owner ) ;
spin_unlock ( & ctx - > flc_lock ) ;
percpu_up_read ( & file_rwsem ) ;
( * func ) ( ) ;
module_put ( owner ) ;
goto retry ;
}
2006-03-26 13:37:26 +04:00
if ( conflock )
2014-08-22 18:18:42 +04:00
locks_copy_conflock ( conflock , fl ) ;
2005-04-17 02:20:36 +04:00
error = - EAGAIN ;
if ( ! ( request - > fl_flags & FL_SLEEP ) )
goto out ;
2013-06-21 16:58:15 +04:00
/*
* Deadlock detection and insertion into the blocked
* locks list must be done while holding the same lock !
*/
2005-04-17 02:20:36 +04:00
error = - EDEADLK ;
2013-06-21 16:58:20 +04:00
spin_lock ( & blocked_lock_lock ) ;
2019-03-25 15:15:14 +03:00
/*
* Ensure that we don ' t find any locks blocked on this
* request during deadlock detection .
*/
__locks_wake_up_blocks ( request ) ;
2013-06-21 16:58:15 +04:00
if ( likely ( ! posix_locks_deadlock ( request , fl ) ) ) {
error = FILE_LOCK_DEFERRED ;
fs/locks: create a tree of dependent requests.
When we find an existing lock which conflicts with a request,
and the request wants to wait, we currently add the request
to a list. When the lock is removed, the whole list is woken.
This can cause the thundering-herd problem.
To reduce the problem, we make use of the (new) fact that
a pending request can itself have a list of blocked requests.
When we find a conflict, we look through the existing blocked requests.
If any one of them blocks the new request, the new request is attached
below that request, otherwise it is added to the list of blocked
requests, which are now known to be mutually non-conflicting.
This way, when the lock is released, only a set of non-conflicting
locks will be woken, the rest can stay asleep.
If the lock request cannot be granted and the request needs to be
requeued, all the other requests it blocks will then be woken
To make this more concrete:
If you have a many-core machine, and have many threads all wanting to
briefly lock a give file (udev is known to do this), you can get quite
poor performance.
When one thread releases a lock, it wakes up all other threads that
are waiting (classic thundering-herd) - one will get the lock and the
others go to sleep.
When you have few cores, this is not very noticeable: by the time the
4th or 5th thread gets enough CPU time to try to claim the lock, the
earlier threads have claimed it, done what was needed, and released.
So with few cores, many of the threads don't end up contending.
With 50+ cores, lost of threads can get the CPU at the same time,
and the contention can easily be measured.
This patchset creates a tree of pending lock requests in which siblings
don't conflict and each lock request does conflict with its parent.
When a lock is released, only requests which don't conflict with each
other a woken.
Testing shows that lock-acquisitions-per-second is now fairly stable
even as the number of contending process goes to 1000. Without this
patch, locks-per-second drops off steeply after a few 10s of
processes.
There is a small cost to this extra complexity.
At 20 processes running a particular test on 72 cores, the lock
acquisitions per second drops from 1.8 million to 1.4 million with
this patch. For 100 processes, this patch still provides 1.4 million
while without this patch there are about 700,000.
Reported-and-tested-by: Martin Wilck <mwilck@suse.de>
Signed-off-by: NeilBrown <neilb@suse.com>
Reviewed-by: J. Bruce Fields <bfields@redhat.com>
Signed-off-by: Jeff Layton <jlayton@kernel.org>
2018-11-30 02:04:08 +03:00
__locks_insert_block ( fl , request ,
posix_locks_conflict ) ;
2013-06-21 16:58:15 +04:00
}
2013-06-21 16:58:20 +04:00
spin_unlock ( & blocked_lock_lock ) ;
2005-04-17 02:20:36 +04:00
goto out ;
2018-11-30 02:04:08 +03:00
}
}
2005-04-17 02:20:36 +04:00
/* If we're just looking for a conflict, we're done. */
error = 0 ;
if ( request - > fl_flags & FL_ACCESS )
goto out ;
2015-01-16 23:05:55 +03:00
/* Find the first old lock with the same owner as the new lock */
list_for_each_entry ( fl , & ctx - > flc_posix , fl_list ) {
if ( posix_same_owner ( request , fl ) )
break ;
2005-04-17 02:20:36 +04:00
}
2013-06-21 16:58:12 +04:00
/* Process locks with this owner. */
2015-01-16 23:05:55 +03:00
list_for_each_entry_safe_from ( fl , tmp , & ctx - > flc_posix , fl_list ) {
if ( ! posix_same_owner ( request , fl ) )
break ;
/* Detect adjacent or overlapping regions (if same lock type) */
2005-04-17 02:20:36 +04:00
if ( request - > fl_type = = fl - > fl_type ) {
2005-08-26 03:25:35 +04:00
/* In all comparisons of start vs end, use
* " start - 1 " rather than " end + 1 " . If end
* is OFFSET_MAX , end + 1 will become negative .
*/
2005-04-17 02:20:36 +04:00
if ( fl - > fl_end < request - > fl_start - 1 )
2015-01-16 23:05:55 +03:00
continue ;
2005-04-17 02:20:36 +04:00
/* If the next lock in the list has entirely bigger
* addresses than the new one , insert the lock here .
*/
2005-08-26 03:25:35 +04:00
if ( fl - > fl_start - 1 > request - > fl_end )
2005-04-17 02:20:36 +04:00
break ;
/* If we come here, the new and old lock are of the
* same type and adjacent or overlapping . Make one
* lock yielding from the lower start address of both
* locks to the higher end address .
*/
if ( fl - > fl_start > request - > fl_start )
fl - > fl_start = request - > fl_start ;
else
request - > fl_start = fl - > fl_start ;
if ( fl - > fl_end < request - > fl_end )
fl - > fl_end = request - > fl_end ;
else
request - > fl_end = fl - > fl_end ;
if ( added ) {
2015-02-16 22:32:03 +03:00
locks_delete_lock_ctx ( fl , & dispose ) ;
2005-04-17 02:20:36 +04:00
continue ;
}
request = fl ;
2013-06-21 16:58:13 +04:00
added = true ;
2015-01-16 23:05:55 +03:00
} else {
2005-04-17 02:20:36 +04:00
/* Processing for different lock types is a bit
* more complex .
*/
if ( fl - > fl_end < request - > fl_start )
2015-01-16 23:05:55 +03:00
continue ;
2005-04-17 02:20:36 +04:00
if ( fl - > fl_start > request - > fl_end )
break ;
if ( request - > fl_type = = F_UNLCK )
2013-06-21 16:58:13 +04:00
added = true ;
2005-04-17 02:20:36 +04:00
if ( fl - > fl_start < request - > fl_start )
left = fl ;
/* If the next lock in the list has a higher end
* address than the new one , insert the new one here .
*/
if ( fl - > fl_end > request - > fl_end ) {
right = fl ;
break ;
}
if ( fl - > fl_start > = request - > fl_start ) {
/* The new lock completely replaces an old
* one ( This may happen several times ) .
*/
if ( added ) {
2015-02-16 22:32:03 +03:00
locks_delete_lock_ctx ( fl , & dispose ) ;
2005-04-17 02:20:36 +04:00
continue ;
}
2014-08-12 16:03:49 +04:00
/*
* Replace the old lock with new_fl , and
* remove the old one . It ' s safe to do the
* insert here since we know that we won ' t be
* using new_fl later , and that the lock is
* just replacing an existing lock .
2005-04-17 02:20:36 +04:00
*/
2014-08-12 16:03:49 +04:00
error = - ENOLCK ;
if ( ! new_fl )
goto out ;
locks_copy_lock ( new_fl , request ) ;
2020-06-01 12:16:16 +03:00
locks_move_blocks ( new_fl , request ) ;
2014-08-12 16:03:49 +04:00
request = new_fl ;
new_fl = NULL ;
2015-02-16 22:32:03 +03:00
locks_insert_lock_ctx ( request , & fl - > fl_list ) ;
locks_delete_lock_ctx ( fl , & dispose ) ;
2013-06-21 16:58:13 +04:00
added = true ;
2005-04-17 02:20:36 +04:00
}
}
}
2006-06-23 13:05:09 +04:00
/*
2013-06-21 16:58:12 +04:00
* The above code only modifies existing locks in case of merging or
* replacing . If new lock ( s ) need to be inserted all modifications are
* done below this , so it ' s safe yet to bail out .
2006-06-23 13:05:09 +04:00
*/
error = - ENOLCK ; /* "no luck" */
if ( right & & left = = right & & ! new_fl2 )
goto out ;
2005-04-17 02:20:36 +04:00
error = 0 ;
if ( ! added ) {
2006-06-30 00:38:32 +04:00
if ( request - > fl_type = = F_UNLCK ) {
if ( request - > fl_flags & FL_EXISTS )
error = - ENOENT ;
2005-04-17 02:20:36 +04:00
goto out ;
2006-06-30 00:38:32 +04:00
}
2006-06-23 13:05:09 +04:00
if ( ! new_fl ) {
error = - ENOLCK ;
goto out ;
}
2005-04-17 02:20:36 +04:00
locks_copy_lock ( new_fl , request ) ;
2018-11-30 02:04:08 +03:00
locks_move_blocks ( new_fl , request ) ;
2015-02-16 22:32:03 +03:00
locks_insert_lock_ctx ( new_fl , & fl - > fl_list ) ;
2015-02-18 01:08:23 +03:00
fl = new_fl ;
2005-04-17 02:20:36 +04:00
new_fl = NULL ;
}
if ( right ) {
if ( left = = right ) {
/* The new lock breaks the old one in two pieces,
* so we have to use the second new lock .
*/
left = new_fl2 ;
new_fl2 = NULL ;
locks_copy_lock ( left , right ) ;
2015-02-16 22:32:03 +03:00
locks_insert_lock_ctx ( left , & fl - > fl_list ) ;
2005-04-17 02:20:36 +04:00
}
right - > fl_start = request - > fl_end + 1 ;
locks_wake_up_blocks ( right ) ;
}
if ( left ) {
left - > fl_end = request - > fl_start - 1 ;
locks_wake_up_blocks ( left ) ;
}
out :
2015-01-16 23:05:57 +03:00
spin_unlock ( & ctx - > flc_lock ) ;
2019-02-21 17:38:40 +03:00
percpu_up_read ( & file_rwsem ) ;
2005-04-17 02:20:36 +04:00
/*
* Free any unused locks .
*/
if ( new_fl )
locks_free_lock ( new_fl ) ;
if ( new_fl2 )
locks_free_lock ( new_fl2 ) ;
2014-08-11 22:20:31 +04:00
locks_dispose_list ( & dispose ) ;
2016-01-07 05:26:10 +03:00
trace_posix_lock_inode ( inode , request , error ) ;
2005-04-17 02:20:36 +04:00
return error ;
}
/**
* posix_lock_file - Apply a POSIX - style lock to a file
* @ filp : The file to apply the lock to
* @ fl : The lock to be applied
2007-01-19 00:15:35 +03:00
* @ conflock : Place to return a copy of the conflicting lock , if found .
2005-04-17 02:20:36 +04:00
*
* Add a POSIX style lock to a file .
* We merge adjacent & overlapping locks whenever possible .
* POSIX locks are sorted by owner task , then by starting address
2006-06-30 00:38:32 +04:00
*
* Note that if called with an FL_EXISTS argument , the caller may determine
* whether or not a lock was successfully freed by testing the return
* value for - ENOENT .
2005-04-17 02:20:36 +04:00
*/
2007-01-19 00:15:35 +03:00
int posix_lock_file ( struct file * filp , struct file_lock * fl ,
2006-03-26 13:37:26 +04:00
struct file_lock * conflock )
{
2016-09-16 13:44:20 +03:00
return posix_lock_inode ( locks_inode ( filp ) , fl , conflock ) ;
2005-04-17 02:20:36 +04:00
}
2007-01-19 00:15:35 +03:00
EXPORT_SYMBOL ( posix_lock_file ) ;
2005-04-17 02:20:36 +04:00
/**
2015-07-11 13:43:02 +03:00
* posix_lock_inode_wait - Apply a POSIX - style lock to a file
* @ inode : inode of file to which lock request should be applied
2005-04-17 02:20:36 +04:00
* @ fl : The lock to be applied
*
2015-10-22 20:38:15 +03:00
* Apply a POSIX style lock request to an inode .
2005-04-17 02:20:36 +04:00
*/
2015-10-22 20:38:15 +03:00
static int posix_lock_inode_wait ( struct inode * inode , struct file_lock * fl )
2005-04-17 02:20:36 +04:00
{
int error ;
might_sleep ( ) ;
for ( ; ; ) {
2016-01-08 02:27:42 +03:00
error = posix_lock_inode ( inode , fl , NULL ) ;
2008-07-25 12:48:57 +04:00
if ( error ! = FILE_LOCK_DEFERRED )
2005-04-17 02:20:36 +04:00
break ;
2020-03-18 14:52:21 +03:00
error = wait_event_interruptible ( fl - > fl_wait ,
list_empty ( & fl - > fl_blocked_member ) ) ;
2018-11-30 02:04:08 +03:00
if ( error )
break ;
2005-04-17 02:20:36 +04:00
}
2018-11-30 02:04:08 +03:00
locks_delete_block ( fl ) ;
2005-04-17 02:20:36 +04:00
return error ;
}
2015-07-11 13:43:02 +03:00
2011-07-27 02:25:49 +04:00
static void lease_clear_pending ( struct file_lock * fl , int arg )
{
switch ( arg ) {
case F_UNLCK :
fl - > fl_flags & = ~ FL_UNLOCK_PENDING ;
2020-08-24 01:36:59 +03:00
fallthrough ;
2011-07-27 02:25:49 +04:00
case F_RDLCK :
fl - > fl_flags & = ~ FL_DOWNGRADE_PENDING ;
}
}
2005-04-17 02:20:36 +04:00
/* We already had a lease on this file; just change its type */
2015-01-16 23:05:57 +03:00
int lease_modify ( struct file_lock * fl , int arg , struct list_head * dispose )
2005-04-17 02:20:36 +04:00
{
int error = assign_type ( fl , arg ) ;
if ( error )
return error ;
2011-07-27 02:25:49 +04:00
lease_clear_pending ( fl , arg ) ;
2005-04-17 02:20:36 +04:00
locks_wake_up_blocks ( fl ) ;
2012-07-27 08:42:52 +04:00
if ( arg = = F_UNLCK ) {
struct file * filp = fl - > fl_file ;
f_delown ( filp ) ;
filp - > f_owner . signum = 0 ;
2012-07-28 00:18:00 +04:00
fasync_helper ( 0 , fl - > fl_file , 0 , & fl - > fl_fasync ) ;
if ( fl - > fl_fasync ! = NULL ) {
printk ( KERN_ERR " locks_delete_lock: fasync == %p \n " , fl - > fl_fasync ) ;
fl - > fl_fasync = NULL ;
}
2015-02-16 22:32:03 +03:00
locks_delete_lock_ctx ( fl , dispose ) ;
2012-07-27 08:42:52 +04:00
}
2005-04-17 02:20:36 +04:00
return 0 ;
}
EXPORT_SYMBOL ( lease_modify ) ;
2011-07-27 02:25:49 +04:00
static bool past_time ( unsigned long then )
{
if ( ! then )
/* 0 is a special value meaning "this never expires": */
return false ;
return time_after ( jiffies , then ) ;
}
2014-09-01 15:12:07 +04:00
static void time_out_leases ( struct inode * inode , struct list_head * dispose )
2005-04-17 02:20:36 +04:00
{
2015-01-16 23:05:55 +03:00
struct file_lock_context * ctx = inode - > i_flctx ;
struct file_lock * fl , * tmp ;
2005-04-17 02:20:36 +04:00
2015-01-16 23:05:57 +03:00
lockdep_assert_held ( & ctx - > flc_lock ) ;
2014-08-23 02:50:48 +04:00
2015-01-16 23:05:55 +03:00
list_for_each_entry_safe ( fl , tmp , & ctx - > flc_lease , fl_list ) {
2014-05-09 22:13:05 +04:00
trace_time_out_leases ( inode , fl ) ;
2011-07-27 02:25:49 +04:00
if ( past_time ( fl - > fl_downgrade_time ) )
2015-01-16 23:05:57 +03:00
lease_modify ( fl , F_RDLCK , dispose ) ;
2011-07-27 02:25:49 +04:00
if ( past_time ( fl - > fl_break_time ) )
2015-01-16 23:05:57 +03:00
lease_modify ( fl , F_UNLCK , dispose ) ;
2005-04-17 02:20:36 +04:00
}
}
2012-03-05 22:18:59 +04:00
static bool leases_conflict ( struct file_lock * lease , struct file_lock * breaker )
{
2019-06-06 04:45:34 +03:00
bool rc ;
2017-07-28 23:35:15 +03:00
if ( lease - > fl_lmops - > lm_breaker_owns_lease
& & lease - > fl_lmops - > lm_breaker_owns_lease ( lease ) )
return false ;
2019-06-06 04:45:34 +03:00
if ( ( breaker - > fl_flags & FL_LAYOUT ) ! = ( lease - > fl_flags & FL_LAYOUT ) ) {
rc = false ;
goto trace ;
}
if ( ( breaker - > fl_flags & FL_DELEG ) & & ( lease - > fl_flags & FL_LEASE ) ) {
rc = false ;
goto trace ;
}
rc = locks_conflict ( breaker , lease ) ;
trace :
trace_leases_conflict ( rc , lease , breaker ) ;
return rc ;
2012-03-05 22:18:59 +04:00
}
2014-09-01 22:53:41 +04:00
static bool
any_leases_conflict ( struct inode * inode , struct file_lock * breaker )
{
2015-01-16 23:05:55 +03:00
struct file_lock_context * ctx = inode - > i_flctx ;
2014-09-01 22:53:41 +04:00
struct file_lock * fl ;
2015-01-16 23:05:57 +03:00
lockdep_assert_held ( & ctx - > flc_lock ) ;
2014-09-01 22:53:41 +04:00
2015-01-16 23:05:55 +03:00
list_for_each_entry ( fl , & ctx - > flc_lease , fl_list ) {
2014-09-01 22:53:41 +04:00
if ( leases_conflict ( fl , breaker ) )
return true ;
}
return false ;
}
2005-04-17 02:20:36 +04:00
/**
* __break_lease - revoke all outstanding leases on file
* @ inode : the inode of the file to return
2012-03-05 22:18:59 +04:00
* @ mode : O_RDONLY : break only write leases ; O_WRONLY or O_RDWR :
* break all leases
* @ type : FL_LEASE : break leases and delegations ; FL_DELEG : break
* only delegations
2005-04-17 02:20:36 +04:00
*
2007-05-10 00:10:27 +04:00
* break_lease ( inlined for speed ) has checked there already is at least
* some kind of lock ( maybe a lease ) on this file . Leases are broken on
* a call to open ( ) or truncate ( ) . This function can sleep unless you
2005-04-17 02:20:36 +04:00
* specified % O_NONBLOCK to your open ( ) .
*/
2012-03-05 22:18:59 +04:00
int __break_lease ( struct inode * inode , unsigned int mode , unsigned int type )
2005-04-17 02:20:36 +04:00
{
2011-07-27 02:25:49 +04:00
int error = 0 ;
2015-09-21 10:43:06 +03:00
struct file_lock_context * ctx ;
2015-03-27 05:34:20 +03:00
struct file_lock * new_fl , * fl , * tmp ;
2005-04-17 02:20:36 +04:00
unsigned long break_time ;
2009-12-24 14:47:55 +03:00
int want_write = ( mode & O_ACCMODE ) ! = O_RDONLY ;
2014-09-01 15:12:07 +04:00
LIST_HEAD ( dispose ) ;
2005-04-17 02:20:36 +04:00
2009-12-24 14:47:55 +03:00
new_fl = lease_alloc ( NULL , want_write ? F_WRLCK : F_RDLCK ) ;
2011-12-26 22:25:26 +04:00
if ( IS_ERR ( new_fl ) )
return PTR_ERR ( new_fl ) ;
2012-03-05 22:18:59 +04:00
new_fl - > fl_flags = type ;
2005-04-17 02:20:36 +04:00
2015-01-16 23:05:55 +03:00
/* typically we will check that ctx is non-NULL before calling */
2015-09-21 10:43:06 +03:00
ctx = smp_load_acquire ( & inode - > i_flctx ) ;
2015-01-16 23:05:55 +03:00
if ( ! ctx ) {
WARN_ON_ONCE ( 1 ) ;
2019-08-20 02:47:34 +03:00
goto free_lock ;
2015-01-16 23:05:55 +03:00
}
2019-02-21 17:38:40 +03:00
percpu_down_read ( & file_rwsem ) ;
2015-01-16 23:05:57 +03:00
spin_lock ( & ctx - > flc_lock ) ;
2005-04-17 02:20:36 +04:00
2014-09-01 15:12:07 +04:00
time_out_leases ( inode , & dispose ) ;
2005-04-17 02:20:36 +04:00
2014-09-01 22:53:41 +04:00
if ( ! any_leases_conflict ( inode , new_fl ) )
2011-07-27 02:25:49 +04:00
goto out ;
2005-04-17 02:20:36 +04:00
break_time = 0 ;
if ( lease_break_time > 0 ) {
break_time = jiffies + lease_break_time * HZ ;
if ( break_time = = 0 )
break_time + + ; /* so that 0 means no break time */
}
2015-03-27 05:34:20 +03:00
list_for_each_entry_safe ( fl , tmp , & ctx - > flc_lease , fl_list ) {
2012-03-05 22:18:59 +04:00
if ( ! leases_conflict ( fl , new_fl ) )
continue ;
2011-07-27 02:25:49 +04:00
if ( want_write ) {
if ( fl - > fl_flags & FL_UNLOCK_PENDING )
continue ;
fl - > fl_flags | = FL_UNLOCK_PENDING ;
2005-04-17 02:20:36 +04:00
fl - > fl_break_time = break_time ;
2011-07-27 02:25:49 +04:00
} else {
2015-01-16 23:05:55 +03:00
if ( lease_breaking ( fl ) )
2011-07-27 02:25:49 +04:00
continue ;
fl - > fl_flags | = FL_DOWNGRADE_PENDING ;
fl - > fl_downgrade_time = break_time ;
2005-04-17 02:20:36 +04:00
}
2014-09-01 23:06:54 +04:00
if ( fl - > fl_lmops - > lm_break ( fl ) )
2015-02-16 22:32:03 +03:00
locks_delete_lock_ctx ( fl , & dispose ) ;
2005-04-17 02:20:36 +04:00
}
2015-01-16 23:05:55 +03:00
if ( list_empty ( & ctx - > flc_lease ) )
2014-09-01 23:06:54 +04:00
goto out ;
2014-09-01 22:27:43 +04:00
if ( mode & O_NONBLOCK ) {
2014-05-09 22:13:05 +04:00
trace_break_lease_noblock ( inode , new_fl ) ;
2005-04-17 02:20:36 +04:00
error = - EWOULDBLOCK ;
goto out ;
}
restart :
2015-01-16 23:05:55 +03:00
fl = list_first_entry ( & ctx - > flc_lease , struct file_lock , fl_list ) ;
break_time = fl - > fl_break_time ;
2014-04-15 14:17:49 +04:00
if ( break_time ! = 0 )
2005-04-17 02:20:36 +04:00
break_time - = jiffies ;
2014-04-15 14:17:49 +04:00
if ( break_time = = 0 )
break_time + + ;
fs/locks: create a tree of dependent requests.
When we find an existing lock which conflicts with a request,
and the request wants to wait, we currently add the request
to a list. When the lock is removed, the whole list is woken.
This can cause the thundering-herd problem.
To reduce the problem, we make use of the (new) fact that
a pending request can itself have a list of blocked requests.
When we find a conflict, we look through the existing blocked requests.
If any one of them blocks the new request, the new request is attached
below that request, otherwise it is added to the list of blocked
requests, which are now known to be mutually non-conflicting.
This way, when the lock is released, only a set of non-conflicting
locks will be woken, the rest can stay asleep.
If the lock request cannot be granted and the request needs to be
requeued, all the other requests it blocks will then be woken
To make this more concrete:
If you have a many-core machine, and have many threads all wanting to
briefly lock a give file (udev is known to do this), you can get quite
poor performance.
When one thread releases a lock, it wakes up all other threads that
are waiting (classic thundering-herd) - one will get the lock and the
others go to sleep.
When you have few cores, this is not very noticeable: by the time the
4th or 5th thread gets enough CPU time to try to claim the lock, the
earlier threads have claimed it, done what was needed, and released.
So with few cores, many of the threads don't end up contending.
With 50+ cores, lost of threads can get the CPU at the same time,
and the contention can easily be measured.
This patchset creates a tree of pending lock requests in which siblings
don't conflict and each lock request does conflict with its parent.
When a lock is released, only requests which don't conflict with each
other a woken.
Testing shows that lock-acquisitions-per-second is now fairly stable
even as the number of contending process goes to 1000. Without this
patch, locks-per-second drops off steeply after a few 10s of
processes.
There is a small cost to this extra complexity.
At 20 processes running a particular test on 72 cores, the lock
acquisitions per second drops from 1.8 million to 1.4 million with
this patch. For 100 processes, this patch still provides 1.4 million
while without this patch there are about 700,000.
Reported-and-tested-by: Martin Wilck <mwilck@suse.de>
Signed-off-by: NeilBrown <neilb@suse.com>
Reviewed-by: J. Bruce Fields <bfields@redhat.com>
Signed-off-by: Jeff Layton <jlayton@kernel.org>
2018-11-30 02:04:08 +03:00
locks_insert_block ( fl , new_fl , leases_conflict ) ;
2014-05-09 22:13:05 +04:00
trace_break_lease_block ( inode , new_fl ) ;
2015-01-16 23:05:57 +03:00
spin_unlock ( & ctx - > flc_lock ) ;
2019-02-21 17:38:40 +03:00
percpu_up_read ( & file_rwsem ) ;
2015-06-22 15:16:33 +03:00
2014-09-01 15:12:07 +04:00
locks_dispose_list ( & dispose ) ;
2008-01-15 07:28:30 +03:00
error = wait_event_interruptible_timeout ( new_fl - > fl_wait ,
2020-03-18 14:52:21 +03:00
list_empty ( & new_fl - > fl_blocked_member ) ,
break_time ) ;
2015-06-22 15:16:33 +03:00
2019-02-21 17:38:40 +03:00
percpu_down_read ( & file_rwsem ) ;
2015-01-16 23:05:57 +03:00
spin_lock ( & ctx - > flc_lock ) ;
2014-05-09 22:13:05 +04:00
trace_break_lease_unblock ( inode , new_fl ) ;
2013-06-21 16:58:15 +04:00
locks_delete_block ( new_fl ) ;
2005-04-17 02:20:36 +04:00
if ( error > = 0 ) {
2011-07-27 02:25:49 +04:00
/*
* Wait for the next conflicting lease that has not been
* broken yet
*/
2014-09-01 22:53:41 +04:00
if ( error = = 0 )
time_out_leases ( inode , & dispose ) ;
if ( any_leases_conflict ( inode , new_fl ) )
goto restart ;
2005-04-17 02:20:36 +04:00
error = 0 ;
}
out :
2015-01-16 23:05:57 +03:00
spin_unlock ( & ctx - > flc_lock ) ;
2019-02-21 17:38:40 +03:00
percpu_up_read ( & file_rwsem ) ;
2014-09-01 15:12:07 +04:00
locks_dispose_list ( & dispose ) ;
2019-08-20 02:47:34 +03:00
free_lock :
2011-12-26 22:25:26 +04:00
locks_free_lock ( new_fl ) ;
2005-04-17 02:20:36 +04:00
return error ;
}
EXPORT_SYMBOL ( __break_lease ) ;
/**
2018-01-03 18:14:34 +03:00
* lease_get_mtime - update modified time of an inode with exclusive lease
2005-04-17 02:20:36 +04:00
* @ inode : the inode
2018-01-03 18:14:34 +03:00
* @ time : pointer to a timespec which contains the last modified time
2005-04-17 02:20:36 +04:00
*
* This is to force NFS clients to flush their caches for files with
* exclusive leases . The justification is that if someone has an
2008-03-20 03:01:00 +03:00
* exclusive lease , then they could be modifying it .
2005-04-17 02:20:36 +04:00
*/
vfs: change inode times to use struct timespec64
struct timespec is not y2038 safe. Transition vfs to use
y2038 safe struct timespec64 instead.
The change was made with the help of the following cocinelle
script. This catches about 80% of the changes.
All the header file and logic changes are included in the
first 5 rules. The rest are trivial substitutions.
I avoid changing any of the function signatures or any other
filesystem specific data structures to keep the patch simple
for review.
The script can be a little shorter by combining different cases.
But, this version was sufficient for my usecase.
virtual patch
@ depends on patch @
identifier now;
@@
- struct timespec
+ struct timespec64
current_time ( ... )
{
- struct timespec now = current_kernel_time();
+ struct timespec64 now = current_kernel_time64();
...
- return timespec_trunc(
+ return timespec64_trunc(
... );
}
@ depends on patch @
identifier xtime;
@@
struct \( iattr \| inode \| kstat \) {
...
- struct timespec xtime;
+ struct timespec64 xtime;
...
}
@ depends on patch @
identifier t;
@@
struct inode_operations {
...
int (*update_time) (...,
- struct timespec t,
+ struct timespec64 t,
...);
...
}
@ depends on patch @
identifier t;
identifier fn_update_time =~ "update_time$";
@@
fn_update_time (...,
- struct timespec *t,
+ struct timespec64 *t,
...) { ... }
@ depends on patch @
identifier t;
@@
lease_get_mtime( ... ,
- struct timespec *t
+ struct timespec64 *t
) { ... }
@te depends on patch forall@
identifier ts;
local idexpression struct inode *inode_node;
identifier i_xtime =~ "^i_[acm]time$";
identifier ia_xtime =~ "^ia_[acm]time$";
identifier fn_update_time =~ "update_time$";
identifier fn;
expression e, E3;
local idexpression struct inode *node1;
local idexpression struct inode *node2;
local idexpression struct iattr *attr1;
local idexpression struct iattr *attr2;
local idexpression struct iattr attr;
identifier i_xtime1 =~ "^i_[acm]time$";
identifier i_xtime2 =~ "^i_[acm]time$";
identifier ia_xtime1 =~ "^ia_[acm]time$";
identifier ia_xtime2 =~ "^ia_[acm]time$";
@@
(
(
- struct timespec ts;
+ struct timespec64 ts;
|
- struct timespec ts = current_time(inode_node);
+ struct timespec64 ts = current_time(inode_node);
)
<+... when != ts
(
- timespec_equal(&inode_node->i_xtime, &ts)
+ timespec64_equal(&inode_node->i_xtime, &ts)
|
- timespec_equal(&ts, &inode_node->i_xtime)
+ timespec64_equal(&ts, &inode_node->i_xtime)
|
- timespec_compare(&inode_node->i_xtime, &ts)
+ timespec64_compare(&inode_node->i_xtime, &ts)
|
- timespec_compare(&ts, &inode_node->i_xtime)
+ timespec64_compare(&ts, &inode_node->i_xtime)
|
ts = current_time(e)
|
fn_update_time(..., &ts,...)
|
inode_node->i_xtime = ts
|
node1->i_xtime = ts
|
ts = inode_node->i_xtime
|
<+... attr1->ia_xtime ...+> = ts
|
ts = attr1->ia_xtime
|
ts.tv_sec
|
ts.tv_nsec
|
btrfs_set_stack_timespec_sec(..., ts.tv_sec)
|
btrfs_set_stack_timespec_nsec(..., ts.tv_nsec)
|
- ts = timespec64_to_timespec(
+ ts =
...
-)
|
- ts = ktime_to_timespec(
+ ts = ktime_to_timespec64(
...)
|
- ts = E3
+ ts = timespec_to_timespec64(E3)
|
- ktime_get_real_ts(&ts)
+ ktime_get_real_ts64(&ts)
|
fn(...,
- ts
+ timespec64_to_timespec(ts)
,...)
)
...+>
(
<... when != ts
- return ts;
+ return timespec64_to_timespec(ts);
...>
)
|
- timespec_equal(&node1->i_xtime1, &node2->i_xtime2)
+ timespec64_equal(&node1->i_xtime2, &node2->i_xtime2)
|
- timespec_equal(&node1->i_xtime1, &attr2->ia_xtime2)
+ timespec64_equal(&node1->i_xtime2, &attr2->ia_xtime2)
|
- timespec_compare(&node1->i_xtime1, &node2->i_xtime2)
+ timespec64_compare(&node1->i_xtime1, &node2->i_xtime2)
|
node1->i_xtime1 =
- timespec_trunc(attr1->ia_xtime1,
+ timespec64_trunc(attr1->ia_xtime1,
...)
|
- attr1->ia_xtime1 = timespec_trunc(attr2->ia_xtime2,
+ attr1->ia_xtime1 = timespec64_trunc(attr2->ia_xtime2,
...)
|
- ktime_get_real_ts(&attr1->ia_xtime1)
+ ktime_get_real_ts64(&attr1->ia_xtime1)
|
- ktime_get_real_ts(&attr.ia_xtime1)
+ ktime_get_real_ts64(&attr.ia_xtime1)
)
@ depends on patch @
struct inode *node;
struct iattr *attr;
identifier fn;
identifier i_xtime =~ "^i_[acm]time$";
identifier ia_xtime =~ "^ia_[acm]time$";
expression e;
@@
(
- fn(node->i_xtime);
+ fn(timespec64_to_timespec(node->i_xtime));
|
fn(...,
- node->i_xtime);
+ timespec64_to_timespec(node->i_xtime));
|
- e = fn(attr->ia_xtime);
+ e = fn(timespec64_to_timespec(attr->ia_xtime));
)
@ depends on patch forall @
struct inode *node;
struct iattr *attr;
identifier i_xtime =~ "^i_[acm]time$";
identifier ia_xtime =~ "^ia_[acm]time$";
identifier fn;
@@
{
+ struct timespec ts;
<+...
(
+ ts = timespec64_to_timespec(node->i_xtime);
fn (...,
- &node->i_xtime,
+ &ts,
...);
|
+ ts = timespec64_to_timespec(attr->ia_xtime);
fn (...,
- &attr->ia_xtime,
+ &ts,
...);
)
...+>
}
@ depends on patch forall @
struct inode *node;
struct iattr *attr;
struct kstat *stat;
identifier ia_xtime =~ "^ia_[acm]time$";
identifier i_xtime =~ "^i_[acm]time$";
identifier xtime =~ "^[acm]time$";
identifier fn, ret;
@@
{
+ struct timespec ts;
<+...
(
+ ts = timespec64_to_timespec(node->i_xtime);
ret = fn (...,
- &node->i_xtime,
+ &ts,
...);
|
+ ts = timespec64_to_timespec(node->i_xtime);
ret = fn (...,
- &node->i_xtime);
+ &ts);
|
+ ts = timespec64_to_timespec(attr->ia_xtime);
ret = fn (...,
- &attr->ia_xtime,
+ &ts,
...);
|
+ ts = timespec64_to_timespec(attr->ia_xtime);
ret = fn (...,
- &attr->ia_xtime);
+ &ts);
|
+ ts = timespec64_to_timespec(stat->xtime);
ret = fn (...,
- &stat->xtime);
+ &ts);
)
...+>
}
@ depends on patch @
struct inode *node;
struct inode *node2;
identifier i_xtime1 =~ "^i_[acm]time$";
identifier i_xtime2 =~ "^i_[acm]time$";
identifier i_xtime3 =~ "^i_[acm]time$";
struct iattr *attrp;
struct iattr *attrp2;
struct iattr attr ;
identifier ia_xtime1 =~ "^ia_[acm]time$";
identifier ia_xtime2 =~ "^ia_[acm]time$";
struct kstat *stat;
struct kstat stat1;
struct timespec64 ts;
identifier xtime =~ "^[acmb]time$";
expression e;
@@
(
( node->i_xtime2 \| attrp->ia_xtime2 \| attr.ia_xtime2 \) = node->i_xtime1 ;
|
node->i_xtime2 = \( node2->i_xtime1 \| timespec64_trunc(...) \);
|
node->i_xtime2 = node->i_xtime1 = node->i_xtime3 = \(ts \| current_time(...) \);
|
node->i_xtime1 = node->i_xtime3 = \(ts \| current_time(...) \);
|
stat->xtime = node2->i_xtime1;
|
stat1.xtime = node2->i_xtime1;
|
( node->i_xtime2 \| attrp->ia_xtime2 \) = attrp->ia_xtime1 ;
|
( attrp->ia_xtime1 \| attr.ia_xtime1 \) = attrp2->ia_xtime2;
|
- e = node->i_xtime1;
+ e = timespec64_to_timespec( node->i_xtime1 );
|
- e = attrp->ia_xtime1;
+ e = timespec64_to_timespec( attrp->ia_xtime1 );
|
node->i_xtime1 = current_time(...);
|
node->i_xtime2 = node->i_xtime1 = node->i_xtime3 =
- e;
+ timespec_to_timespec64(e);
|
node->i_xtime1 = node->i_xtime3 =
- e;
+ timespec_to_timespec64(e);
|
- node->i_xtime1 = e;
+ node->i_xtime1 = timespec_to_timespec64(e);
)
Signed-off-by: Deepa Dinamani <deepa.kernel@gmail.com>
Cc: <anton@tuxera.com>
Cc: <balbi@kernel.org>
Cc: <bfields@fieldses.org>
Cc: <darrick.wong@oracle.com>
Cc: <dhowells@redhat.com>
Cc: <dsterba@suse.com>
Cc: <dwmw2@infradead.org>
Cc: <hch@lst.de>
Cc: <hirofumi@mail.parknet.co.jp>
Cc: <hubcap@omnibond.com>
Cc: <jack@suse.com>
Cc: <jaegeuk@kernel.org>
Cc: <jaharkes@cs.cmu.edu>
Cc: <jslaby@suse.com>
Cc: <keescook@chromium.org>
Cc: <mark@fasheh.com>
Cc: <miklos@szeredi.hu>
Cc: <nico@linaro.org>
Cc: <reiserfs-devel@vger.kernel.org>
Cc: <richard@nod.at>
Cc: <sage@redhat.com>
Cc: <sfrench@samba.org>
Cc: <swhiteho@redhat.com>
Cc: <tj@kernel.org>
Cc: <trond.myklebust@primarydata.com>
Cc: <tytso@mit.edu>
Cc: <viro@zeniv.linux.org.uk>
2018-05-09 05:36:02 +03:00
void lease_get_mtime ( struct inode * inode , struct timespec64 * time )
2005-04-17 02:20:36 +04:00
{
2014-08-22 18:18:44 +04:00
bool has_lease = false ;
2015-09-21 10:43:06 +03:00
struct file_lock_context * ctx ;
2015-01-16 23:05:55 +03:00
struct file_lock * fl ;
2014-08-22 18:18:44 +04:00
2015-09-21 10:43:06 +03:00
ctx = smp_load_acquire ( & inode - > i_flctx ) ;
2015-01-16 23:05:55 +03:00
if ( ctx & & ! list_empty_careful ( & ctx - > flc_lease ) ) {
2015-01-16 23:05:57 +03:00
spin_lock ( & ctx - > flc_lock ) ;
2015-11-18 16:40:33 +03:00
fl = list_first_entry_or_null ( & ctx - > flc_lease ,
struct file_lock , fl_list ) ;
if ( fl & & ( fl - > fl_type = = F_WRLCK ) )
has_lease = true ;
2015-01-16 23:05:57 +03:00
spin_unlock ( & ctx - > flc_lock ) ;
2014-08-22 18:18:44 +04:00
}
if ( has_lease )
2016-09-14 17:48:06 +03:00
* time = current_time ( inode ) ;
2005-04-17 02:20:36 +04:00
}
EXPORT_SYMBOL ( lease_get_mtime ) ;
/**
* fcntl_getlease - Enquire what lease is currently active
* @ filp : the file
*
* The value returned by this function will be one of
* ( if no lease break is pending ) :
*
* % F_RDLCK to indicate a shared lease is held .
*
* % F_WRLCK to indicate an exclusive lease is held .
*
* % F_UNLCK to indicate no lease is held .
*
* ( if a lease break is pending ) :
*
* % F_RDLCK to indicate an exclusive lease needs to be
* changed to a shared lease ( or removed ) .
*
* % F_UNLCK to indicate the lease needs to be removed .
*
* XXX : sfr & willy disagree over whether F_INPROGRESS
* should be returned to userspace .
*/
int fcntl_getlease ( struct file * filp )
{
struct file_lock * fl ;
2016-09-16 13:44:20 +03:00
struct inode * inode = locks_inode ( filp ) ;
2015-09-21 10:43:06 +03:00
struct file_lock_context * ctx ;
2005-04-17 02:20:36 +04:00
int type = F_UNLCK ;
2014-09-01 15:12:07 +04:00
LIST_HEAD ( dispose ) ;
2005-04-17 02:20:36 +04:00
2015-09-21 10:43:06 +03:00
ctx = smp_load_acquire ( & inode - > i_flctx ) ;
2015-01-16 23:05:55 +03:00
if ( ctx & & ! list_empty_careful ( & ctx - > flc_lease ) ) {
2019-02-21 17:38:40 +03:00
percpu_down_read ( & file_rwsem ) ;
2015-01-16 23:05:57 +03:00
spin_lock ( & ctx - > flc_lock ) ;
2016-09-16 13:44:20 +03:00
time_out_leases ( inode , & dispose ) ;
2015-01-16 23:05:55 +03:00
list_for_each_entry ( fl , & ctx - > flc_lease , fl_list ) {
if ( fl - > fl_file ! = filp )
continue ;
2011-07-27 02:25:49 +04:00
type = target_leasetype ( fl ) ;
2005-04-17 02:20:36 +04:00
break ;
}
2015-01-16 23:05:57 +03:00
spin_unlock ( & ctx - > flc_lock ) ;
2019-02-21 17:38:40 +03:00
percpu_up_read ( & file_rwsem ) ;
2016-10-08 11:12:28 +03:00
2015-01-16 23:05:55 +03:00
locks_dispose_list ( & dispose ) ;
2005-04-17 02:20:36 +04:00
}
return type ;
}
2014-02-03 21:13:06 +04:00
/**
2019-06-07 17:24:38 +03:00
* check_conflicting_open - see if the given file points to an inode that has
2018-11-30 02:04:08 +03:00
* an existing open that would conflict with the
* desired lease .
2019-06-07 17:24:38 +03:00
* @ filp : file to check
2014-02-03 21:13:06 +04:00
* @ arg : type of lease that we ' re trying to acquire
2015-08-10 04:43:17 +03:00
* @ flags : current lock flags
2014-02-03 21:13:06 +04:00
*
* Check to see if there ' s an existing open fd on this file that would
* conflict with the lease we ' re trying to set .
*/
static int
2019-06-07 17:24:38 +03:00
check_conflicting_open ( struct file * filp , const long arg , int flags )
2014-02-03 21:13:06 +04:00
{
2019-06-07 17:24:38 +03:00
struct inode * inode = locks_inode ( filp ) ;
int self_wcount = 0 , self_rcount = 0 ;
2014-02-03 21:13:06 +04:00
2015-01-21 21:17:03 +03:00
if ( flags & FL_LAYOUT )
return 0 ;
2021-04-16 21:00:18 +03:00
if ( flags & FL_DELEG )
/* We leave these checks to the caller */
return 0 ;
2015-01-21 21:17:03 +03:00
2019-06-07 17:24:38 +03:00
if ( arg = = F_RDLCK )
return inode_is_open_for_write ( inode ) ? - EAGAIN : 0 ;
else if ( arg ! = F_WRLCK )
return 0 ;
/*
* Make sure that only read / write count is from lease requestor .
* Note that this will result in denying write leases when i_writecount
* is negative , which is what we want . ( We shouldn ' t grant write leases
* on files open for execution . )
*/
if ( filp - > f_mode & FMODE_WRITE )
self_wcount = 1 ;
else if ( filp - > f_mode & FMODE_READ )
self_rcount = 1 ;
2014-02-03 21:13:06 +04:00
2019-06-07 17:24:38 +03:00
if ( atomic_read ( & inode - > i_writecount ) ! = self_wcount | |
atomic_read ( & inode - > i_readcount ) ! = self_rcount )
return - EAGAIN ;
2014-02-03 21:13:06 +04:00
2019-06-07 17:24:38 +03:00
return 0 ;
2014-02-03 21:13:06 +04:00
}
2014-08-22 18:40:25 +04:00
static int
generic_add_lease ( struct file * filp , long arg , struct file_lock * * flp , void * * priv )
2005-04-17 02:20:36 +04:00
{
2015-01-16 23:05:55 +03:00
struct file_lock * fl , * my_fl = NULL , * lease ;
2019-06-07 17:24:38 +03:00
struct inode * inode = locks_inode ( filp ) ;
2015-01-16 23:05:55 +03:00
struct file_lock_context * ctx ;
2012-03-05 22:18:59 +04:00
bool is_deleg = ( * flp ) - > fl_flags & FL_DELEG ;
2011-08-19 18:59:49 +04:00
int error ;
2014-09-01 15:12:07 +04:00
LIST_HEAD ( dispose ) ;
2005-04-17 02:20:36 +04:00
2010-10-31 01:31:14 +04:00
lease = * flp ;
2014-05-09 22:13:05 +04:00
trace_generic_add_lease ( inode , lease ) ;
2015-04-03 16:04:03 +03:00
/* Note that arg is never F_UNLCK here */
ctx = locks_get_lock_context ( inode , arg ) ;
2015-01-16 23:05:55 +03:00
if ( ! ctx )
return - ENOMEM ;
2012-03-05 22:18:59 +04:00
/*
* In the delegation case we need mutual exclusion with
* a number of operations that take the i_mutex . We trylock
* because delegations are an optional optimization , and if
* there ' s some chance of a conflict - - we ' d rather not
* bother , maybe that ' s a sign this just isn ' t a good file to
* hand out a delegation on .
*/
2016-01-22 23:40:57 +03:00
if ( is_deleg & & ! inode_trylock ( inode ) )
2012-03-05 22:18:59 +04:00
return - EAGAIN ;
if ( is_deleg & & arg = = F_WRLCK ) {
/* Write delegations are not currently supported: */
2016-01-22 23:40:57 +03:00
inode_unlock ( inode ) ;
2012-03-05 22:18:59 +04:00
WARN_ON_ONCE ( 1 ) ;
return - EINVAL ;
}
2010-10-31 01:31:14 +04:00
2019-02-21 17:38:40 +03:00
percpu_down_read ( & file_rwsem ) ;
2015-01-16 23:05:57 +03:00
spin_lock ( & ctx - > flc_lock ) ;
2014-09-01 15:12:07 +04:00
time_out_leases ( inode , & dispose ) ;
2019-06-07 17:24:38 +03:00
error = check_conflicting_open ( filp , arg , lease - > fl_flags ) ;
2014-02-03 21:13:06 +04:00
if ( error )
2010-10-31 01:31:14 +04:00
goto out ;
2007-06-01 01:03:46 +04:00
2005-04-17 02:20:36 +04:00
/*
* At this point , we know that if there is an exclusive
* lease on this file , then we hold it on this filp
* ( otherwise our open of this file would have blocked ) .
* And if we are trying to acquire an exclusive lease ,
* then the file is not open by anyone ( including us )
* except for this filp .
*/
2011-08-19 18:59:49 +04:00
error = - EAGAIN ;
2015-01-16 23:05:55 +03:00
list_for_each_entry ( fl , & ctx - > flc_lease , fl_list ) {
2015-01-21 21:14:02 +03:00
if ( fl - > fl_file = = filp & &
fl - > fl_owner = = lease - > fl_owner ) {
2015-01-16 23:05:55 +03:00
my_fl = fl ;
2011-08-19 18:59:49 +04:00
continue ;
}
2015-01-16 23:05:55 +03:00
2011-08-19 18:59:49 +04:00
/*
* No exclusive leases if someone else has a lease on
* this file :
*/
if ( arg = = F_WRLCK )
goto out ;
/*
* Modifying our existing lease is OK , but no getting a
* new lease if someone else is opening for write :
*/
if ( fl - > fl_flags & FL_UNLOCK_PENDING )
goto out ;
2005-04-17 02:20:36 +04:00
}
2015-01-16 23:05:55 +03:00
if ( my_fl ! = NULL ) {
2015-03-05 01:34:32 +03:00
lease = my_fl ;
error = lease - > fl_lmops - > lm_change ( lease , arg , & dispose ) ;
2014-08-22 18:55:47 +04:00
if ( error )
goto out ;
goto out_setup ;
2005-04-17 02:20:36 +04:00
}
error = - EINVAL ;
if ( ! leases_enable )
goto out ;
2015-02-16 22:32:03 +03:00
locks_insert_lock_ctx ( lease , & ctx - > flc_lease ) ;
2014-02-03 21:13:06 +04:00
/*
* The check in break_lease ( ) is lockless . It ' s possible for another
* open to race in after we did the earlier check for a conflicting
* open but before the lease was inserted . Check again for a
* conflicting open and cancel the lease if there is one .
*
* We also add a barrier here to ensure that the insertion of the lock
* precedes these checks .
*/
smp_mb ( ) ;
2019-06-07 17:24:38 +03:00
error = check_conflicting_open ( filp , arg , lease - > fl_flags ) ;
2015-01-16 23:05:55 +03:00
if ( error ) {
2015-02-16 22:32:03 +03:00
locks_unlink_lock_ctx ( lease ) ;
2015-01-16 23:05:55 +03:00
goto out ;
}
2014-08-22 18:55:47 +04:00
out_setup :
if ( lease - > fl_lmops - > lm_setup )
lease - > fl_lmops - > lm_setup ( lease , priv ) ;
2005-04-17 02:20:36 +04:00
out :
2015-01-16 23:05:57 +03:00
spin_unlock ( & ctx - > flc_lock ) ;
2019-02-21 17:38:40 +03:00
percpu_up_read ( & file_rwsem ) ;
2014-09-01 15:12:07 +04:00
locks_dispose_list ( & dispose ) ;
2012-03-05 22:18:59 +04:00
if ( is_deleg )
2016-01-22 23:40:57 +03:00
inode_unlock ( inode ) ;
2015-01-16 23:05:55 +03:00
if ( ! error & & ! my_fl )
2014-08-22 18:55:47 +04:00
* flp = NULL ;
2005-04-17 02:20:36 +04:00
return error ;
}
2011-09-21 16:34:32 +04:00
2015-01-21 21:14:02 +03:00
static int generic_delete_lease ( struct file * filp , void * owner )
2011-09-21 16:34:32 +04:00
{
2014-08-22 18:18:45 +04:00
int error = - EAGAIN ;
2015-01-16 23:05:55 +03:00
struct file_lock * fl , * victim = NULL ;
2016-09-16 13:44:20 +03:00
struct inode * inode = locks_inode ( filp ) ;
2015-09-21 10:43:06 +03:00
struct file_lock_context * ctx ;
2014-09-01 15:12:07 +04:00
LIST_HEAD ( dispose ) ;
2011-09-21 16:34:32 +04:00
2015-09-21 10:43:06 +03:00
ctx = smp_load_acquire ( & inode - > i_flctx ) ;
2015-01-16 23:05:55 +03:00
if ( ! ctx ) {
trace_generic_delete_lease ( inode , NULL ) ;
return error ;
}
2019-02-21 17:38:40 +03:00
percpu_down_read ( & file_rwsem ) ;
2015-01-16 23:05:57 +03:00
spin_lock ( & ctx - > flc_lock ) ;
2015-01-16 23:05:55 +03:00
list_for_each_entry ( fl , & ctx - > flc_lease , fl_list ) {
2015-01-21 21:14:02 +03:00
if ( fl - > fl_file = = filp & &
fl - > fl_owner = = owner ) {
2015-01-16 23:05:55 +03:00
victim = fl ;
2014-08-22 18:18:45 +04:00
break ;
2015-01-16 23:05:55 +03:00
}
2011-09-21 16:34:32 +04:00
}
2015-03-14 16:45:35 +03:00
trace_generic_delete_lease ( inode , victim ) ;
2015-01-16 23:05:55 +03:00
if ( victim )
2015-01-16 23:05:57 +03:00
error = fl - > fl_lmops - > lm_change ( victim , F_UNLCK , & dispose ) ;
2015-01-16 23:05:57 +03:00
spin_unlock ( & ctx - > flc_lock ) ;
2019-02-21 17:38:40 +03:00
percpu_up_read ( & file_rwsem ) ;
2014-09-01 15:12:07 +04:00
locks_dispose_list ( & dispose ) ;
2014-08-22 18:18:45 +04:00
return error ;
2011-09-21 16:34:32 +04:00
}
/**
* generic_setlease - sets a lease on an open file
2014-08-22 18:55:47 +04:00
* @ filp : file pointer
* @ arg : type of lease to obtain
* @ flp : input - file_lock to use , output - file_lock inserted
* @ priv : private data for lm_setup ( may be NULL if lm_setup
* doesn ' t require it )
2011-09-21 16:34:32 +04:00
*
* The ( input ) flp - > fl_lmops - > lm_break function is required
* by break_lease ( ) .
*/
2014-08-22 18:40:25 +04:00
int generic_setlease ( struct file * filp , long arg , struct file_lock * * flp ,
void * * priv )
2011-09-21 16:34:32 +04:00
{
2016-09-16 13:44:20 +03:00
struct inode * inode = locks_inode ( filp ) ;
2011-09-21 16:34:32 +04:00
int error ;
2012-03-04 09:17:15 +04:00
if ( ( ! uid_eq ( current_fsuid ( ) , inode - > i_uid ) ) & & ! capable ( CAP_LEASE ) )
2011-09-21 16:34:32 +04:00
return - EACCES ;
if ( ! S_ISREG ( inode - > i_mode ) )
return - EINVAL ;
error = security_file_lock ( filp , arg ) ;
if ( error )
return error ;
switch ( arg ) {
case F_UNLCK :
2015-01-21 21:14:02 +03:00
return generic_delete_lease ( filp , * priv ) ;
2011-09-21 16:34:32 +04:00
case F_RDLCK :
case F_WRLCK :
2014-08-22 18:18:45 +04:00
if ( ! ( * flp ) - > fl_lmops - > lm_break ) {
WARN_ON_ONCE ( 1 ) ;
return - ENOLCK ;
}
2015-01-21 21:17:03 +03:00
2014-08-22 18:40:25 +04:00
return generic_add_lease ( filp , arg , flp , priv ) ;
2011-09-21 16:34:32 +04:00
default :
2012-07-13 21:35:36 +04:00
return - EINVAL ;
2011-09-21 16:34:32 +04:00
}
}
2007-07-31 11:39:22 +04:00
EXPORT_SYMBOL ( generic_setlease ) ;
2005-04-17 02:20:36 +04:00
2019-08-18 21:18:45 +03:00
# if IS_ENABLED(CONFIG_SRCU)
/*
* Kernel subsystems can register to be notified on any attempt to set
* a new lease with the lease_notifier_chain . This is used by ( e . g . ) nfsd
* to close files that it may have cached when there is an attempt to set a
* conflicting lease .
*/
static struct srcu_notifier_head lease_notifier_chain ;
static inline void
lease_notifier_chain_init ( void )
{
srcu_init_notifier_head ( & lease_notifier_chain ) ;
}
static inline void
setlease_notifier ( long arg , struct file_lock * lease )
{
if ( arg ! = F_UNLCK )
srcu_notifier_call_chain ( & lease_notifier_chain , arg , lease ) ;
}
int lease_register_notifier ( struct notifier_block * nb )
{
return srcu_notifier_chain_register ( & lease_notifier_chain , nb ) ;
}
EXPORT_SYMBOL_GPL ( lease_register_notifier ) ;
void lease_unregister_notifier ( struct notifier_block * nb )
{
srcu_notifier_chain_unregister ( & lease_notifier_chain , nb ) ;
}
EXPORT_SYMBOL_GPL ( lease_unregister_notifier ) ;
# else /* !IS_ENABLED(CONFIG_SRCU) */
static inline void
lease_notifier_chain_init ( void )
{
}
static inline void
setlease_notifier ( long arg , struct file_lock * lease )
{
}
int lease_register_notifier ( struct notifier_block * nb )
{
return 0 ;
}
EXPORT_SYMBOL_GPL ( lease_register_notifier ) ;
void lease_unregister_notifier ( struct notifier_block * nb )
{
}
EXPORT_SYMBOL_GPL ( lease_unregister_notifier ) ;
# endif /* IS_ENABLED(CONFIG_SRCU) */
2010-09-18 17:09:31 +04:00
/**
2014-08-23 02:13:28 +04:00
* vfs_setlease - sets a lease on an open file
2014-08-22 18:55:47 +04:00
* @ filp : file pointer
* @ arg : type of lease to obtain
* @ lease : file_lock to use when adding a lease
* @ priv : private info for lm_setup when adding a lease ( may be
2018-11-30 02:04:08 +03:00
* NULL if lm_setup doesn ' t require it )
2014-08-23 02:13:28 +04:00
*
* Call this to establish a lease on the file . The " lease " argument is not
* used for F_UNLCK requests and may be NULL . For commands that set or alter
2017-05-27 13:07:18 +03:00
* an existing lease , the ` ` ( * lease ) - > fl_lmops - > lm_break ` ` operation must be
* set ; if not , this function will return - ENOLCK ( and generate a scary - looking
2014-08-23 02:13:28 +04:00
* stack trace ) .
2014-08-22 18:55:47 +04:00
*
* The " priv " pointer is passed directly to the lm_setup function as - is . It
* may be NULL if the lm_setup operation doesn ' t require it .
2005-04-17 02:20:36 +04:00
*/
2014-08-22 18:40:25 +04:00
int
vfs_setlease ( struct file * filp , long arg , struct file_lock * * lease , void * * priv )
2005-04-17 02:20:36 +04:00
{
2019-08-18 21:18:45 +03:00
if ( lease )
setlease_notifier ( arg , * lease ) ;
2018-07-18 16:44:43 +03:00
if ( filp - > f_op - > setlease )
2014-08-23 02:50:48 +04:00
return filp - > f_op - > setlease ( filp , arg , lease , priv ) ;
2014-08-22 18:55:47 +04:00
else
2014-08-23 02:50:48 +04:00
return generic_setlease ( filp , arg , lease , priv ) ;
2005-04-17 02:20:36 +04:00
}
2007-06-08 01:09:49 +04:00
EXPORT_SYMBOL_GPL ( vfs_setlease ) ;
2005-04-17 02:20:36 +04:00
2010-10-31 01:31:13 +04:00
static int do_fcntl_add_lease ( unsigned int fd , struct file * filp , long arg )
2005-04-17 02:20:36 +04:00
{
2014-08-22 18:55:47 +04:00
struct file_lock * fl ;
2010-10-27 20:38:12 +04:00
struct fasync_struct * new ;
2005-04-17 02:20:36 +04:00
int error ;
2010-10-27 17:46:08 +04:00
fl = lease_alloc ( filp , arg ) ;
if ( IS_ERR ( fl ) )
return PTR_ERR ( fl ) ;
2005-04-17 02:20:36 +04:00
2010-10-27 20:38:12 +04:00
new = fasync_alloc ( ) ;
if ( ! new ) {
locks_free_lock ( fl ) ;
return - ENOMEM ;
}
2014-08-22 18:55:47 +04:00
new - > fa_fd = fd ;
2010-10-27 20:38:12 +04:00
2014-08-22 18:55:47 +04:00
error = vfs_setlease ( filp , arg , & fl , ( void * * ) & new ) ;
2014-08-12 02:14:12 +04:00
if ( fl )
locks_free_lock ( fl ) ;
2010-10-27 20:38:12 +04:00
if ( new )
fasync_free ( new ) ;
2005-04-17 02:20:36 +04:00
return error ;
}
2010-10-31 01:31:13 +04:00
/**
* fcntl_setlease - sets a lease on an open file
* @ fd : open file descriptor
* @ filp : file pointer
* @ arg : type of lease to obtain
*
* Call this fcntl to establish a lease on the file .
* Note that you also need to call % F_SETSIG to
* receive a signal when the lease is broken .
*/
int fcntl_setlease ( unsigned int fd , struct file * filp , long arg )
{
if ( arg = = F_UNLCK )
2015-01-21 21:14:02 +03:00
return vfs_setlease ( filp , F_UNLCK , NULL , ( void * * ) & filp ) ;
2010-10-31 01:31:13 +04:00
return do_fcntl_add_lease ( fd , filp , arg ) ;
}
2005-04-17 02:20:36 +04:00
/**
2015-07-11 13:43:02 +03:00
* flock_lock_inode_wait - Apply a FLOCK - style lock to a file
* @ inode : inode of the file to apply to
2005-04-17 02:20:36 +04:00
* @ fl : The lock to be applied
*
2015-07-11 13:43:02 +03:00
* Apply a FLOCK style lock request to an inode .
2005-04-17 02:20:36 +04:00
*/
2015-10-22 20:38:15 +03:00
static int flock_lock_inode_wait ( struct inode * inode , struct file_lock * fl )
2005-04-17 02:20:36 +04:00
{
int error ;
might_sleep ( ) ;
for ( ; ; ) {
2015-07-11 13:43:02 +03:00
error = flock_lock_inode ( inode , fl ) ;
2008-07-25 12:48:57 +04:00
if ( error ! = FILE_LOCK_DEFERRED )
2005-04-17 02:20:36 +04:00
break ;
2020-03-18 14:52:21 +03:00
error = wait_event_interruptible ( fl - > fl_wait ,
list_empty ( & fl - > fl_blocked_member ) ) ;
2018-11-30 02:04:08 +03:00
if ( error )
break ;
2005-04-17 02:20:36 +04:00
}
2018-11-30 02:04:08 +03:00
locks_delete_block ( fl ) ;
2005-04-17 02:20:36 +04:00
return error ;
}
2015-10-22 20:38:13 +03:00
/**
* locks_lock_inode_wait - Apply a lock to an inode
* @ inode : inode of the file to apply to
* @ fl : The lock to be applied
*
* Apply a POSIX or FLOCK style lock request to an inode .
*/
int locks_lock_inode_wait ( struct inode * inode , struct file_lock * fl )
{
int res = 0 ;
switch ( fl - > fl_flags & ( FL_POSIX | FL_FLOCK ) ) {
case FL_POSIX :
res = posix_lock_inode_wait ( inode , fl ) ;
break ;
case FL_FLOCK :
res = flock_lock_inode_wait ( inode , fl ) ;
break ;
default :
BUG ( ) ;
}
return res ;
}
EXPORT_SYMBOL ( locks_lock_inode_wait ) ;
2005-04-17 02:20:36 +04:00
/**
* sys_flock : - flock ( ) system call .
* @ fd : the file descriptor to lock .
* @ cmd : the type of lock to apply .
*
* Apply a % FL_FLOCK style lock to an open file descriptor .
2017-05-27 13:07:18 +03:00
* The @ cmd can be one of :
2005-04-17 02:20:36 +04:00
*
2017-05-27 13:07:18 +03:00
* - % LOCK_SH - - a shared lock .
* - % LOCK_EX - - an exclusive lock .
* - % LOCK_UN - - remove an existing lock .
2021-09-10 22:36:29 +03:00
* - % LOCK_MAND - - a ' mandatory ' flock . ( DEPRECATED )
2005-04-17 02:20:36 +04:00
*
2021-09-10 22:36:29 +03:00
* % LOCK_MAND support has been removed from the kernel .
2005-04-17 02:20:36 +04:00
*/
2009-01-14 16:14:18 +03:00
SYSCALL_DEFINE2 ( flock , unsigned int , fd , unsigned int , cmd )
2005-04-17 02:20:36 +04:00
{
2012-08-28 20:52:22 +04:00
struct fd f = fdget ( fd ) ;
2005-04-17 02:20:36 +04:00
struct file_lock * lock ;
int can_sleep , unlock ;
int error ;
error = - EBADF ;
2012-08-28 20:52:22 +04:00
if ( ! f . file )
2005-04-17 02:20:36 +04:00
goto out ;
can_sleep = ! ( cmd & LOCK_NB ) ;
cmd & = ~ LOCK_NB ;
unlock = ( cmd = = LOCK_UN ) ;
2021-09-10 22:36:29 +03:00
if ( ! unlock & & ! ( f . file - > f_mode & ( FMODE_READ | FMODE_WRITE ) ) )
goto out_putf ;
/*
* LOCK_MAND locks were broken for a long time in that they never
* conflicted with one another and didn ' t prevent any sort of open ,
* read or write activity .
*
* Just ignore these requests now , to preserve legacy behavior , but
* throw a warning to let people know that they don ' t actually work .
*/
if ( cmd & LOCK_MAND ) {
pr_warn_once ( " Attempt to set a LOCK_MAND lock via flock(2). This support has been removed and the request ignored. \n " ) ;
error = 0 ;
2005-04-17 02:20:36 +04:00
goto out_putf ;
2021-09-10 22:36:29 +03:00
}
2005-04-17 02:20:36 +04:00
2018-11-30 02:04:08 +03:00
lock = flock_make_lock ( f . file , cmd , NULL ) ;
2014-09-04 18:25:06 +04:00
if ( IS_ERR ( lock ) ) {
error = PTR_ERR ( lock ) ;
2005-04-17 02:20:36 +04:00
goto out_putf ;
2014-09-04 18:25:06 +04:00
}
2005-04-17 02:20:36 +04:00
if ( can_sleep )
lock - > fl_flags | = FL_SLEEP ;
2012-08-28 20:52:22 +04:00
error = security_file_lock ( f . file , lock - > fl_type ) ;
2005-04-17 02:20:36 +04:00
if ( error )
goto out_free ;
2018-07-18 16:44:43 +03:00
if ( f . file - > f_op - > flock )
2012-08-28 20:52:22 +04:00
error = f . file - > f_op - > flock ( f . file ,
2005-04-17 02:20:36 +04:00
( can_sleep ) ? F_SETLKW : F_SETLK ,
lock ) ;
else
2015-10-22 20:38:14 +03:00
error = locks_lock_file_wait ( f . file , lock ) ;
2005-04-17 02:20:36 +04:00
out_free :
2006-03-31 14:30:55 +04:00
locks_free_lock ( lock ) ;
2005-04-17 02:20:36 +04:00
out_putf :
2012-08-28 20:52:22 +04:00
fdput ( f ) ;
2005-04-17 02:20:36 +04:00
out :
return error ;
}
2007-02-21 08:58:50 +03:00
/**
* vfs_test_lock - test file byte range lock
* @ filp : The file to test lock for
2007-05-12 00:22:50 +04:00
* @ fl : The lock to test ; also used to hold result
2007-02-21 08:58:50 +03:00
*
* Returns - ERRNO on failure . Indicates presence of conflicting lock by
* setting conf - > fl_type to something other than F_UNLCK .
*/
int vfs_test_lock ( struct file * filp , struct file_lock * fl )
{
2018-07-18 16:44:43 +03:00
if ( filp - > f_op - > lock )
2007-02-21 08:58:50 +03:00
return filp - > f_op - > lock ( filp , F_GETLK , fl ) ;
posix_test_lock ( filp , fl ) ;
return 0 ;
}
EXPORT_SYMBOL_GPL ( vfs_test_lock ) ;
fs/locks: Remove fl_nspid and use fs-specific l_pid for remote locks
Since commit c69899a17ca4 "NFSv4: Update of VFS byte range lock must be
atomic with the stateid update", NFSv4 has been inserting locks in rpciod
worker context. The result is that the file_lock's fl_nspid is the
kworker's pid instead of the original userspace pid.
The fl_nspid is only used to represent the namespaced virtual pid number
when displaying locks or returning from F_GETLK. There's no reason to set
it for every inserted lock, since we can usually just look it up from
fl_pid. So, instead of looking up and holding struct pid for every lock,
let's just look up the virtual pid number from fl_pid when it is needed.
That means we can remove fl_nspid entirely.
The translaton and presentation of fl_pid should handle the following four
cases:
1 - F_GETLK on a remote file with a remote lock:
In this case, the filesystem should determine the l_pid to return here.
Filesystems should indicate that the fl_pid represents a non-local pid
value that should not be translated by returning an fl_pid <= 0.
2 - F_GETLK on a local file with a remote lock:
This should be the l_pid of the lock manager process, and translated.
3 - F_GETLK on a remote file with a local lock, and
4 - F_GETLK on a local file with a local lock:
These should be the translated l_pid of the local locking process.
Fuse was already doing the correct thing by translating the pid into the
caller's namespace. With this change we must update fuse to translate
to init's pid namespace, so that the locks API can then translate from
init's pid namespace into the pid namespace of the caller.
With this change, the locks API will expect that if a filesystem returns
a remote pid as opposed to a local pid for F_GETLK, that remote pid will
be <= 0. This signifies that the pid is remote, and the locks API will
forego translating that pid into the pid namespace of the local calling
process.
Finally, we convert remote filesystems to present remote pids using
negative numbers. Have lustre, 9p, ceph, cifs, and dlm negate the remote
pid returned for F_GETLK lock requests.
Since local pids will never be larger than PID_MAX_LIMIT (which is
currently defined as <= 4 million), but pid_t is an unsigned int, we
should have plenty of room to represent remote pids with negative
numbers if we assume that remote pid numbers are similarly limited.
If this is not the case, then we run the risk of having a remote pid
returned for which there is also a corresponding local pid. This is a
problem we have now, but this patch should reduce the chances of that
occurring, while also returning those remote pid numbers, for whatever
that may be worth.
Signed-off-by: Benjamin Coddington <bcodding@redhat.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
2017-07-16 17:28:22 +03:00
/**
* locks_translate_pid - translate a file_lock ' s fl_pid number into a namespace
* @ fl : The file_lock who ' s fl_pid should be translated
* @ ns : The namespace into which the pid should be translated
*
* Used to tranlate a fl_pid into a namespace virtual pid number
*/
static pid_t locks_translate_pid ( struct file_lock * fl , struct pid_namespace * ns )
{
pid_t vnr ;
struct pid * pid ;
if ( IS_OFDLCK ( fl ) )
return - 1 ;
if ( IS_REMOTELCK ( fl ) )
return fl - > fl_pid ;
2018-06-08 17:27:11 +03:00
/*
* If the flock owner process is dead and its pid has been already
* freed , the translation below won ' t work , but we still want to show
* flock owner pid number in init pidns .
*/
if ( ns = = & init_pid_ns )
return ( pid_t ) fl - > fl_pid ;
fs/locks: Remove fl_nspid and use fs-specific l_pid for remote locks
Since commit c69899a17ca4 "NFSv4: Update of VFS byte range lock must be
atomic with the stateid update", NFSv4 has been inserting locks in rpciod
worker context. The result is that the file_lock's fl_nspid is the
kworker's pid instead of the original userspace pid.
The fl_nspid is only used to represent the namespaced virtual pid number
when displaying locks or returning from F_GETLK. There's no reason to set
it for every inserted lock, since we can usually just look it up from
fl_pid. So, instead of looking up and holding struct pid for every lock,
let's just look up the virtual pid number from fl_pid when it is needed.
That means we can remove fl_nspid entirely.
The translaton and presentation of fl_pid should handle the following four
cases:
1 - F_GETLK on a remote file with a remote lock:
In this case, the filesystem should determine the l_pid to return here.
Filesystems should indicate that the fl_pid represents a non-local pid
value that should not be translated by returning an fl_pid <= 0.
2 - F_GETLK on a local file with a remote lock:
This should be the l_pid of the lock manager process, and translated.
3 - F_GETLK on a remote file with a local lock, and
4 - F_GETLK on a local file with a local lock:
These should be the translated l_pid of the local locking process.
Fuse was already doing the correct thing by translating the pid into the
caller's namespace. With this change we must update fuse to translate
to init's pid namespace, so that the locks API can then translate from
init's pid namespace into the pid namespace of the caller.
With this change, the locks API will expect that if a filesystem returns
a remote pid as opposed to a local pid for F_GETLK, that remote pid will
be <= 0. This signifies that the pid is remote, and the locks API will
forego translating that pid into the pid namespace of the local calling
process.
Finally, we convert remote filesystems to present remote pids using
negative numbers. Have lustre, 9p, ceph, cifs, and dlm negate the remote
pid returned for F_GETLK lock requests.
Since local pids will never be larger than PID_MAX_LIMIT (which is
currently defined as <= 4 million), but pid_t is an unsigned int, we
should have plenty of room to represent remote pids with negative
numbers if we assume that remote pid numbers are similarly limited.
If this is not the case, then we run the risk of having a remote pid
returned for which there is also a corresponding local pid. This is a
problem we have now, but this patch should reduce the chances of that
occurring, while also returning those remote pid numbers, for whatever
that may be worth.
Signed-off-by: Benjamin Coddington <bcodding@redhat.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
2017-07-16 17:28:22 +03:00
rcu_read_lock ( ) ;
pid = find_pid_ns ( fl - > fl_pid , & init_pid_ns ) ;
vnr = pid_nr_ns ( pid , ns ) ;
rcu_read_unlock ( ) ;
return vnr ;
}
2007-02-21 00:10:11 +03:00
static int posix_lock_to_flock ( struct flock * flock , struct file_lock * fl )
{
fs/locks: Remove fl_nspid and use fs-specific l_pid for remote locks
Since commit c69899a17ca4 "NFSv4: Update of VFS byte range lock must be
atomic with the stateid update", NFSv4 has been inserting locks in rpciod
worker context. The result is that the file_lock's fl_nspid is the
kworker's pid instead of the original userspace pid.
The fl_nspid is only used to represent the namespaced virtual pid number
when displaying locks or returning from F_GETLK. There's no reason to set
it for every inserted lock, since we can usually just look it up from
fl_pid. So, instead of looking up and holding struct pid for every lock,
let's just look up the virtual pid number from fl_pid when it is needed.
That means we can remove fl_nspid entirely.
The translaton and presentation of fl_pid should handle the following four
cases:
1 - F_GETLK on a remote file with a remote lock:
In this case, the filesystem should determine the l_pid to return here.
Filesystems should indicate that the fl_pid represents a non-local pid
value that should not be translated by returning an fl_pid <= 0.
2 - F_GETLK on a local file with a remote lock:
This should be the l_pid of the lock manager process, and translated.
3 - F_GETLK on a remote file with a local lock, and
4 - F_GETLK on a local file with a local lock:
These should be the translated l_pid of the local locking process.
Fuse was already doing the correct thing by translating the pid into the
caller's namespace. With this change we must update fuse to translate
to init's pid namespace, so that the locks API can then translate from
init's pid namespace into the pid namespace of the caller.
With this change, the locks API will expect that if a filesystem returns
a remote pid as opposed to a local pid for F_GETLK, that remote pid will
be <= 0. This signifies that the pid is remote, and the locks API will
forego translating that pid into the pid namespace of the local calling
process.
Finally, we convert remote filesystems to present remote pids using
negative numbers. Have lustre, 9p, ceph, cifs, and dlm negate the remote
pid returned for F_GETLK lock requests.
Since local pids will never be larger than PID_MAX_LIMIT (which is
currently defined as <= 4 million), but pid_t is an unsigned int, we
should have plenty of room to represent remote pids with negative
numbers if we assume that remote pid numbers are similarly limited.
If this is not the case, then we run the risk of having a remote pid
returned for which there is also a corresponding local pid. This is a
problem we have now, but this patch should reduce the chances of that
occurring, while also returning those remote pid numbers, for whatever
that may be worth.
Signed-off-by: Benjamin Coddington <bcodding@redhat.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
2017-07-16 17:28:22 +03:00
flock - > l_pid = locks_translate_pid ( fl , task_active_pid_ns ( current ) ) ;
2007-02-21 00:10:11 +03:00
# if BITS_PER_LONG == 32
/*
* Make sure we can represent the posix lock via
* legacy 32 bit flock .
*/
if ( fl - > fl_start > OFFT_OFFSET_MAX )
return - EOVERFLOW ;
if ( fl - > fl_end ! = OFFSET_MAX & & fl - > fl_end > OFFT_OFFSET_MAX )
return - EOVERFLOW ;
# endif
flock - > l_start = fl - > fl_start ;
flock - > l_len = fl - > fl_end = = OFFSET_MAX ? 0 :
fl - > fl_end - fl - > fl_start + 1 ;
flock - > l_whence = 0 ;
2007-05-11 02:38:43 +04:00
flock - > l_type = fl - > fl_type ;
2007-02-21 00:10:11 +03:00
return 0 ;
}
# if BITS_PER_LONG == 32
static void posix_lock_to_flock64 ( struct flock64 * flock , struct file_lock * fl )
{
fs/locks: Remove fl_nspid and use fs-specific l_pid for remote locks
Since commit c69899a17ca4 "NFSv4: Update of VFS byte range lock must be
atomic with the stateid update", NFSv4 has been inserting locks in rpciod
worker context. The result is that the file_lock's fl_nspid is the
kworker's pid instead of the original userspace pid.
The fl_nspid is only used to represent the namespaced virtual pid number
when displaying locks or returning from F_GETLK. There's no reason to set
it for every inserted lock, since we can usually just look it up from
fl_pid. So, instead of looking up and holding struct pid for every lock,
let's just look up the virtual pid number from fl_pid when it is needed.
That means we can remove fl_nspid entirely.
The translaton and presentation of fl_pid should handle the following four
cases:
1 - F_GETLK on a remote file with a remote lock:
In this case, the filesystem should determine the l_pid to return here.
Filesystems should indicate that the fl_pid represents a non-local pid
value that should not be translated by returning an fl_pid <= 0.
2 - F_GETLK on a local file with a remote lock:
This should be the l_pid of the lock manager process, and translated.
3 - F_GETLK on a remote file with a local lock, and
4 - F_GETLK on a local file with a local lock:
These should be the translated l_pid of the local locking process.
Fuse was already doing the correct thing by translating the pid into the
caller's namespace. With this change we must update fuse to translate
to init's pid namespace, so that the locks API can then translate from
init's pid namespace into the pid namespace of the caller.
With this change, the locks API will expect that if a filesystem returns
a remote pid as opposed to a local pid for F_GETLK, that remote pid will
be <= 0. This signifies that the pid is remote, and the locks API will
forego translating that pid into the pid namespace of the local calling
process.
Finally, we convert remote filesystems to present remote pids using
negative numbers. Have lustre, 9p, ceph, cifs, and dlm negate the remote
pid returned for F_GETLK lock requests.
Since local pids will never be larger than PID_MAX_LIMIT (which is
currently defined as <= 4 million), but pid_t is an unsigned int, we
should have plenty of room to represent remote pids with negative
numbers if we assume that remote pid numbers are similarly limited.
If this is not the case, then we run the risk of having a remote pid
returned for which there is also a corresponding local pid. This is a
problem we have now, but this patch should reduce the chances of that
occurring, while also returning those remote pid numbers, for whatever
that may be worth.
Signed-off-by: Benjamin Coddington <bcodding@redhat.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
2017-07-16 17:28:22 +03:00
flock - > l_pid = locks_translate_pid ( fl , task_active_pid_ns ( current ) ) ;
2007-02-21 00:10:11 +03:00
flock - > l_start = fl - > fl_start ;
flock - > l_len = fl - > fl_end = = OFFSET_MAX ? 0 :
fl - > fl_end - fl - > fl_start + 1 ;
flock - > l_whence = 0 ;
flock - > l_type = fl - > fl_type ;
}
# endif
2005-04-17 02:20:36 +04:00
/* Report the first existing lock that would conflict with l.
* This implements the F_GETLK command of fcntl ( ) .
*/
2017-05-27 13:07:19 +03:00
int fcntl_getlk ( struct file * filp , unsigned int cmd , struct flock * flock )
2005-04-17 02:20:36 +04:00
{
2017-07-16 17:28:21 +03:00
struct file_lock * fl ;
2005-04-17 02:20:36 +04:00
int error ;
2017-07-16 17:28:21 +03:00
fl = locks_alloc_lock ( ) ;
if ( fl = = NULL )
return - ENOMEM ;
2005-04-17 02:20:36 +04:00
error = - EINVAL ;
2017-05-27 13:07:19 +03:00
if ( flock - > l_type ! = F_RDLCK & & flock - > l_type ! = F_WRLCK )
2005-04-17 02:20:36 +04:00
goto out ;
2017-07-16 17:28:21 +03:00
error = flock_to_posix_lock ( filp , fl , flock ) ;
2005-04-17 02:20:36 +04:00
if ( error )
goto out ;
2014-04-22 16:23:58 +04:00
if ( cmd = = F_OFD_GETLK ) {
2014-03-04 19:30:23 +04:00
error = - EINVAL ;
2017-05-27 13:07:19 +03:00
if ( flock - > l_pid ! = 0 )
2014-03-04 19:30:23 +04:00
goto out ;
2017-07-16 17:28:21 +03:00
fl - > fl_flags | = FL_OFDLCK ;
fl - > fl_owner = filp ;
2014-02-03 21:13:10 +04:00
}
2017-07-16 17:28:21 +03:00
error = vfs_test_lock ( filp , fl ) ;
2007-02-21 08:58:50 +03:00
if ( error )
goto out ;
2018-11-30 02:04:08 +03:00
2017-07-16 17:28:21 +03:00
flock - > l_type = fl - > fl_type ;
if ( fl - > fl_type ! = F_UNLCK ) {
error = posix_lock_to_flock ( flock , fl ) ;
2007-02-21 00:10:11 +03:00
if ( error )
2017-07-16 17:28:21 +03:00
goto out ;
2005-04-17 02:20:36 +04:00
}
out :
2017-07-16 17:28:21 +03:00
locks_free_lock ( fl ) ;
2005-04-17 02:20:36 +04:00
return error ;
}
2007-01-18 23:08:55 +03:00
/**
* vfs_lock_file - file byte range lock
* @ filp : The file to apply the lock to
* @ cmd : type of locking operation ( F_SETLK , F_GETLK , etc . )
* @ fl : The lock to be applied
2007-01-19 00:15:35 +03:00
* @ conf : Place to return a copy of the conflicting lock , if found .
*
* A caller that doesn ' t care about the conflicting lock may pass NULL
* as the final argument .
*
* If the filesystem defines a private - > lock ( ) method , then @ conf will
* be left unchanged ; so a caller that cares should initialize it to
* some acceptable default .
locks: add fl_grant callback for asynchronous lock return
Acquiring a lock on a cluster filesystem may require communication with
remote hosts, and to avoid blocking lockd or nfsd threads during such
communication, we allow the results to be returned asynchronously.
When a ->lock() call needs to block, the file system will return
-EINPROGRESS, and then later return the results with a call to the
routine in the fl_grant field of the lock_manager_operations struct.
This differs from the case when ->lock returns -EAGAIN to a blocking
lock request; in that case, the filesystem calls fl_notify when the lock
is granted, and the caller retries the original lock. So while
fl_notify is merely a hint to the caller that it should retry, fl_grant
actually communicates the final result of the lock operation (with the
lock already acquired in the succesful case).
Therefore fl_grant takes a lock, a status and, for the test lock case, a
conflicting lock. We also allow fl_grant to return an error to the
filesystem, to handle the case where the fl_grant requests arrives after
the lock manager has already given up waiting for it.
Signed-off-by: Marc Eshel <eshel@almaden.ibm.com>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
2006-12-06 07:31:28 +03:00
*
* To avoid blocking kernel daemons , such as lockd , that need to acquire POSIX
* locks , the - > lock ( ) interface may return asynchronously , before the lock has
* been granted or denied by the underlying filesystem , if ( and only if )
2011-07-21 04:21:59 +04:00
* lm_grant is set . Callers expecting - > lock ( ) to return asynchronously
locks: add fl_grant callback for asynchronous lock return
Acquiring a lock on a cluster filesystem may require communication with
remote hosts, and to avoid blocking lockd or nfsd threads during such
communication, we allow the results to be returned asynchronously.
When a ->lock() call needs to block, the file system will return
-EINPROGRESS, and then later return the results with a call to the
routine in the fl_grant field of the lock_manager_operations struct.
This differs from the case when ->lock returns -EAGAIN to a blocking
lock request; in that case, the filesystem calls fl_notify when the lock
is granted, and the caller retries the original lock. So while
fl_notify is merely a hint to the caller that it should retry, fl_grant
actually communicates the final result of the lock operation (with the
lock already acquired in the succesful case).
Therefore fl_grant takes a lock, a status and, for the test lock case, a
conflicting lock. We also allow fl_grant to return an error to the
filesystem, to handle the case where the fl_grant requests arrives after
the lock manager has already given up waiting for it.
Signed-off-by: Marc Eshel <eshel@almaden.ibm.com>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
2006-12-06 07:31:28 +03:00
* will only use F_SETLK , not F_SETLKW ; they will set FL_SLEEP if ( and only if )
* the request is for a blocking lock . When - > lock ( ) does return asynchronously ,
2011-07-21 04:21:59 +04:00
* it must return FILE_LOCK_DEFERRED , and call - > lm_grant ( ) when the lock
locks: add fl_grant callback for asynchronous lock return
Acquiring a lock on a cluster filesystem may require communication with
remote hosts, and to avoid blocking lockd or nfsd threads during such
communication, we allow the results to be returned asynchronously.
When a ->lock() call needs to block, the file system will return
-EINPROGRESS, and then later return the results with a call to the
routine in the fl_grant field of the lock_manager_operations struct.
This differs from the case when ->lock returns -EAGAIN to a blocking
lock request; in that case, the filesystem calls fl_notify when the lock
is granted, and the caller retries the original lock. So while
fl_notify is merely a hint to the caller that it should retry, fl_grant
actually communicates the final result of the lock operation (with the
lock already acquired in the succesful case).
Therefore fl_grant takes a lock, a status and, for the test lock case, a
conflicting lock. We also allow fl_grant to return an error to the
filesystem, to handle the case where the fl_grant requests arrives after
the lock manager has already given up waiting for it.
Signed-off-by: Marc Eshel <eshel@almaden.ibm.com>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
2006-12-06 07:31:28 +03:00
* request completes .
* If the request is for non - blocking lock the file system should return
2008-07-25 12:48:57 +04:00
* FILE_LOCK_DEFERRED then try to get the lock and call the callback routine
* with the result . If the request timed out the callback routine will return a
locks: add fl_grant callback for asynchronous lock return
Acquiring a lock on a cluster filesystem may require communication with
remote hosts, and to avoid blocking lockd or nfsd threads during such
communication, we allow the results to be returned asynchronously.
When a ->lock() call needs to block, the file system will return
-EINPROGRESS, and then later return the results with a call to the
routine in the fl_grant field of the lock_manager_operations struct.
This differs from the case when ->lock returns -EAGAIN to a blocking
lock request; in that case, the filesystem calls fl_notify when the lock
is granted, and the caller retries the original lock. So while
fl_notify is merely a hint to the caller that it should retry, fl_grant
actually communicates the final result of the lock operation (with the
lock already acquired in the succesful case).
Therefore fl_grant takes a lock, a status and, for the test lock case, a
conflicting lock. We also allow fl_grant to return an error to the
filesystem, to handle the case where the fl_grant requests arrives after
the lock manager has already given up waiting for it.
Signed-off-by: Marc Eshel <eshel@almaden.ibm.com>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
2006-12-06 07:31:28 +03:00
* nonzero return code and the file system should release the lock . The file
* system is also responsible to keep a corresponding posix lock when it
* grants a lock so the VFS can find out which locks are locally held and do
* the correct lock cleanup when required .
* The underlying filesystem must not drop the kernel lock or call
2011-07-21 04:21:59 +04:00
* - > lm_grant ( ) before returning to the caller with a FILE_LOCK_DEFERRED
locks: add fl_grant callback for asynchronous lock return
Acquiring a lock on a cluster filesystem may require communication with
remote hosts, and to avoid blocking lockd or nfsd threads during such
communication, we allow the results to be returned asynchronously.
When a ->lock() call needs to block, the file system will return
-EINPROGRESS, and then later return the results with a call to the
routine in the fl_grant field of the lock_manager_operations struct.
This differs from the case when ->lock returns -EAGAIN to a blocking
lock request; in that case, the filesystem calls fl_notify when the lock
is granted, and the caller retries the original lock. So while
fl_notify is merely a hint to the caller that it should retry, fl_grant
actually communicates the final result of the lock operation (with the
lock already acquired in the succesful case).
Therefore fl_grant takes a lock, a status and, for the test lock case, a
conflicting lock. We also allow fl_grant to return an error to the
filesystem, to handle the case where the fl_grant requests arrives after
the lock manager has already given up waiting for it.
Signed-off-by: Marc Eshel <eshel@almaden.ibm.com>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
2006-12-06 07:31:28 +03:00
* return code .
2007-01-18 23:08:55 +03:00
*/
2007-01-19 00:15:35 +03:00
int vfs_lock_file ( struct file * filp , unsigned int cmd , struct file_lock * fl , struct file_lock * conf )
2007-01-18 23:08:55 +03:00
{
2018-07-18 16:44:43 +03:00
if ( filp - > f_op - > lock )
2007-01-18 23:08:55 +03:00
return filp - > f_op - > lock ( filp , cmd , fl ) ;
else
2007-01-19 00:15:35 +03:00
return posix_lock_file ( filp , fl , conf ) ;
2007-01-18 23:08:55 +03:00
}
EXPORT_SYMBOL_GPL ( vfs_lock_file ) ;
2008-07-25 12:48:57 +04:00
static int do_lock_file_wait ( struct file * filp , unsigned int cmd ,
struct file_lock * fl )
{
int error ;
error = security_file_lock ( filp , fl - > fl_type ) ;
if ( error )
return error ;
2008-07-25 12:48:58 +04:00
for ( ; ; ) {
error = vfs_lock_file ( filp , cmd , fl , NULL ) ;
if ( error ! = FILE_LOCK_DEFERRED )
2008-07-25 12:48:57 +04:00
break ;
2020-03-18 14:52:21 +03:00
error = wait_event_interruptible ( fl - > fl_wait ,
list_empty ( & fl - > fl_blocked_member ) ) ;
2018-11-30 02:04:08 +03:00
if ( error )
break ;
2008-07-25 12:48:57 +04:00
}
2018-11-30 02:04:08 +03:00
locks_delete_block ( fl ) ;
2008-07-25 12:48:57 +04:00
return error ;
}
2015-10-15 16:07:07 +03:00
/* Ensure that fl->fl_file has compatible f_mode for F_SETLK calls */
2014-05-09 19:41:54 +04:00
static int
check_fmode_for_setlk ( struct file_lock * fl )
{
switch ( fl - > fl_type ) {
case F_RDLCK :
if ( ! ( fl - > fl_file - > f_mode & FMODE_READ ) )
return - EBADF ;
break ;
case F_WRLCK :
if ( ! ( fl - > fl_file - > f_mode & FMODE_WRITE ) )
return - EBADF ;
}
return 0 ;
}
2005-04-17 02:20:36 +04:00
/* Apply the lock described by l to an open file descriptor.
* This implements both the F_SETLK and F_SETLKW commands of fcntl ( ) .
*/
[PATCH] stale POSIX lock handling
I believe that there is a problem with the handling of POSIX locks, which
the attached patch should address.
The problem appears to be a race between fcntl(2) and close(2). A
multithreaded application could close a file descriptor at the same time as
it is trying to acquire a lock using the same file descriptor. I would
suggest that that multithreaded application is not providing the proper
synchronization for itself, but the OS should still behave correctly.
SUS3 (Single UNIX Specification Version 3, read: POSIX) indicates that when
a file descriptor is closed, that all POSIX locks on the file, owned by the
process which closed the file descriptor, should be released.
The trick here is when those locks are released. The current code releases
all locks which exist when close is processing, but any locks in progress
are handled when the last reference to the open file is released.
There are three cases to consider.
One is the simple case, a multithreaded (mt) process has a file open and
races to close it and acquire a lock on it. In this case, the close will
release one reference to the open file and when the fcntl is done, it will
release the other reference. For this situation, no locks should exist on
the file when both the close and fcntl operations are done. The current
system will handle this case because the last reference to the open file is
being released.
The second case is when the mt process has dup(2)'d the file descriptor.
The close will release one reference to the file and the fcntl, when done,
will release another, but there will still be at least one more reference
to the open file. One could argue that the existence of a lock on the file
after the close has completed is okay, because it was acquired after the
close operation and there is still a way for the application to release the
lock on the file, using an existing file descriptor.
The third case is when the mt process has forked, after opening the file
and either before or after becoming an mt process. In this case, each
process would hold a reference to the open file. For each process, this
degenerates to first case above. However, the lock continues to exist
until both processes have released their references to the open file. This
lock could block other lock requests.
The changes to release the lock when the last reference to the open file
aren't quite right because they would allow the lock to exist as long as
there was a reference to the open file. This is too long.
The new proposed solution is to add support in the fcntl code path to
detect a race with close and then to release the lock which was just
acquired when such as race is detected. This causes locks to be released
in a timely fashion and for the system to conform to the POSIX semantic
specification.
This was tested by instrumenting a kernel to detect the handling locks and
then running a program which generates case #3 above. A dangling lock
could be reliably generated. When the changes to detect the close/fcntl
race were added, a dangling lock could no longer be generated.
Cc: Matthew Wilcox <willy@debian.org>
Cc: Trond Myklebust <trond.myklebust@fys.uio.no>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-27 22:45:09 +04:00
int fcntl_setlk ( unsigned int fd , struct file * filp , unsigned int cmd ,
2017-05-27 13:07:19 +03:00
struct flock * flock )
2005-04-17 02:20:36 +04:00
{
struct file_lock * file_lock = locks_alloc_lock ( ) ;
2017-05-27 13:07:19 +03:00
struct inode * inode = locks_inode ( filp ) ;
2008-05-06 21:58:34 +04:00
struct file * f ;
2005-04-17 02:20:36 +04:00
int error ;
if ( file_lock = = NULL )
return - ENOLCK ;
2017-05-27 13:07:19 +03:00
error = flock_to_posix_lock ( filp , file_lock , flock ) ;
2005-04-17 02:20:36 +04:00
if ( error )
goto out ;
2014-02-03 21:13:10 +04:00
2014-05-09 19:41:54 +04:00
error = check_fmode_for_setlk ( file_lock ) ;
if ( error )
goto out ;
2014-02-03 21:13:10 +04:00
/*
* If the cmd is requesting file - private locks , then set the
2014-04-22 16:24:32 +04:00
* FL_OFDLCK flag and override the owner .
2014-02-03 21:13:10 +04:00
*/
switch ( cmd ) {
2014-04-22 16:23:58 +04:00
case F_OFD_SETLK :
2014-03-04 19:30:23 +04:00
error = - EINVAL ;
2017-05-27 13:07:19 +03:00
if ( flock - > l_pid ! = 0 )
2014-03-04 19:30:23 +04:00
goto out ;
2014-02-03 21:13:10 +04:00
cmd = F_SETLK ;
2014-04-22 16:24:32 +04:00
file_lock - > fl_flags | = FL_OFDLCK ;
2014-07-13 19:00:38 +04:00
file_lock - > fl_owner = filp ;
2014-02-03 21:13:10 +04:00
break ;
2014-04-22 16:23:58 +04:00
case F_OFD_SETLKW :
2014-03-04 19:30:23 +04:00
error = - EINVAL ;
2017-05-27 13:07:19 +03:00
if ( flock - > l_pid ! = 0 )
2014-03-04 19:30:23 +04:00
goto out ;
2014-02-03 21:13:10 +04:00
cmd = F_SETLKW ;
2014-04-22 16:24:32 +04:00
file_lock - > fl_flags | = FL_OFDLCK ;
2014-07-13 19:00:38 +04:00
file_lock - > fl_owner = filp ;
2020-08-24 01:36:59 +03:00
fallthrough ;
2014-02-03 21:13:10 +04:00
case F_SETLKW :
2005-04-17 02:20:36 +04:00
file_lock - > fl_flags | = FL_SLEEP ;
}
2014-02-03 21:13:10 +04:00
2008-07-25 12:48:57 +04:00
error = do_lock_file_wait ( filp , cmd , file_lock ) ;
2005-04-17 02:20:36 +04:00
[PATCH] stale POSIX lock handling
I believe that there is a problem with the handling of POSIX locks, which
the attached patch should address.
The problem appears to be a race between fcntl(2) and close(2). A
multithreaded application could close a file descriptor at the same time as
it is trying to acquire a lock using the same file descriptor. I would
suggest that that multithreaded application is not providing the proper
synchronization for itself, but the OS should still behave correctly.
SUS3 (Single UNIX Specification Version 3, read: POSIX) indicates that when
a file descriptor is closed, that all POSIX locks on the file, owned by the
process which closed the file descriptor, should be released.
The trick here is when those locks are released. The current code releases
all locks which exist when close is processing, but any locks in progress
are handled when the last reference to the open file is released.
There are three cases to consider.
One is the simple case, a multithreaded (mt) process has a file open and
races to close it and acquire a lock on it. In this case, the close will
release one reference to the open file and when the fcntl is done, it will
release the other reference. For this situation, no locks should exist on
the file when both the close and fcntl operations are done. The current
system will handle this case because the last reference to the open file is
being released.
The second case is when the mt process has dup(2)'d the file descriptor.
The close will release one reference to the file and the fcntl, when done,
will release another, but there will still be at least one more reference
to the open file. One could argue that the existence of a lock on the file
after the close has completed is okay, because it was acquired after the
close operation and there is still a way for the application to release the
lock on the file, using an existing file descriptor.
The third case is when the mt process has forked, after opening the file
and either before or after becoming an mt process. In this case, each
process would hold a reference to the open file. For each process, this
degenerates to first case above. However, the lock continues to exist
until both processes have released their references to the open file. This
lock could block other lock requests.
The changes to release the lock when the last reference to the open file
aren't quite right because they would allow the lock to exist as long as
there was a reference to the open file. This is too long.
The new proposed solution is to add support in the fcntl code path to
detect a race with close and then to release the lock which was just
acquired when such as race is detected. This causes locks to be released
in a timely fashion and for the system to conform to the POSIX semantic
specification.
This was tested by instrumenting a kernel to detect the handling locks and
then running a program which generates case #3 above. A dangling lock
could be reliably generated. When the changes to detect the close/fcntl
race were added, a dangling lock could no longer be generated.
Cc: Matthew Wilcox <willy@debian.org>
Cc: Trond Myklebust <trond.myklebust@fys.uio.no>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-27 22:45:09 +04:00
/*
2016-01-08 15:30:43 +03:00
* Attempt to detect a close / fcntl race and recover by releasing the
* lock that was just acquired . There is no need to do that when we ' re
* unlocking though , or for OFD locks .
[PATCH] stale POSIX lock handling
I believe that there is a problem with the handling of POSIX locks, which
the attached patch should address.
The problem appears to be a race between fcntl(2) and close(2). A
multithreaded application could close a file descriptor at the same time as
it is trying to acquire a lock using the same file descriptor. I would
suggest that that multithreaded application is not providing the proper
synchronization for itself, but the OS should still behave correctly.
SUS3 (Single UNIX Specification Version 3, read: POSIX) indicates that when
a file descriptor is closed, that all POSIX locks on the file, owned by the
process which closed the file descriptor, should be released.
The trick here is when those locks are released. The current code releases
all locks which exist when close is processing, but any locks in progress
are handled when the last reference to the open file is released.
There are three cases to consider.
One is the simple case, a multithreaded (mt) process has a file open and
races to close it and acquire a lock on it. In this case, the close will
release one reference to the open file and when the fcntl is done, it will
release the other reference. For this situation, no locks should exist on
the file when both the close and fcntl operations are done. The current
system will handle this case because the last reference to the open file is
being released.
The second case is when the mt process has dup(2)'d the file descriptor.
The close will release one reference to the file and the fcntl, when done,
will release another, but there will still be at least one more reference
to the open file. One could argue that the existence of a lock on the file
after the close has completed is okay, because it was acquired after the
close operation and there is still a way for the application to release the
lock on the file, using an existing file descriptor.
The third case is when the mt process has forked, after opening the file
and either before or after becoming an mt process. In this case, each
process would hold a reference to the open file. For each process, this
degenerates to first case above. However, the lock continues to exist
until both processes have released their references to the open file. This
lock could block other lock requests.
The changes to release the lock when the last reference to the open file
aren't quite right because they would allow the lock to exist as long as
there was a reference to the open file. This is too long.
The new proposed solution is to add support in the fcntl code path to
detect a race with close and then to release the lock which was just
acquired when such as race is detected. This causes locks to be released
in a timely fashion and for the system to conform to the POSIX semantic
specification.
This was tested by instrumenting a kernel to detect the handling locks and
then running a program which generates case #3 above. A dangling lock
could be reliably generated. When the changes to detect the close/fcntl
race were added, a dangling lock could no longer be generated.
Cc: Matthew Wilcox <willy@debian.org>
Cc: Trond Myklebust <trond.myklebust@fys.uio.no>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-27 22:45:09 +04:00
*/
2016-01-08 15:30:43 +03:00
if ( ! error & & file_lock - > fl_type ! = F_UNLCK & &
! ( file_lock - > fl_flags & FL_OFDLCK ) ) {
2020-11-21 02:14:25 +03:00
struct files_struct * files = current - > files ;
2016-01-08 00:38:10 +03:00
/*
* We need that spin_lock here - it prevents reordering between
* update of i_flctx - > flc_posix and check for it done in
* close ( ) . rcu_read_lock ( ) wouldn ' t do .
*/
2020-11-21 02:14:25 +03:00
spin_lock ( & files - > file_lock ) ;
f = files_lookup_fd_locked ( files , fd ) ;
spin_unlock ( & files - > file_lock ) ;
2016-01-08 00:38:10 +03:00
if ( f ! = filp ) {
file_lock - > fl_type = F_UNLCK ;
error = do_lock_file_wait ( filp , cmd , file_lock ) ;
WARN_ON_ONCE ( error ) ;
error = - EBADF ;
}
2005-04-17 02:20:36 +04:00
}
[PATCH] stale POSIX lock handling
I believe that there is a problem with the handling of POSIX locks, which
the attached patch should address.
The problem appears to be a race between fcntl(2) and close(2). A
multithreaded application could close a file descriptor at the same time as
it is trying to acquire a lock using the same file descriptor. I would
suggest that that multithreaded application is not providing the proper
synchronization for itself, but the OS should still behave correctly.
SUS3 (Single UNIX Specification Version 3, read: POSIX) indicates that when
a file descriptor is closed, that all POSIX locks on the file, owned by the
process which closed the file descriptor, should be released.
The trick here is when those locks are released. The current code releases
all locks which exist when close is processing, but any locks in progress
are handled when the last reference to the open file is released.
There are three cases to consider.
One is the simple case, a multithreaded (mt) process has a file open and
races to close it and acquire a lock on it. In this case, the close will
release one reference to the open file and when the fcntl is done, it will
release the other reference. For this situation, no locks should exist on
the file when both the close and fcntl operations are done. The current
system will handle this case because the last reference to the open file is
being released.
The second case is when the mt process has dup(2)'d the file descriptor.
The close will release one reference to the file and the fcntl, when done,
will release another, but there will still be at least one more reference
to the open file. One could argue that the existence of a lock on the file
after the close has completed is okay, because it was acquired after the
close operation and there is still a way for the application to release the
lock on the file, using an existing file descriptor.
The third case is when the mt process has forked, after opening the file
and either before or after becoming an mt process. In this case, each
process would hold a reference to the open file. For each process, this
degenerates to first case above. However, the lock continues to exist
until both processes have released their references to the open file. This
lock could block other lock requests.
The changes to release the lock when the last reference to the open file
aren't quite right because they would allow the lock to exist as long as
there was a reference to the open file. This is too long.
The new proposed solution is to add support in the fcntl code path to
detect a race with close and then to release the lock which was just
acquired when such as race is detected. This causes locks to be released
in a timely fashion and for the system to conform to the POSIX semantic
specification.
This was tested by instrumenting a kernel to detect the handling locks and
then running a program which generates case #3 above. A dangling lock
could be reliably generated. When the changes to detect the close/fcntl
race were added, a dangling lock could no longer be generated.
Cc: Matthew Wilcox <willy@debian.org>
Cc: Trond Myklebust <trond.myklebust@fys.uio.no>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-27 22:45:09 +04:00
out :
2016-01-07 05:26:10 +03:00
trace_fcntl_setlk ( inode , file_lock , error ) ;
2005-04-17 02:20:36 +04:00
locks_free_lock ( file_lock ) ;
return error ;
}
# if BITS_PER_LONG == 32
/* Report the first existing lock that would conflict with l.
* This implements the F_GETLK command of fcntl ( ) .
*/
2017-05-27 13:07:19 +03:00
int fcntl_getlk64 ( struct file * filp , unsigned int cmd , struct flock64 * flock )
2005-04-17 02:20:36 +04:00
{
2017-07-16 17:28:21 +03:00
struct file_lock * fl ;
2005-04-17 02:20:36 +04:00
int error ;
2017-07-16 17:28:21 +03:00
fl = locks_alloc_lock ( ) ;
if ( fl = = NULL )
return - ENOMEM ;
2005-04-17 02:20:36 +04:00
error = - EINVAL ;
2017-05-27 13:07:19 +03:00
if ( flock - > l_type ! = F_RDLCK & & flock - > l_type ! = F_WRLCK )
2005-04-17 02:20:36 +04:00
goto out ;
2017-07-16 17:28:21 +03:00
error = flock64_to_posix_lock ( filp , fl , flock ) ;
2005-04-17 02:20:36 +04:00
if ( error )
goto out ;
2014-04-22 16:23:58 +04:00
if ( cmd = = F_OFD_GETLK ) {
2014-03-04 19:30:23 +04:00
error = - EINVAL ;
2017-05-27 13:07:19 +03:00
if ( flock - > l_pid ! = 0 )
2014-03-04 19:30:23 +04:00
goto out ;
2014-02-03 21:13:10 +04:00
cmd = F_GETLK64 ;
2017-07-16 17:28:21 +03:00
fl - > fl_flags | = FL_OFDLCK ;
fl - > fl_owner = filp ;
2014-02-03 21:13:10 +04:00
}
2017-07-16 17:28:21 +03:00
error = vfs_test_lock ( filp , fl ) ;
2007-02-21 08:58:50 +03:00
if ( error )
goto out ;
2017-07-16 17:28:21 +03:00
flock - > l_type = fl - > fl_type ;
if ( fl - > fl_type ! = F_UNLCK )
posix_lock_to_flock64 ( flock , fl ) ;
2014-08-22 18:18:43 +04:00
2005-04-17 02:20:36 +04:00
out :
2017-07-16 17:28:21 +03:00
locks_free_lock ( fl ) ;
2005-04-17 02:20:36 +04:00
return error ;
}
/* Apply the lock described by l to an open file descriptor.
* This implements both the F_SETLK and F_SETLKW commands of fcntl ( ) .
*/
[PATCH] stale POSIX lock handling
I believe that there is a problem with the handling of POSIX locks, which
the attached patch should address.
The problem appears to be a race between fcntl(2) and close(2). A
multithreaded application could close a file descriptor at the same time as
it is trying to acquire a lock using the same file descriptor. I would
suggest that that multithreaded application is not providing the proper
synchronization for itself, but the OS should still behave correctly.
SUS3 (Single UNIX Specification Version 3, read: POSIX) indicates that when
a file descriptor is closed, that all POSIX locks on the file, owned by the
process which closed the file descriptor, should be released.
The trick here is when those locks are released. The current code releases
all locks which exist when close is processing, but any locks in progress
are handled when the last reference to the open file is released.
There are three cases to consider.
One is the simple case, a multithreaded (mt) process has a file open and
races to close it and acquire a lock on it. In this case, the close will
release one reference to the open file and when the fcntl is done, it will
release the other reference. For this situation, no locks should exist on
the file when both the close and fcntl operations are done. The current
system will handle this case because the last reference to the open file is
being released.
The second case is when the mt process has dup(2)'d the file descriptor.
The close will release one reference to the file and the fcntl, when done,
will release another, but there will still be at least one more reference
to the open file. One could argue that the existence of a lock on the file
after the close has completed is okay, because it was acquired after the
close operation and there is still a way for the application to release the
lock on the file, using an existing file descriptor.
The third case is when the mt process has forked, after opening the file
and either before or after becoming an mt process. In this case, each
process would hold a reference to the open file. For each process, this
degenerates to first case above. However, the lock continues to exist
until both processes have released their references to the open file. This
lock could block other lock requests.
The changes to release the lock when the last reference to the open file
aren't quite right because they would allow the lock to exist as long as
there was a reference to the open file. This is too long.
The new proposed solution is to add support in the fcntl code path to
detect a race with close and then to release the lock which was just
acquired when such as race is detected. This causes locks to be released
in a timely fashion and for the system to conform to the POSIX semantic
specification.
This was tested by instrumenting a kernel to detect the handling locks and
then running a program which generates case #3 above. A dangling lock
could be reliably generated. When the changes to detect the close/fcntl
race were added, a dangling lock could no longer be generated.
Cc: Matthew Wilcox <willy@debian.org>
Cc: Trond Myklebust <trond.myklebust@fys.uio.no>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-27 22:45:09 +04:00
int fcntl_setlk64 ( unsigned int fd , struct file * filp , unsigned int cmd ,
2017-05-27 13:07:19 +03:00
struct flock64 * flock )
2005-04-17 02:20:36 +04:00
{
struct file_lock * file_lock = locks_alloc_lock ( ) ;
2008-05-06 21:58:34 +04:00
struct file * f ;
2005-04-17 02:20:36 +04:00
int error ;
if ( file_lock = = NULL )
return - ENOLCK ;
2017-05-27 13:07:19 +03:00
error = flock64_to_posix_lock ( filp , file_lock , flock ) ;
2005-04-17 02:20:36 +04:00
if ( error )
goto out ;
2014-02-03 21:13:10 +04:00
2014-05-09 19:41:54 +04:00
error = check_fmode_for_setlk ( file_lock ) ;
if ( error )
goto out ;
2014-02-03 21:13:10 +04:00
/*
* If the cmd is requesting file - private locks , then set the
2014-04-22 16:24:32 +04:00
* FL_OFDLCK flag and override the owner .
2014-02-03 21:13:10 +04:00
*/
switch ( cmd ) {
2014-04-22 16:23:58 +04:00
case F_OFD_SETLK :
2014-03-04 19:30:23 +04:00
error = - EINVAL ;
2017-05-27 13:07:19 +03:00
if ( flock - > l_pid ! = 0 )
2014-03-04 19:30:23 +04:00
goto out ;
2014-02-03 21:13:10 +04:00
cmd = F_SETLK64 ;
2014-04-22 16:24:32 +04:00
file_lock - > fl_flags | = FL_OFDLCK ;
2014-07-13 19:00:38 +04:00
file_lock - > fl_owner = filp ;
2014-02-03 21:13:10 +04:00
break ;
2014-04-22 16:23:58 +04:00
case F_OFD_SETLKW :
2014-03-04 19:30:23 +04:00
error = - EINVAL ;
2017-05-27 13:07:19 +03:00
if ( flock - > l_pid ! = 0 )
2014-03-04 19:30:23 +04:00
goto out ;
2014-02-03 21:13:10 +04:00
cmd = F_SETLKW64 ;
2014-04-22 16:24:32 +04:00
file_lock - > fl_flags | = FL_OFDLCK ;
2014-07-13 19:00:38 +04:00
file_lock - > fl_owner = filp ;
2020-08-24 01:36:59 +03:00
fallthrough ;
2014-02-03 21:13:10 +04:00
case F_SETLKW64 :
2005-04-17 02:20:36 +04:00
file_lock - > fl_flags | = FL_SLEEP ;
}
2014-02-03 21:13:10 +04:00
2008-07-25 12:48:57 +04:00
error = do_lock_file_wait ( filp , cmd , file_lock ) ;
2005-04-17 02:20:36 +04:00
[PATCH] stale POSIX lock handling
I believe that there is a problem with the handling of POSIX locks, which
the attached patch should address.
The problem appears to be a race between fcntl(2) and close(2). A
multithreaded application could close a file descriptor at the same time as
it is trying to acquire a lock using the same file descriptor. I would
suggest that that multithreaded application is not providing the proper
synchronization for itself, but the OS should still behave correctly.
SUS3 (Single UNIX Specification Version 3, read: POSIX) indicates that when
a file descriptor is closed, that all POSIX locks on the file, owned by the
process which closed the file descriptor, should be released.
The trick here is when those locks are released. The current code releases
all locks which exist when close is processing, but any locks in progress
are handled when the last reference to the open file is released.
There are three cases to consider.
One is the simple case, a multithreaded (mt) process has a file open and
races to close it and acquire a lock on it. In this case, the close will
release one reference to the open file and when the fcntl is done, it will
release the other reference. For this situation, no locks should exist on
the file when both the close and fcntl operations are done. The current
system will handle this case because the last reference to the open file is
being released.
The second case is when the mt process has dup(2)'d the file descriptor.
The close will release one reference to the file and the fcntl, when done,
will release another, but there will still be at least one more reference
to the open file. One could argue that the existence of a lock on the file
after the close has completed is okay, because it was acquired after the
close operation and there is still a way for the application to release the
lock on the file, using an existing file descriptor.
The third case is when the mt process has forked, after opening the file
and either before or after becoming an mt process. In this case, each
process would hold a reference to the open file. For each process, this
degenerates to first case above. However, the lock continues to exist
until both processes have released their references to the open file. This
lock could block other lock requests.
The changes to release the lock when the last reference to the open file
aren't quite right because they would allow the lock to exist as long as
there was a reference to the open file. This is too long.
The new proposed solution is to add support in the fcntl code path to
detect a race with close and then to release the lock which was just
acquired when such as race is detected. This causes locks to be released
in a timely fashion and for the system to conform to the POSIX semantic
specification.
This was tested by instrumenting a kernel to detect the handling locks and
then running a program which generates case #3 above. A dangling lock
could be reliably generated. When the changes to detect the close/fcntl
race were added, a dangling lock could no longer be generated.
Cc: Matthew Wilcox <willy@debian.org>
Cc: Trond Myklebust <trond.myklebust@fys.uio.no>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-27 22:45:09 +04:00
/*
2016-01-08 15:30:43 +03:00
* Attempt to detect a close / fcntl race and recover by releasing the
* lock that was just acquired . There is no need to do that when we ' re
* unlocking though , or for OFD locks .
[PATCH] stale POSIX lock handling
I believe that there is a problem with the handling of POSIX locks, which
the attached patch should address.
The problem appears to be a race between fcntl(2) and close(2). A
multithreaded application could close a file descriptor at the same time as
it is trying to acquire a lock using the same file descriptor. I would
suggest that that multithreaded application is not providing the proper
synchronization for itself, but the OS should still behave correctly.
SUS3 (Single UNIX Specification Version 3, read: POSIX) indicates that when
a file descriptor is closed, that all POSIX locks on the file, owned by the
process which closed the file descriptor, should be released.
The trick here is when those locks are released. The current code releases
all locks which exist when close is processing, but any locks in progress
are handled when the last reference to the open file is released.
There are three cases to consider.
One is the simple case, a multithreaded (mt) process has a file open and
races to close it and acquire a lock on it. In this case, the close will
release one reference to the open file and when the fcntl is done, it will
release the other reference. For this situation, no locks should exist on
the file when both the close and fcntl operations are done. The current
system will handle this case because the last reference to the open file is
being released.
The second case is when the mt process has dup(2)'d the file descriptor.
The close will release one reference to the file and the fcntl, when done,
will release another, but there will still be at least one more reference
to the open file. One could argue that the existence of a lock on the file
after the close has completed is okay, because it was acquired after the
close operation and there is still a way for the application to release the
lock on the file, using an existing file descriptor.
The third case is when the mt process has forked, after opening the file
and either before or after becoming an mt process. In this case, each
process would hold a reference to the open file. For each process, this
degenerates to first case above. However, the lock continues to exist
until both processes have released their references to the open file. This
lock could block other lock requests.
The changes to release the lock when the last reference to the open file
aren't quite right because they would allow the lock to exist as long as
there was a reference to the open file. This is too long.
The new proposed solution is to add support in the fcntl code path to
detect a race with close and then to release the lock which was just
acquired when such as race is detected. This causes locks to be released
in a timely fashion and for the system to conform to the POSIX semantic
specification.
This was tested by instrumenting a kernel to detect the handling locks and
then running a program which generates case #3 above. A dangling lock
could be reliably generated. When the changes to detect the close/fcntl
race were added, a dangling lock could no longer be generated.
Cc: Matthew Wilcox <willy@debian.org>
Cc: Trond Myklebust <trond.myklebust@fys.uio.no>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-27 22:45:09 +04:00
*/
2016-01-08 15:30:43 +03:00
if ( ! error & & file_lock - > fl_type ! = F_UNLCK & &
! ( file_lock - > fl_flags & FL_OFDLCK ) ) {
2020-11-21 02:14:25 +03:00
struct files_struct * files = current - > files ;
2016-01-08 00:38:10 +03:00
/*
* We need that spin_lock here - it prevents reordering between
* update of i_flctx - > flc_posix and check for it done in
* close ( ) . rcu_read_lock ( ) wouldn ' t do .
*/
2020-11-21 02:14:25 +03:00
spin_lock ( & files - > file_lock ) ;
f = files_lookup_fd_locked ( files , fd ) ;
spin_unlock ( & files - > file_lock ) ;
2016-01-08 00:38:10 +03:00
if ( f ! = filp ) {
file_lock - > fl_type = F_UNLCK ;
error = do_lock_file_wait ( filp , cmd , file_lock ) ;
WARN_ON_ONCE ( error ) ;
error = - EBADF ;
}
2005-04-17 02:20:36 +04:00
}
out :
locks_free_lock ( file_lock ) ;
return error ;
}
# endif /* BITS_PER_LONG == 32 */
/*
* This function is called when the file is being removed
* from the task ' s fd array . POSIX locks belonging to this task
* are deleted at this time .
*/
void locks_remove_posix ( struct file * filp , fl_owner_t owner )
{
2016-01-07 05:26:10 +03:00
int error ;
2016-09-16 13:44:20 +03:00
struct inode * inode = locks_inode ( filp ) ;
2006-06-23 13:05:11 +04:00
struct file_lock lock ;
2015-09-21 10:43:06 +03:00
struct file_lock_context * ctx ;
2005-04-17 02:20:36 +04:00
/*
* If there are no locks held on this file , we don ' t need to call
* posix_lock_file ( ) . Another process could be setting a lock on this
* file at the same time , but we wouldn ' t remove that lock anyway .
*/
2016-09-16 13:44:20 +03:00
ctx = smp_load_acquire ( & inode - > i_flctx ) ;
2015-01-16 23:05:55 +03:00
if ( ! ctx | | list_empty ( & ctx - > flc_posix ) )
2005-04-17 02:20:36 +04:00
return ;
2018-11-30 02:04:08 +03:00
locks_init_lock ( & lock ) ;
2005-04-17 02:20:36 +04:00
lock . fl_type = F_UNLCK ;
2006-06-23 13:05:12 +04:00
lock . fl_flags = FL_POSIX | FL_CLOSE ;
2005-04-17 02:20:36 +04:00
lock . fl_start = 0 ;
lock . fl_end = OFFSET_MAX ;
lock . fl_owner = owner ;
lock . fl_pid = current - > tgid ;
lock . fl_file = filp ;
lock . fl_ops = NULL ;
lock . fl_lmops = NULL ;
2016-01-07 05:26:10 +03:00
error = vfs_lock_file ( filp , F_SETLK , & lock , NULL ) ;
2005-04-17 02:20:36 +04:00
if ( lock . fl_ops & & lock . fl_ops - > fl_release_private )
lock . fl_ops - > fl_release_private ( & lock ) ;
2016-09-16 13:44:20 +03:00
trace_locks_remove_posix ( inode , & lock , error ) ;
2005-04-17 02:20:36 +04:00
}
EXPORT_SYMBOL ( locks_remove_posix ) ;
2015-01-16 23:05:58 +03:00
/* The i_flctx must be valid when calling into here */
2015-01-16 23:05:54 +03:00
static void
2015-09-21 10:43:06 +03:00
locks_remove_flock ( struct file * filp , struct file_lock_context * flctx )
2015-01-16 23:05:54 +03:00
{
2018-11-30 02:04:08 +03:00
struct file_lock fl ;
2016-09-16 13:44:20 +03:00
struct inode * inode = locks_inode ( filp ) ;
2015-01-16 23:05:54 +03:00
2015-01-16 23:05:58 +03:00
if ( list_empty ( & flctx - > flc_flock ) )
2015-01-16 23:05:54 +03:00
return ;
2018-11-30 02:04:08 +03:00
flock_make_lock ( filp , LOCK_UN , & fl ) ;
fl . fl_flags | = FL_CLOSE ;
2018-07-18 16:44:43 +03:00
if ( filp - > f_op - > flock )
2015-01-16 23:05:54 +03:00
filp - > f_op - > flock ( filp , F_SETLKW , & fl ) ;
else
2015-07-11 13:43:02 +03:00
flock_lock_inode ( inode , & fl ) ;
2015-01-16 23:05:54 +03:00
if ( fl . fl_ops & & fl . fl_ops - > fl_release_private )
fl . fl_ops - > fl_release_private ( & fl ) ;
}
2015-01-16 23:05:58 +03:00
/* The i_flctx must be valid when calling into here */
2015-01-16 23:05:55 +03:00
static void
2015-09-21 10:43:06 +03:00
locks_remove_lease ( struct file * filp , struct file_lock_context * ctx )
2015-01-16 23:05:55 +03:00
{
struct file_lock * fl , * tmp ;
LIST_HEAD ( dispose ) ;
2015-01-16 23:05:58 +03:00
if ( list_empty ( & ctx - > flc_lease ) )
2015-01-16 23:05:55 +03:00
return ;
2019-02-21 17:38:40 +03:00
percpu_down_read ( & file_rwsem ) ;
2015-01-16 23:05:57 +03:00
spin_lock ( & ctx - > flc_lock ) ;
2015-01-16 23:05:55 +03:00
list_for_each_entry_safe ( fl , tmp , & ctx - > flc_lease , fl_list )
2015-02-17 03:37:42 +03:00
if ( filp = = fl - > fl_file )
lease_modify ( fl , F_UNLCK , & dispose ) ;
2015-01-16 23:05:57 +03:00
spin_unlock ( & ctx - > flc_lock ) ;
2019-02-21 17:38:40 +03:00
percpu_up_read ( & file_rwsem ) ;
2016-10-08 11:12:28 +03:00
2015-01-16 23:05:55 +03:00
locks_dispose_list ( & dispose ) ;
}
2005-04-17 02:20:36 +04:00
/*
* This function is called on the last close of an open file .
*/
2014-02-03 21:13:08 +04:00
void locks_remove_file ( struct file * filp )
2005-04-17 02:20:36 +04:00
{
2015-09-21 10:43:06 +03:00
struct file_lock_context * ctx ;
2016-09-16 13:44:20 +03:00
ctx = smp_load_acquire ( & locks_inode ( filp ) - > i_flctx ) ;
2015-09-21 10:43:06 +03:00
if ( ! ctx )
2015-01-16 23:05:58 +03:00
return ;
2015-01-16 23:05:54 +03:00
/* remove any OFD locks */
2014-07-13 19:00:38 +04:00
locks_remove_posix ( filp , filp ) ;
2014-02-03 21:13:10 +04:00
2015-01-16 23:05:54 +03:00
/* remove flock locks */
2015-09-21 10:43:06 +03:00
locks_remove_flock ( filp , ctx ) ;
2015-01-16 23:05:54 +03:00
2015-01-16 23:05:55 +03:00
/* remove any leases */
2015-09-21 10:43:06 +03:00
locks_remove_lease ( filp , ctx ) ;
2017-07-21 20:36:25 +03:00
spin_lock ( & ctx - > flc_lock ) ;
locks_check_ctx_file_list ( filp , & ctx - > flc_posix , " POSIX " ) ;
locks_check_ctx_file_list ( filp , & ctx - > flc_flock , " FLOCK " ) ;
locks_check_ctx_file_list ( filp , & ctx - > flc_lease , " LEASE " ) ;
spin_unlock ( & ctx - > flc_lock ) ;
2005-04-17 02:20:36 +04:00
}
2007-01-19 01:52:58 +03:00
/**
* vfs_cancel_lock - file byte range unblock lock
* @ filp : The file to apply the unblock to
* @ fl : The lock to be unblocked
*
* Used by lock managers to cancel blocked requests
*/
int vfs_cancel_lock ( struct file * filp , struct file_lock * fl )
{
2018-07-18 16:44:43 +03:00
if ( filp - > f_op - > lock )
2007-01-19 01:52:58 +03:00
return filp - > f_op - > lock ( filp , F_CANCELLK , fl ) ;
return 0 ;
}
EXPORT_SYMBOL_GPL ( vfs_cancel_lock ) ;
2007-10-02 01:41:15 +04:00
# ifdef CONFIG_PROC_FS
2008-10-04 22:34:18 +04:00
# include <linux/proc_fs.h>
2007-10-02 01:41:15 +04:00
# include <linux/seq_file.h>
2013-06-21 16:58:22 +04:00
struct locks_iterator {
int li_cpu ;
loff_t li_pos ;
} ;
2007-10-02 01:41:15 +04:00
static void lock_get_status ( struct seq_file * f , struct file_lock * fl ,
2021-02-26 06:58:29 +03:00
loff_t id , char * pfx , int repeat )
2005-04-17 02:20:36 +04:00
{
struct inode * inode = NULL ;
2008-01-17 03:07:08 +03:00
unsigned int fl_pid ;
2020-05-18 21:07:38 +03:00
struct pid_namespace * proc_pidns = proc_pid_ns ( file_inode ( f - > file ) - > i_sb ) ;
2021-09-10 22:36:29 +03:00
int type ;
2008-01-17 03:07:08 +03:00
fs/locks: Remove fl_nspid and use fs-specific l_pid for remote locks
Since commit c69899a17ca4 "NFSv4: Update of VFS byte range lock must be
atomic with the stateid update", NFSv4 has been inserting locks in rpciod
worker context. The result is that the file_lock's fl_nspid is the
kworker's pid instead of the original userspace pid.
The fl_nspid is only used to represent the namespaced virtual pid number
when displaying locks or returning from F_GETLK. There's no reason to set
it for every inserted lock, since we can usually just look it up from
fl_pid. So, instead of looking up and holding struct pid for every lock,
let's just look up the virtual pid number from fl_pid when it is needed.
That means we can remove fl_nspid entirely.
The translaton and presentation of fl_pid should handle the following four
cases:
1 - F_GETLK on a remote file with a remote lock:
In this case, the filesystem should determine the l_pid to return here.
Filesystems should indicate that the fl_pid represents a non-local pid
value that should not be translated by returning an fl_pid <= 0.
2 - F_GETLK on a local file with a remote lock:
This should be the l_pid of the lock manager process, and translated.
3 - F_GETLK on a remote file with a local lock, and
4 - F_GETLK on a local file with a local lock:
These should be the translated l_pid of the local locking process.
Fuse was already doing the correct thing by translating the pid into the
caller's namespace. With this change we must update fuse to translate
to init's pid namespace, so that the locks API can then translate from
init's pid namespace into the pid namespace of the caller.
With this change, the locks API will expect that if a filesystem returns
a remote pid as opposed to a local pid for F_GETLK, that remote pid will
be <= 0. This signifies that the pid is remote, and the locks API will
forego translating that pid into the pid namespace of the local calling
process.
Finally, we convert remote filesystems to present remote pids using
negative numbers. Have lustre, 9p, ceph, cifs, and dlm negate the remote
pid returned for F_GETLK lock requests.
Since local pids will never be larger than PID_MAX_LIMIT (which is
currently defined as <= 4 million), but pid_t is an unsigned int, we
should have plenty of room to represent remote pids with negative
numbers if we assume that remote pid numbers are similarly limited.
If this is not the case, then we run the risk of having a remote pid
returned for which there is also a corresponding local pid. This is a
problem we have now, but this patch should reduce the chances of that
occurring, while also returning those remote pid numbers, for whatever
that may be worth.
Signed-off-by: Benjamin Coddington <bcodding@redhat.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
2017-07-16 17:28:22 +03:00
fl_pid = locks_translate_pid ( fl , proc_pidns ) ;
/*
2018-06-08 17:27:12 +03:00
* If lock owner is dead ( and pid is freed ) or not visible in current
* pidns , zero is shown as a pid value . Check lock info from
* init_pid_ns to get saved lock pid value .
fs/locks: Remove fl_nspid and use fs-specific l_pid for remote locks
Since commit c69899a17ca4 "NFSv4: Update of VFS byte range lock must be
atomic with the stateid update", NFSv4 has been inserting locks in rpciod
worker context. The result is that the file_lock's fl_nspid is the
kworker's pid instead of the original userspace pid.
The fl_nspid is only used to represent the namespaced virtual pid number
when displaying locks or returning from F_GETLK. There's no reason to set
it for every inserted lock, since we can usually just look it up from
fl_pid. So, instead of looking up and holding struct pid for every lock,
let's just look up the virtual pid number from fl_pid when it is needed.
That means we can remove fl_nspid entirely.
The translaton and presentation of fl_pid should handle the following four
cases:
1 - F_GETLK on a remote file with a remote lock:
In this case, the filesystem should determine the l_pid to return here.
Filesystems should indicate that the fl_pid represents a non-local pid
value that should not be translated by returning an fl_pid <= 0.
2 - F_GETLK on a local file with a remote lock:
This should be the l_pid of the lock manager process, and translated.
3 - F_GETLK on a remote file with a local lock, and
4 - F_GETLK on a local file with a local lock:
These should be the translated l_pid of the local locking process.
Fuse was already doing the correct thing by translating the pid into the
caller's namespace. With this change we must update fuse to translate
to init's pid namespace, so that the locks API can then translate from
init's pid namespace into the pid namespace of the caller.
With this change, the locks API will expect that if a filesystem returns
a remote pid as opposed to a local pid for F_GETLK, that remote pid will
be <= 0. This signifies that the pid is remote, and the locks API will
forego translating that pid into the pid namespace of the local calling
process.
Finally, we convert remote filesystems to present remote pids using
negative numbers. Have lustre, 9p, ceph, cifs, and dlm negate the remote
pid returned for F_GETLK lock requests.
Since local pids will never be larger than PID_MAX_LIMIT (which is
currently defined as <= 4 million), but pid_t is an unsigned int, we
should have plenty of room to represent remote pids with negative
numbers if we assume that remote pid numbers are similarly limited.
If this is not the case, then we run the risk of having a remote pid
returned for which there is also a corresponding local pid. This is a
problem we have now, but this patch should reduce the chances of that
occurring, while also returning those remote pid numbers, for whatever
that may be worth.
Signed-off-by: Benjamin Coddington <bcodding@redhat.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
2017-07-16 17:28:22 +03:00
*/
2005-04-17 02:20:36 +04:00
if ( fl - > fl_file ! = NULL )
2016-09-16 13:44:20 +03:00
inode = locks_inode ( fl - > fl_file ) ;
2005-04-17 02:20:36 +04:00
2021-02-26 06:58:29 +03:00
seq_printf ( f , " %lld: " , id ) ;
if ( repeat )
seq_printf ( f , " %*s " , repeat - 1 + ( int ) strlen ( pfx ) , pfx ) ;
2005-04-17 02:20:36 +04:00
if ( IS_POSIX ( fl ) ) {
2014-02-03 21:13:09 +04:00
if ( fl - > fl_flags & FL_ACCESS )
2014-05-09 22:13:05 +04:00
seq_puts ( f , " ACCESS " ) ;
2014-04-22 16:24:32 +04:00
else if ( IS_OFDLCK ( fl ) )
2014-05-09 22:13:05 +04:00
seq_puts ( f , " OFDLCK " ) ;
2014-02-03 21:13:09 +04:00
else
2014-05-09 22:13:05 +04:00
seq_puts ( f , " POSIX " ) ;
2014-02-03 21:13:09 +04:00
seq_printf ( f , " %s " ,
2021-08-19 21:56:38 +03:00
( inode = = NULL ) ? " *NOINODE* " : " ADVISORY " ) ;
2005-04-17 02:20:36 +04:00
} else if ( IS_FLOCK ( fl ) ) {
2021-09-10 22:36:29 +03:00
seq_puts ( f , " FLOCK ADVISORY " ) ;
2005-04-17 02:20:36 +04:00
} else if ( IS_LEASE ( fl ) ) {
2014-08-11 21:36:54 +04:00
if ( fl - > fl_flags & FL_DELEG )
seq_puts ( f , " DELEG " ) ;
else
seq_puts ( f , " LEASE " ) ;
2011-07-27 04:10:51 +04:00
if ( lease_breaking ( fl ) )
2014-05-09 22:13:05 +04:00
seq_puts ( f , " BREAKING " ) ;
2005-04-17 02:20:36 +04:00
else if ( fl - > fl_file )
2014-05-09 22:13:05 +04:00
seq_puts ( f , " ACTIVE " ) ;
2005-04-17 02:20:36 +04:00
else
2014-05-09 22:13:05 +04:00
seq_puts ( f , " BREAKER " ) ;
2005-04-17 02:20:36 +04:00
} else {
2014-05-09 22:13:05 +04:00
seq_puts ( f , " UNKNOWN UNKNOWN " ) ;
2005-04-17 02:20:36 +04:00
}
2021-09-10 22:36:29 +03:00
type = IS_LEASE ( fl ) ? target_leasetype ( fl ) : fl - > fl_type ;
2019-07-24 20:16:31 +03:00
2021-09-10 22:36:29 +03:00
seq_printf ( f , " %s " , ( type = = F_WRLCK ) ? " WRITE " :
( type = = F_RDLCK ) ? " READ " : " UNLCK " ) ;
2005-04-17 02:20:36 +04:00
if ( inode ) {
2015-04-03 16:04:04 +03:00
/* userspace relies on this representation of dev_t */
2019-12-22 21:45:28 +03:00
seq_printf ( f , " %d %02x:%02x:%lu " , fl_pid ,
2005-04-17 02:20:36 +04:00
MAJOR ( inode - > i_sb - > s_dev ) ,
MINOR ( inode - > i_sb - > s_dev ) , inode - > i_ino ) ;
} else {
2008-01-17 03:07:08 +03:00
seq_printf ( f , " %d <none>:0 " , fl_pid ) ;
2005-04-17 02:20:36 +04:00
}
if ( IS_POSIX ( fl ) ) {
if ( fl - > fl_end = = OFFSET_MAX )
2007-10-02 01:41:15 +04:00
seq_printf ( f , " %Ld EOF \n " , fl - > fl_start ) ;
2005-04-17 02:20:36 +04:00
else
2007-10-02 01:41:15 +04:00
seq_printf ( f , " %Ld %Ld \n " , fl - > fl_start , fl - > fl_end ) ;
2005-04-17 02:20:36 +04:00
} else {
2014-05-09 22:13:05 +04:00
seq_puts ( f , " 0 EOF \n " ) ;
2005-04-17 02:20:36 +04:00
}
}
2021-02-26 06:58:29 +03:00
static struct file_lock * get_next_blocked_member ( struct file_lock * node )
{
struct file_lock * tmp ;
/* NULL node or root node */
if ( node = = NULL | | node - > fl_blocker = = NULL )
return NULL ;
/* Next member in the linked list could be itself */
tmp = list_next_entry ( node , fl_blocked_member ) ;
if ( list_entry_is_head ( tmp , & node - > fl_blocker - > fl_blocked_requests , fl_blocked_member )
| | tmp = = node ) {
return NULL ;
}
return tmp ;
}
2007-10-02 01:41:15 +04:00
static int locks_show ( struct seq_file * f , void * v )
2005-04-17 02:20:36 +04:00
{
2013-06-21 16:58:22 +04:00
struct locks_iterator * iter = f - > private ;
2021-02-26 06:58:29 +03:00
struct file_lock * cur , * tmp ;
2020-05-18 21:07:38 +03:00
struct pid_namespace * proc_pidns = proc_pid_ns ( file_inode ( f - > file ) - > i_sb ) ;
2021-02-26 06:58:29 +03:00
int level = 0 ;
2005-04-17 02:20:36 +04:00
2021-02-26 06:58:29 +03:00
cur = hlist_entry ( v , struct file_lock , fl_link ) ;
2005-04-17 02:20:36 +04:00
2021-02-26 06:58:29 +03:00
if ( locks_translate_pid ( cur , proc_pidns ) = = 0 )
2016-08-17 23:18:46 +03:00
return 0 ;
2021-02-26 06:58:29 +03:00
/* View this crossed linked list as a binary tree, the first member of fl_blocked_requests
* is the left child of current node , the next silibing in fl_blocked_member is the
* right child , we can alse get the parent of current node from fl_blocker , so this
* question becomes traversal of a binary tree
*/
while ( cur ! = NULL ) {
if ( level )
lock_get_status ( f , cur , iter - > li_pos , " -> " , level ) ;
else
lock_get_status ( f , cur , iter - > li_pos , " " , level ) ;
2005-04-17 02:20:36 +04:00
2021-02-26 06:58:29 +03:00
if ( ! list_empty ( & cur - > fl_blocked_requests ) ) {
/* Turn left */
cur = list_first_entry_or_null ( & cur - > fl_blocked_requests ,
struct file_lock , fl_blocked_member ) ;
level + + ;
} else {
/* Turn right */
tmp = get_next_blocked_member ( cur ) ;
/* Fall back to parent node */
while ( tmp = = NULL & & cur - > fl_blocker ! = NULL ) {
cur = cur - > fl_blocker ;
level - - ;
tmp = get_next_blocked_member ( cur ) ;
}
cur = tmp ;
}
}
2007-10-02 22:21:34 +04:00
2007-10-02 01:41:15 +04:00
return 0 ;
}
2005-04-17 02:20:36 +04:00
2015-04-16 22:49:38 +03:00
static void __show_fd_locks ( struct seq_file * f ,
struct list_head * head , int * id ,
struct file * filp , struct files_struct * files )
{
struct file_lock * fl ;
list_for_each_entry ( fl , head , fl_list ) {
if ( filp ! = fl - > fl_file )
continue ;
if ( fl - > fl_owner ! = files & &
fl - > fl_owner ! = filp )
continue ;
( * id ) + + ;
seq_puts ( f , " lock: \t " ) ;
2021-02-26 06:58:29 +03:00
lock_get_status ( f , fl , * id , " " , 0 ) ;
2015-04-16 22:49:38 +03:00
}
}
void show_fd_locks ( struct seq_file * f ,
struct file * filp , struct files_struct * files )
{
2016-09-16 13:44:20 +03:00
struct inode * inode = locks_inode ( filp ) ;
2015-04-16 22:49:38 +03:00
struct file_lock_context * ctx ;
int id = 0 ;
2015-09-21 10:43:06 +03:00
ctx = smp_load_acquire ( & inode - > i_flctx ) ;
2015-04-16 22:49:38 +03:00
if ( ! ctx )
return ;
spin_lock ( & ctx - > flc_lock ) ;
__show_fd_locks ( f , & ctx - > flc_flock , & id , filp , files ) ;
__show_fd_locks ( f , & ctx - > flc_posix , & id , filp , files ) ;
__show_fd_locks ( f , & ctx - > flc_lease , & id , filp , files ) ;
spin_unlock ( & ctx - > flc_lock ) ;
}
2007-10-02 01:41:15 +04:00
static void * locks_start ( struct seq_file * f , loff_t * pos )
2014-02-03 21:13:07 +04:00
__acquires ( & blocked_lock_lock )
2007-10-02 01:41:15 +04:00
{
2013-06-21 16:58:22 +04:00
struct locks_iterator * iter = f - > private ;
2010-10-27 01:22:33 +04:00
2013-06-21 16:58:22 +04:00
iter - > li_pos = * pos + 1 ;
2015-06-22 15:16:33 +03:00
percpu_down_write ( & file_rwsem ) ;
2013-06-21 16:58:20 +04:00
spin_lock ( & blocked_lock_lock ) ;
2015-06-22 15:16:34 +03:00
return seq_hlist_start_percpu ( & file_lock_list . hlist , & iter - > li_cpu , * pos ) ;
2007-10-02 01:41:15 +04:00
}
2005-04-17 02:20:36 +04:00
2007-10-02 01:41:15 +04:00
static void * locks_next ( struct seq_file * f , void * v , loff_t * pos )
{
2013-06-21 16:58:22 +04:00
struct locks_iterator * iter = f - > private ;
+ + iter - > li_pos ;
2015-06-22 15:16:34 +03:00
return seq_hlist_next_percpu ( v , & file_lock_list . hlist , & iter - > li_cpu , pos ) ;
2007-10-02 01:41:15 +04:00
}
2005-04-17 02:20:36 +04:00
2007-10-02 01:41:15 +04:00
static void locks_stop ( struct seq_file * f , void * v )
2014-02-03 21:13:07 +04:00
__releases ( & blocked_lock_lock )
2007-10-02 01:41:15 +04:00
{
2013-06-21 16:58:20 +04:00
spin_unlock ( & blocked_lock_lock ) ;
2015-06-22 15:16:33 +03:00
percpu_up_write ( & file_rwsem ) ;
2005-04-17 02:20:36 +04:00
}
2008-10-04 22:34:18 +04:00
static const struct seq_operations locks_seq_operations = {
2007-10-02 01:41:15 +04:00
. start = locks_start ,
. next = locks_next ,
. stop = locks_stop ,
. show = locks_show ,
} ;
2008-10-04 22:34:18 +04:00
static int __init proc_locks_init ( void )
{
2018-04-24 18:05:17 +03:00
proc_create_seq_private ( " locks " , 0 , NULL , & locks_seq_operations ,
sizeof ( struct locks_iterator ) , NULL ) ;
2008-10-04 22:34:18 +04:00
return 0 ;
}
2015-12-17 22:11:03 +03:00
fs_initcall ( proc_locks_init ) ;
2007-10-02 01:41:15 +04:00
# endif
2005-04-17 02:20:36 +04:00
static int __init filelock_init ( void )
{
2013-06-21 16:58:22 +04:00
int i ;
2015-01-16 23:05:54 +03:00
flctx_cache = kmem_cache_create ( " file_lock_ctx " ,
2021-09-07 21:21:48 +03:00
sizeof ( struct file_lock_context ) , 0 , SLAB_PANIC , NULL ) ;
2015-01-16 23:05:54 +03:00
2005-04-17 02:20:36 +04:00
filelock_cache = kmem_cache_create ( " file_lock_cache " ,
2021-09-07 21:21:48 +03:00
sizeof ( struct file_lock ) , 0 , SLAB_PANIC , NULL ) ;
2011-07-07 15:06:09 +04:00
2015-06-22 15:16:34 +03:00
for_each_possible_cpu ( i ) {
struct file_lock_list_struct * fll = per_cpu_ptr ( & file_lock_list , i ) ;
spin_lock_init ( & fll - > lock ) ;
INIT_HLIST_HEAD ( & fll - > hlist ) ;
}
2013-06-21 16:58:22 +04:00
2019-08-18 21:18:45 +03:00
lease_notifier_chain_init ( ) ;
2005-04-17 02:20:36 +04:00
return 0 ;
}
core_initcall ( filelock_init ) ;