Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617/* SPDX-License-Identifier: GPL-2.0 */#ifndef _LINUX_FILELOCK_H#define _LINUX_FILELOCK_H
#include <linux/fs.h>
#define FL_POSIX BIT(0) /* POSIX lock */#define FL_FLOCK BIT(1) /* BSD lock */#define FL_DELEG BIT(2) /* NFSv4 delegation */#define FL_ACCESS BIT(3) /* not trying to lock, just looking */#define FL_EXISTS BIT(4) /* when unlocking, test for existence */#define FL_LEASE BIT(5) /* file lease */#define FL_CLOSE BIT(6) /* unlock on close */#define FL_SLEEP BIT(7) /* A blocking lock */#define FL_DOWNGRADE_PENDING BIT(8) /* Lease is being downgraded */#define FL_UNLOCK_PENDING BIT(9) /* Lease is being broken */#define FL_OFDLCK BIT(10) /* POSIX lock "owned" by struct file */#define FL_LAYOUT BIT(11) /* outstanding pNFS layout */#define FL_RECLAIM BIT(12) /* reclaiming from a reboot server */#define FL_IGN_DIR_CREATE BIT(13) /* ignore DIR_CREATE events */#define FL_IGN_DIR_DELETE BIT(14) /* ignore DIR_DELETE events */#define FL_IGN_DIR_RENAME BIT(15) /* ignore DIR_RENAME events */
#define FL_CLOSE_POSIX (FL_POSIX | FL_CLOSE)
/* * Special return value from posix_lock_file() and vfs_lock_file() for * asynchronous locking. */#define FILE_LOCK_DEFERRED 1
#define LEASE_BREAK_LEASE BIT(0) // break leases and delegations#define LEASE_BREAK_DELEG BIT(1) // break delegations only#define LEASE_BREAK_LAYOUT BIT(2) // break layouts only#define LEASE_BREAK_NONBLOCK BIT(3) // non-blocking break#define LEASE_BREAK_OPEN_RDONLY BIT(4) // readonly open event#define LEASE_BREAK_DIR_CREATE BIT(5) // dir deleg create event#define LEASE_BREAK_DIR_DELETE BIT(6) // dir deleg delete event#define LEASE_BREAK_DIR_RENAME BIT(7) // dir deleg rename event
struct file_lock;struct file_lease;
struct file_lock_operations { void (*fl_copy_lock)(struct file_lock *, struct file_lock *); void (*fl_release_private)(struct file_lock *);};
struct lock_manager_operations { void *lm_mod_owner; fl_owner_t (*lm_get_owner)(fl_owner_t); void (*lm_put_owner)(fl_owner_t); void (*lm_notify)(struct file_lock *); /* unblock callback */ int (*lm_grant)(struct file_lock *, int); bool (*lm_lock_expirable)(struct file_lock *cfl); void (*lm_expire_lock)(void);};
struct lease_manager_operations { bool (*lm_break)(struct file_lease *); int (*lm_change)(struct file_lease *, int, struct list_head *); void (*lm_setup)(struct file_lease *, void **); bool (*lm_breaker_owns_lease)(struct file_lease *); int (*lm_open_conflict)(struct file *, int); bool (*lm_breaker_timedout)(struct file_lease *fl);};
struct lock_manager { struct list_head list; /* * NFSv4 and up also want opens blocked during the grace period; * NLM doesn't care: */ bool block_opens;};
struct net;void locks_start_grace(struct net *, struct lock_manager *);void locks_end_grace(struct lock_manager *);bool locks_in_grace(struct net *);bool opens_in_grace(struct net *);
/* * struct file_lock has a union that some filesystems use to track * their own private info. The NFS side of things is defined here: */#include <linux/nfs_fs_i.h>
/* * struct file_lock represents a generic "file lock". It's used to represent * POSIX byte range locks, BSD (flock) locks, and leases. It's important to * note that the same struct is used to represent both a request for a lock and * the lock itself, but the same object is never used for both. * * FIXME: should we create a separate "struct lock_request" to help distinguish * these two uses? * * The varous i_flctx lists are ordered by: * * 1) lock owner * 2) lock range start * 3) lock range end * * Obviously, the last two criteria only matter for POSIX locks. */
struct file_lock_core { struct file_lock_core *flc_blocker; /* The lock that is blocking us */ struct list_head flc_list; /* link into file_lock_context */ struct hlist_node flc_link; /* node in global lists */ struct list_head flc_blocked_requests; /* list of requests with * ->fl_blocker pointing here */ struct list_head flc_blocked_member; /* node in * ->fl_blocker->fl_blocked_requests */ fl_owner_t flc_owner; unsigned int flc_flags; unsigned char flc_type; pid_t flc_pid; int flc_link_cpu; /* what cpu's list is this on? */ wait_queue_head_t flc_wait; struct file *flc_file;};
struct file_lock { struct file_lock_core c; loff_t fl_start; loff_t fl_end;
const struct file_lock_operations *fl_ops; /* Callbacks for filesystems */ const struct lock_manager_operations *fl_lmops; /* Callbacks for lockmanagers */ union { struct nfs_lock_info nfs_fl; struct nfs4_lock_info nfs4_fl; struct { struct list_head link; /* link in AFS vnode's pending_locks list */ int state; /* state of grant or error if -ve */ unsigned int debug_id; } afs; struct { struct inode *inode; } ceph; } fl_u;} __randomize_layout;
struct file_lease { struct file_lock_core c; struct fasync_struct * fl_fasync; /* for lease break notifications */ /* for lease breaks: */ unsigned long fl_break_time; unsigned long fl_downgrade_time; const struct lease_manager_operations *fl_lmops; /* Callbacks for lease managers */} __randomize_layout;
struct file_lock_context { spinlock_t flc_lock; struct list_head flc_flock; struct list_head flc_posix; struct list_head flc_lease;};
#ifdef CONFIG_FILE_LOCKINGint fcntl_getlk(struct file *, unsigned int, struct flock *);int fcntl_setlk(unsigned int, struct file *, unsigned int, struct flock *);
#if BITS_PER_LONG == 32int fcntl_getlk64(struct file *, unsigned int, struct flock64 *);int fcntl_setlk64(unsigned int, struct file *, unsigned int, struct flock64 *);#endif
int fcntl_setlease(unsigned int fd, struct file *filp, int arg);int fcntl_getlease(struct file *filp);int fcntl_setdeleg(unsigned int fd, struct file *filp, struct delegation *deleg);int fcntl_getdeleg(struct file *filp, struct delegation *deleg);
static inline bool lock_is_unlock(struct file_lock *fl){ return fl->c.flc_type == F_UNLCK;}
static inline bool lock_is_read(struct file_lock *fl){ return fl->c.flc_type == F_RDLCK;}
static inline bool lock_is_write(struct file_lock *fl){ return fl->c.flc_type == F_WRLCK;}
static inline void locks_wake_up_waiter(struct file_lock_core *flc){ wake_up(&flc->flc_wait);}
static inline void locks_wake_up(struct file_lock *fl){ locks_wake_up_waiter(&fl->c);}
static inline bool locks_can_async_lock(const struct file_operations *fops){ return !fops->lock || fops->fop_flags & FOP_ASYNC_LOCK;}
/* fs/locks.c */void locks_free_lock_context(struct inode *inode);void locks_free_lock(struct file_lock *fl);void locks_init_lock(struct file_lock *);struct file_lock *locks_alloc_lock(void);void locks_copy_lock(struct file_lock *, struct file_lock *);void locks_copy_conflock(struct file_lock *, struct file_lock *);void locks_remove_posix(struct file *, fl_owner_t);void locks_remove_file(struct file *);void locks_release_private(struct file_lock *);void posix_test_lock(struct file *, struct file_lock *);int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);int locks_delete_block(struct file_lock *);int vfs_test_lock(struct file *, struct file_lock *);int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);int vfs_cancel_lock(struct file *filp, struct file_lock *fl);bool vfs_inode_has_locks(struct inode *inode);int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl);
void locks_init_lease(struct file_lease *);void locks_free_lease(struct file_lease *fl);struct file_lease *locks_alloc_lease(void);int __break_lease(struct inode *inode, unsigned int flags);void lease_get_mtime(struct inode *, struct timespec64 *time);int generic_setlease(struct file *, int, struct file_lease **, void **priv);int kernel_setlease(struct file *, int, struct file_lease **, void **);int vfs_setlease(struct file *, int, struct file_lease **, void **);int lease_modify(struct file_lease *, int, struct list_head *);u32 inode_lease_ignore_mask(struct inode *inode);
struct notifier_block;int lease_register_notifier(struct notifier_block *);void lease_unregister_notifier(struct notifier_block *);
struct files_struct;void show_fd_locks(struct seq_file *f, struct file *filp, struct files_struct *files);bool locks_owner_has_blockers(struct file_lock_context *flctx, fl_owner_t owner);
static inline struct file_lock_context *locks_inode_context(const struct inode *inode){ /* * Paired with smp_store_release in locks_get_lock_context(). * * Ensures ->i_flctx will be visible if we spotted the flag. */ if (likely(!(smp_load_acquire(&inode->i_opflags) & IOP_FLCTX))) return NULL; return READ_ONCE(inode->i_flctx);}
#else /* !CONFIG_FILE_LOCKING */static inline int fcntl_getlk(struct file *file, unsigned int cmd, struct flock __user *user){ return -EINVAL;}
static inline int fcntl_setlk(unsigned int fd, struct file *file, unsigned int cmd, struct flock __user *user){ return -EACCES;}
#if BITS_PER_LONG == 32static inline int fcntl_getlk64(struct file *file, unsigned int cmd, struct flock64 *user){ return -EINVAL;}
static inline int fcntl_setlk64(unsigned int fd, struct file *file, unsigned int cmd, struct flock64 *user){ return -EACCES;}#endifstatic inline int fcntl_setlease(unsigned int fd, struct file *filp, int arg){ return -EINVAL;}
static inline int fcntl_getlease(struct file *filp){ return F_UNLCK;}
static inline int fcntl_setdeleg(unsigned int fd, struct file *filp, struct delegation *deleg){ return -EINVAL;}
static inline int fcntl_getdeleg(struct file *filp, struct delegation *deleg){ return -EINVAL;}
static inline bool lock_is_unlock(struct file_lock *fl){ return false;}
static inline bool lock_is_read(struct file_lock *fl){ return false;}
static inline bool lock_is_write(struct file_lock *fl){ return false;}
static inline void locks_wake_up(struct file_lock *fl){}
static inline voidlocks_free_lock_context(struct inode *inode){}
static inline void locks_init_lock(struct file_lock *fl){ return;}
static inline void locks_init_lease(struct file_lease *fl){ return;}
static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl){ return;}
static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl){ return;}
static inline void locks_remove_posix(struct file *filp, fl_owner_t owner){ return;}
static inline void locks_remove_file(struct file *filp){ return;}
static inline void posix_test_lock(struct file *filp, struct file_lock *fl){ return;}
static inline int posix_lock_file(struct file *filp, struct file_lock *fl, struct file_lock *conflock){ return -ENOLCK;}
static inline int locks_delete_block(struct file_lock *waiter){ return -ENOENT;}
static inline int vfs_test_lock(struct file *filp, struct file_lock *fl){ return 0;}
static inline int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf){ return -ENOLCK;}
static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl){ return 0;}
static inline bool vfs_inode_has_locks(struct inode *inode){ return false;}
static inline int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl){ return -ENOLCK;}
static inline int __break_lease(struct inode *inode, unsigned int flags){ return 0;}
static inline void lease_get_mtime(struct inode *inode, struct timespec64 *time){ return;}
static inline int generic_setlease(struct file *filp, int arg, struct file_lease **flp, void **priv){ return -EINVAL;}
static inline int kernel_setlease(struct file *filp, int arg, struct file_lease **lease, void **priv){ return -EINVAL;}
static inline int vfs_setlease(struct file *filp, int arg, struct file_lease **lease, void **priv){ return -EINVAL;}
static inline int lease_modify(struct file_lease *fl, int arg, struct list_head *dispose){ return -EINVAL;}
struct files_struct;static inline void show_fd_locks(struct seq_file *f, struct file *filp, struct files_struct *files) {}static inline bool locks_owner_has_blockers(struct file_lock_context *flctx, fl_owner_t owner){ return false;}
static inline struct file_lock_context *locks_inode_context(const struct inode *inode){ return NULL;}
#endif /* !CONFIG_FILE_LOCKING */
/* for walking lists of file_locks linked by fl_list */#define for_each_file_lock(_fl, _head) list_for_each_entry(_fl, _head, c.flc_list)
static inline int locks_lock_file_wait(struct file *filp, struct file_lock *fl){ return locks_lock_inode_wait(file_inode(filp), fl);}
#ifdef CONFIG_FILE_LOCKINGstatic inline unsigned int openmode_to_lease_flags(unsigned int mode){ unsigned int flags = 0;
if ((mode & O_ACCMODE) == O_RDONLY) flags |= LEASE_BREAK_OPEN_RDONLY; if (mode & O_NONBLOCK) flags |= LEASE_BREAK_NONBLOCK; return flags;}
static inline int break_lease(struct inode *inode, unsigned int mode){ struct file_lock_context *flctx;
/* * Since this check is lockless, we must ensure that any refcounts * taken are done before checking i_flctx->flc_lease. Otherwise, we * could end up racing with tasks trying to set a new lease on this * file. */ flctx = locks_inode_context(inode); if (!flctx) return 0; smp_mb(); if (!list_empty_careful(&flctx->flc_lease)) return __break_lease(inode, LEASE_BREAK_LEASE | openmode_to_lease_flags(mode)); return 0;}
static inline int break_deleg(struct inode *inode, unsigned int flags){ struct file_lock_context *flctx;
/* * Since this check is lockless, we must ensure that any refcounts * taken are done before checking i_flctx->flc_lease. Otherwise, we * could end up racing with tasks trying to set a new lease on this * file. */ flctx = locks_inode_context(inode); if (!flctx) return 0; smp_mb(); if (!list_empty_careful(&flctx->flc_lease)) { flags |= LEASE_BREAK_DELEG; return __break_lease(inode, flags); } return 0;}
struct delegated_inode { struct inode *di_inode;};
static inline bool is_delegated(struct delegated_inode *di){ return di->di_inode;}
/** * try_break_deleg - do a non-blocking delegation break * @inode: inode that should have its delegations broken * @flags: extra LEASE_BREAK_* flags to pass to break_deleg() * @di: returns pointer to delegated inode (may be NULL) * * Break delegations in a non-blocking fashion. If there are * outstanding delegations and @di is set, then an extra reference * will be taken on @inode and @di->di_inode will be populated so * that it may be waited upon. * * Returns 0 if there is no need to wait or an error. If -EWOULDBLOCK * is returned, then @di will be populated (if non-NULL). */static inline int try_break_deleg(struct inode *inode, unsigned int flags, struct delegated_inode *di){ int ret;
ret = break_deleg(inode, flags | LEASE_BREAK_NONBLOCK); if (ret == -EWOULDBLOCK && di) { di->di_inode = inode; ihold(inode); } return ret;}
static inline int break_deleg_wait(struct delegated_inode *di){ int ret;
ret = break_deleg(di->di_inode, 0); iput(di->di_inode); di->di_inode = NULL; return ret;}
static inline int break_layout(struct inode *inode, bool wait){ struct file_lock_context *flctx;
smp_mb(); flctx = locks_inode_context(inode); if (flctx && !list_empty_careful(&flctx->flc_lease)) { unsigned int flags = LEASE_BREAK_LAYOUT;
if (!wait) flags |= LEASE_BREAK_NONBLOCK;
return __break_lease(inode, flags); } return 0;}
#else /* !CONFIG_FILE_LOCKING */struct delegated_inode { };
static inline bool is_delegated(struct delegated_inode *di){ return false;}
static inline int break_lease(struct inode *inode, unsigned int mode){ return 0;}
static inline int break_deleg(struct inode *inode, unsigned int flags){ return 0;}
static inline int try_break_deleg(struct inode *inode, unsigned int flags, struct delegated_inode *delegated_inode){ return 0;}
static inline int break_deleg_wait(struct delegated_inode *delegated_inode){ BUG(); return 0;}
static inline int break_layout(struct inode *inode, bool wait){ return 0;}
#endif /* CONFIG_FILE_LOCKING */
#endif /* _LINUX_FILELOCK_H */