| Message ID | 20240116-flsplit-v1-3-c9d0f4370a5d@kernel.org |
|---|---|
| State | New |
| Headers | show |
| Series | filelock: split struct file_lock into file_lock and file_lease structs | expand |
On Tue, Jan 16, 2024 at 02:45:59PM -0500, Jeff Layton wrote: > This is the direct result of the changes generated by coccinelle. There > is still about 1/4 of the callsites that need to be touched by hand > here. > > Signed-off-by: Jeff Layton <jlayton@kernel.org> For the changes in include/linux/lockd/lockd.h, fs/lockd/, and fs/nfsd/: Acked-by: Chuck Lever <chuck.lever@oracle.com> > --- > fs/9p/vfs_file.c | 38 ++--- > fs/afs/flock.c | 55 +++--- > fs/ceph/locks.c | 66 +++---- > fs/dlm/plock.c | 44 ++--- > fs/fuse/file.c | 14 +- > fs/gfs2/file.c | 16 +- > fs/lockd/clnt4xdr.c | 6 +- > fs/lockd/clntlock.c | 2 +- > fs/lockd/clntproc.c | 60 ++++--- > fs/lockd/clntxdr.c | 6 +- > fs/lockd/svclock.c | 10 +- > fs/lockd/svcsubs.c | 20 +-- > fs/lockd/xdr.c | 6 +- > fs/lockd/xdr4.c | 6 +- > fs/locks.c | 406 +++++++++++++++++++++++--------------------- > fs/nfs/delegation.c | 2 +- > fs/nfs/file.c | 22 +-- > fs/nfs/nfs3proc.c | 2 +- > fs/nfs/nfs4proc.c | 35 ++-- > fs/nfs/nfs4state.c | 4 +- > fs/nfs/nfs4xdr.c | 8 +- > fs/nfs/write.c | 4 +- > fs/nfsd/filecache.c | 4 +- > fs/nfsd/nfs4layouts.c | 15 +- > fs/nfsd/nfs4state.c | 73 ++++---- > fs/ocfs2/locks.c | 12 +- > fs/ocfs2/stack_user.c | 2 +- > fs/smb/client/cifssmb.c | 8 +- > fs/smb/client/file.c | 72 ++++---- > fs/smb/client/smb2file.c | 2 +- > fs/smb/server/smb2pdu.c | 44 ++--- > fs/smb/server/vfs.c | 12 +- > include/linux/lockd/lockd.h | 8 +- > 33 files changed, 554 insertions(+), 530 deletions(-) > > diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c > index 11cd8d23f6f2..f35ac7cb782e 100644 > --- a/fs/9p/vfs_file.c > +++ b/fs/9p/vfs_file.c > @@ -107,7 +107,7 @@ static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl) > > p9_debug(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl); > > - if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { > + if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_core.fl_type != F_UNLCK) { > filemap_write_and_wait(inode->i_mapping); > invalidate_mapping_pages(&inode->i_data, 0, -1); > } > @@ -127,7 +127,7 @@ static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl) > fid = filp->private_data; > BUG_ON(fid == NULL); > > - BUG_ON((fl->fl_flags & FL_POSIX) != FL_POSIX); > + BUG_ON((fl->fl_core.fl_flags & FL_POSIX) != FL_POSIX); > > res = locks_lock_file_wait(filp, fl); > if (res < 0) > @@ -136,7 +136,7 @@ static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl) > /* convert posix lock to p9 tlock args */ > memset(&flock, 0, sizeof(flock)); > /* map the lock type */ > - switch (fl->fl_type) { > + switch (fl->fl_core.fl_type) { > case F_RDLCK: > flock.type = P9_LOCK_TYPE_RDLCK; > break; > @@ -152,7 +152,7 @@ static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl) > flock.length = 0; > else > flock.length = fl->fl_end - fl->fl_start + 1; > - flock.proc_id = fl->fl_pid; > + flock.proc_id = fl->fl_core.fl_pid; > flock.client_id = fid->clnt->name; > if (IS_SETLKW(cmd)) > flock.flags = P9_LOCK_FLAGS_BLOCK; > @@ -207,12 +207,12 @@ static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl) > * incase server returned error for lock request, revert > * it locally > */ > - if (res < 0 && fl->fl_type != F_UNLCK) { > - fl_type = fl->fl_type; > - fl->fl_type = F_UNLCK; > + if (res < 0 && fl->fl_core.fl_type != F_UNLCK) { > + fl_type = fl->fl_core.fl_type; > + fl->fl_core.fl_type = F_UNLCK; > /* Even if this fails we want to return the remote error */ > locks_lock_file_wait(filp, fl); > - fl->fl_type = fl_type; > + fl->fl_core.fl_type = fl_type; > } > if (flock.client_id != fid->clnt->name) > kfree(flock.client_id); > @@ -234,7 +234,7 @@ static int v9fs_file_getlock(struct file *filp, struct file_lock *fl) > * if we have a conflicting lock locally, no need to validate > * with server > */ > - if (fl->fl_type != F_UNLCK) > + if (fl->fl_core.fl_type != F_UNLCK) > return res; > > /* convert posix lock to p9 tgetlock args */ > @@ -245,7 +245,7 @@ static int v9fs_file_getlock(struct file *filp, struct file_lock *fl) > glock.length = 0; > else > glock.length = fl->fl_end - fl->fl_start + 1; > - glock.proc_id = fl->fl_pid; > + glock.proc_id = fl->fl_core.fl_pid; > glock.client_id = fid->clnt->name; > > res = p9_client_getlock_dotl(fid, &glock); > @@ -254,13 +254,13 @@ static int v9fs_file_getlock(struct file *filp, struct file_lock *fl) > /* map 9p lock type to os lock type */ > switch (glock.type) { > case P9_LOCK_TYPE_RDLCK: > - fl->fl_type = F_RDLCK; > + fl->fl_core.fl_type = F_RDLCK; > break; > case P9_LOCK_TYPE_WRLCK: > - fl->fl_type = F_WRLCK; > + fl->fl_core.fl_type = F_WRLCK; > break; > case P9_LOCK_TYPE_UNLCK: > - fl->fl_type = F_UNLCK; > + fl->fl_core.fl_type = F_UNLCK; > break; > } > if (glock.type != P9_LOCK_TYPE_UNLCK) { > @@ -269,7 +269,7 @@ static int v9fs_file_getlock(struct file *filp, struct file_lock *fl) > fl->fl_end = OFFSET_MAX; > else > fl->fl_end = glock.start + glock.length - 1; > - fl->fl_pid = -glock.proc_id; > + fl->fl_core.fl_pid = -glock.proc_id; > } > out: > if (glock.client_id != fid->clnt->name) > @@ -293,7 +293,7 @@ static int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl) > p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %pD\n", > filp, cmd, fl, filp); > > - if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { > + if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_core.fl_type != F_UNLCK) { > filemap_write_and_wait(inode->i_mapping); > invalidate_mapping_pages(&inode->i_data, 0, -1); > } > @@ -324,16 +324,16 @@ static int v9fs_file_flock_dotl(struct file *filp, int cmd, > p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %pD\n", > filp, cmd, fl, filp); > > - if (!(fl->fl_flags & FL_FLOCK)) > + if (!(fl->fl_core.fl_flags & FL_FLOCK)) > goto out_err; > > - if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { > + if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_core.fl_type != F_UNLCK) { > filemap_write_and_wait(inode->i_mapping); > invalidate_mapping_pages(&inode->i_data, 0, -1); > } > /* Convert flock to posix lock */ > - fl->fl_flags |= FL_POSIX; > - fl->fl_flags ^= FL_FLOCK; > + fl->fl_core.fl_flags |= FL_POSIX; > + fl->fl_core.fl_flags ^= FL_FLOCK; > > if (IS_SETLK(cmd) | IS_SETLKW(cmd)) > ret = v9fs_file_do_lock(filp, cmd, fl); > diff --git a/fs/afs/flock.c b/fs/afs/flock.c > index 9c6dea3139f5..212cca72c061 100644 > --- a/fs/afs/flock.c > +++ b/fs/afs/flock.c > @@ -93,13 +93,13 @@ static void afs_grant_locks(struct afs_vnode *vnode) > bool exclusive = (vnode->lock_type == AFS_LOCK_WRITE); > > list_for_each_entry_safe(p, _p, &vnode->pending_locks, fl_u.afs.link) { > - if (!exclusive && p->fl_type == F_WRLCK) > + if (!exclusive && p->fl_core.fl_type == F_WRLCK) > continue; > > list_move_tail(&p->fl_u.afs.link, &vnode->granted_locks); > p->fl_u.afs.state = AFS_LOCK_GRANTED; > trace_afs_flock_op(vnode, p, afs_flock_op_grant); > - wake_up(&p->fl_wait); > + wake_up(&p->fl_core.fl_wait); > } > } > > @@ -121,16 +121,16 @@ static void afs_next_locker(struct afs_vnode *vnode, int error) > > list_for_each_entry_safe(p, _p, &vnode->pending_locks, fl_u.afs.link) { > if (error && > - p->fl_type == fl_type && > - afs_file_key(p->fl_file) == key) { > + p->fl_core.fl_type == fl_type && > + afs_file_key(p->fl_core.fl_file) == key) { > list_del_init(&p->fl_u.afs.link); > p->fl_u.afs.state = error; > - wake_up(&p->fl_wait); > + wake_up(&p->fl_core.fl_wait); > } > > /* Select the next locker to hand off to. */ > if (next && > - (next->fl_type == F_WRLCK || p->fl_type == F_RDLCK)) > + (next->fl_core.fl_type == F_WRLCK || p->fl_core.fl_type == F_RDLCK)) > continue; > next = p; > } > @@ -142,7 +142,7 @@ static void afs_next_locker(struct afs_vnode *vnode, int error) > afs_set_lock_state(vnode, AFS_VNODE_LOCK_SETTING); > next->fl_u.afs.state = AFS_LOCK_YOUR_TRY; > trace_afs_flock_op(vnode, next, afs_flock_op_wake); > - wake_up(&next->fl_wait); > + wake_up(&next->fl_core.fl_wait); > } else { > afs_set_lock_state(vnode, AFS_VNODE_LOCK_NONE); > trace_afs_flock_ev(vnode, NULL, afs_flock_no_lockers, 0); > @@ -166,7 +166,7 @@ static void afs_kill_lockers_enoent(struct afs_vnode *vnode) > struct file_lock, fl_u.afs.link); > list_del_init(&p->fl_u.afs.link); > p->fl_u.afs.state = -ENOENT; > - wake_up(&p->fl_wait); > + wake_up(&p->fl_core.fl_wait); > } > > key_put(vnode->lock_key); > @@ -464,14 +464,14 @@ static int afs_do_setlk(struct file *file, struct file_lock *fl) > > _enter("{%llx:%llu},%llu-%llu,%u,%u", > vnode->fid.vid, vnode->fid.vnode, > - fl->fl_start, fl->fl_end, fl->fl_type, mode); > + fl->fl_start, fl->fl_end, fl->fl_core.fl_type, mode); > > fl->fl_ops = &afs_lock_ops; > INIT_LIST_HEAD(&fl->fl_u.afs.link); > fl->fl_u.afs.state = AFS_LOCK_PENDING; > > partial = (fl->fl_start != 0 || fl->fl_end != OFFSET_MAX); > - type = (fl->fl_type == F_RDLCK) ? AFS_LOCK_READ : AFS_LOCK_WRITE; > + type = (fl->fl_core.fl_type == F_RDLCK) ? AFS_LOCK_READ : AFS_LOCK_WRITE; > if (mode == afs_flock_mode_write && partial) > type = AFS_LOCK_WRITE; > > @@ -524,7 +524,7 @@ static int afs_do_setlk(struct file *file, struct file_lock *fl) > } > > if (vnode->lock_state == AFS_VNODE_LOCK_NONE && > - !(fl->fl_flags & FL_SLEEP)) { > + !(fl->fl_core.fl_flags & FL_SLEEP)) { > ret = -EAGAIN; > if (type == AFS_LOCK_READ) { > if (vnode->status.lock_count == -1) > @@ -621,7 +621,7 @@ static int afs_do_setlk(struct file *file, struct file_lock *fl) > return 0; > > lock_is_contended: > - if (!(fl->fl_flags & FL_SLEEP)) { > + if (!(fl->fl_core.fl_flags & FL_SLEEP)) { > list_del_init(&fl->fl_u.afs.link); > afs_next_locker(vnode, 0); > ret = -EAGAIN; > @@ -641,7 +641,7 @@ static int afs_do_setlk(struct file *file, struct file_lock *fl) > spin_unlock(&vnode->lock); > > trace_afs_flock_ev(vnode, fl, afs_flock_waiting, 0); > - ret = wait_event_interruptible(fl->fl_wait, > + ret = wait_event_interruptible(fl->fl_core.fl_wait, > fl->fl_u.afs.state != AFS_LOCK_PENDING); > trace_afs_flock_ev(vnode, fl, afs_flock_waited, ret); > > @@ -704,7 +704,8 @@ static int afs_do_unlk(struct file *file, struct file_lock *fl) > struct afs_vnode *vnode = AFS_FS_I(file_inode(file)); > int ret; > > - _enter("{%llx:%llu},%u", vnode->fid.vid, vnode->fid.vnode, fl->fl_type); > + _enter("{%llx:%llu},%u", vnode->fid.vid, vnode->fid.vnode, > + fl->fl_core.fl_type); > > trace_afs_flock_op(vnode, fl, afs_flock_op_unlock); > > @@ -730,11 +731,11 @@ static int afs_do_getlk(struct file *file, struct file_lock *fl) > if (vnode->lock_state == AFS_VNODE_LOCK_DELETED) > return -ENOENT; > > - fl->fl_type = F_UNLCK; > + fl->fl_core.fl_type = F_UNLCK; > > /* check local lock records first */ > posix_test_lock(file, fl); > - if (fl->fl_type == F_UNLCK) { > + if (fl->fl_core.fl_type == F_UNLCK) { > /* no local locks; consult the server */ > ret = afs_fetch_status(vnode, key, false, NULL); > if (ret < 0) > @@ -743,18 +744,18 @@ static int afs_do_getlk(struct file *file, struct file_lock *fl) > lock_count = READ_ONCE(vnode->status.lock_count); > if (lock_count != 0) { > if (lock_count > 0) > - fl->fl_type = F_RDLCK; > + fl->fl_core.fl_type = F_RDLCK; > else > - fl->fl_type = F_WRLCK; > + fl->fl_core.fl_type = F_WRLCK; > fl->fl_start = 0; > fl->fl_end = OFFSET_MAX; > - fl->fl_pid = 0; > + fl->fl_core.fl_pid = 0; > } > } > > ret = 0; > error: > - _leave(" = %d [%hd]", ret, fl->fl_type); > + _leave(" = %d [%hd]", ret, fl->fl_core.fl_type); > return ret; > } > > @@ -769,7 +770,7 @@ int afs_lock(struct file *file, int cmd, struct file_lock *fl) > > _enter("{%llx:%llu},%d,{t=%x,fl=%x,r=%Ld:%Ld}", > vnode->fid.vid, vnode->fid.vnode, cmd, > - fl->fl_type, fl->fl_flags, > + fl->fl_core.fl_type, fl->fl_core.fl_flags, > (long long) fl->fl_start, (long long) fl->fl_end); > > if (IS_GETLK(cmd)) > @@ -778,7 +779,7 @@ int afs_lock(struct file *file, int cmd, struct file_lock *fl) > fl->fl_u.afs.debug_id = atomic_inc_return(&afs_file_lock_debug_id); > trace_afs_flock_op(vnode, fl, afs_flock_op_lock); > > - if (fl->fl_type == F_UNLCK) > + if (fl->fl_core.fl_type == F_UNLCK) > ret = afs_do_unlk(file, fl); > else > ret = afs_do_setlk(file, fl); > @@ -804,7 +805,7 @@ int afs_flock(struct file *file, int cmd, struct file_lock *fl) > > _enter("{%llx:%llu},%d,{t=%x,fl=%x}", > vnode->fid.vid, vnode->fid.vnode, cmd, > - fl->fl_type, fl->fl_flags); > + fl->fl_core.fl_type, fl->fl_core.fl_flags); > > /* > * No BSD flocks over NFS allowed. > @@ -813,14 +814,14 @@ int afs_flock(struct file *file, int cmd, struct file_lock *fl) > * Not sure whether that would be unique, though, or whether > * that would break in other places. > */ > - if (!(fl->fl_flags & FL_FLOCK)) > + if (!(fl->fl_core.fl_flags & FL_FLOCK)) > return -ENOLCK; > > fl->fl_u.afs.debug_id = atomic_inc_return(&afs_file_lock_debug_id); > trace_afs_flock_op(vnode, fl, afs_flock_op_flock); > > /* we're simulating flock() locks using posix locks on the server */ > - if (fl->fl_type == F_UNLCK) > + if (fl->fl_core.fl_type == F_UNLCK) > ret = afs_do_unlk(file, fl); > else > ret = afs_do_setlk(file, fl); > @@ -843,7 +844,7 @@ int afs_flock(struct file *file, int cmd, struct file_lock *fl) > */ > static void afs_fl_copy_lock(struct file_lock *new, struct file_lock *fl) > { > - struct afs_vnode *vnode = AFS_FS_I(file_inode(fl->fl_file)); > + struct afs_vnode *vnode = AFS_FS_I(file_inode(fl->fl_core.fl_file)); > > _enter(""); > > @@ -861,7 +862,7 @@ static void afs_fl_copy_lock(struct file_lock *new, struct file_lock *fl) > */ > static void afs_fl_release_private(struct file_lock *fl) > { > - struct afs_vnode *vnode = AFS_FS_I(file_inode(fl->fl_file)); > + struct afs_vnode *vnode = AFS_FS_I(file_inode(fl->fl_core.fl_file)); > > _enter(""); > > diff --git a/fs/ceph/locks.c b/fs/ceph/locks.c > index e07ad29ff8b9..ee12f9864980 100644 > --- a/fs/ceph/locks.c > +++ b/fs/ceph/locks.c > @@ -33,7 +33,7 @@ void __init ceph_flock_init(void) > > static void ceph_fl_copy_lock(struct file_lock *dst, struct file_lock *src) > { > - struct inode *inode = file_inode(dst->fl_file); > + struct inode *inode = file_inode(dst->fl_core.fl_file); > atomic_inc(&ceph_inode(inode)->i_filelock_ref); > dst->fl_u.ceph.inode = igrab(inode); > } > @@ -110,17 +110,18 @@ static int ceph_lock_message(u8 lock_type, u16 operation, struct inode *inode, > else > length = fl->fl_end - fl->fl_start + 1; > > - owner = secure_addr(fl->fl_owner); > + owner = secure_addr(fl->fl_core.fl_owner); > > doutc(cl, "rule: %d, op: %d, owner: %llx, pid: %llu, " > "start: %llu, length: %llu, wait: %d, type: %d\n", > - (int)lock_type, (int)operation, owner, (u64)fl->fl_pid, > - fl->fl_start, length, wait, fl->fl_type); > + (int)lock_type, (int)operation, owner, > + (u64) fl->fl_core.fl_pid, > + fl->fl_start, length, wait, fl->fl_core.fl_type); > > req->r_args.filelock_change.rule = lock_type; > req->r_args.filelock_change.type = cmd; > req->r_args.filelock_change.owner = cpu_to_le64(owner); > - req->r_args.filelock_change.pid = cpu_to_le64((u64)fl->fl_pid); > + req->r_args.filelock_change.pid = cpu_to_le64((u64) fl->fl_core.fl_pid); > req->r_args.filelock_change.start = cpu_to_le64(fl->fl_start); > req->r_args.filelock_change.length = cpu_to_le64(length); > req->r_args.filelock_change.wait = wait; > @@ -130,13 +131,13 @@ static int ceph_lock_message(u8 lock_type, u16 operation, struct inode *inode, > err = ceph_mdsc_wait_request(mdsc, req, wait ? > ceph_lock_wait_for_completion : NULL); > if (!err && operation == CEPH_MDS_OP_GETFILELOCK) { > - fl->fl_pid = -le64_to_cpu(req->r_reply_info.filelock_reply->pid); > + fl->fl_core.fl_pid = -le64_to_cpu(req->r_reply_info.filelock_reply->pid); > if (CEPH_LOCK_SHARED == req->r_reply_info.filelock_reply->type) > - fl->fl_type = F_RDLCK; > + fl->fl_core.fl_type = F_RDLCK; > else if (CEPH_LOCK_EXCL == req->r_reply_info.filelock_reply->type) > - fl->fl_type = F_WRLCK; > + fl->fl_core.fl_type = F_WRLCK; > else > - fl->fl_type = F_UNLCK; > + fl->fl_core.fl_type = F_UNLCK; > > fl->fl_start = le64_to_cpu(req->r_reply_info.filelock_reply->start); > length = le64_to_cpu(req->r_reply_info.filelock_reply->start) + > @@ -150,8 +151,8 @@ static int ceph_lock_message(u8 lock_type, u16 operation, struct inode *inode, > ceph_mdsc_put_request(req); > doutc(cl, "rule: %d, op: %d, pid: %llu, start: %llu, " > "length: %llu, wait: %d, type: %d, err code %d\n", > - (int)lock_type, (int)operation, (u64)fl->fl_pid, > - fl->fl_start, length, wait, fl->fl_type, err); > + (int)lock_type, (int)operation, (u64) fl->fl_core.fl_pid, > + fl->fl_start, length, wait, fl->fl_core.fl_type, err); > return err; > } > > @@ -227,10 +228,10 @@ static int ceph_lock_wait_for_completion(struct ceph_mds_client *mdsc, > static int try_unlock_file(struct file *file, struct file_lock *fl) > { > int err; > - unsigned int orig_flags = fl->fl_flags; > - fl->fl_flags |= FL_EXISTS; > + unsigned int orig_flags = fl->fl_core.fl_flags; > + fl->fl_core.fl_flags |= FL_EXISTS; > err = locks_lock_file_wait(file, fl); > - fl->fl_flags = orig_flags; > + fl->fl_core.fl_flags = orig_flags; > if (err == -ENOENT) { > if (!(orig_flags & FL_EXISTS)) > err = 0; > @@ -253,13 +254,13 @@ int ceph_lock(struct file *file, int cmd, struct file_lock *fl) > u8 wait = 0; > u8 lock_cmd; > > - if (!(fl->fl_flags & FL_POSIX)) > + if (!(fl->fl_core.fl_flags & FL_POSIX)) > return -ENOLCK; > > if (ceph_inode_is_shutdown(inode)) > return -ESTALE; > > - doutc(cl, "fl_owner: %p\n", fl->fl_owner); > + doutc(cl, "fl_owner: %p\n", fl->fl_core.fl_owner); > > /* set wait bit as appropriate, then make command as Ceph expects it*/ > if (IS_GETLK(cmd)) > @@ -273,19 +274,19 @@ int ceph_lock(struct file *file, int cmd, struct file_lock *fl) > } > spin_unlock(&ci->i_ceph_lock); > if (err < 0) { > - if (op == CEPH_MDS_OP_SETFILELOCK && F_UNLCK == fl->fl_type) > + if (op == CEPH_MDS_OP_SETFILELOCK && F_UNLCK == fl->fl_core.fl_type) > posix_lock_file(file, fl, NULL); > return err; > } > > - if (F_RDLCK == fl->fl_type) > + if (F_RDLCK == fl->fl_core.fl_type) > lock_cmd = CEPH_LOCK_SHARED; > - else if (F_WRLCK == fl->fl_type) > + else if (F_WRLCK == fl->fl_core.fl_type) > lock_cmd = CEPH_LOCK_EXCL; > else > lock_cmd = CEPH_LOCK_UNLOCK; > > - if (op == CEPH_MDS_OP_SETFILELOCK && F_UNLCK == fl->fl_type) { > + if (op == CEPH_MDS_OP_SETFILELOCK && F_UNLCK == fl->fl_core.fl_type) { > err = try_unlock_file(file, fl); > if (err <= 0) > return err; > @@ -293,7 +294,7 @@ int ceph_lock(struct file *file, int cmd, struct file_lock *fl) > > err = ceph_lock_message(CEPH_LOCK_FCNTL, op, inode, lock_cmd, wait, fl); > if (!err) { > - if (op == CEPH_MDS_OP_SETFILELOCK && F_UNLCK != fl->fl_type) { > + if (op == CEPH_MDS_OP_SETFILELOCK && F_UNLCK != fl->fl_core.fl_type) { > doutc(cl, "locking locally\n"); > err = posix_lock_file(file, fl, NULL); > if (err) { > @@ -319,13 +320,13 @@ int ceph_flock(struct file *file, int cmd, struct file_lock *fl) > u8 wait = 0; > u8 lock_cmd; > > - if (!(fl->fl_flags & FL_FLOCK)) > + if (!(fl->fl_core.fl_flags & FL_FLOCK)) > return -ENOLCK; > > if (ceph_inode_is_shutdown(inode)) > return -ESTALE; > > - doutc(cl, "fl_file: %p\n", fl->fl_file); > + doutc(cl, "fl_file: %p\n", fl->fl_core.fl_file); > > spin_lock(&ci->i_ceph_lock); > if (ci->i_ceph_flags & CEPH_I_ERROR_FILELOCK) { > @@ -333,7 +334,7 @@ int ceph_flock(struct file *file, int cmd, struct file_lock *fl) > } > spin_unlock(&ci->i_ceph_lock); > if (err < 0) { > - if (F_UNLCK == fl->fl_type) > + if (F_UNLCK == fl->fl_core.fl_type) > locks_lock_file_wait(file, fl); > return err; > } > @@ -341,14 +342,14 @@ int ceph_flock(struct file *file, int cmd, struct file_lock *fl) > if (IS_SETLKW(cmd)) > wait = 1; > > - if (F_RDLCK == fl->fl_type) > + if (F_RDLCK == fl->fl_core.fl_type) > lock_cmd = CEPH_LOCK_SHARED; > - else if (F_WRLCK == fl->fl_type) > + else if (F_WRLCK == fl->fl_core.fl_type) > lock_cmd = CEPH_LOCK_EXCL; > else > lock_cmd = CEPH_LOCK_UNLOCK; > > - if (F_UNLCK == fl->fl_type) { > + if (F_UNLCK == fl->fl_core.fl_type) { > err = try_unlock_file(file, fl); > if (err <= 0) > return err; > @@ -356,7 +357,7 @@ int ceph_flock(struct file *file, int cmd, struct file_lock *fl) > > err = ceph_lock_message(CEPH_LOCK_FLOCK, CEPH_MDS_OP_SETFILELOCK, > inode, lock_cmd, wait, fl); > - if (!err && F_UNLCK != fl->fl_type) { > + if (!err && F_UNLCK != fl->fl_core.fl_type) { > err = locks_lock_file_wait(file, fl); > if (err) { > ceph_lock_message(CEPH_LOCK_FLOCK, > @@ -408,10 +409,10 @@ static int lock_to_ceph_filelock(struct inode *inode, > cephlock->start = cpu_to_le64(lock->fl_start); > cephlock->length = cpu_to_le64(lock->fl_end - lock->fl_start + 1); > cephlock->client = cpu_to_le64(0); > - cephlock->pid = cpu_to_le64((u64)lock->fl_pid); > - cephlock->owner = cpu_to_le64(secure_addr(lock->fl_owner)); > + cephlock->pid = cpu_to_le64((u64) lock->fl_core.fl_pid); > + cephlock->owner = cpu_to_le64(secure_addr(lock->fl_core.fl_owner)); > > - switch (lock->fl_type) { > + switch (lock->fl_core.fl_type) { > case F_RDLCK: > cephlock->type = CEPH_LOCK_SHARED; > break; > @@ -422,7 +423,8 @@ static int lock_to_ceph_filelock(struct inode *inode, > cephlock->type = CEPH_LOCK_UNLOCK; > break; > default: > - doutc(cl, "Have unknown lock type %d\n", lock->fl_type); > + doutc(cl, "Have unknown lock type %d\n", > + lock->fl_core.fl_type); > err = -EINVAL; > } > > diff --git a/fs/dlm/plock.c b/fs/dlm/plock.c > index d814c5121367..e98d09c06f57 100644 > --- a/fs/dlm/plock.c > +++ b/fs/dlm/plock.c > @@ -138,14 +138,14 @@ int dlm_posix_lock(dlm_lockspace_t *lockspace, u64 number, struct file *file, > } > > op->info.optype = DLM_PLOCK_OP_LOCK; > - op->info.pid = fl->fl_pid; > - op->info.ex = (fl->fl_type == F_WRLCK); > - op->info.wait = !!(fl->fl_flags & FL_SLEEP); > + op->info.pid = fl->fl_core.fl_pid; > + op->info.ex = (fl->fl_core.fl_type == F_WRLCK); > + op->info.wait = !!(fl->fl_core.fl_flags & FL_SLEEP); > op->info.fsid = ls->ls_global_id; > op->info.number = number; > op->info.start = fl->fl_start; > op->info.end = fl->fl_end; > - op->info.owner = (__u64)(long)fl->fl_owner; > + op->info.owner = (__u64)(long) fl->fl_core.fl_owner; > /* async handling */ > if (fl->fl_lmops && fl->fl_lmops->lm_grant) { > op_data = kzalloc(sizeof(*op_data), GFP_NOFS); > @@ -258,7 +258,7 @@ static int dlm_plock_callback(struct plock_op *op) > } > > /* got fs lock; bookkeep locally as well: */ > - flc->fl_flags &= ~FL_SLEEP; > + flc->fl_core.fl_flags &= ~FL_SLEEP; > if (posix_lock_file(file, flc, NULL)) { > /* > * This can only happen in the case of kmalloc() failure. > @@ -291,7 +291,7 @@ int dlm_posix_unlock(dlm_lockspace_t *lockspace, u64 number, struct file *file, > struct dlm_ls *ls; > struct plock_op *op; > int rv; > - unsigned char fl_flags = fl->fl_flags; > + unsigned char fl_flags = fl->fl_core.fl_flags; > > ls = dlm_find_lockspace_local(lockspace); > if (!ls) > @@ -304,7 +304,7 @@ int dlm_posix_unlock(dlm_lockspace_t *lockspace, u64 number, struct file *file, > } > > /* cause the vfs unlock to return ENOENT if lock is not found */ > - fl->fl_flags |= FL_EXISTS; > + fl->fl_core.fl_flags |= FL_EXISTS; > > rv = locks_lock_file_wait(file, fl); > if (rv == -ENOENT) { > @@ -317,14 +317,14 @@ int dlm_posix_unlock(dlm_lockspace_t *lockspace, u64 number, struct file *file, > } > > op->info.optype = DLM_PLOCK_OP_UNLOCK; > - op->info.pid = fl->fl_pid; > + op->info.pid = fl->fl_core.fl_pid; > op->info.fsid = ls->ls_global_id; > op->info.number = number; > op->info.start = fl->fl_start; > op->info.end = fl->fl_end; > - op->info.owner = (__u64)(long)fl->fl_owner; > + op->info.owner = (__u64)(long) fl->fl_core.fl_owner; > > - if (fl->fl_flags & FL_CLOSE) { > + if (fl->fl_core.fl_flags & FL_CLOSE) { > op->info.flags |= DLM_PLOCK_FL_CLOSE; > send_op(op); > rv = 0; > @@ -345,7 +345,7 @@ int dlm_posix_unlock(dlm_lockspace_t *lockspace, u64 number, struct file *file, > dlm_release_plock_op(op); > out: > dlm_put_lockspace(ls); > - fl->fl_flags = fl_flags; > + fl->fl_core.fl_flags = fl_flags; > return rv; > } > EXPORT_SYMBOL_GPL(dlm_posix_unlock); > @@ -375,14 +375,14 @@ int dlm_posix_cancel(dlm_lockspace_t *lockspace, u64 number, struct file *file, > return -EINVAL; > > memset(&info, 0, sizeof(info)); > - info.pid = fl->fl_pid; > - info.ex = (fl->fl_type == F_WRLCK); > + info.pid = fl->fl_core.fl_pid; > + info.ex = (fl->fl_core.fl_type == F_WRLCK); > info.fsid = ls->ls_global_id; > dlm_put_lockspace(ls); > info.number = number; > info.start = fl->fl_start; > info.end = fl->fl_end; > - info.owner = (__u64)(long)fl->fl_owner; > + info.owner = (__u64)(long) fl->fl_core.fl_owner; > > rv = do_lock_cancel(&info); > switch (rv) { > @@ -437,13 +437,13 @@ int dlm_posix_get(dlm_lockspace_t *lockspace, u64 number, struct file *file, > } > > op->info.optype = DLM_PLOCK_OP_GET; > - op->info.pid = fl->fl_pid; > - op->info.ex = (fl->fl_type == F_WRLCK); > + op->info.pid = fl->fl_core.fl_pid; > + op->info.ex = (fl->fl_core.fl_type == F_WRLCK); > op->info.fsid = ls->ls_global_id; > op->info.number = number; > op->info.start = fl->fl_start; > op->info.end = fl->fl_end; > - op->info.owner = (__u64)(long)fl->fl_owner; > + op->info.owner = (__u64)(long) fl->fl_core.fl_owner; > > send_op(op); > wait_event(recv_wq, (op->done != 0)); > @@ -455,16 +455,16 @@ int dlm_posix_get(dlm_lockspace_t *lockspace, u64 number, struct file *file, > > rv = op->info.rv; > > - fl->fl_type = F_UNLCK; > + fl->fl_core.fl_type = F_UNLCK; > if (rv == -ENOENT) > rv = 0; > else if (rv > 0) { > locks_init_lock(fl); > - fl->fl_type = (op->info.ex) ? F_WRLCK : F_RDLCK; > - fl->fl_flags = FL_POSIX; > - fl->fl_pid = op->info.pid; > + fl->fl_core.fl_type = (op->info.ex) ? F_WRLCK : F_RDLCK; > + fl->fl_core.fl_flags = FL_POSIX; > + fl->fl_core.fl_pid = op->info.pid; > if (op->info.nodeid != dlm_our_nodeid()) > - fl->fl_pid = -fl->fl_pid; > + fl->fl_core.fl_pid = -fl->fl_core.fl_pid; > fl->fl_start = op->info.start; > fl->fl_end = op->info.end; > rv = 0; > diff --git a/fs/fuse/file.c b/fs/fuse/file.c > index 148a71b8b4d0..13c38696074d 100644 > --- a/fs/fuse/file.c > +++ b/fs/fuse/file.c > @@ -2509,14 +2509,14 @@ static int convert_fuse_file_lock(struct fuse_conn *fc, > * translate it into the caller's pid namespace. > */ > rcu_read_lock(); > - fl->fl_pid = pid_nr_ns(find_pid_ns(ffl->pid, fc->pid_ns), &init_pid_ns); > + fl->fl_core.fl_pid = pid_nr_ns(find_pid_ns(ffl->pid, fc->pid_ns), &init_pid_ns); > rcu_read_unlock(); > break; > > default: > return -EIO; > } > - fl->fl_type = ffl->type; > + fl->fl_core.fl_type = ffl->type; > return 0; > } > > @@ -2530,10 +2530,10 @@ static void fuse_lk_fill(struct fuse_args *args, struct file *file, > > memset(inarg, 0, sizeof(*inarg)); > inarg->fh = ff->fh; > - inarg->owner = fuse_lock_owner_id(fc, fl->fl_owner); > + inarg->owner = fuse_lock_owner_id(fc, fl->fl_core.fl_owner); > inarg->lk.start = fl->fl_start; > inarg->lk.end = fl->fl_end; > - inarg->lk.type = fl->fl_type; > + inarg->lk.type = fl->fl_core.fl_type; > inarg->lk.pid = pid; > if (flock) > inarg->lk_flags |= FUSE_LK_FLOCK; > @@ -2570,8 +2570,8 @@ static int fuse_setlk(struct file *file, struct file_lock *fl, int flock) > struct fuse_mount *fm = get_fuse_mount(inode); > FUSE_ARGS(args); > struct fuse_lk_in inarg; > - int opcode = (fl->fl_flags & FL_SLEEP) ? FUSE_SETLKW : FUSE_SETLK; > - struct pid *pid = fl->fl_type != F_UNLCK ? task_tgid(current) : NULL; > + int opcode = (fl->fl_core.fl_flags & FL_SLEEP) ? FUSE_SETLKW : FUSE_SETLK; > + struct pid *pid = fl->fl_core.fl_type != F_UNLCK ? task_tgid(current) : NULL; > pid_t pid_nr = pid_nr_ns(pid, fm->fc->pid_ns); > int err; > > @@ -2581,7 +2581,7 @@ static int fuse_setlk(struct file *file, struct file_lock *fl, int flock) > } > > /* Unlock on close is handled by the flush method */ > - if ((fl->fl_flags & FL_CLOSE_POSIX) == FL_CLOSE_POSIX) > + if ((fl->fl_core.fl_flags & FL_CLOSE_POSIX) == FL_CLOSE_POSIX) > return 0; > > fuse_lk_fill(&args, file, fl, opcode, pid_nr, flock, &inarg); > diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c > index 992ca4effb50..fdcd29583cc8 100644 > --- a/fs/gfs2/file.c > +++ b/fs/gfs2/file.c > @@ -1440,10 +1440,10 @@ static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl) > struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host); > struct lm_lockstruct *ls = &sdp->sd_lockstruct; > > - if (!(fl->fl_flags & FL_POSIX)) > + if (!(fl->fl_core.fl_flags & FL_POSIX)) > return -ENOLCK; > if (gfs2_withdrawing_or_withdrawn(sdp)) { > - if (fl->fl_type == F_UNLCK) > + if (fl->fl_core.fl_type == F_UNLCK) > locks_lock_file_wait(file, fl); > return -EIO; > } > @@ -1451,7 +1451,7 @@ static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl) > return dlm_posix_cancel(ls->ls_dlm, ip->i_no_addr, file, fl); > else if (IS_GETLK(cmd)) > return dlm_posix_get(ls->ls_dlm, ip->i_no_addr, file, fl); > - else if (fl->fl_type == F_UNLCK) > + else if (fl->fl_core.fl_type == F_UNLCK) > return dlm_posix_unlock(ls->ls_dlm, ip->i_no_addr, file, fl); > else > return dlm_posix_lock(ls->ls_dlm, ip->i_no_addr, file, cmd, fl); > @@ -1483,7 +1483,7 @@ static int do_flock(struct file *file, int cmd, struct file_lock *fl) > int error = 0; > int sleeptime; > > - state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED; > + state = (fl->fl_core.fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED; > flags = GL_EXACT | GL_NOPID; > if (!IS_SETLKW(cmd)) > flags |= LM_FLAG_TRY_1CB; > @@ -1495,8 +1495,8 @@ static int do_flock(struct file *file, int cmd, struct file_lock *fl) > if (fl_gh->gh_state == state) > goto out; > locks_init_lock(&request); > - request.fl_type = F_UNLCK; > - request.fl_flags = FL_FLOCK; > + request.fl_core.fl_type = F_UNLCK; > + request.fl_core.fl_flags = FL_FLOCK; > locks_lock_file_wait(file, &request); > gfs2_glock_dq(fl_gh); > gfs2_holder_reinit(state, flags, fl_gh); > @@ -1557,10 +1557,10 @@ static void do_unflock(struct file *file, struct file_lock *fl) > > static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl) > { > - if (!(fl->fl_flags & FL_FLOCK)) > + if (!(fl->fl_core.fl_flags & FL_FLOCK)) > return -ENOLCK; > > - if (fl->fl_type == F_UNLCK) { > + if (fl->fl_core.fl_type == F_UNLCK) { > do_unflock(file, fl); > return 0; > } else { > diff --git a/fs/lockd/clnt4xdr.c b/fs/lockd/clnt4xdr.c > index 8161667c976f..ed00bd2869a7 100644 > --- a/fs/lockd/clnt4xdr.c > +++ b/fs/lockd/clnt4xdr.c > @@ -270,7 +270,7 @@ static int decode_nlm4_holder(struct xdr_stream *xdr, struct nlm_res *result) > goto out_overflow; > exclusive = be32_to_cpup(p++); > lock->svid = be32_to_cpup(p); > - fl->fl_pid = (pid_t)lock->svid; > + fl->fl_core.fl_pid = (pid_t)lock->svid; > > error = decode_netobj(xdr, &lock->oh); > if (unlikely(error)) > @@ -280,8 +280,8 @@ static int decode_nlm4_holder(struct xdr_stream *xdr, struct nlm_res *result) > if (unlikely(p == NULL)) > goto out_overflow; > > - fl->fl_flags = FL_POSIX; > - fl->fl_type = exclusive != 0 ? F_WRLCK : F_RDLCK; > + fl->fl_core.fl_flags = FL_POSIX; > + fl->fl_core.fl_type = exclusive != 0 ? F_WRLCK : F_RDLCK; > p = xdr_decode_hyper(p, &l_offset); > xdr_decode_hyper(p, &l_len); > nlm4svc_set_file_lock_range(fl, l_offset, l_len); > diff --git a/fs/lockd/clntlock.c b/fs/lockd/clntlock.c > index 5d85715be763..c15a6d5f1acf 100644 > --- a/fs/lockd/clntlock.c > +++ b/fs/lockd/clntlock.c > @@ -185,7 +185,7 @@ __be32 nlmclnt_grant(const struct sockaddr *addr, const struct nlm_lock *lock) > continue; > if (!rpc_cmp_addr(nlm_addr(block->b_host), addr)) > continue; > - if (nfs_compare_fh(NFS_FH(file_inode(fl_blocked->fl_file)), fh) != 0) > + if (nfs_compare_fh(NFS_FH(file_inode(fl_blocked->fl_core.fl_file)), fh) != 0) > continue; > /* Alright, we found a lock. Set the return status > * and wake up the caller > diff --git a/fs/lockd/clntproc.c b/fs/lockd/clntproc.c > index fba6c7fa7474..ac1d07034346 100644 > --- a/fs/lockd/clntproc.c > +++ b/fs/lockd/clntproc.c > @@ -133,7 +133,8 @@ static void nlmclnt_setlockargs(struct nlm_rqst *req, struct file_lock *fl) > char *nodename = req->a_host->h_rpcclnt->cl_nodename; > > nlmclnt_next_cookie(&argp->cookie); > - memcpy(&lock->fh, NFS_FH(file_inode(fl->fl_file)), sizeof(struct nfs_fh)); > + memcpy(&lock->fh, NFS_FH(file_inode(fl->fl_core.fl_file)), > + sizeof(struct nfs_fh)); > lock->caller = nodename; > lock->oh.data = req->a_owner; > lock->oh.len = snprintf(req->a_owner, sizeof(req->a_owner), "%u@%s", > @@ -142,7 +143,7 @@ static void nlmclnt_setlockargs(struct nlm_rqst *req, struct file_lock *fl) > lock->svid = fl->fl_u.nfs_fl.owner->pid; > lock->fl.fl_start = fl->fl_start; > lock->fl.fl_end = fl->fl_end; > - lock->fl.fl_type = fl->fl_type; > + lock->fl.fl_type = fl->fl_core.fl_type; > } > > static void nlmclnt_release_lockargs(struct nlm_rqst *req) > @@ -182,7 +183,7 @@ int nlmclnt_proc(struct nlm_host *host, int cmd, struct file_lock *fl, void *dat > call->a_callback_data = data; > > if (IS_SETLK(cmd) || IS_SETLKW(cmd)) { > - if (fl->fl_type != F_UNLCK) { > + if (fl->fl_core.fl_type != F_UNLCK) { > call->a_args.block = IS_SETLKW(cmd) ? 1 : 0; > status = nlmclnt_lock(call, fl); > } else > @@ -432,13 +433,14 @@ nlmclnt_test(struct nlm_rqst *req, struct file_lock *fl) > { > int status; > > - status = nlmclnt_call(nfs_file_cred(fl->fl_file), req, NLMPROC_TEST); > + status = nlmclnt_call(nfs_file_cred(fl->fl_core.fl_file), req, > + NLMPROC_TEST); > if (status < 0) > goto out; > > switch (req->a_res.status) { > case nlm_granted: > - fl->fl_type = F_UNLCK; > + fl->fl_core.fl_type = F_UNLCK; > break; > case nlm_lck_denied: > /* > @@ -446,8 +448,8 @@ nlmclnt_test(struct nlm_rqst *req, struct file_lock *fl) > */ > fl->fl_start = req->a_res.lock.fl.fl_start; > fl->fl_end = req->a_res.lock.fl.fl_end; > - fl->fl_type = req->a_res.lock.fl.fl_type; > - fl->fl_pid = -req->a_res.lock.fl.fl_pid; > + fl->fl_core.fl_type = req->a_res.lock.fl.fl_type; > + fl->fl_core.fl_pid = -req->a_res.lock.fl.fl_pid; > break; > default: > status = nlm_stat_to_errno(req->a_res.status); > @@ -485,14 +487,15 @@ static const struct file_lock_operations nlmclnt_lock_ops = { > static void nlmclnt_locks_init_private(struct file_lock *fl, struct nlm_host *host) > { > fl->fl_u.nfs_fl.state = 0; > - fl->fl_u.nfs_fl.owner = nlmclnt_find_lockowner(host, fl->fl_owner); > + fl->fl_u.nfs_fl.owner = nlmclnt_find_lockowner(host, > + fl->fl_core.fl_owner); > INIT_LIST_HEAD(&fl->fl_u.nfs_fl.list); > fl->fl_ops = &nlmclnt_lock_ops; > } > > static int do_vfs_lock(struct file_lock *fl) > { > - return locks_lock_file_wait(fl->fl_file, fl); > + return locks_lock_file_wait(fl->fl_core.fl_file, fl); > } > > /* > @@ -518,11 +521,11 @@ static int do_vfs_lock(struct file_lock *fl) > static int > nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) > { > - const struct cred *cred = nfs_file_cred(fl->fl_file); > + const struct cred *cred = nfs_file_cred(fl->fl_core.fl_file); > struct nlm_host *host = req->a_host; > struct nlm_res *resp = &req->a_res; > struct nlm_wait block; > - unsigned char fl_flags = fl->fl_flags; > + unsigned char fl_flags = fl->fl_core.fl_flags; > unsigned char fl_type; > __be32 b_status; > int status = -ENOLCK; > @@ -531,9 +534,9 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) > goto out; > req->a_args.state = nsm_local_state; > > - fl->fl_flags |= FL_ACCESS; > + fl->fl_core.fl_flags |= FL_ACCESS; > status = do_vfs_lock(fl); > - fl->fl_flags = fl_flags; > + fl->fl_core.fl_flags = fl_flags; > if (status < 0) > goto out; > > @@ -591,11 +594,11 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) > goto again; > } > /* Ensure the resulting lock will get added to granted list */ > - fl->fl_flags |= FL_SLEEP; > + fl->fl_core.fl_flags |= FL_SLEEP; > if (do_vfs_lock(fl) < 0) > printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __func__); > up_read(&host->h_rwsem); > - fl->fl_flags = fl_flags; > + fl->fl_core.fl_flags = fl_flags; > status = 0; > } > if (status < 0) > @@ -622,13 +625,13 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) > req->a_host->h_addrlen, req->a_res.status); > dprintk("lockd: lock attempt ended in fatal error.\n" > " Attempting to unlock.\n"); > - fl_type = fl->fl_type; > - fl->fl_type = F_UNLCK; > + fl_type = fl->fl_core.fl_type; > + fl->fl_core.fl_type = F_UNLCK; > down_read(&host->h_rwsem); > do_vfs_lock(fl); > up_read(&host->h_rwsem); > - fl->fl_type = fl_type; > - fl->fl_flags = fl_flags; > + fl->fl_core.fl_type = fl_type; > + fl->fl_core.fl_flags = fl_flags; > nlmclnt_async_call(cred, req, NLMPROC_UNLOCK, &nlmclnt_unlock_ops); > return status; > } > @@ -651,12 +654,13 @@ nlmclnt_reclaim(struct nlm_host *host, struct file_lock *fl, > nlmclnt_setlockargs(req, fl); > req->a_args.reclaim = 1; > > - status = nlmclnt_call(nfs_file_cred(fl->fl_file), req, NLMPROC_LOCK); > + status = nlmclnt_call(nfs_file_cred(fl->fl_core.fl_file), req, > + NLMPROC_LOCK); > if (status >= 0 && req->a_res.status == nlm_granted) > return 0; > > printk(KERN_WARNING "lockd: failed to reclaim lock for pid %d " > - "(errno %d, status %d)\n", fl->fl_pid, > + "(errno %d, status %d)\n", fl->fl_core.fl_pid, > status, ntohl(req->a_res.status)); > > /* > @@ -683,26 +687,26 @@ nlmclnt_unlock(struct nlm_rqst *req, struct file_lock *fl) > struct nlm_host *host = req->a_host; > struct nlm_res *resp = &req->a_res; > int status; > - unsigned char fl_flags = fl->fl_flags; > + unsigned char fl_flags = fl->fl_core.fl_flags; > > /* > * Note: the server is supposed to either grant us the unlock > * request, or to deny it with NLM_LCK_DENIED_GRACE_PERIOD. In either > * case, we want to unlock. > */ > - fl->fl_flags |= FL_EXISTS; > + fl->fl_core.fl_flags |= FL_EXISTS; > down_read(&host->h_rwsem); > status = do_vfs_lock(fl); > up_read(&host->h_rwsem); > - fl->fl_flags = fl_flags; > + fl->fl_core.fl_flags = fl_flags; > if (status == -ENOENT) { > status = 0; > goto out; > } > > refcount_inc(&req->a_count); > - status = nlmclnt_async_call(nfs_file_cred(fl->fl_file), req, > - NLMPROC_UNLOCK, &nlmclnt_unlock_ops); > + status = nlmclnt_async_call(nfs_file_cred(fl->fl_core.fl_file), req, > + NLMPROC_UNLOCK, &nlmclnt_unlock_ops); > if (status < 0) > goto out; > > @@ -795,8 +799,8 @@ static int nlmclnt_cancel(struct nlm_host *host, int block, struct file_lock *fl > req->a_args.block = block; > > refcount_inc(&req->a_count); > - status = nlmclnt_async_call(nfs_file_cred(fl->fl_file), req, > - NLMPROC_CANCEL, &nlmclnt_cancel_ops); > + status = nlmclnt_async_call(nfs_file_cred(fl->fl_core.fl_file), req, > + NLMPROC_CANCEL, &nlmclnt_cancel_ops); > if (status == 0 && req->a_res.status == nlm_lck_denied) > status = -ENOLCK; > nlmclnt_release_call(req); > diff --git a/fs/lockd/clntxdr.c b/fs/lockd/clntxdr.c > index 4df62f635529..b0b87a00cd81 100644 > --- a/fs/lockd/clntxdr.c > +++ b/fs/lockd/clntxdr.c > @@ -265,7 +265,7 @@ static int decode_nlm_holder(struct xdr_stream *xdr, struct nlm_res *result) > goto out_overflow; > exclusive = be32_to_cpup(p++); > lock->svid = be32_to_cpup(p); > - fl->fl_pid = (pid_t)lock->svid; > + fl->fl_core.fl_pid = (pid_t)lock->svid; > > error = decode_netobj(xdr, &lock->oh); > if (unlikely(error)) > @@ -275,8 +275,8 @@ static int decode_nlm_holder(struct xdr_stream *xdr, struct nlm_res *result) > if (unlikely(p == NULL)) > goto out_overflow; > > - fl->fl_flags = FL_POSIX; > - fl->fl_type = exclusive != 0 ? F_WRLCK : F_RDLCK; > + fl->fl_core.fl_flags = FL_POSIX; > + fl->fl_core.fl_type = exclusive != 0 ? F_WRLCK : F_RDLCK; > l_offset = be32_to_cpup(p++); > l_len = be32_to_cpup(p); > end = l_offset + l_len - 1; > diff --git a/fs/lockd/svclock.c b/fs/lockd/svclock.c > index 2dc10900ad1c..520886a4b57e 100644 > --- a/fs/lockd/svclock.c > +++ b/fs/lockd/svclock.c > @@ -157,9 +157,9 @@ nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock) > list_for_each_entry(block, &nlm_blocked, b_list) { > fl = &block->b_call->a_args.lock.fl; > dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%s\n", > - block->b_file, fl->fl_pid, > + block->b_file, fl->fl_core.fl_pid, > (long long)fl->fl_start, > - (long long)fl->fl_end, fl->fl_type, > + (long long)fl->fl_end, fl->fl_core.fl_type, > nlmdbg_cookie2a(&block->b_call->a_args.cookie)); > if (block->b_file == file && nlm_compare_locks(fl, &lock->fl)) { > kref_get(&block->b_count); > @@ -409,7 +409,7 @@ nlmsvc_release_lockowner(struct nlm_lock *lock) > void nlmsvc_locks_init_private(struct file_lock *fl, struct nlm_host *host, > pid_t pid) > { > - fl->fl_owner = nlmsvc_find_lockowner(host, pid); > + fl->fl_core.fl_owner = nlmsvc_find_lockowner(host, pid); > } > > /* > @@ -993,8 +993,8 @@ nlmsvc_grant_reply(struct nlm_cookie *cookie, __be32 status) > /* Client doesn't want it, just unlock it */ > nlmsvc_unlink_block(block); > fl = &block->b_call->a_args.lock.fl; > - fl->fl_type = F_UNLCK; > - error = vfs_lock_file(fl->fl_file, F_SETLK, fl, NULL); > + fl->fl_core.fl_type = F_UNLCK; > + error = vfs_lock_file(fl->fl_core.fl_file, F_SETLK, fl, NULL); > if (error) > pr_warn("lockd: unable to unlock lock rejected by client!\n"); > break; > diff --git a/fs/lockd/svcsubs.c b/fs/lockd/svcsubs.c > index e3b6229e7ae5..61b5c7ef8a12 100644 > --- a/fs/lockd/svcsubs.c > +++ b/fs/lockd/svcsubs.c > @@ -73,7 +73,7 @@ static inline unsigned int file_hash(struct nfs_fh *f) > > int lock_to_openmode(struct file_lock *lock) > { > - return (lock->fl_type == F_WRLCK) ? O_WRONLY : O_RDONLY; > + return (lock->fl_core.fl_type == F_WRLCK) ? O_WRONLY : O_RDONLY; > } > > /* > @@ -181,18 +181,18 @@ static int nlm_unlock_files(struct nlm_file *file, const struct file_lock *fl) > struct file_lock lock; > > locks_init_lock(&lock); > - lock.fl_type = F_UNLCK; > + lock.fl_core.fl_type = F_UNLCK; > lock.fl_start = 0; > lock.fl_end = OFFSET_MAX; > - lock.fl_owner = fl->fl_owner; > - lock.fl_pid = fl->fl_pid; > - lock.fl_flags = FL_POSIX; > + lock.fl_core.fl_owner = fl->fl_core.fl_owner; > + lock.fl_core.fl_pid = fl->fl_core.fl_pid; > + lock.fl_core.fl_flags = FL_POSIX; > > - lock.fl_file = file->f_file[O_RDONLY]; > - if (lock.fl_file && vfs_lock_file(lock.fl_file, F_SETLK, &lock, NULL)) > + lock.fl_core.fl_file = file->f_file[O_RDONLY]; > + if (lock.fl_core.fl_file && vfs_lock_file(lock.fl_core.fl_file, F_SETLK, &lock, NULL)) > goto out_err; > - lock.fl_file = file->f_file[O_WRONLY]; > - if (lock.fl_file && vfs_lock_file(lock.fl_file, F_SETLK, &lock, NULL)) > + lock.fl_core.fl_file = file->f_file[O_WRONLY]; > + if (lock.fl_core.fl_file && vfs_lock_file(lock.fl_core.fl_file, F_SETLK, &lock, NULL)) > goto out_err; > return 0; > out_err: > @@ -225,7 +225,7 @@ nlm_traverse_locks(struct nlm_host *host, struct nlm_file *file, > /* update current lock count */ > file->f_locks++; > > - lockhost = ((struct nlm_lockowner *)fl->fl_owner)->host; > + lockhost = ((struct nlm_lockowner *) fl->fl_core.fl_owner)->host; > if (match(lockhost, host)) { > > spin_unlock(&flctx->flc_lock); > diff --git a/fs/lockd/xdr.c b/fs/lockd/xdr.c > index 2fb5748dae0c..4a676a51eb6c 100644 > --- a/fs/lockd/xdr.c > +++ b/fs/lockd/xdr.c > @@ -88,8 +88,8 @@ svcxdr_decode_lock(struct xdr_stream *xdr, struct nlm_lock *lock) > return false; > > locks_init_lock(fl); > - fl->fl_flags = FL_POSIX; > - fl->fl_type = F_RDLCK; > + fl->fl_core.fl_flags = FL_POSIX; > + fl->fl_core.fl_type = F_RDLCK; > end = start + len - 1; > fl->fl_start = s32_to_loff_t(start); > if (len == 0 || end < 0) > @@ -107,7 +107,7 @@ svcxdr_encode_holder(struct xdr_stream *xdr, const struct nlm_lock *lock) > s32 start, len; > > /* exclusive */ > - if (xdr_stream_encode_bool(xdr, fl->fl_type != F_RDLCK) < 0) > + if (xdr_stream_encode_bool(xdr, fl->fl_core.fl_type != F_RDLCK) < 0) > return false; > if (xdr_stream_encode_u32(xdr, lock->svid) < 0) > return false; > diff --git a/fs/lockd/xdr4.c b/fs/lockd/xdr4.c > index 5fcbf30cd275..67e53f91717a 100644 > --- a/fs/lockd/xdr4.c > +++ b/fs/lockd/xdr4.c > @@ -89,8 +89,8 @@ svcxdr_decode_lock(struct xdr_stream *xdr, struct nlm_lock *lock) > return false; > > locks_init_lock(fl); > - fl->fl_flags = FL_POSIX; > - fl->fl_type = F_RDLCK; > + fl->fl_core.fl_flags = FL_POSIX; > + fl->fl_core.fl_type = F_RDLCK; > nlm4svc_set_file_lock_range(fl, lock->lock_start, lock->lock_len); > return true; > } > @@ -102,7 +102,7 @@ svcxdr_encode_holder(struct xdr_stream *xdr, const struct nlm_lock *lock) > s64 start, len; > > /* exclusive */ > - if (xdr_stream_encode_bool(xdr, fl->fl_type != F_RDLCK) < 0) > + if (xdr_stream_encode_bool(xdr, fl->fl_core.fl_type != F_RDLCK) < 0) > return false; > if (xdr_stream_encode_u32(xdr, lock->svid) < 0) > return false; > diff --git a/fs/locks.c b/fs/locks.c > index cc7c117ee192..cd6ffa22a1ce 100644 > --- a/fs/locks.c > +++ b/fs/locks.c > @@ -78,16 +78,16 @@ > > static bool lease_breaking(struct file_lock *fl) > { > - return fl->fl_flags & (FL_UNLOCK_PENDING | FL_DOWNGRADE_PENDING); > + return fl->fl_core.fl_flags & (FL_UNLOCK_PENDING | FL_DOWNGRADE_PENDING); > } > > static int target_leasetype(struct file_lock *fl) > { > - if (fl->fl_flags & FL_UNLOCK_PENDING) > + if (fl->fl_core.fl_flags & FL_UNLOCK_PENDING) > return F_UNLCK; > - if (fl->fl_flags & FL_DOWNGRADE_PENDING) > + if (fl->fl_core.fl_flags & FL_DOWNGRADE_PENDING) > return F_RDLCK; > - return fl->fl_type; > + return fl->fl_core.fl_type; > } > > static int leases_enable = 1; > @@ -207,7 +207,9 @@ 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); > + pr_warn("%s: fl_owner=%p fl_flags=0x%x fl_type=0x%x fl_pid=%u\n", list_type, > + fl->fl_core.fl_owner, fl->fl_core.fl_flags, > + fl->fl_core.fl_type, fl->fl_core.fl_pid); > } > } > > @@ -236,12 +238,13 @@ locks_check_ctx_file_list(struct file *filp, struct list_head *list, > struct inode *inode = file_inode(filp); > > list_for_each_entry(fl, list, fl_list) > - if (fl->fl_file == filp) > + if (fl->fl_core.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); > + fl->fl_core.fl_owner, fl->fl_core.fl_flags, > + fl->fl_core.fl_type, fl->fl_core.fl_pid); > } > > void > @@ -257,11 +260,11 @@ locks_free_lock_context(struct inode *inode) > > static void locks_init_lock_heads(struct file_lock *fl) > { > - INIT_HLIST_NODE(&fl->fl_link); > - INIT_LIST_HEAD(&fl->fl_list); > - INIT_LIST_HEAD(&fl->fl_blocked_requests); > - INIT_LIST_HEAD(&fl->fl_blocked_member); > - init_waitqueue_head(&fl->fl_wait); > + INIT_HLIST_NODE(&fl->fl_core.fl_link); > + INIT_LIST_HEAD(&fl->fl_core.fl_list); > + INIT_LIST_HEAD(&fl->fl_core.fl_blocked_requests); > + INIT_LIST_HEAD(&fl->fl_core.fl_blocked_member); > + init_waitqueue_head(&fl->fl_core.fl_wait); > } > > /* Allocate an empty lock structure. */ > @@ -278,11 +281,11 @@ EXPORT_SYMBOL_GPL(locks_alloc_lock); > > void locks_release_private(struct file_lock *fl) > { > - 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)); > + BUG_ON(waitqueue_active(&fl->fl_core.fl_wait)); > + BUG_ON(!list_empty(&fl->fl_core.fl_list)); > + BUG_ON(!list_empty(&fl->fl_core.fl_blocked_requests)); > + BUG_ON(!list_empty(&fl->fl_core.fl_blocked_member)); > + BUG_ON(!hlist_unhashed(&fl->fl_core.fl_link)); > > if (fl->fl_ops) { > if (fl->fl_ops->fl_release_private) > @@ -292,8 +295,8 @@ void locks_release_private(struct file_lock *fl) > > if (fl->fl_lmops) { > if (fl->fl_lmops->lm_put_owner) { > - fl->fl_lmops->lm_put_owner(fl->fl_owner); > - fl->fl_owner = NULL; > + fl->fl_lmops->lm_put_owner(fl->fl_core.fl_owner); > + fl->fl_core.fl_owner = NULL; > } > fl->fl_lmops = NULL; > } > @@ -316,9 +319,9 @@ bool locks_owner_has_blockers(struct file_lock_context *flctx, > > spin_lock(&flctx->flc_lock); > list_for_each_entry(fl, &flctx->flc_posix, fl_list) { > - if (fl->fl_owner != owner) > + if (fl->fl_core.fl_owner != owner) > continue; > - if (!list_empty(&fl->fl_blocked_requests)) { > + if (!list_empty(&fl->fl_core.fl_blocked_requests)) { > spin_unlock(&flctx->flc_lock); > return true; > } > @@ -343,7 +346,7 @@ locks_dispose_list(struct list_head *dispose) > > while (!list_empty(dispose)) { > fl = list_first_entry(dispose, struct file_lock, fl_list); > - list_del_init(&fl->fl_list); > + list_del_init(&fl->fl_core.fl_list); > locks_free_lock(fl); > } > } > @@ -360,11 +363,11 @@ EXPORT_SYMBOL(locks_init_lock); > */ > void locks_copy_conflock(struct file_lock *new, struct file_lock *fl) > { > - new->fl_owner = fl->fl_owner; > - new->fl_pid = fl->fl_pid; > - new->fl_file = NULL; > - new->fl_flags = fl->fl_flags; > - new->fl_type = fl->fl_type; > + new->fl_core.fl_owner = fl->fl_core.fl_owner; > + new->fl_core.fl_pid = fl->fl_core.fl_pid; > + new->fl_core.fl_file = NULL; > + new->fl_core.fl_flags = fl->fl_core.fl_flags; > + new->fl_core.fl_type = fl->fl_core.fl_type; > new->fl_start = fl->fl_start; > new->fl_end = fl->fl_end; > new->fl_lmops = fl->fl_lmops; > @@ -372,7 +375,7 @@ void locks_copy_conflock(struct file_lock *new, struct file_lock *fl) > > if (fl->fl_lmops) { > if (fl->fl_lmops->lm_get_owner) > - fl->fl_lmops->lm_get_owner(fl->fl_owner); > + fl->fl_lmops->lm_get_owner(fl->fl_core.fl_owner); > } > } > EXPORT_SYMBOL(locks_copy_conflock); > @@ -384,7 +387,7 @@ void locks_copy_lock(struct file_lock *new, struct file_lock *fl) > > locks_copy_conflock(new, fl); > > - new->fl_file = fl->fl_file; > + new->fl_core.fl_file = fl->fl_core.fl_file; > new->fl_ops = fl->fl_ops; > > if (fl->fl_ops) { > @@ -403,12 +406,14 @@ static void locks_move_blocks(struct file_lock *new, struct file_lock *fl) > * ->fl_blocked_requests, so we don't need a lock to check if it > * is empty. > */ > - if (list_empty(&fl->fl_blocked_requests)) > + if (list_empty(&fl->fl_core.fl_blocked_requests)) > return; > spin_lock(&blocked_lock_lock); > - list_splice_init(&fl->fl_blocked_requests, &new->fl_blocked_requests); > - list_for_each_entry(f, &new->fl_blocked_requests, fl_blocked_member) > - f->fl_blocker = new; > + list_splice_init(&fl->fl_core.fl_blocked_requests, > + &new->fl_core.fl_blocked_requests); > + list_for_each_entry(f, &new->fl_core.fl_blocked_requests, > + fl_blocked_member) > + f->fl_core.fl_blocker = new; > spin_unlock(&blocked_lock_lock); > } > > @@ -429,11 +434,11 @@ static void flock_make_lock(struct file *filp, struct file_lock *fl, int type) > { > locks_init_lock(fl); > > - fl->fl_file = filp; > - fl->fl_owner = filp; > - fl->fl_pid = current->tgid; > - fl->fl_flags = FL_FLOCK; > - fl->fl_type = type; > + fl->fl_core.fl_file = filp; > + fl->fl_core.fl_owner = filp; > + fl->fl_core.fl_pid = current->tgid; > + fl->fl_core.fl_flags = FL_FLOCK; > + fl->fl_core.fl_type = type; > fl->fl_end = OFFSET_MAX; > } > > @@ -443,7 +448,7 @@ static int assign_type(struct file_lock *fl, int type) > case F_RDLCK: > case F_WRLCK: > case F_UNLCK: > - fl->fl_type = type; > + fl->fl_core.fl_type = type; > break; > default: > return -EINVAL; > @@ -488,10 +493,10 @@ static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl, > } else > fl->fl_end = OFFSET_MAX; > > - fl->fl_owner = current->files; > - fl->fl_pid = current->tgid; > - fl->fl_file = filp; > - fl->fl_flags = FL_POSIX; > + fl->fl_core.fl_owner = current->files; > + fl->fl_core.fl_pid = current->tgid; > + fl->fl_core.fl_file = filp; > + fl->fl_core.fl_flags = FL_POSIX; > fl->fl_ops = NULL; > fl->fl_lmops = NULL; > > @@ -525,7 +530,7 @@ lease_break_callback(struct file_lock *fl) > static void > lease_setup(struct file_lock *fl, void **priv) > { > - struct file *filp = fl->fl_file; > + struct file *filp = fl->fl_core.fl_file; > struct fasync_struct *fa = *priv; > > /* > @@ -553,11 +558,11 @@ static int lease_init(struct file *filp, int type, struct file_lock *fl) > if (assign_type(fl, type) != 0) > return -EINVAL; > > - fl->fl_owner = filp; > - fl->fl_pid = current->tgid; > + fl->fl_core.fl_owner = filp; > + fl->fl_core.fl_pid = current->tgid; > > - fl->fl_file = filp; > - fl->fl_flags = FL_LEASE; > + fl->fl_core.fl_file = filp; > + fl->fl_core.fl_flags = FL_LEASE; > fl->fl_start = 0; > fl->fl_end = OFFSET_MAX; > fl->fl_ops = NULL; > @@ -595,7 +600,7 @@ static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2) > */ > static int posix_same_owner(struct file_lock *fl1, struct file_lock *fl2) > { > - return fl1->fl_owner == fl2->fl_owner; > + return fl1->fl_core.fl_owner == fl2->fl_core.fl_owner; > } > > /* Must be called with the flc_lock held! */ > @@ -606,8 +611,8 @@ static void locks_insert_global_locks(struct file_lock *fl) > percpu_rwsem_assert_held(&file_rwsem); > > spin_lock(&fll->lock); > - fl->fl_link_cpu = smp_processor_id(); > - hlist_add_head(&fl->fl_link, &fll->hlist); > + fl->fl_core.fl_link_cpu = smp_processor_id(); > + hlist_add_head(&fl->fl_core.fl_link, &fll->hlist); > spin_unlock(&fll->lock); > } > > @@ -623,33 +628,34 @@ static void locks_delete_global_locks(struct file_lock *fl) > * is done while holding the flc_lock, and new insertions into the list > * also require that it be held. > */ > - if (hlist_unhashed(&fl->fl_link)) > + if (hlist_unhashed(&fl->fl_core.fl_link)) > return; > > - fll = per_cpu_ptr(&file_lock_list, fl->fl_link_cpu); > + fll = per_cpu_ptr(&file_lock_list, fl->fl_core.fl_link_cpu); > spin_lock(&fll->lock); > - hlist_del_init(&fl->fl_link); > + hlist_del_init(&fl->fl_core.fl_link); > spin_unlock(&fll->lock); > } > > static unsigned long > posix_owner_key(struct file_lock *fl) > { > - return (unsigned long)fl->fl_owner; > + return (unsigned long) fl->fl_core.fl_owner; > } > > static void locks_insert_global_blocked(struct file_lock *waiter) > { > lockdep_assert_held(&blocked_lock_lock); > > - hash_add(blocked_hash, &waiter->fl_link, posix_owner_key(waiter)); > + hash_add(blocked_hash, &waiter->fl_core.fl_link, > + posix_owner_key(waiter)); > } > > static void locks_delete_global_blocked(struct file_lock *waiter) > { > lockdep_assert_held(&blocked_lock_lock); > > - hash_del(&waiter->fl_link); > + hash_del(&waiter->fl_core.fl_link); > } > > /* Remove waiter from blocker's block list. > @@ -660,28 +666,28 @@ static void locks_delete_global_blocked(struct file_lock *waiter) > static void __locks_delete_block(struct file_lock *waiter) > { > locks_delete_global_blocked(waiter); > - list_del_init(&waiter->fl_blocked_member); > + list_del_init(&waiter->fl_core.fl_blocked_member); > } > > static void __locks_wake_up_blocks(struct file_lock *blocker) > { > - while (!list_empty(&blocker->fl_blocked_requests)) { > + while (!list_empty(&blocker->fl_core.fl_blocked_requests)) { > struct file_lock *waiter; > > - waiter = list_first_entry(&blocker->fl_blocked_requests, > + waiter = list_first_entry(&blocker->fl_core.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); > + wake_up(&waiter->fl_core.fl_wait); > > /* > * 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); > + smp_store_release(&waiter->fl_core.fl_blocker, NULL); > } > } > > @@ -716,12 +722,12 @@ int locks_delete_block(struct file_lock *waiter) > * 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)) > + if (!smp_load_acquire(&waiter->fl_core.fl_blocker) && > + list_empty(&waiter->fl_core.fl_blocked_requests)) > return status; > > spin_lock(&blocked_lock_lock); > - if (waiter->fl_blocker) > + if (waiter->fl_core.fl_blocker) > status = 0; > __locks_wake_up_blocks(waiter); > __locks_delete_block(waiter); > @@ -730,7 +736,7 @@ int locks_delete_block(struct file_lock *waiter) > * 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); > + smp_store_release(&waiter->fl_core.fl_blocker, NULL); > spin_unlock(&blocked_lock_lock); > return status; > } > @@ -757,16 +763,18 @@ static void __locks_insert_block(struct file_lock *blocker, > struct file_lock *)) > { > struct file_lock *fl; > - BUG_ON(!list_empty(&waiter->fl_blocked_member)); > + BUG_ON(!list_empty(&waiter->fl_core.fl_blocked_member)); > > new_blocker: > - list_for_each_entry(fl, &blocker->fl_blocked_requests, fl_blocked_member) > + list_for_each_entry(fl, &blocker->fl_core.fl_blocked_requests, > + fl_blocked_member) > if (conflict(fl, waiter)) { > blocker = fl; > goto new_blocker; > } > - waiter->fl_blocker = blocker; > - list_add_tail(&waiter->fl_blocked_member, &blocker->fl_blocked_requests); > + waiter->fl_core.fl_blocker = blocker; > + list_add_tail(&waiter->fl_core.fl_blocked_member, > + &blocker->fl_core.fl_blocked_requests); > if (IS_POSIX(blocker) && !IS_OFDLCK(blocker)) > locks_insert_global_blocked(waiter); > > @@ -802,7 +810,7 @@ static void locks_wake_up_blocks(struct file_lock *blocker) > * fl_blocked_requests list does not require the flc_lock, so we must > * recheck list_empty() after acquiring the blocked_lock_lock. > */ > - if (list_empty(&blocker->fl_blocked_requests)) > + if (list_empty(&blocker->fl_core.fl_blocked_requests)) > return; > > spin_lock(&blocked_lock_lock); > @@ -813,7 +821,7 @@ static void locks_wake_up_blocks(struct file_lock *blocker) > static void > locks_insert_lock_ctx(struct file_lock *fl, struct list_head *before) > { > - list_add_tail(&fl->fl_list, before); > + list_add_tail(&fl->fl_core.fl_list, before); > locks_insert_global_locks(fl); > } > > @@ -821,7 +829,7 @@ static void > locks_unlink_lock_ctx(struct file_lock *fl) > { > locks_delete_global_locks(fl); > - list_del_init(&fl->fl_list); > + list_del_init(&fl->fl_core.fl_list); > locks_wake_up_blocks(fl); > } > > @@ -830,7 +838,7 @@ locks_delete_lock_ctx(struct file_lock *fl, struct list_head *dispose) > { > locks_unlink_lock_ctx(fl); > if (dispose) > - list_add(&fl->fl_list, dispose); > + list_add(&fl->fl_core.fl_list, dispose); > else > locks_free_lock(fl); > } > @@ -841,9 +849,9 @@ locks_delete_lock_ctx(struct file_lock *fl, struct list_head *dispose) > static bool locks_conflict(struct file_lock *caller_fl, > struct file_lock *sys_fl) > { > - if (sys_fl->fl_type == F_WRLCK) > + if (sys_fl->fl_core.fl_type == F_WRLCK) > return true; > - if (caller_fl->fl_type == F_WRLCK) > + if (caller_fl->fl_core.fl_type == F_WRLCK) > return true; > return false; > } > @@ -874,7 +882,7 @@ static bool posix_test_locks_conflict(struct file_lock *caller_fl, > struct file_lock *sys_fl) > { > /* F_UNLCK checks any locks on the same fd. */ > - if (caller_fl->fl_type == F_UNLCK) { > + if (caller_fl->fl_core.fl_type == F_UNLCK) { > if (!posix_same_owner(caller_fl, sys_fl)) > return false; > return locks_overlap(caller_fl, sys_fl); > @@ -891,7 +899,7 @@ static bool flock_locks_conflict(struct file_lock *caller_fl, > /* FLOCK locks referring to the same filp do not conflict with > * each other. > */ > - if (caller_fl->fl_file == sys_fl->fl_file) > + if (caller_fl->fl_core.fl_file == sys_fl->fl_core.fl_file) > return false; > > return locks_conflict(caller_fl, sys_fl); > @@ -908,7 +916,7 @@ posix_test_lock(struct file *filp, struct file_lock *fl) > > ctx = locks_inode_context(inode); > if (!ctx || list_empty_careful(&ctx->flc_posix)) { > - fl->fl_type = F_UNLCK; > + fl->fl_core.fl_type = F_UNLCK; > return; > } > > @@ -930,7 +938,7 @@ posix_test_lock(struct file *filp, struct file_lock *fl) > locks_copy_conflock(fl, cfl); > goto out; > } > - fl->fl_type = F_UNLCK; > + fl->fl_core.fl_type = F_UNLCK; > out: > spin_unlock(&ctx->flc_lock); > return; > @@ -979,8 +987,8 @@ static struct file_lock *what_owner_is_waiting_for(struct file_lock *block_fl) > > hash_for_each_possible(blocked_hash, fl, fl_link, posix_owner_key(block_fl)) { > if (posix_same_owner(fl, block_fl)) { > - while (fl->fl_blocker) > - fl = fl->fl_blocker; > + while (fl->fl_core.fl_blocker) > + fl = fl->fl_core.fl_blocker; > return fl; > } > } > @@ -1027,14 +1035,14 @@ static int flock_lock_inode(struct inode *inode, struct file_lock *request) > bool found = false; > LIST_HEAD(dispose); > > - ctx = locks_get_lock_context(inode, request->fl_type); > + ctx = locks_get_lock_context(inode, request->fl_core.fl_type); > if (!ctx) { > - if (request->fl_type != F_UNLCK) > + if (request->fl_core.fl_type != F_UNLCK) > return -ENOMEM; > - return (request->fl_flags & FL_EXISTS) ? -ENOENT : 0; > + return (request->fl_core.fl_flags & FL_EXISTS) ? -ENOENT : 0; > } > > - if (!(request->fl_flags & FL_ACCESS) && (request->fl_type != F_UNLCK)) { > + if (!(request->fl_core.fl_flags & FL_ACCESS) && (request->fl_core.fl_type != F_UNLCK)) { > new_fl = locks_alloc_lock(); > if (!new_fl) > return -ENOMEM; > @@ -1042,21 +1050,21 @@ static int flock_lock_inode(struct inode *inode, struct file_lock *request) > > percpu_down_read(&file_rwsem); > spin_lock(&ctx->flc_lock); > - if (request->fl_flags & FL_ACCESS) > + if (request->fl_core.fl_flags & FL_ACCESS) > goto find_conflict; > > list_for_each_entry(fl, &ctx->flc_flock, fl_list) { > - if (request->fl_file != fl->fl_file) > + if (request->fl_core.fl_file != fl->fl_core.fl_file) > continue; > - if (request->fl_type == fl->fl_type) > + if (request->fl_core.fl_type == fl->fl_core.fl_type) > goto out; > found = true; > locks_delete_lock_ctx(fl, &dispose); > break; > } > > - if (request->fl_type == F_UNLCK) { > - if ((request->fl_flags & FL_EXISTS) && !found) > + if (request->fl_core.fl_type == F_UNLCK) { > + if ((request->fl_core.fl_flags & FL_EXISTS) && !found) > error = -ENOENT; > goto out; > } > @@ -1066,13 +1074,13 @@ static int flock_lock_inode(struct inode *inode, struct file_lock *request) > if (!flock_locks_conflict(request, fl)) > continue; > error = -EAGAIN; > - if (!(request->fl_flags & FL_SLEEP)) > + if (!(request->fl_core.fl_flags & FL_SLEEP)) > goto out; > error = FILE_LOCK_DEFERRED; > locks_insert_block(fl, request, flock_locks_conflict); > goto out; > } > - if (request->fl_flags & FL_ACCESS) > + if (request->fl_core.fl_flags & FL_ACCESS) > goto out; > locks_copy_lock(new_fl, request); > locks_move_blocks(new_fl, request); > @@ -1105,9 +1113,9 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, > void *owner; > void (*func)(void); > > - ctx = locks_get_lock_context(inode, request->fl_type); > + ctx = locks_get_lock_context(inode, request->fl_core.fl_type); > if (!ctx) > - return (request->fl_type == F_UNLCK) ? 0 : -ENOMEM; > + return (request->fl_core.fl_type == F_UNLCK) ? 0 : -ENOMEM; > > /* > * We may need two file_lock structures for this operation, > @@ -1115,8 +1123,8 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, > * > * In some cases we can be sure, that no new locks will be needed > */ > - if (!(request->fl_flags & FL_ACCESS) && > - (request->fl_type != F_UNLCK || > + if (!(request->fl_core.fl_flags & FL_ACCESS) && > + (request->fl_core.fl_type != F_UNLCK || > request->fl_start != 0 || request->fl_end != OFFSET_MAX)) { > new_fl = locks_alloc_lock(); > new_fl2 = locks_alloc_lock(); > @@ -1130,7 +1138,7 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, > * there are any, either return error or put the request on the > * blocker's list of waiters and the global blocked_hash. > */ > - if (request->fl_type != F_UNLCK) { > + if (request->fl_core.fl_type != F_UNLCK) { > list_for_each_entry(fl, &ctx->flc_posix, fl_list) { > if (!posix_locks_conflict(request, fl)) > continue; > @@ -1148,7 +1156,7 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, > if (conflock) > locks_copy_conflock(conflock, fl); > error = -EAGAIN; > - if (!(request->fl_flags & FL_SLEEP)) > + if (!(request->fl_core.fl_flags & FL_SLEEP)) > goto out; > /* > * Deadlock detection and insertion into the blocked > @@ -1173,7 +1181,7 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, > > /* If we're just looking for a conflict, we're done. */ > error = 0; > - if (request->fl_flags & FL_ACCESS) > + if (request->fl_core.fl_flags & FL_ACCESS) > goto out; > > /* Find the first old lock with the same owner as the new lock */ > @@ -1188,7 +1196,7 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, > break; > > /* Detect adjacent or overlapping regions (if same lock type) */ > - if (request->fl_type == fl->fl_type) { > + if (request->fl_core.fl_type == fl->fl_core.fl_type) { > /* In all comparisons of start vs end, use > * "start - 1" rather than "end + 1". If end > * is OFFSET_MAX, end + 1 will become negative. > @@ -1228,7 +1236,7 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, > continue; > if (fl->fl_start > request->fl_end) > break; > - if (request->fl_type == F_UNLCK) > + if (request->fl_core.fl_type == F_UNLCK) > added = true; > if (fl->fl_start < request->fl_start) > left = fl; > @@ -1261,7 +1269,8 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, > locks_move_blocks(new_fl, request); > request = new_fl; > new_fl = NULL; > - locks_insert_lock_ctx(request, &fl->fl_list); > + locks_insert_lock_ctx(request, > + &fl->fl_core.fl_list); > locks_delete_lock_ctx(fl, &dispose); > added = true; > } > @@ -1279,8 +1288,8 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, > > error = 0; > if (!added) { > - if (request->fl_type == F_UNLCK) { > - if (request->fl_flags & FL_EXISTS) > + if (request->fl_core.fl_type == F_UNLCK) { > + if (request->fl_core.fl_flags & FL_EXISTS) > error = -ENOENT; > goto out; > } > @@ -1291,7 +1300,7 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, > } > locks_copy_lock(new_fl, request); > locks_move_blocks(new_fl, request); > - locks_insert_lock_ctx(new_fl, &fl->fl_list); > + locks_insert_lock_ctx(new_fl, &fl->fl_core.fl_list); > fl = new_fl; > new_fl = NULL; > } > @@ -1303,7 +1312,7 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, > left = new_fl2; > new_fl2 = NULL; > locks_copy_lock(left, right); > - locks_insert_lock_ctx(left, &fl->fl_list); > + locks_insert_lock_ctx(left, &fl->fl_core.fl_list); > } > right->fl_start = request->fl_end + 1; > locks_wake_up_blocks(right); > @@ -1364,8 +1373,8 @@ static int posix_lock_inode_wait(struct inode *inode, struct file_lock *fl) > error = posix_lock_inode(inode, fl, NULL); > if (error != FILE_LOCK_DEFERRED) > break; > - error = wait_event_interruptible(fl->fl_wait, > - list_empty(&fl->fl_blocked_member)); > + error = wait_event_interruptible(fl->fl_core.fl_wait, > + list_empty(&fl->fl_core.fl_blocked_member)); > if (error) > break; > } > @@ -1377,10 +1386,10 @@ static void lease_clear_pending(struct file_lock *fl, int arg) > { > switch (arg) { > case F_UNLCK: > - fl->fl_flags &= ~FL_UNLOCK_PENDING; > + fl->fl_core.fl_flags &= ~FL_UNLOCK_PENDING; > fallthrough; > case F_RDLCK: > - fl->fl_flags &= ~FL_DOWNGRADE_PENDING; > + fl->fl_core.fl_flags &= ~FL_DOWNGRADE_PENDING; > } > } > > @@ -1394,11 +1403,11 @@ int lease_modify(struct file_lock *fl, int arg, struct list_head *dispose) > lease_clear_pending(fl, arg); > locks_wake_up_blocks(fl); > if (arg == F_UNLCK) { > - struct file *filp = fl->fl_file; > + struct file *filp = fl->fl_core.fl_file; > > f_delown(filp); > filp->f_owner.signum = 0; > - fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync); > + fasync_helper(0, fl->fl_core.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; > @@ -1440,11 +1449,11 @@ static bool leases_conflict(struct file_lock *lease, struct file_lock *breaker) > if (lease->fl_lmops->lm_breaker_owns_lease > && lease->fl_lmops->lm_breaker_owns_lease(lease)) > return false; > - if ((breaker->fl_flags & FL_LAYOUT) != (lease->fl_flags & FL_LAYOUT)) { > + if ((breaker->fl_core.fl_flags & FL_LAYOUT) != (lease->fl_core.fl_flags & FL_LAYOUT)) { > rc = false; > goto trace; > } > - if ((breaker->fl_flags & FL_DELEG) && (lease->fl_flags & FL_LEASE)) { > + if ((breaker->fl_core.fl_flags & FL_DELEG) && (lease->fl_core.fl_flags & FL_LEASE)) { > rc = false; > goto trace; > } > @@ -1495,7 +1504,7 @@ int __break_lease(struct inode *inode, unsigned int mode, unsigned int type) > new_fl = lease_alloc(NULL, want_write ? F_WRLCK : F_RDLCK); > if (IS_ERR(new_fl)) > return PTR_ERR(new_fl); > - new_fl->fl_flags = type; > + new_fl->fl_core.fl_flags = type; > > /* typically we will check that ctx is non-NULL before calling */ > ctx = locks_inode_context(inode); > @@ -1523,14 +1532,14 @@ int __break_lease(struct inode *inode, unsigned int mode, unsigned int type) > if (!leases_conflict(fl, new_fl)) > continue; > if (want_write) { > - if (fl->fl_flags & FL_UNLOCK_PENDING) > + if (fl->fl_core.fl_flags & FL_UNLOCK_PENDING) > continue; > - fl->fl_flags |= FL_UNLOCK_PENDING; > + fl->fl_core.fl_flags |= FL_UNLOCK_PENDING; > fl->fl_break_time = break_time; > } else { > if (lease_breaking(fl)) > continue; > - fl->fl_flags |= FL_DOWNGRADE_PENDING; > + fl->fl_core.fl_flags |= FL_DOWNGRADE_PENDING; > fl->fl_downgrade_time = break_time; > } > if (fl->fl_lmops->lm_break(fl)) > @@ -1559,9 +1568,9 @@ int __break_lease(struct inode *inode, unsigned int mode, unsigned int type) > percpu_up_read(&file_rwsem); > > locks_dispose_list(&dispose); > - error = wait_event_interruptible_timeout(new_fl->fl_wait, > - list_empty(&new_fl->fl_blocked_member), > - break_time); > + error = wait_event_interruptible_timeout(new_fl->fl_core.fl_wait, > + list_empty(&new_fl->fl_core.fl_blocked_member), > + break_time); > > percpu_down_read(&file_rwsem); > spin_lock(&ctx->flc_lock); > @@ -1608,7 +1617,7 @@ void lease_get_mtime(struct inode *inode, struct timespec64 *time) > spin_lock(&ctx->flc_lock); > fl = list_first_entry_or_null(&ctx->flc_lease, > struct file_lock, fl_list); > - if (fl && (fl->fl_type == F_WRLCK)) > + if (fl && (fl->fl_core.fl_type == F_WRLCK)) > has_lease = true; > spin_unlock(&ctx->flc_lock); > } > @@ -1655,7 +1664,7 @@ int fcntl_getlease(struct file *filp) > spin_lock(&ctx->flc_lock); > time_out_leases(inode, &dispose); > list_for_each_entry(fl, &ctx->flc_lease, fl_list) { > - if (fl->fl_file != filp) > + if (fl->fl_core.fl_file != filp) > continue; > type = target_leasetype(fl); > break; > @@ -1720,7 +1729,7 @@ generic_add_lease(struct file *filp, int arg, struct file_lock **flp, void **pri > struct file_lock *fl, *my_fl = NULL, *lease; > struct inode *inode = file_inode(filp); > struct file_lock_context *ctx; > - bool is_deleg = (*flp)->fl_flags & FL_DELEG; > + bool is_deleg = (*flp)->fl_core.fl_flags & FL_DELEG; > int error; > LIST_HEAD(dispose); > > @@ -1746,7 +1755,7 @@ generic_add_lease(struct file *filp, int arg, struct file_lock **flp, void **pri > percpu_down_read(&file_rwsem); > spin_lock(&ctx->flc_lock); > time_out_leases(inode, &dispose); > - error = check_conflicting_open(filp, arg, lease->fl_flags); > + error = check_conflicting_open(filp, arg, lease->fl_core.fl_flags); > if (error) > goto out; > > @@ -1760,8 +1769,8 @@ generic_add_lease(struct file *filp, int arg, struct file_lock **flp, void **pri > */ > error = -EAGAIN; > list_for_each_entry(fl, &ctx->flc_lease, fl_list) { > - if (fl->fl_file == filp && > - fl->fl_owner == lease->fl_owner) { > + if (fl->fl_core.fl_file == filp && > + fl->fl_core.fl_owner == lease->fl_core.fl_owner) { > my_fl = fl; > continue; > } > @@ -1776,7 +1785,7 @@ generic_add_lease(struct file *filp, int arg, struct file_lock **flp, void **pri > * 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) > + if (fl->fl_core.fl_flags & FL_UNLOCK_PENDING) > goto out; > } > > @@ -1803,7 +1812,7 @@ generic_add_lease(struct file *filp, int arg, struct file_lock **flp, void **pri > * precedes these checks. > */ > smp_mb(); > - error = check_conflicting_open(filp, arg, lease->fl_flags); > + error = check_conflicting_open(filp, arg, lease->fl_core.fl_flags); > if (error) { > locks_unlink_lock_ctx(lease); > goto out; > @@ -1840,8 +1849,8 @@ static int generic_delete_lease(struct file *filp, void *owner) > percpu_down_read(&file_rwsem); > spin_lock(&ctx->flc_lock); > list_for_each_entry(fl, &ctx->flc_lease, fl_list) { > - if (fl->fl_file == filp && > - fl->fl_owner == owner) { > + if (fl->fl_core.fl_file == filp && > + fl->fl_core.fl_owner == owner) { > victim = fl; > break; > } > @@ -2017,8 +2026,8 @@ static int flock_lock_inode_wait(struct inode *inode, struct file_lock *fl) > error = flock_lock_inode(inode, fl); > if (error != FILE_LOCK_DEFERRED) > break; > - error = wait_event_interruptible(fl->fl_wait, > - list_empty(&fl->fl_blocked_member)); > + error = wait_event_interruptible(fl->fl_core.fl_wait, > + list_empty(&fl->fl_core.fl_blocked_member)); > if (error) > break; > } > @@ -2036,7 +2045,7 @@ static int flock_lock_inode_wait(struct inode *inode, struct file_lock *fl) > int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl) > { > int res = 0; > - switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) { > + switch (fl->fl_core.fl_flags & (FL_POSIX|FL_FLOCK)) { > case FL_POSIX: > res = posix_lock_inode_wait(inode, fl); > break; > @@ -2098,13 +2107,13 @@ SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd) > > flock_make_lock(f.file, &fl, type); > > - error = security_file_lock(f.file, fl.fl_type); > + error = security_file_lock(f.file, fl.fl_core.fl_type); > if (error) > goto out_putf; > > can_sleep = !(cmd & LOCK_NB); > if (can_sleep) > - fl.fl_flags |= FL_SLEEP; > + fl.fl_core.fl_flags |= FL_SLEEP; > > if (f.file->f_op->flock) > error = f.file->f_op->flock(f.file, > @@ -2130,7 +2139,7 @@ SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd) > */ > int vfs_test_lock(struct file *filp, struct file_lock *fl) > { > - WARN_ON_ONCE(filp != fl->fl_file); > + WARN_ON_ONCE(filp != fl->fl_core.fl_file); > if (filp->f_op->lock) > return filp->f_op->lock(filp, F_GETLK, fl); > posix_test_lock(filp, fl); > @@ -2153,17 +2162,17 @@ static pid_t locks_translate_pid(struct file_lock *fl, struct pid_namespace *ns) > if (IS_OFDLCK(fl)) > return -1; > if (IS_REMOTELCK(fl)) > - return fl->fl_pid; > + return fl->fl_core.fl_pid; > /* > * 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; > + return (pid_t) fl->fl_core.fl_pid; > > rcu_read_lock(); > - pid = find_pid_ns(fl->fl_pid, &init_pid_ns); > + pid = find_pid_ns(fl->fl_core.fl_pid, &init_pid_ns); > vnr = pid_nr_ns(pid, ns); > rcu_read_unlock(); > return vnr; > @@ -2186,7 +2195,7 @@ static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl) > 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; > + flock->l_type = fl->fl_core.fl_type; > return 0; > } > > @@ -2198,7 +2207,7 @@ static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl) > 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; > + flock->l_type = fl->fl_core.fl_type; > } > #endif > > @@ -2227,16 +2236,16 @@ int fcntl_getlk(struct file *filp, unsigned int cmd, struct flock *flock) > if (flock->l_pid != 0) > goto out; > > - fl->fl_flags |= FL_OFDLCK; > - fl->fl_owner = filp; > + fl->fl_core.fl_flags |= FL_OFDLCK; > + fl->fl_core.fl_owner = filp; > } > > error = vfs_test_lock(filp, fl); > if (error) > goto out; > > - flock->l_type = fl->fl_type; > - if (fl->fl_type != F_UNLCK) { > + flock->l_type = fl->fl_core.fl_type; > + if (fl->fl_core.fl_type != F_UNLCK) { > error = posix_lock_to_flock(flock, fl); > if (error) > goto out; > @@ -2283,7 +2292,7 @@ int fcntl_getlk(struct file *filp, unsigned int cmd, struct flock *flock) > */ > int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf) > { > - WARN_ON_ONCE(filp != fl->fl_file); > + WARN_ON_ONCE(filp != fl->fl_core.fl_file); > if (filp->f_op->lock) > return filp->f_op->lock(filp, cmd, fl); > else > @@ -2296,7 +2305,7 @@ static int do_lock_file_wait(struct file *filp, unsigned int cmd, > { > int error; > > - error = security_file_lock(filp, fl->fl_type); > + error = security_file_lock(filp, fl->fl_core.fl_type); > if (error) > return error; > > @@ -2304,8 +2313,8 @@ static int do_lock_file_wait(struct file *filp, unsigned int cmd, > error = vfs_lock_file(filp, cmd, fl, NULL); > if (error != FILE_LOCK_DEFERRED) > break; > - error = wait_event_interruptible(fl->fl_wait, > - list_empty(&fl->fl_blocked_member)); > + error = wait_event_interruptible(fl->fl_core.fl_wait, > + list_empty(&fl->fl_core.fl_blocked_member)); > if (error) > break; > } > @@ -2318,13 +2327,13 @@ static int do_lock_file_wait(struct file *filp, unsigned int cmd, > static int > check_fmode_for_setlk(struct file_lock *fl) > { > - switch (fl->fl_type) { > + switch (fl->fl_core.fl_type) { > case F_RDLCK: > - if (!(fl->fl_file->f_mode & FMODE_READ)) > + if (!(fl->fl_core.fl_file->f_mode & FMODE_READ)) > return -EBADF; > break; > case F_WRLCK: > - if (!(fl->fl_file->f_mode & FMODE_WRITE)) > + if (!(fl->fl_core.fl_file->f_mode & FMODE_WRITE)) > return -EBADF; > } > return 0; > @@ -2363,8 +2372,8 @@ int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd, > goto out; > > cmd = F_SETLK; > - file_lock->fl_flags |= FL_OFDLCK; > - file_lock->fl_owner = filp; > + file_lock->fl_core.fl_flags |= FL_OFDLCK; > + file_lock->fl_core.fl_owner = filp; > break; > case F_OFD_SETLKW: > error = -EINVAL; > @@ -2372,11 +2381,11 @@ int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd, > goto out; > > cmd = F_SETLKW; > - file_lock->fl_flags |= FL_OFDLCK; > - file_lock->fl_owner = filp; > + file_lock->fl_core.fl_flags |= FL_OFDLCK; > + file_lock->fl_core.fl_owner = filp; > fallthrough; > case F_SETLKW: > - file_lock->fl_flags |= FL_SLEEP; > + file_lock->fl_core.fl_flags |= FL_SLEEP; > } > > error = do_lock_file_wait(filp, cmd, file_lock); > @@ -2386,8 +2395,8 @@ int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd, > * lock that was just acquired. There is no need to do that when we're > * unlocking though, or for OFD locks. > */ > - if (!error && file_lock->fl_type != F_UNLCK && > - !(file_lock->fl_flags & FL_OFDLCK)) { > + if (!error && file_lock->fl_core.fl_type != F_UNLCK && > + !(file_lock->fl_core.fl_flags & FL_OFDLCK)) { > struct files_struct *files = current->files; > /* > * We need that spin_lock here - it prevents reordering between > @@ -2398,7 +2407,7 @@ int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd, > f = files_lookup_fd_locked(files, fd); > spin_unlock(&files->file_lock); > if (f != filp) { > - file_lock->fl_type = F_UNLCK; > + file_lock->fl_core.fl_type = F_UNLCK; > error = do_lock_file_wait(filp, cmd, file_lock); > WARN_ON_ONCE(error); > error = -EBADF; > @@ -2437,16 +2446,16 @@ int fcntl_getlk64(struct file *filp, unsigned int cmd, struct flock64 *flock) > if (flock->l_pid != 0) > goto out; > > - fl->fl_flags |= FL_OFDLCK; > - fl->fl_owner = filp; > + fl->fl_core.fl_flags |= FL_OFDLCK; > + fl->fl_core.fl_owner = filp; > } > > error = vfs_test_lock(filp, fl); > if (error) > goto out; > > - flock->l_type = fl->fl_type; > - if (fl->fl_type != F_UNLCK) > + flock->l_type = fl->fl_core.fl_type; > + if (fl->fl_core.fl_type != F_UNLCK) > posix_lock_to_flock64(flock, fl); > > out: > @@ -2486,8 +2495,8 @@ int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd, > goto out; > > cmd = F_SETLK64; > - file_lock->fl_flags |= FL_OFDLCK; > - file_lock->fl_owner = filp; > + file_lock->fl_core.fl_flags |= FL_OFDLCK; > + file_lock->fl_core.fl_owner = filp; > break; > case F_OFD_SETLKW: > error = -EINVAL; > @@ -2495,11 +2504,11 @@ int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd, > goto out; > > cmd = F_SETLKW64; > - file_lock->fl_flags |= FL_OFDLCK; > - file_lock->fl_owner = filp; > + file_lock->fl_core.fl_flags |= FL_OFDLCK; > + file_lock->fl_core.fl_owner = filp; > fallthrough; > case F_SETLKW64: > - file_lock->fl_flags |= FL_SLEEP; > + file_lock->fl_core.fl_flags |= FL_SLEEP; > } > > error = do_lock_file_wait(filp, cmd, file_lock); > @@ -2509,8 +2518,8 @@ int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd, > * lock that was just acquired. There is no need to do that when we're > * unlocking though, or for OFD locks. > */ > - if (!error && file_lock->fl_type != F_UNLCK && > - !(file_lock->fl_flags & FL_OFDLCK)) { > + if (!error && file_lock->fl_core.fl_type != F_UNLCK && > + !(file_lock->fl_core.fl_flags & FL_OFDLCK)) { > struct files_struct *files = current->files; > /* > * We need that spin_lock here - it prevents reordering between > @@ -2521,7 +2530,7 @@ int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd, > f = files_lookup_fd_locked(files, fd); > spin_unlock(&files->file_lock); > if (f != filp) { > - file_lock->fl_type = F_UNLCK; > + file_lock->fl_core.fl_type = F_UNLCK; > error = do_lock_file_wait(filp, cmd, file_lock); > WARN_ON_ONCE(error); > error = -EBADF; > @@ -2555,13 +2564,13 @@ void locks_remove_posix(struct file *filp, fl_owner_t owner) > return; > > locks_init_lock(&lock); > - lock.fl_type = F_UNLCK; > - lock.fl_flags = FL_POSIX | FL_CLOSE; > + lock.fl_core.fl_type = F_UNLCK; > + lock.fl_core.fl_flags = FL_POSIX | FL_CLOSE; > lock.fl_start = 0; > lock.fl_end = OFFSET_MAX; > - lock.fl_owner = owner; > - lock.fl_pid = current->tgid; > - lock.fl_file = filp; > + lock.fl_core.fl_owner = owner; > + lock.fl_core.fl_pid = current->tgid; > + lock.fl_core.fl_file = filp; > lock.fl_ops = NULL; > lock.fl_lmops = NULL; > > @@ -2584,7 +2593,7 @@ locks_remove_flock(struct file *filp, struct file_lock_context *flctx) > return; > > flock_make_lock(filp, &fl, F_UNLCK); > - fl.fl_flags |= FL_CLOSE; > + fl.fl_core.fl_flags |= FL_CLOSE; > > if (filp->f_op->flock) > filp->f_op->flock(filp, F_SETLKW, &fl); > @@ -2608,7 +2617,7 @@ locks_remove_lease(struct file *filp, struct file_lock_context *ctx) > percpu_down_read(&file_rwsem); > spin_lock(&ctx->flc_lock); > list_for_each_entry_safe(fl, tmp, &ctx->flc_lease, fl_list) > - if (filp == fl->fl_file) > + if (filp == fl->fl_core.fl_file) > lease_modify(fl, F_UNLCK, &dispose); > spin_unlock(&ctx->flc_lock); > percpu_up_read(&file_rwsem); > @@ -2652,7 +2661,7 @@ void locks_remove_file(struct file *filp) > */ > int vfs_cancel_lock(struct file *filp, struct file_lock *fl) > { > - WARN_ON_ONCE(filp != fl->fl_file); > + WARN_ON_ONCE(filp != fl->fl_core.fl_file); > if (filp->f_op->lock) > return filp->f_op->lock(filp, F_CANCELLK, fl); > return 0; > @@ -2706,8 +2715,8 @@ static void lock_get_status(struct seq_file *f, struct file_lock *fl, > * init_pid_ns to get saved lock pid value. > */ > > - if (fl->fl_file != NULL) > - inode = file_inode(fl->fl_file); > + if (fl->fl_core.fl_file != NULL) > + inode = file_inode(fl->fl_core.fl_file); > > seq_printf(f, "%lld: ", id); > > @@ -2715,7 +2724,7 @@ static void lock_get_status(struct seq_file *f, struct file_lock *fl, > seq_printf(f, "%*s", repeat - 1 + (int)strlen(pfx), pfx); > > if (IS_POSIX(fl)) { > - if (fl->fl_flags & FL_ACCESS) > + if (fl->fl_core.fl_flags & FL_ACCESS) > seq_puts(f, "ACCESS"); > else if (IS_OFDLCK(fl)) > seq_puts(f, "OFDLCK"); > @@ -2727,21 +2736,21 @@ static void lock_get_status(struct seq_file *f, struct file_lock *fl, > } else if (IS_FLOCK(fl)) { > seq_puts(f, "FLOCK ADVISORY "); > } else if (IS_LEASE(fl)) { > - if (fl->fl_flags & FL_DELEG) > + if (fl->fl_core.fl_flags & FL_DELEG) > seq_puts(f, "DELEG "); > else > seq_puts(f, "LEASE "); > > if (lease_breaking(fl)) > seq_puts(f, "BREAKING "); > - else if (fl->fl_file) > + else if (fl->fl_core.fl_file) > seq_puts(f, "ACTIVE "); > else > seq_puts(f, "BREAKER "); > } else { > seq_puts(f, "UNKNOWN UNKNOWN "); > } > - type = IS_LEASE(fl) ? target_leasetype(fl) : fl->fl_type; > + type = IS_LEASE(fl) ? target_leasetype(fl) : fl->fl_core.fl_type; > > seq_printf(f, "%s ", (type == F_WRLCK) ? "WRITE" : > (type == F_RDLCK) ? "READ" : "UNLCK"); > @@ -2768,12 +2777,12 @@ 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) > + if (node == NULL || node->fl_core.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) > + if (list_entry_is_head(tmp, &node->fl_core.fl_blocker->fl_blocked_requests, fl_blocked_member) > || tmp == node) { > return NULL; > } > @@ -2804,17 +2813,18 @@ static int locks_show(struct seq_file *f, void *v) > else > lock_get_status(f, cur, iter->li_pos, "", level); > > - if (!list_empty(&cur->fl_blocked_requests)) { > + if (!list_empty(&cur->fl_core.fl_blocked_requests)) { > /* Turn left */ > - cur = list_first_entry_or_null(&cur->fl_blocked_requests, > - struct file_lock, fl_blocked_member); > + cur = list_first_entry_or_null(&cur->fl_core.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; > + while (tmp == NULL && cur->fl_core.fl_blocker != NULL) { > + cur = cur->fl_core.fl_blocker; > level--; > tmp = get_next_blocked_member(cur); > } > @@ -2833,10 +2843,10 @@ static void __show_fd_locks(struct seq_file *f, > > list_for_each_entry(fl, head, fl_list) { > > - if (filp != fl->fl_file) > + if (filp != fl->fl_core.fl_file) > continue; > - if (fl->fl_owner != files && > - fl->fl_owner != filp) > + if (fl->fl_core.fl_owner != files && > + fl->fl_core.fl_owner != filp) > continue; > > (*id)++; > diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c > index fa1a14def45c..31741967ab95 100644 > --- a/fs/nfs/delegation.c > +++ b/fs/nfs/delegation.c > @@ -157,7 +157,7 @@ static int nfs_delegation_claim_locks(struct nfs4_state *state, const nfs4_state > spin_lock(&flctx->flc_lock); > restart: > list_for_each_entry(fl, list, fl_list) { > - if (nfs_file_open_context(fl->fl_file)->state != state) > + if (nfs_file_open_context(fl->fl_core.fl_file)->state != state) > continue; > spin_unlock(&flctx->flc_lock); > status = nfs4_lock_delegation_recall(fl, state, stateid); > diff --git a/fs/nfs/file.c b/fs/nfs/file.c > index 8577ccf621f5..94c56c3d9177 100644 > --- a/fs/nfs/file.c > +++ b/fs/nfs/file.c > @@ -720,15 +720,15 @@ do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) > { > struct inode *inode = filp->f_mapping->host; > int status = 0; > - unsigned int saved_type = fl->fl_type; > + unsigned int saved_type = fl->fl_core.fl_type; > > /* Try local locking first */ > posix_test_lock(filp, fl); > - if (fl->fl_type != F_UNLCK) { > + if (fl->fl_core.fl_type != F_UNLCK) { > /* found a conflict */ > goto out; > } > - fl->fl_type = saved_type; > + fl->fl_core.fl_type = saved_type; > > if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) > goto out_noconflict; > @@ -740,7 +740,7 @@ do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) > out: > return status; > out_noconflict: > - fl->fl_type = F_UNLCK; > + fl->fl_core.fl_type = F_UNLCK; > goto out; > } > > @@ -765,7 +765,7 @@ do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) > * If we're signalled while cleaning up locks on process exit, we > * still need to complete the unlock. > */ > - if (status < 0 && !(fl->fl_flags & FL_CLOSE)) > + if (status < 0 && !(fl->fl_core.fl_flags & FL_CLOSE)) > return status; > } > > @@ -832,12 +832,12 @@ int nfs_lock(struct file *filp, int cmd, struct file_lock *fl) > int is_local = 0; > > dprintk("NFS: lock(%pD2, t=%x, fl=%x, r=%lld:%lld)\n", > - filp, fl->fl_type, fl->fl_flags, > + filp, fl->fl_core.fl_type, fl->fl_core.fl_flags, > (long long)fl->fl_start, (long long)fl->fl_end); > > nfs_inc_stats(inode, NFSIOS_VFSLOCK); > > - if (fl->fl_flags & FL_RECLAIM) > + if (fl->fl_core.fl_flags & FL_RECLAIM) > return -ENOGRACE; > > if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL) > @@ -851,7 +851,7 @@ int nfs_lock(struct file *filp, int cmd, struct file_lock *fl) > > if (IS_GETLK(cmd)) > ret = do_getlk(filp, cmd, fl, is_local); > - else if (fl->fl_type == F_UNLCK) > + else if (fl->fl_core.fl_type == F_UNLCK) > ret = do_unlk(filp, cmd, fl, is_local); > else > ret = do_setlk(filp, cmd, fl, is_local); > @@ -869,16 +869,16 @@ int nfs_flock(struct file *filp, int cmd, struct file_lock *fl) > int is_local = 0; > > dprintk("NFS: flock(%pD2, t=%x, fl=%x)\n", > - filp, fl->fl_type, fl->fl_flags); > + filp, fl->fl_core.fl_type, fl->fl_core.fl_flags); > > - if (!(fl->fl_flags & FL_FLOCK)) > + if (!(fl->fl_core.fl_flags & FL_FLOCK)) > return -ENOLCK; > > if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK) > is_local = 1; > > /* We're simulating flock() locks using posix locks on the server */ > - if (fl->fl_type == F_UNLCK) > + if (fl->fl_core.fl_type == F_UNLCK) > return do_unlk(filp, cmd, fl, is_local); > return do_setlk(filp, cmd, fl, is_local); > } > diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c > index 2de66e4e8280..d6d8900d8d83 100644 > --- a/fs/nfs/nfs3proc.c > +++ b/fs/nfs/nfs3proc.c > @@ -963,7 +963,7 @@ nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl) > struct nfs_open_context *ctx = nfs_file_open_context(filp); > int status; > > - if (fl->fl_flags & FL_CLOSE) { > + if (fl->fl_core.fl_flags & FL_CLOSE) { > l_ctx = nfs_get_lock_context(ctx); > if (IS_ERR(l_ctx)) > l_ctx = NULL; > diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c > index 23819a756508..a5596007b4d9 100644 > --- a/fs/nfs/nfs4proc.c > +++ b/fs/nfs/nfs4proc.c > @@ -6800,7 +6800,7 @@ static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock > status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); > switch (status) { > case 0: > - request->fl_type = F_UNLCK; > + request->fl_core.fl_type = F_UNLCK; > break; > case -NFS4ERR_DENIED: > status = 0; > @@ -7018,8 +7018,8 @@ static struct rpc_task *nfs4_do_unlck(struct file_lock *fl, > /* Ensure this is an unlock - when canceling a lock, the > * canceled lock is passed in, and it won't be an unlock. > */ > - fl->fl_type = F_UNLCK; > - if (fl->fl_flags & FL_CLOSE) > + fl->fl_core.fl_type = F_UNLCK; > + if (fl->fl_core.fl_flags & FL_CLOSE) > set_bit(NFS_CONTEXT_UNLOCK, &ctx->flags); > > data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid); > @@ -7045,11 +7045,11 @@ static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock * > struct rpc_task *task; > struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t); > int status = 0; > - unsigned char fl_flags = request->fl_flags; > + unsigned char fl_flags = request->fl_core.fl_flags; > > status = nfs4_set_lock_state(state, request); > /* Unlock _before_ we do the RPC call */ > - request->fl_flags |= FL_EXISTS; > + request->fl_core.fl_flags |= FL_EXISTS; > /* Exclude nfs_delegation_claim_locks() */ > mutex_lock(&sp->so_delegreturn_mutex); > /* Exclude nfs4_reclaim_open_stateid() - note nesting! */ > @@ -7073,14 +7073,16 @@ static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock * > status = -ENOMEM; > if (IS_ERR(seqid)) > goto out; > - task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid); > + task = nfs4_do_unlck(request, > + nfs_file_open_context(request->fl_core.fl_file), > + lsp, seqid); > status = PTR_ERR(task); > if (IS_ERR(task)) > goto out; > status = rpc_wait_for_completion_task(task); > rpc_put_task(task); > out: > - request->fl_flags = fl_flags; > + request->fl_core.fl_flags = fl_flags; > trace_nfs4_unlock(request, state, F_SETLK, status); > return status; > } > @@ -7191,7 +7193,7 @@ static void nfs4_lock_done(struct rpc_task *task, void *calldata) > renew_lease(NFS_SERVER(d_inode(data->ctx->dentry)), > data->timestamp); > if (data->arg.new_lock && !data->cancelled) { > - data->fl.fl_flags &= ~(FL_SLEEP | FL_ACCESS); > + data->fl.fl_core.fl_flags &= ~(FL_SLEEP | FL_ACCESS); > if (locks_lock_inode_wait(lsp->ls_state->inode, &data->fl) < 0) > goto out_restart; > } > @@ -7292,7 +7294,8 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *f > if (nfs_server_capable(state->inode, NFS_CAP_MOVEABLE)) > task_setup_data.flags |= RPC_TASK_MOVEABLE; > > - data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file), > + data = nfs4_alloc_lockdata(fl, > + nfs_file_open_context(fl->fl_core.fl_file), > fl->fl_u.nfs4_fl.owner, GFP_KERNEL); > if (data == NULL) > return -ENOMEM; > @@ -7398,10 +7401,10 @@ static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock > { > struct nfs_inode *nfsi = NFS_I(state->inode); > struct nfs4_state_owner *sp = state->owner; > - unsigned char fl_flags = request->fl_flags; > + unsigned char fl_flags = request->fl_core.fl_flags; > int status; > > - request->fl_flags |= FL_ACCESS; > + request->fl_core.fl_flags |= FL_ACCESS; > status = locks_lock_inode_wait(state->inode, request); > if (status < 0) > goto out; > @@ -7410,7 +7413,7 @@ static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock > if (test_bit(NFS_DELEGATED_STATE, &state->flags)) { > /* Yes: cache locks! */ > /* ...but avoid races with delegation recall... */ > - request->fl_flags = fl_flags & ~FL_SLEEP; > + request->fl_core.fl_flags = fl_flags & ~FL_SLEEP; > status = locks_lock_inode_wait(state->inode, request); > up_read(&nfsi->rwsem); > mutex_unlock(&sp->so_delegreturn_mutex); > @@ -7420,7 +7423,7 @@ static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock > mutex_unlock(&sp->so_delegreturn_mutex); > status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW); > out: > - request->fl_flags = fl_flags; > + request->fl_core.fl_flags = fl_flags; > return status; > } > > @@ -7562,7 +7565,7 @@ nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request) > if (!(IS_SETLK(cmd) || IS_SETLKW(cmd))) > return -EINVAL; > > - if (request->fl_type == F_UNLCK) { > + if (request->fl_core.fl_type == F_UNLCK) { > if (state != NULL) > return nfs4_proc_unlck(state, cmd, request); > return 0; > @@ -7571,7 +7574,7 @@ nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request) > if (state == NULL) > return -ENOLCK; > > - if ((request->fl_flags & FL_POSIX) && > + if ((request->fl_core.fl_flags & FL_POSIX) && > !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags)) > return -ENOLCK; > > @@ -7579,7 +7582,7 @@ nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request) > * Don't rely on the VFS having checked the file open mode, > * since it won't do this for flock() locks. > */ > - switch (request->fl_type) { > + switch (request->fl_core.fl_type) { > case F_RDLCK: > if (!(filp->f_mode & FMODE_READ)) > return -EBADF; > diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c > index 9a5d911a7edc..a148b6ac4713 100644 > --- a/fs/nfs/nfs4state.c > +++ b/fs/nfs/nfs4state.c > @@ -980,7 +980,7 @@ int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl) > > if (fl->fl_ops != NULL) > return 0; > - lsp = nfs4_get_lock_state(state, fl->fl_owner); > + lsp = nfs4_get_lock_state(state, fl->fl_core.fl_owner); > if (lsp == NULL) > return -ENOMEM; > fl->fl_u.nfs4_fl.owner = lsp; > @@ -1530,7 +1530,7 @@ static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_ > spin_lock(&flctx->flc_lock); > restart: > list_for_each_entry(fl, list, fl_list) { > - if (nfs_file_open_context(fl->fl_file)->state != state) > + if (nfs_file_open_context(fl->fl_core.fl_file)->state != state) > continue; > spin_unlock(&flctx->flc_lock); > status = ops->recover_lock(state, fl); > diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c > index 69406e60f391..25964af5bb80 100644 > --- a/fs/nfs/nfs4xdr.c > +++ b/fs/nfs/nfs4xdr.c > @@ -1305,7 +1305,7 @@ static void encode_link(struct xdr_stream *xdr, const struct qstr *name, struct > > static inline int nfs4_lock_type(struct file_lock *fl, int block) > { > - if (fl->fl_type == F_RDLCK) > + if (fl->fl_core.fl_type == F_RDLCK) > return block ? NFS4_READW_LT : NFS4_READ_LT; > return block ? NFS4_WRITEW_LT : NFS4_WRITE_LT; > } > @@ -5052,10 +5052,10 @@ static int decode_lock_denied (struct xdr_stream *xdr, struct file_lock *fl) > fl->fl_end = fl->fl_start + (loff_t)length - 1; > if (length == ~(uint64_t)0) > fl->fl_end = OFFSET_MAX; > - fl->fl_type = F_WRLCK; > + fl->fl_core.fl_type = F_WRLCK; > if (type & 1) > - fl->fl_type = F_RDLCK; > - fl->fl_pid = 0; > + fl->fl_core.fl_type = F_RDLCK; > + fl->fl_core.fl_pid = 0; > } > p = xdr_decode_hyper(p, &clientid); /* read 8 bytes */ > namelen = be32_to_cpup(p); /* read 4 bytes */ /* have read all 32 bytes now */ > diff --git a/fs/nfs/write.c b/fs/nfs/write.c > index bb79d3a886ae..a096c84c4678 100644 > --- a/fs/nfs/write.c > +++ b/fs/nfs/write.c > @@ -1301,7 +1301,7 @@ static bool > is_whole_file_wrlock(struct file_lock *fl) > { > return fl->fl_start == 0 && fl->fl_end == OFFSET_MAX && > - fl->fl_type == F_WRLCK; > + fl->fl_core.fl_type == F_WRLCK; > } > > /* If we know the page is up to date, and we're not using byte range locks (or > @@ -1341,7 +1341,7 @@ static int nfs_can_extend_write(struct file *file, struct folio *folio, > } else if (!list_empty(&flctx->flc_flock)) { > fl = list_first_entry(&flctx->flc_flock, struct file_lock, > fl_list); > - if (fl->fl_type == F_WRLCK) > + if (fl->fl_core.fl_type == F_WRLCK) > ret = 1; > } > spin_unlock(&flctx->flc_lock); > diff --git a/fs/nfsd/filecache.c b/fs/nfsd/filecache.c > index 9cb7f0c33df5..0300dae3e11f 100644 > --- a/fs/nfsd/filecache.c > +++ b/fs/nfsd/filecache.c > @@ -662,8 +662,8 @@ nfsd_file_lease_notifier_call(struct notifier_block *nb, unsigned long arg, > struct file_lock *fl = data; > > /* Only close files for F_SETLEASE leases */ > - if (fl->fl_flags & FL_LEASE) > - nfsd_file_close_inode(file_inode(fl->fl_file)); > + if (fl->fl_core.fl_flags & FL_LEASE) > + nfsd_file_close_inode(file_inode(fl->fl_core.fl_file)); > return 0; > } > > diff --git a/fs/nfsd/nfs4layouts.c b/fs/nfsd/nfs4layouts.c > index 5e8096bc5eaa..4bef3349bd90 100644 > --- a/fs/nfsd/nfs4layouts.c > +++ b/fs/nfsd/nfs4layouts.c > @@ -193,14 +193,15 @@ nfsd4_layout_setlease(struct nfs4_layout_stateid *ls) > return -ENOMEM; > locks_init_lock(fl); > fl->fl_lmops = &nfsd4_layouts_lm_ops; > - fl->fl_flags = FL_LAYOUT; > - fl->fl_type = F_RDLCK; > + fl->fl_core.fl_flags = FL_LAYOUT; > + fl->fl_core.fl_type = F_RDLCK; > fl->fl_end = OFFSET_MAX; > - fl->fl_owner = ls; > - fl->fl_pid = current->tgid; > - fl->fl_file = ls->ls_file->nf_file; > + fl->fl_core.fl_owner = ls; > + fl->fl_core.fl_pid = current->tgid; > + fl->fl_core.fl_file = ls->ls_file->nf_file; > > - status = vfs_setlease(fl->fl_file, fl->fl_type, &fl, NULL); > + status = vfs_setlease(fl->fl_core.fl_file, fl->fl_core.fl_type, &fl, > + NULL); > if (status) { > locks_free_lock(fl); > return status; > @@ -731,7 +732,7 @@ nfsd4_layout_lm_break(struct file_lock *fl) > * in time: > */ > fl->fl_break_time = 0; > - nfsd4_recall_file_layout(fl->fl_owner); > + nfsd4_recall_file_layout(fl->fl_core.fl_owner); > return false; > } > > diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c > index 2fa54cfd4882..a6089dbcee9d 100644 > --- a/fs/nfsd/nfs4state.c > +++ b/fs/nfsd/nfs4state.c > @@ -4924,7 +4924,7 @@ static void nfsd_break_one_deleg(struct nfs4_delegation *dp) > static bool > nfsd_break_deleg_cb(struct file_lock *fl) > { > - struct nfs4_delegation *dp = (struct nfs4_delegation *)fl->fl_owner; > + struct nfs4_delegation *dp = (struct nfs4_delegation *) fl->fl_core.fl_owner; > struct nfs4_file *fp = dp->dl_stid.sc_file; > struct nfs4_client *clp = dp->dl_stid.sc_client; > struct nfsd_net *nn; > @@ -4962,7 +4962,7 @@ nfsd_break_deleg_cb(struct file_lock *fl) > */ > static bool nfsd_breaker_owns_lease(struct file_lock *fl) > { > - struct nfs4_delegation *dl = fl->fl_owner; > + struct nfs4_delegation *dl = fl->fl_core.fl_owner; > struct svc_rqst *rqst; > struct nfs4_client *clp; > > @@ -4980,7 +4980,7 @@ static int > nfsd_change_deleg_cb(struct file_lock *onlist, int arg, > struct list_head *dispose) > { > - struct nfs4_delegation *dp = (struct nfs4_delegation *)onlist->fl_owner; > + struct nfs4_delegation *dp = (struct nfs4_delegation *) onlist->fl_core.fl_owner; > struct nfs4_client *clp = dp->dl_stid.sc_client; > > if (arg & F_UNLCK) { > @@ -5340,12 +5340,12 @@ static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, > if (!fl) > return NULL; > fl->fl_lmops = &nfsd_lease_mng_ops; > - fl->fl_flags = FL_DELEG; > - fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK; > + fl->fl_core.fl_flags = FL_DELEG; > + fl->fl_core.fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK; > fl->fl_end = OFFSET_MAX; > - fl->fl_owner = (fl_owner_t)dp; > - fl->fl_pid = current->tgid; > - fl->fl_file = dp->dl_stid.sc_file->fi_deleg_file->nf_file; > + fl->fl_core.fl_owner = (fl_owner_t)dp; > + fl->fl_core.fl_pid = current->tgid; > + fl->fl_core.fl_file = dp->dl_stid.sc_file->fi_deleg_file->nf_file; > return fl; > } > > @@ -5533,7 +5533,8 @@ nfs4_set_delegation(struct nfsd4_open *open, struct nfs4_ol_stateid *stp, > if (!fl) > goto out_clnt_odstate; > > - status = vfs_setlease(fp->fi_deleg_file->nf_file, fl->fl_type, &fl, NULL); > + status = vfs_setlease(fp->fi_deleg_file->nf_file, fl->fl_core.fl_type, > + &fl, NULL); > if (fl) > locks_free_lock(fl); > if (status) > @@ -7149,7 +7150,7 @@ nfsd4_lm_put_owner(fl_owner_t owner) > static bool > nfsd4_lm_lock_expirable(struct file_lock *cfl) > { > - struct nfs4_lockowner *lo = (struct nfs4_lockowner *)cfl->fl_owner; > + struct nfs4_lockowner *lo = (struct nfs4_lockowner *) cfl->fl_core.fl_owner; > struct nfs4_client *clp = lo->lo_owner.so_client; > struct nfsd_net *nn; > > @@ -7171,7 +7172,7 @@ nfsd4_lm_expire_lock(void) > static void > nfsd4_lm_notify(struct file_lock *fl) > { > - struct nfs4_lockowner *lo = (struct nfs4_lockowner *)fl->fl_owner; > + struct nfs4_lockowner *lo = (struct nfs4_lockowner *) fl->fl_core.fl_owner; > struct net *net = lo->lo_owner.so_client->net; > struct nfsd_net *nn = net_generic(net, nfsd_net_id); > struct nfsd4_blocked_lock *nbl = container_of(fl, > @@ -7208,7 +7209,7 @@ nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny) > struct nfs4_lockowner *lo; > > if (fl->fl_lmops == &nfsd_posix_mng_ops) { > - lo = (struct nfs4_lockowner *) fl->fl_owner; > + lo = (struct nfs4_lockowner *) fl->fl_core.fl_owner; > xdr_netobj_dup(&deny->ld_owner, &lo->lo_owner.so_owner, > GFP_KERNEL); > if (!deny->ld_owner.data) > @@ -7227,7 +7228,7 @@ nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny) > if (fl->fl_end != NFS4_MAX_UINT64) > deny->ld_length = fl->fl_end - fl->fl_start + 1; > deny->ld_type = NFS4_READ_LT; > - if (fl->fl_type != F_RDLCK) > + if (fl->fl_core.fl_type != F_RDLCK) > deny->ld_type = NFS4_WRITE_LT; > } > > @@ -7615,11 +7616,11 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, > } > > file_lock = &nbl->nbl_lock; > - file_lock->fl_type = fl_type; > - file_lock->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(&lock_sop->lo_owner)); > - file_lock->fl_pid = current->tgid; > - file_lock->fl_file = nf->nf_file; > - file_lock->fl_flags = fl_flags; > + file_lock->fl_core.fl_type = fl_type; > + file_lock->fl_core.fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(&lock_sop->lo_owner)); > + file_lock->fl_core.fl_pid = current->tgid; > + file_lock->fl_core.fl_file = nf->nf_file; > + file_lock->fl_core.fl_flags = fl_flags; > file_lock->fl_lmops = &nfsd_posix_mng_ops; > file_lock->fl_start = lock->lk_offset; > file_lock->fl_end = last_byte_offset(lock->lk_offset, lock->lk_length); > @@ -7737,9 +7738,9 @@ static __be32 nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct > err = nfserrno(nfsd_open_break_lease(inode, NFSD_MAY_READ)); > if (err) > goto out; > - lock->fl_file = nf->nf_file; > + lock->fl_core.fl_file = nf->nf_file; > err = nfserrno(vfs_test_lock(nf->nf_file, lock)); > - lock->fl_file = NULL; > + lock->fl_core.fl_file = NULL; > out: > inode_unlock(inode); > nfsd_file_put(nf); > @@ -7784,11 +7785,11 @@ nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, > switch (lockt->lt_type) { > case NFS4_READ_LT: > case NFS4_READW_LT: > - file_lock->fl_type = F_RDLCK; > + file_lock->fl_core.fl_type = F_RDLCK; > break; > case NFS4_WRITE_LT: > case NFS4_WRITEW_LT: > - file_lock->fl_type = F_WRLCK; > + file_lock->fl_core.fl_type = F_WRLCK; > break; > default: > dprintk("NFSD: nfs4_lockt: bad lock type!\n"); > @@ -7798,9 +7799,9 @@ nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, > > lo = find_lockowner_str(cstate->clp, &lockt->lt_owner); > if (lo) > - file_lock->fl_owner = (fl_owner_t)lo; > - file_lock->fl_pid = current->tgid; > - file_lock->fl_flags = FL_POSIX; > + file_lock->fl_core.fl_owner = (fl_owner_t)lo; > + file_lock->fl_core.fl_pid = current->tgid; > + file_lock->fl_core.fl_flags = FL_POSIX; > > file_lock->fl_start = lockt->lt_offset; > file_lock->fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length); > @@ -7811,7 +7812,7 @@ nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, > if (status) > goto out; > > - if (file_lock->fl_type != F_UNLCK) { > + if (file_lock->fl_core.fl_type != F_UNLCK) { > status = nfserr_denied; > nfs4_set_lock_denied(file_lock, &lockt->lt_denied); > } > @@ -7867,11 +7868,11 @@ nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, > goto put_file; > } > > - file_lock->fl_type = F_UNLCK; > - file_lock->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(stp->st_stateowner)); > - file_lock->fl_pid = current->tgid; > - file_lock->fl_file = nf->nf_file; > - file_lock->fl_flags = FL_POSIX; > + file_lock->fl_core.fl_type = F_UNLCK; > + file_lock->fl_core.fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(stp->st_stateowner)); > + file_lock->fl_core.fl_pid = current->tgid; > + file_lock->fl_core.fl_file = nf->nf_file; > + file_lock->fl_core.fl_flags = FL_POSIX; > file_lock->fl_lmops = &nfsd_posix_mng_ops; > file_lock->fl_start = locku->lu_offset; > > @@ -7927,7 +7928,7 @@ check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner) > if (flctx && !list_empty_careful(&flctx->flc_posix)) { > spin_lock(&flctx->flc_lock); > list_for_each_entry(fl, &flctx->flc_posix, fl_list) { > - if (fl->fl_owner == (fl_owner_t)lowner) { > + if (fl->fl_core.fl_owner == (fl_owner_t)lowner) { > status = true; > break; > } > @@ -8456,7 +8457,7 @@ nfsd4_deleg_getattr_conflict(struct svc_rqst *rqstp, struct inode *inode) > return 0; > spin_lock(&ctx->flc_lock); > list_for_each_entry(fl, &ctx->flc_lease, fl_list) { > - if (fl->fl_flags == FL_LAYOUT) > + if (fl->fl_core.fl_flags == FL_LAYOUT) > continue; > if (fl->fl_lmops != &nfsd_lease_mng_ops) { > /* > @@ -8464,12 +8465,12 @@ nfsd4_deleg_getattr_conflict(struct svc_rqst *rqstp, struct inode *inode) > * we are done; there isn't any write delegation > * on this inode > */ > - if (fl->fl_type == F_RDLCK) > + if (fl->fl_core.fl_type == F_RDLCK) > break; > goto break_lease; > } > - if (fl->fl_type == F_WRLCK) { > - dp = fl->fl_owner; > + if (fl->fl_core.fl_type == F_WRLCK) { > + dp = fl->fl_core.fl_owner; > if (dp->dl_recall.cb_clp == *(rqstp->rq_lease_breaker)) { > spin_unlock(&ctx->flc_lock); > return 0; > diff --git a/fs/ocfs2/locks.c b/fs/ocfs2/locks.c > index f37174e79fad..30f7af75d18d 100644 > --- a/fs/ocfs2/locks.c > +++ b/fs/ocfs2/locks.c > @@ -27,7 +27,7 @@ static int ocfs2_do_flock(struct file *file, struct inode *inode, > struct ocfs2_file_private *fp = file->private_data; > struct ocfs2_lock_res *lockres = &fp->fp_flock; > > - if (fl->fl_type == F_WRLCK) > + if (fl->fl_core.fl_type == F_WRLCK) > level = 1; > if (!IS_SETLKW(cmd)) > trylock = 1; > @@ -53,8 +53,8 @@ static int ocfs2_do_flock(struct file *file, struct inode *inode, > */ > > locks_init_lock(&request); > - request.fl_type = F_UNLCK; > - request.fl_flags = FL_FLOCK; > + request.fl_core.fl_type = F_UNLCK; > + request.fl_core.fl_flags = FL_FLOCK; > locks_lock_file_wait(file, &request); > > ocfs2_file_unlock(file); > @@ -100,14 +100,14 @@ int ocfs2_flock(struct file *file, int cmd, struct file_lock *fl) > struct inode *inode = file->f_mapping->host; > struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); > > - if (!(fl->fl_flags & FL_FLOCK)) > + if (!(fl->fl_core.fl_flags & FL_FLOCK)) > return -ENOLCK; > > if ((osb->s_mount_opt & OCFS2_MOUNT_LOCALFLOCKS) || > ocfs2_mount_local(osb)) > return locks_lock_file_wait(file, fl); > > - if (fl->fl_type == F_UNLCK) > + if (fl->fl_core.fl_type == F_UNLCK) > return ocfs2_do_funlock(file, cmd, fl); > else > return ocfs2_do_flock(file, inode, cmd, fl); > @@ -118,7 +118,7 @@ int ocfs2_lock(struct file *file, int cmd, struct file_lock *fl) > struct inode *inode = file->f_mapping->host; > struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); > > - if (!(fl->fl_flags & FL_POSIX)) > + if (!(fl->fl_core.fl_flags & FL_POSIX)) > return -ENOLCK; > > return ocfs2_plock(osb->cconn, OCFS2_I(inode)->ip_blkno, file, cmd, fl); > diff --git a/fs/ocfs2/stack_user.c b/fs/ocfs2/stack_user.c > index 9b76ee66aeb2..c66a688dea96 100644 > --- a/fs/ocfs2/stack_user.c > +++ b/fs/ocfs2/stack_user.c > @@ -744,7 +744,7 @@ static int user_plock(struct ocfs2_cluster_connection *conn, > return dlm_posix_cancel(conn->cc_lockspace, ino, file, fl); > else if (IS_GETLK(cmd)) > return dlm_posix_get(conn->cc_lockspace, ino, file, fl); > - else if (fl->fl_type == F_UNLCK) > + else if (fl->fl_core.fl_type == F_UNLCK) > return dlm_posix_unlock(conn->cc_lockspace, ino, file, fl); > else > return dlm_posix_lock(conn->cc_lockspace, ino, file, cmd, fl); > diff --git a/fs/smb/client/cifssmb.c b/fs/smb/client/cifssmb.c > index 01e89070df5a..7140c2baa652 100644 > --- a/fs/smb/client/cifssmb.c > +++ b/fs/smb/client/cifssmb.c > @@ -2066,20 +2066,20 @@ CIFSSMBPosixLock(const unsigned int xid, struct cifs_tcon *tcon, > parm_data = (struct cifs_posix_lock *) > ((char *)&pSMBr->hdr.Protocol + data_offset); > if (parm_data->lock_type == cpu_to_le16(CIFS_UNLCK)) > - pLockData->fl_type = F_UNLCK; > + pLockData->fl_core.fl_type = F_UNLCK; > else { > if (parm_data->lock_type == > cpu_to_le16(CIFS_RDLCK)) > - pLockData->fl_type = F_RDLCK; > + pLockData->fl_core.fl_type = F_RDLCK; > else if (parm_data->lock_type == > cpu_to_le16(CIFS_WRLCK)) > - pLockData->fl_type = F_WRLCK; > + pLockData->fl_core.fl_type = F_WRLCK; > > pLockData->fl_start = le64_to_cpu(parm_data->start); > pLockData->fl_end = pLockData->fl_start + > (le64_to_cpu(parm_data->length) ? > le64_to_cpu(parm_data->length) - 1 : 0); > - pLockData->fl_pid = -le32_to_cpu(parm_data->pid); > + pLockData->fl_core.fl_pid = -le32_to_cpu(parm_data->pid); > } > } > > diff --git a/fs/smb/client/file.c b/fs/smb/client/file.c > index 1b4262aff8fa..1305183842fd 100644 > --- a/fs/smb/client/file.c > +++ b/fs/smb/client/file.c > @@ -1312,20 +1312,20 @@ cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length, > down_read(&cinode->lock_sem); > > exist = cifs_find_lock_conflict(cfile, offset, length, type, > - flock->fl_flags, &conf_lock, > + flock->fl_core.fl_flags, &conf_lock, > CIFS_LOCK_OP); > if (exist) { > flock->fl_start = conf_lock->offset; > flock->fl_end = conf_lock->offset + conf_lock->length - 1; > - flock->fl_pid = conf_lock->pid; > + flock->fl_core.fl_pid = conf_lock->pid; > if (conf_lock->type & server->vals->shared_lock_type) > - flock->fl_type = F_RDLCK; > + flock->fl_core.fl_type = F_RDLCK; > else > - flock->fl_type = F_WRLCK; > + flock->fl_core.fl_type = F_WRLCK; > } else if (!cinode->can_cache_brlcks) > rc = 1; > else > - flock->fl_type = F_UNLCK; > + flock->fl_core.fl_type = F_UNLCK; > > up_read(&cinode->lock_sem); > return rc; > @@ -1401,16 +1401,16 @@ cifs_posix_lock_test(struct file *file, struct file_lock *flock) > { > int rc = 0; > struct cifsInodeInfo *cinode = CIFS_I(file_inode(file)); > - unsigned char saved_type = flock->fl_type; > + unsigned char saved_type = flock->fl_core.fl_type; > > - if ((flock->fl_flags & FL_POSIX) == 0) > + if ((flock->fl_core.fl_flags & FL_POSIX) == 0) > return 1; > > down_read(&cinode->lock_sem); > posix_test_lock(file, flock); > > - if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) { > - flock->fl_type = saved_type; > + if (flock->fl_core.fl_type == F_UNLCK && !cinode->can_cache_brlcks) { > + flock->fl_core.fl_type = saved_type; > rc = 1; > } > > @@ -1431,7 +1431,7 @@ cifs_posix_lock_set(struct file *file, struct file_lock *flock) > struct cifsInodeInfo *cinode = CIFS_I(file_inode(file)); > int rc = FILE_LOCK_DEFERRED + 1; > > - if ((flock->fl_flags & FL_POSIX) == 0) > + if ((flock->fl_core.fl_flags & FL_POSIX) == 0) > return rc; > > cifs_down_write(&cinode->lock_sem); > @@ -1591,12 +1591,12 @@ cifs_push_posix_locks(struct cifsFileInfo *cfile) > break; > } > length = cifs_flock_len(flock); > - if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK) > + if (flock->fl_core.fl_type == F_RDLCK || flock->fl_core.fl_type == F_SHLCK) > type = CIFS_RDLCK; > else > type = CIFS_WRLCK; > lck = list_entry(el, struct lock_to_push, llist); > - lck->pid = hash_lockowner(flock->fl_owner); > + lck->pid = hash_lockowner(flock->fl_core.fl_owner); > lck->netfid = cfile->fid.netfid; > lck->length = length; > lck->type = type; > @@ -1663,42 +1663,43 @@ static void > cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock, > bool *wait_flag, struct TCP_Server_Info *server) > { > - if (flock->fl_flags & FL_POSIX) > + if (flock->fl_core.fl_flags & FL_POSIX) > cifs_dbg(FYI, "Posix\n"); > - if (flock->fl_flags & FL_FLOCK) > + if (flock->fl_core.fl_flags & FL_FLOCK) > cifs_dbg(FYI, "Flock\n"); > - if (flock->fl_flags & FL_SLEEP) { > + if (flock->fl_core.fl_flags & FL_SLEEP) { > cifs_dbg(FYI, "Blocking lock\n"); > *wait_flag = true; > } > - if (flock->fl_flags & FL_ACCESS) > + if (flock->fl_core.fl_flags & FL_ACCESS) > cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n"); > - if (flock->fl_flags & FL_LEASE) > + if (flock->fl_core.fl_flags & FL_LEASE) > cifs_dbg(FYI, "Lease on file - not implemented yet\n"); > - if (flock->fl_flags & > + if (flock->fl_core.fl_flags & > (~(FL_POSIX | FL_FLOCK | FL_SLEEP | > FL_ACCESS | FL_LEASE | FL_CLOSE | FL_OFDLCK))) > - cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags); > + cifs_dbg(FYI, "Unknown lock flags 0x%x\n", > + flock->fl_core.fl_flags); > > *type = server->vals->large_lock_type; > - if (flock->fl_type == F_WRLCK) { > + if (flock->fl_core.fl_type == F_WRLCK) { > cifs_dbg(FYI, "F_WRLCK\n"); > *type |= server->vals->exclusive_lock_type; > *lock = 1; > - } else if (flock->fl_type == F_UNLCK) { > + } else if (flock->fl_core.fl_type == F_UNLCK) { > cifs_dbg(FYI, "F_UNLCK\n"); > *type |= server->vals->unlock_lock_type; > *unlock = 1; > /* Check if unlock includes more than one lock range */ > - } else if (flock->fl_type == F_RDLCK) { > + } else if (flock->fl_core.fl_type == F_RDLCK) { > cifs_dbg(FYI, "F_RDLCK\n"); > *type |= server->vals->shared_lock_type; > *lock = 1; > - } else if (flock->fl_type == F_EXLCK) { > + } else if (flock->fl_core.fl_type == F_EXLCK) { > cifs_dbg(FYI, "F_EXLCK\n"); > *type |= server->vals->exclusive_lock_type; > *lock = 1; > - } else if (flock->fl_type == F_SHLCK) { > + } else if (flock->fl_core.fl_type == F_SHLCK) { > cifs_dbg(FYI, "F_SHLCK\n"); > *type |= server->vals->shared_lock_type; > *lock = 1; > @@ -1730,7 +1731,7 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type, > else > posix_lock_type = CIFS_WRLCK; > rc = CIFSSMBPosixLock(xid, tcon, netfid, > - hash_lockowner(flock->fl_owner), > + hash_lockowner(flock->fl_core.fl_owner), > flock->fl_start, length, flock, > posix_lock_type, wait_flag); > return rc; > @@ -1747,7 +1748,7 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type, > if (rc == 0) { > rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, > type, 0, 1, false); > - flock->fl_type = F_UNLCK; > + flock->fl_core.fl_type = F_UNLCK; > if (rc != 0) > cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n", > rc); > @@ -1755,7 +1756,7 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type, > } > > if (type & server->vals->shared_lock_type) { > - flock->fl_type = F_WRLCK; > + flock->fl_core.fl_type = F_WRLCK; > return 0; > } > > @@ -1767,12 +1768,12 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type, > if (rc == 0) { > rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, > type | server->vals->shared_lock_type, 0, 1, false); > - flock->fl_type = F_RDLCK; > + flock->fl_core.fl_type = F_RDLCK; > if (rc != 0) > cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n", > rc); > } else > - flock->fl_type = F_WRLCK; > + flock->fl_core.fl_type = F_WRLCK; > > return 0; > } > @@ -1940,7 +1941,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type, > posix_lock_type = CIFS_UNLCK; > > rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid, > - hash_lockowner(flock->fl_owner), > + hash_lockowner(flock->fl_core.fl_owner), > flock->fl_start, length, > NULL, posix_lock_type, wait_flag); > goto out; > @@ -1950,7 +1951,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type, > struct cifsLockInfo *lock; > > lock = cifs_lock_init(flock->fl_start, length, type, > - flock->fl_flags); > + flock->fl_core.fl_flags); > if (!lock) > return -ENOMEM; > > @@ -1989,7 +1990,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type, > rc = server->ops->mand_unlock_range(cfile, flock, xid); > > out: > - if ((flock->fl_flags & FL_POSIX) || (flock->fl_flags & FL_FLOCK)) { > + if ((flock->fl_core.fl_flags & FL_POSIX) || (flock->fl_core.fl_flags & FL_FLOCK)) { > /* > * If this is a request to remove all locks because we > * are closing the file, it doesn't matter if the > @@ -1998,7 +1999,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type, > */ > if (rc) { > cifs_dbg(VFS, "%s failed rc=%d\n", __func__, rc); > - if (!(flock->fl_flags & FL_CLOSE)) > + if (!(flock->fl_core.fl_flags & FL_CLOSE)) > return rc; > } > rc = locks_lock_file_wait(file, flock); > @@ -2019,7 +2020,7 @@ int cifs_flock(struct file *file, int cmd, struct file_lock *fl) > > xid = get_xid(); > > - if (!(fl->fl_flags & FL_FLOCK)) { > + if (!(fl->fl_core.fl_flags & FL_FLOCK)) { > rc = -ENOLCK; > free_xid(xid); > return rc; > @@ -2070,7 +2071,8 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *flock) > xid = get_xid(); > > cifs_dbg(FYI, "%s: %pD2 cmd=0x%x type=0x%x flags=0x%x r=%lld:%lld\n", __func__, file, cmd, > - flock->fl_flags, flock->fl_type, (long long)flock->fl_start, > + flock->fl_core.fl_flags, flock->fl_core.fl_type, > + (long long)flock->fl_start, > (long long)flock->fl_end); > > cfile = (struct cifsFileInfo *)file->private_data; > diff --git a/fs/smb/client/smb2file.c b/fs/smb/client/smb2file.c > index e0ee96d69d49..39262617f551 100644 > --- a/fs/smb/client/smb2file.c > +++ b/fs/smb/client/smb2file.c > @@ -228,7 +228,7 @@ smb2_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, > * flock and OFD lock are associated with an open > * file description, not the process. > */ > - if (!(flock->fl_flags & (FL_FLOCK | FL_OFDLCK))) > + if (!(flock->fl_core.fl_flags & (FL_FLOCK | FL_OFDLCK))) > continue; > if (cinode->can_cache_brlcks) { > /* > diff --git a/fs/smb/server/smb2pdu.c b/fs/smb/server/smb2pdu.c > index 3143819935dc..439f68cee402 100644 > --- a/fs/smb/server/smb2pdu.c > +++ b/fs/smb/server/smb2pdu.c > @@ -6748,10 +6748,10 @@ struct file_lock *smb_flock_init(struct file *f) > > locks_init_lock(fl); > > - fl->fl_owner = f; > - fl->fl_pid = current->tgid; > - fl->fl_file = f; > - fl->fl_flags = FL_POSIX; > + fl->fl_core.fl_owner = f; > + fl->fl_core.fl_pid = current->tgid; > + fl->fl_core.fl_file = f; > + fl->fl_core.fl_flags = FL_POSIX; > fl->fl_ops = NULL; > fl->fl_lmops = NULL; > > @@ -6768,30 +6768,30 @@ static int smb2_set_flock_flags(struct file_lock *flock, int flags) > case SMB2_LOCKFLAG_SHARED: > ksmbd_debug(SMB, "received shared request\n"); > cmd = F_SETLKW; > - flock->fl_type = F_RDLCK; > - flock->fl_flags |= FL_SLEEP; > + flock->fl_core.fl_type = F_RDLCK; > + flock->fl_core.fl_flags |= FL_SLEEP; > break; > case SMB2_LOCKFLAG_EXCLUSIVE: > ksmbd_debug(SMB, "received exclusive request\n"); > cmd = F_SETLKW; > - flock->fl_type = F_WRLCK; > - flock->fl_flags |= FL_SLEEP; > + flock->fl_core.fl_type = F_WRLCK; > + flock->fl_core.fl_flags |= FL_SLEEP; > break; > case SMB2_LOCKFLAG_SHARED | SMB2_LOCKFLAG_FAIL_IMMEDIATELY: > ksmbd_debug(SMB, > "received shared & fail immediately request\n"); > cmd = F_SETLK; > - flock->fl_type = F_RDLCK; > + flock->fl_core.fl_type = F_RDLCK; > break; > case SMB2_LOCKFLAG_EXCLUSIVE | SMB2_LOCKFLAG_FAIL_IMMEDIATELY: > ksmbd_debug(SMB, > "received exclusive & fail immediately request\n"); > cmd = F_SETLK; > - flock->fl_type = F_WRLCK; > + flock->fl_core.fl_type = F_WRLCK; > break; > case SMB2_LOCKFLAG_UNLOCK: > ksmbd_debug(SMB, "received unlock request\n"); > - flock->fl_type = F_UNLCK; > + flock->fl_core.fl_type = F_UNLCK; > cmd = F_SETLK; > break; > } > @@ -6829,13 +6829,13 @@ static void smb2_remove_blocked_lock(void **argv) > struct file_lock *flock = (struct file_lock *)argv[0]; > > ksmbd_vfs_posix_lock_unblock(flock); > - wake_up(&flock->fl_wait); > + wake_up(&flock->fl_core.fl_wait); > } > > static inline bool lock_defer_pending(struct file_lock *fl) > { > /* check pending lock waiters */ > - return waitqueue_active(&fl->fl_wait); > + return waitqueue_active(&fl->fl_core.fl_wait); > } > > /** > @@ -6926,8 +6926,8 @@ int smb2_lock(struct ksmbd_work *work) > list_for_each_entry(cmp_lock, &lock_list, llist) { > if (cmp_lock->fl->fl_start <= flock->fl_start && > cmp_lock->fl->fl_end >= flock->fl_end) { > - if (cmp_lock->fl->fl_type != F_UNLCK && > - flock->fl_type != F_UNLCK) { > + if (cmp_lock->fl->fl_core.fl_type != F_UNLCK && > + flock->fl_core.fl_type != F_UNLCK) { > pr_err("conflict two locks in one request\n"); > err = -EINVAL; > locks_free_lock(flock); > @@ -6975,12 +6975,12 @@ int smb2_lock(struct ksmbd_work *work) > list_for_each_entry(conn, &conn_list, conns_list) { > spin_lock(&conn->llist_lock); > list_for_each_entry_safe(cmp_lock, tmp2, &conn->lock_list, clist) { > - if (file_inode(cmp_lock->fl->fl_file) != > - file_inode(smb_lock->fl->fl_file)) > + if (file_inode(cmp_lock->fl->fl_core.fl_file) != > + file_inode(smb_lock->fl->fl_core.fl_file)) > continue; > > - if (smb_lock->fl->fl_type == F_UNLCK) { > - if (cmp_lock->fl->fl_file == smb_lock->fl->fl_file && > + if (smb_lock->fl->fl_core.fl_type == F_UNLCK) { > + if (cmp_lock->fl->fl_core.fl_file == smb_lock->fl->fl_core.fl_file && > cmp_lock->start == smb_lock->start && > cmp_lock->end == smb_lock->end && > !lock_defer_pending(cmp_lock->fl)) { > @@ -6997,7 +6997,7 @@ int smb2_lock(struct ksmbd_work *work) > continue; > } > > - if (cmp_lock->fl->fl_file == smb_lock->fl->fl_file) { > + if (cmp_lock->fl->fl_core.fl_file == smb_lock->fl->fl_core.fl_file) { > if (smb_lock->flags & SMB2_LOCKFLAG_SHARED) > continue; > } else { > @@ -7039,7 +7039,7 @@ int smb2_lock(struct ksmbd_work *work) > } > up_read(&conn_list_lock); > out_check_cl: > - if (smb_lock->fl->fl_type == F_UNLCK && nolock) { > + if (smb_lock->fl->fl_core.fl_type == F_UNLCK && nolock) { > pr_err("Try to unlock nolocked range\n"); > rsp->hdr.Status = STATUS_RANGE_NOT_LOCKED; > goto out; > @@ -7163,7 +7163,7 @@ int smb2_lock(struct ksmbd_work *work) > struct file_lock *rlock = NULL; > > rlock = smb_flock_init(filp); > - rlock->fl_type = F_UNLCK; > + rlock->fl_core.fl_type = F_UNLCK; > rlock->fl_start = smb_lock->start; > rlock->fl_end = smb_lock->end; > > diff --git a/fs/smb/server/vfs.c b/fs/smb/server/vfs.c > index a6961bfe3e13..f7bb6f19492b 100644 > --- a/fs/smb/server/vfs.c > +++ b/fs/smb/server/vfs.c > @@ -340,15 +340,15 @@ static int check_lock_range(struct file *filp, loff_t start, loff_t end, > list_for_each_entry(flock, &ctx->flc_posix, fl_list) { > /* check conflict locks */ > if (flock->fl_end >= start && end >= flock->fl_start) { > - if (flock->fl_type == F_RDLCK) { > + if (flock->fl_core.fl_type == F_RDLCK) { > if (type == WRITE) { > pr_err("not allow write by shared lock\n"); > error = 1; > goto out; > } > - } else if (flock->fl_type == F_WRLCK) { > + } else if (flock->fl_core.fl_type == F_WRLCK) { > /* check owner in lock */ > - if (flock->fl_file != filp) { > + if (flock->fl_core.fl_file != filp) { > error = 1; > pr_err("not allow rw access by exclusive lock from other opens\n"); > goto out; > @@ -1837,13 +1837,13 @@ int ksmbd_vfs_copy_file_ranges(struct ksmbd_work *work, > > void ksmbd_vfs_posix_lock_wait(struct file_lock *flock) > { > - wait_event(flock->fl_wait, !flock->fl_blocker); > + wait_event(flock->fl_core.fl_wait, !flock->fl_core.fl_blocker); > } > > int ksmbd_vfs_posix_lock_wait_timeout(struct file_lock *flock, long timeout) > { > - return wait_event_interruptible_timeout(flock->fl_wait, > - !flock->fl_blocker, > + return wait_event_interruptible_timeout(flock->fl_core.fl_wait, > + !flock->fl_core.fl_blocker, > timeout); > } > > diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h > index 9f565416d186..c4b9faa261f7 100644 > --- a/include/linux/lockd/lockd.h > +++ b/include/linux/lockd/lockd.h > @@ -375,12 +375,12 @@ static inline int nlm_privileged_requester(const struct svc_rqst *rqstp) > static inline int nlm_compare_locks(const struct file_lock *fl1, > const struct file_lock *fl2) > { > - return file_inode(fl1->fl_file) == file_inode(fl2->fl_file) > - && fl1->fl_pid == fl2->fl_pid > - && fl1->fl_owner == fl2->fl_owner > + return file_inode(fl1->fl_core.fl_file) == file_inode(fl2->fl_core.fl_file) > + && fl1->fl_core.fl_pid == fl2->fl_core.fl_pid > + && fl1->fl_core.fl_owner == fl2->fl_core.fl_owner > && fl1->fl_start == fl2->fl_start > && fl1->fl_end == fl2->fl_end > - &&(fl1->fl_type == fl2->fl_type || fl2->fl_type == F_UNLCK); > + &&(fl1->fl_core.fl_type == fl2->fl_core.fl_type || fl2->fl_core.fl_type == F_UNLCK); > } > > extern const struct lock_manager_operations nlmsvc_lock_operations; > > -- > 2.43.0 >
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c index 11cd8d23f6f2..f35ac7cb782e 100644 --- a/fs/9p/vfs_file.c +++ b/fs/9p/vfs_file.c @@ -107,7 +107,7 @@ static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl) p9_debug(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl); - if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { + if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_core.fl_type != F_UNLCK) { filemap_write_and_wait(inode->i_mapping); invalidate_mapping_pages(&inode->i_data, 0, -1); } @@ -127,7 +127,7 @@ static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl) fid = filp->private_data; BUG_ON(fid == NULL); - BUG_ON((fl->fl_flags & FL_POSIX) != FL_POSIX); + BUG_ON((fl->fl_core.fl_flags & FL_POSIX) != FL_POSIX); res = locks_lock_file_wait(filp, fl); if (res < 0) @@ -136,7 +136,7 @@ static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl) /* convert posix lock to p9 tlock args */ memset(&flock, 0, sizeof(flock)); /* map the lock type */ - switch (fl->fl_type) { + switch (fl->fl_core.fl_type) { case F_RDLCK: flock.type = P9_LOCK_TYPE_RDLCK; break; @@ -152,7 +152,7 @@ static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl) flock.length = 0; else flock.length = fl->fl_end - fl->fl_start + 1; - flock.proc_id = fl->fl_pid; + flock.proc_id = fl->fl_core.fl_pid; flock.client_id = fid->clnt->name; if (IS_SETLKW(cmd)) flock.flags = P9_LOCK_FLAGS_BLOCK; @@ -207,12 +207,12 @@ static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl) * incase server returned error for lock request, revert * it locally */ - if (res < 0 && fl->fl_type != F_UNLCK) { - fl_type = fl->fl_type; - fl->fl_type = F_UNLCK; + if (res < 0 && fl->fl_core.fl_type != F_UNLCK) { + fl_type = fl->fl_core.fl_type; + fl->fl_core.fl_type = F_UNLCK; /* Even if this fails we want to return the remote error */ locks_lock_file_wait(filp, fl); - fl->fl_type = fl_type; + fl->fl_core.fl_type = fl_type; } if (flock.client_id != fid->clnt->name) kfree(flock.client_id); @@ -234,7 +234,7 @@ static int v9fs_file_getlock(struct file *filp, struct file_lock *fl) * if we have a conflicting lock locally, no need to validate * with server */ - if (fl->fl_type != F_UNLCK) + if (fl->fl_core.fl_type != F_UNLCK) return res; /* convert posix lock to p9 tgetlock args */ @@ -245,7 +245,7 @@ static int v9fs_file_getlock(struct file *filp, struct file_lock *fl) glock.length = 0; else glock.length = fl->fl_end - fl->fl_start + 1; - glock.proc_id = fl->fl_pid; + glock.proc_id = fl->fl_core.fl_pid; glock.client_id = fid->clnt->name; res = p9_client_getlock_dotl(fid, &glock); @@ -254,13 +254,13 @@ static int v9fs_file_getlock(struct file *filp, struct file_lock *fl) /* map 9p lock type to os lock type */ switch (glock.type) { case P9_LOCK_TYPE_RDLCK: - fl->fl_type = F_RDLCK; + fl->fl_core.fl_type = F_RDLCK; break; case P9_LOCK_TYPE_WRLCK: - fl->fl_type = F_WRLCK; + fl->fl_core.fl_type = F_WRLCK; break; case P9_LOCK_TYPE_UNLCK: - fl->fl_type = F_UNLCK; + fl->fl_core.fl_type = F_UNLCK; break; } if (glock.type != P9_LOCK_TYPE_UNLCK) { @@ -269,7 +269,7 @@ static int v9fs_file_getlock(struct file *filp, struct file_lock *fl) fl->fl_end = OFFSET_MAX; else fl->fl_end = glock.start + glock.length - 1; - fl->fl_pid = -glock.proc_id; + fl->fl_core.fl_pid = -glock.proc_id; } out: if (glock.client_id != fid->clnt->name) @@ -293,7 +293,7 @@ static int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl) p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %pD\n", filp, cmd, fl, filp); - if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { + if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_core.fl_type != F_UNLCK) { filemap_write_and_wait(inode->i_mapping); invalidate_mapping_pages(&inode->i_data, 0, -1); } @@ -324,16 +324,16 @@ static int v9fs_file_flock_dotl(struct file *filp, int cmd, p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %pD\n", filp, cmd, fl, filp); - if (!(fl->fl_flags & FL_FLOCK)) + if (!(fl->fl_core.fl_flags & FL_FLOCK)) goto out_err; - if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { + if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_core.fl_type != F_UNLCK) { filemap_write_and_wait(inode->i_mapping); invalidate_mapping_pages(&inode->i_data, 0, -1); } /* Convert flock to posix lock */ - fl->fl_flags |= FL_POSIX; - fl->fl_flags ^= FL_FLOCK; + fl->fl_core.fl_flags |= FL_POSIX; + fl->fl_core.fl_flags ^= FL_FLOCK; if (IS_SETLK(cmd) | IS_SETLKW(cmd)) ret = v9fs_file_do_lock(filp, cmd, fl); diff --git a/fs/afs/flock.c b/fs/afs/flock.c index 9c6dea3139f5..212cca72c061 100644 --- a/fs/afs/flock.c +++ b/fs/afs/flock.c @@ -93,13 +93,13 @@ static void afs_grant_locks(struct afs_vnode *vnode) bool exclusive = (vnode->lock_type == AFS_LOCK_WRITE); list_for_each_entry_safe(p, _p, &vnode->pending_locks, fl_u.afs.link) { - if (!exclusive && p->fl_type == F_WRLCK) + if (!exclusive && p->fl_core.fl_type == F_WRLCK) continue; list_move_tail(&p->fl_u.afs.link, &vnode->granted_locks); p->fl_u.afs.state = AFS_LOCK_GRANTED; trace_afs_flock_op(vnode, p, afs_flock_op_grant); - wake_up(&p->fl_wait); + wake_up(&p->fl_core.fl_wait); } } @@ -121,16 +121,16 @@ static void afs_next_locker(struct afs_vnode *vnode, int error) list_for_each_entry_safe(p, _p, &vnode->pending_locks, fl_u.afs.link) { if (error && - p->fl_type == fl_type && - afs_file_key(p->fl_file) == key) { + p->fl_core.fl_type == fl_type && + afs_file_key(p->fl_core.fl_file) == key) { list_del_init(&p->fl_u.afs.link); p->fl_u.afs.state = error; - wake_up(&p->fl_wait); + wake_up(&p->fl_core.fl_wait); } /* Select the next locker to hand off to. */ if (next && - (next->fl_type == F_WRLCK || p->fl_type == F_RDLCK)) + (next->fl_core.fl_type == F_WRLCK || p->fl_core.fl_type == F_RDLCK)) continue; next = p; } @@ -142,7 +142,7 @@ static void afs_next_locker(struct afs_vnode *vnode, int error) afs_set_lock_state(vnode, AFS_VNODE_LOCK_SETTING); next->fl_u.afs.state = AFS_LOCK_YOUR_TRY; trace_afs_flock_op(vnode, next, afs_flock_op_wake); - wake_up(&next->fl_wait); + wake_up(&next->fl_core.fl_wait); } else { afs_set_lock_state(vnode, AFS_VNODE_LOCK_NONE); trace_afs_flock_ev(vnode, NULL, afs_flock_no_lockers, 0); @@ -166,7 +166,7 @@ static void afs_kill_lockers_enoent(struct afs_vnode *vnode) struct file_lock, fl_u.afs.link); list_del_init(&p->fl_u.afs.link); p->fl_u.afs.state = -ENOENT; - wake_up(&p->fl_wait); + wake_up(&p->fl_core.fl_wait); } key_put(vnode->lock_key); @@ -464,14 +464,14 @@ static int afs_do_setlk(struct file *file, struct file_lock *fl) _enter("{%llx:%llu},%llu-%llu,%u,%u", vnode->fid.vid, vnode->fid.vnode, - fl->fl_start, fl->fl_end, fl->fl_type, mode); + fl->fl_start, fl->fl_end, fl->fl_core.fl_type, mode); fl->fl_ops = &afs_lock_ops; INIT_LIST_HEAD(&fl->fl_u.afs.link); fl->fl_u.afs.state = AFS_LOCK_PENDING; partial = (fl->fl_start != 0 || fl->fl_end != OFFSET_MAX); - type = (fl->fl_type == F_RDLCK) ? AFS_LOCK_READ : AFS_LOCK_WRITE; + type = (fl->fl_core.fl_type == F_RDLCK) ? AFS_LOCK_READ : AFS_LOCK_WRITE; if (mode == afs_flock_mode_write && partial) type = AFS_LOCK_WRITE; @@ -524,7 +524,7 @@ static int afs_do_setlk(struct file *file, struct file_lock *fl) } if (vnode->lock_state == AFS_VNODE_LOCK_NONE && - !(fl->fl_flags & FL_SLEEP)) { + !(fl->fl_core.fl_flags & FL_SLEEP)) { ret = -EAGAIN; if (type == AFS_LOCK_READ) { if (vnode->status.lock_count == -1) @@ -621,7 +621,7 @@ static int afs_do_setlk(struct file *file, struct file_lock *fl) return 0; lock_is_contended: - if (!(fl->fl_flags & FL_SLEEP)) { + if (!(fl->fl_core.fl_flags & FL_SLEEP)) { list_del_init(&fl->fl_u.afs.link); afs_next_locker(vnode, 0); ret = -EAGAIN; @@ -641,7 +641,7 @@ static int afs_do_setlk(struct file *file, struct file_lock *fl) spin_unlock(&vnode->lock); trace_afs_flock_ev(vnode, fl, afs_flock_waiting, 0); - ret = wait_event_interruptible(fl->fl_wait, + ret = wait_event_interruptible(fl->fl_core.fl_wait, fl->fl_u.afs.state != AFS_LOCK_PENDING); trace_afs_flock_ev(vnode, fl, afs_flock_waited, ret); @@ -704,7 +704,8 @@ static int afs_do_unlk(struct file *file, struct file_lock *fl) struct afs_vnode *vnode = AFS_FS_I(file_inode(file)); int ret; - _enter("{%llx:%llu},%u", vnode->fid.vid, vnode->fid.vnode, fl->fl_type); + _enter("{%llx:%llu},%u", vnode->fid.vid, vnode->fid.vnode, + fl->fl_core.fl_type); trace_afs_flock_op(vnode, fl, afs_flock_op_unlock); @@ -730,11 +731,11 @@ static int afs_do_getlk(struct file *file, struct file_lock *fl) if (vnode->lock_state == AFS_VNODE_LOCK_DELETED) return -ENOENT; - fl->fl_type = F_UNLCK; + fl->fl_core.fl_type = F_UNLCK; /* check local lock records first */ posix_test_lock(file, fl); - if (fl->fl_type == F_UNLCK) { + if (fl->fl_core.fl_type == F_UNLCK) { /* no local locks; consult the server */ ret = afs_fetch_status(vnode, key, false, NULL); if (ret < 0) @@ -743,18 +744,18 @@ static int afs_do_getlk(struct file *file, struct file_lock *fl) lock_count = READ_ONCE(vnode->status.lock_count); if (lock_count != 0) { if (lock_count > 0) - fl->fl_type = F_RDLCK; + fl->fl_core.fl_type = F_RDLCK; else - fl->fl_type = F_WRLCK; + fl->fl_core.fl_type = F_WRLCK; fl->fl_start = 0; fl->fl_end = OFFSET_MAX; - fl->fl_pid = 0; + fl->fl_core.fl_pid = 0; } } ret = 0; error: - _leave(" = %d [%hd]", ret, fl->fl_type); + _leave(" = %d [%hd]", ret, fl->fl_core.fl_type); return ret; } @@ -769,7 +770,7 @@ int afs_lock(struct file *file, int cmd, struct file_lock *fl) _enter("{%llx:%llu},%d,{t=%x,fl=%x,r=%Ld:%Ld}", vnode->fid.vid, vnode->fid.vnode, cmd, - fl->fl_type, fl->fl_flags, + fl->fl_core.fl_type, fl->fl_core.fl_flags, (long long) fl->fl_start, (long long) fl->fl_end); if (IS_GETLK(cmd)) @@ -778,7 +779,7 @@ int afs_lock(struct file *file, int cmd, struct file_lock *fl) fl->fl_u.afs.debug_id = atomic_inc_return(&afs_file_lock_debug_id); trace_afs_flock_op(vnode, fl, afs_flock_op_lock); - if (fl->fl_type == F_UNLCK) + if (fl->fl_core.fl_type == F_UNLCK) ret = afs_do_unlk(file, fl); else ret = afs_do_setlk(file, fl); @@ -804,7 +805,7 @@ int afs_flock(struct file *file, int cmd, struct file_lock *fl) _enter("{%llx:%llu},%d,{t=%x,fl=%x}", vnode->fid.vid, vnode->fid.vnode, cmd, - fl->fl_type, fl->fl_flags); + fl->fl_core.fl_type, fl->fl_core.fl_flags); /* * No BSD flocks over NFS allowed. @@ -813,14 +814,14 @@ int afs_flock(struct file *file, int cmd, struct file_lock *fl) * Not sure whether that would be unique, though, or whether * that would break in other places. */ - if (!(fl->fl_flags & FL_FLOCK)) + if (!(fl->fl_core.fl_flags & FL_FLOCK)) return -ENOLCK; fl->fl_u.afs.debug_id = atomic_inc_return(&afs_file_lock_debug_id); trace_afs_flock_op(vnode, fl, afs_flock_op_flock); /* we're simulating flock() locks using posix locks on the server */ - if (fl->fl_type == F_UNLCK) + if (fl->fl_core.fl_type == F_UNLCK) ret = afs_do_unlk(file, fl); else ret = afs_do_setlk(file, fl); @@ -843,7 +844,7 @@ int afs_flock(struct file *file, int cmd, struct file_lock *fl) */ static void afs_fl_copy_lock(struct file_lock *new, struct file_lock *fl) { - struct afs_vnode *vnode = AFS_FS_I(file_inode(fl->fl_file)); + struct afs_vnode *vnode = AFS_FS_I(file_inode(fl->fl_core.fl_file)); _enter(""); @@ -861,7 +862,7 @@ static void afs_fl_copy_lock(struct file_lock *new, struct file_lock *fl) */ static void afs_fl_release_private(struct file_lock *fl) { - struct afs_vnode *vnode = AFS_FS_I(file_inode(fl->fl_file)); + struct afs_vnode *vnode = AFS_FS_I(file_inode(fl->fl_core.fl_file)); _enter(""); diff --git a/fs/ceph/locks.c b/fs/ceph/locks.c index e07ad29ff8b9..ee12f9864980 100644 --- a/fs/ceph/locks.c +++ b/fs/ceph/locks.c @@ -33,7 +33,7 @@ void __init ceph_flock_init(void) static void ceph_fl_copy_lock(struct file_lock *dst, struct file_lock *src) { - struct inode *inode = file_inode(dst->fl_file); + struct inode *inode = file_inode(dst->fl_core.fl_file); atomic_inc(&ceph_inode(inode)->i_filelock_ref); dst->fl_u.ceph.inode = igrab(inode); } @@ -110,17 +110,18 @@ static int ceph_lock_message(u8 lock_type, u16 operation, struct inode *inode, else length = fl->fl_end - fl->fl_start + 1; - owner = secure_addr(fl->fl_owner); + owner = secure_addr(fl->fl_core.fl_owner); doutc(cl, "rule: %d, op: %d, owner: %llx, pid: %llu, " "start: %llu, length: %llu, wait: %d, type: %d\n", - (int)lock_type, (int)operation, owner, (u64)fl->fl_pid, - fl->fl_start, length, wait, fl->fl_type); + (int)lock_type, (int)operation, owner, + (u64) fl->fl_core.fl_pid, + fl->fl_start, length, wait, fl->fl_core.fl_type); req->r_args.filelock_change.rule = lock_type; req->r_args.filelock_change.type = cmd; req->r_args.filelock_change.owner = cpu_to_le64(owner); - req->r_args.filelock_change.pid = cpu_to_le64((u64)fl->fl_pid); + req->r_args.filelock_change.pid = cpu_to_le64((u64) fl->fl_core.fl_pid); req->r_args.filelock_change.start = cpu_to_le64(fl->fl_start); req->r_args.filelock_change.length = cpu_to_le64(length); req->r_args.filelock_change.wait = wait; @@ -130,13 +131,13 @@ static int ceph_lock_message(u8 lock_type, u16 operation, struct inode *inode, err = ceph_mdsc_wait_request(mdsc, req, wait ? ceph_lock_wait_for_completion : NULL); if (!err && operation == CEPH_MDS_OP_GETFILELOCK) { - fl->fl_pid = -le64_to_cpu(req->r_reply_info.filelock_reply->pid); + fl->fl_core.fl_pid = -le64_to_cpu(req->r_reply_info.filelock_reply->pid); if (CEPH_LOCK_SHARED == req->r_reply_info.filelock_reply->type) - fl->fl_type = F_RDLCK; + fl->fl_core.fl_type = F_RDLCK; else if (CEPH_LOCK_EXCL == req->r_reply_info.filelock_reply->type) - fl->fl_type = F_WRLCK; + fl->fl_core.fl_type = F_WRLCK; else - fl->fl_type = F_UNLCK; + fl->fl_core.fl_type = F_UNLCK; fl->fl_start = le64_to_cpu(req->r_reply_info.filelock_reply->start); length = le64_to_cpu(req->r_reply_info.filelock_reply->start) + @@ -150,8 +151,8 @@ static int ceph_lock_message(u8 lock_type, u16 operation, struct inode *inode, ceph_mdsc_put_request(req); doutc(cl, "rule: %d, op: %d, pid: %llu, start: %llu, " "length: %llu, wait: %d, type: %d, err code %d\n", - (int)lock_type, (int)operation, (u64)fl->fl_pid, - fl->fl_start, length, wait, fl->fl_type, err); + (int)lock_type, (int)operation, (u64) fl->fl_core.fl_pid, + fl->fl_start, length, wait, fl->fl_core.fl_type, err); return err; } @@ -227,10 +228,10 @@ static int ceph_lock_wait_for_completion(struct ceph_mds_client *mdsc, static int try_unlock_file(struct file *file, struct file_lock *fl) { int err; - unsigned int orig_flags = fl->fl_flags; - fl->fl_flags |= FL_EXISTS; + unsigned int orig_flags = fl->fl_core.fl_flags; + fl->fl_core.fl_flags |= FL_EXISTS; err = locks_lock_file_wait(file, fl); - fl->fl_flags = orig_flags; + fl->fl_core.fl_flags = orig_flags; if (err == -ENOENT) { if (!(orig_flags & FL_EXISTS)) err = 0; @@ -253,13 +254,13 @@ int ceph_lock(struct file *file, int cmd, struct file_lock *fl) u8 wait = 0; u8 lock_cmd; - if (!(fl->fl_flags & FL_POSIX)) + if (!(fl->fl_core.fl_flags & FL_POSIX)) return -ENOLCK; if (ceph_inode_is_shutdown(inode)) return -ESTALE; - doutc(cl, "fl_owner: %p\n", fl->fl_owner); + doutc(cl, "fl_owner: %p\n", fl->fl_core.fl_owner); /* set wait bit as appropriate, then make command as Ceph expects it*/ if (IS_GETLK(cmd)) @@ -273,19 +274,19 @@ int ceph_lock(struct file *file, int cmd, struct file_lock *fl) } spin_unlock(&ci->i_ceph_lock); if (err < 0) { - if (op == CEPH_MDS_OP_SETFILELOCK && F_UNLCK == fl->fl_type) + if (op == CEPH_MDS_OP_SETFILELOCK && F_UNLCK == fl->fl_core.fl_type) posix_lock_file(file, fl, NULL); return err; } - if (F_RDLCK == fl->fl_type) + if (F_RDLCK == fl->fl_core.fl_type) lock_cmd = CEPH_LOCK_SHARED; - else if (F_WRLCK == fl->fl_type) + else if (F_WRLCK == fl->fl_core.fl_type) lock_cmd = CEPH_LOCK_EXCL; else lock_cmd = CEPH_LOCK_UNLOCK; - if (op == CEPH_MDS_OP_SETFILELOCK && F_UNLCK == fl->fl_type) { + if (op == CEPH_MDS_OP_SETFILELOCK && F_UNLCK == fl->fl_core.fl_type) { err = try_unlock_file(file, fl); if (err <= 0) return err; @@ -293,7 +294,7 @@ int ceph_lock(struct file *file, int cmd, struct file_lock *fl) err = ceph_lock_message(CEPH_LOCK_FCNTL, op, inode, lock_cmd, wait, fl); if (!err) { - if (op == CEPH_MDS_OP_SETFILELOCK && F_UNLCK != fl->fl_type) { + if (op == CEPH_MDS_OP_SETFILELOCK && F_UNLCK != fl->fl_core.fl_type) { doutc(cl, "locking locally\n"); err = posix_lock_file(file, fl, NULL); if (err) { @@ -319,13 +320,13 @@ int ceph_flock(struct file *file, int cmd, struct file_lock *fl) u8 wait = 0; u8 lock_cmd; - if (!(fl->fl_flags & FL_FLOCK)) + if (!(fl->fl_core.fl_flags & FL_FLOCK)) return -ENOLCK; if (ceph_inode_is_shutdown(inode)) return -ESTALE; - doutc(cl, "fl_file: %p\n", fl->fl_file); + doutc(cl, "fl_file: %p\n", fl->fl_core.fl_file); spin_lock(&ci->i_ceph_lock); if (ci->i_ceph_flags & CEPH_I_ERROR_FILELOCK) { @@ -333,7 +334,7 @@ int ceph_flock(struct file *file, int cmd, struct file_lock *fl) } spin_unlock(&ci->i_ceph_lock); if (err < 0) { - if (F_UNLCK == fl->fl_type) + if (F_UNLCK == fl->fl_core.fl_type) locks_lock_file_wait(file, fl); return err; } @@ -341,14 +342,14 @@ int ceph_flock(struct file *file, int cmd, struct file_lock *fl) if (IS_SETLKW(cmd)) wait = 1; - if (F_RDLCK == fl->fl_type) + if (F_RDLCK == fl->fl_core.fl_type) lock_cmd = CEPH_LOCK_SHARED; - else if (F_WRLCK == fl->fl_type) + else if (F_WRLCK == fl->fl_core.fl_type) lock_cmd = CEPH_LOCK_EXCL; else lock_cmd = CEPH_LOCK_UNLOCK; - if (F_UNLCK == fl->fl_type) { + if (F_UNLCK == fl->fl_core.fl_type) { err = try_unlock_file(file, fl); if (err <= 0) return err; @@ -356,7 +357,7 @@ int ceph_flock(struct file *file, int cmd, struct file_lock *fl) err = ceph_lock_message(CEPH_LOCK_FLOCK, CEPH_MDS_OP_SETFILELOCK, inode, lock_cmd, wait, fl); - if (!err && F_UNLCK != fl->fl_type) { + if (!err && F_UNLCK != fl->fl_core.fl_type) { err = locks_lock_file_wait(file, fl); if (err) { ceph_lock_message(CEPH_LOCK_FLOCK, @@ -408,10 +409,10 @@ static int lock_to_ceph_filelock(struct inode *inode, cephlock->start = cpu_to_le64(lock->fl_start); cephlock->length = cpu_to_le64(lock->fl_end - lock->fl_start + 1); cephlock->client = cpu_to_le64(0); - cephlock->pid = cpu_to_le64((u64)lock->fl_pid); - cephlock->owner = cpu_to_le64(secure_addr(lock->fl_owner)); + cephlock->pid = cpu_to_le64((u64) lock->fl_core.fl_pid); + cephlock->owner = cpu_to_le64(secure_addr(lock->fl_core.fl_owner)); - switch (lock->fl_type) { + switch (lock->fl_core.fl_type) { case F_RDLCK: cephlock->type = CEPH_LOCK_SHARED; break; @@ -422,7 +423,8 @@ static int lock_to_ceph_filelock(struct inode *inode, cephlock->type = CEPH_LOCK_UNLOCK; break; default: - doutc(cl, "Have unknown lock type %d\n", lock->fl_type); + doutc(cl, "Have unknown lock type %d\n", + lock->fl_core.fl_type); err = -EINVAL; } diff --git a/fs/dlm/plock.c b/fs/dlm/plock.c index d814c5121367..e98d09c06f57 100644 --- a/fs/dlm/plock.c +++ b/fs/dlm/plock.c @@ -138,14 +138,14 @@ int dlm_posix_lock(dlm_lockspace_t *lockspace, u64 number, struct file *file, } op->info.optype = DLM_PLOCK_OP_LOCK; - op->info.pid = fl->fl_pid; - op->info.ex = (fl->fl_type == F_WRLCK); - op->info.wait = !!(fl->fl_flags & FL_SLEEP); + op->info.pid = fl->fl_core.fl_pid; + op->info.ex = (fl->fl_core.fl_type == F_WRLCK); + op->info.wait = !!(fl->fl_core.fl_flags & FL_SLEEP); op->info.fsid = ls->ls_global_id; op->info.number = number; op->info.start = fl->fl_start; op->info.end = fl->fl_end; - op->info.owner = (__u64)(long)fl->fl_owner; + op->info.owner = (__u64)(long) fl->fl_core.fl_owner; /* async handling */ if (fl->fl_lmops && fl->fl_lmops->lm_grant) { op_data = kzalloc(sizeof(*op_data), GFP_NOFS); @@ -258,7 +258,7 @@ static int dlm_plock_callback(struct plock_op *op) } /* got fs lock; bookkeep locally as well: */ - flc->fl_flags &= ~FL_SLEEP; + flc->fl_core.fl_flags &= ~FL_SLEEP; if (posix_lock_file(file, flc, NULL)) { /* * This can only happen in the case of kmalloc() failure. @@ -291,7 +291,7 @@ int dlm_posix_unlock(dlm_lockspace_t *lockspace, u64 number, struct file *file, struct dlm_ls *ls; struct plock_op *op; int rv; - unsigned char fl_flags = fl->fl_flags; + unsigned char fl_flags = fl->fl_core.fl_flags; ls = dlm_find_lockspace_local(lockspace); if (!ls) @@ -304,7 +304,7 @@ int dlm_posix_unlock(dlm_lockspace_t *lockspace, u64 number, struct file *file, } /* cause the vfs unlock to return ENOENT if lock is not found */ - fl->fl_flags |= FL_EXISTS; + fl->fl_core.fl_flags |= FL_EXISTS; rv = locks_lock_file_wait(file, fl); if (rv == -ENOENT) { @@ -317,14 +317,14 @@ int dlm_posix_unlock(dlm_lockspace_t *lockspace, u64 number, struct file *file, } op->info.optype = DLM_PLOCK_OP_UNLOCK; - op->info.pid = fl->fl_pid; + op->info.pid = fl->fl_core.fl_pid; op->info.fsid = ls->ls_global_id; op->info.number = number; op->info.start = fl->fl_start; op->info.end = fl->fl_end; - op->info.owner = (__u64)(long)fl->fl_owner; + op->info.owner = (__u64)(long) fl->fl_core.fl_owner; - if (fl->fl_flags & FL_CLOSE) { + if (fl->fl_core.fl_flags & FL_CLOSE) { op->info.flags |= DLM_PLOCK_FL_CLOSE; send_op(op); rv = 0; @@ -345,7 +345,7 @@ int dlm_posix_unlock(dlm_lockspace_t *lockspace, u64 number, struct file *file, dlm_release_plock_op(op); out: dlm_put_lockspace(ls); - fl->fl_flags = fl_flags; + fl->fl_core.fl_flags = fl_flags; return rv; } EXPORT_SYMBOL_GPL(dlm_posix_unlock); @@ -375,14 +375,14 @@ int dlm_posix_cancel(dlm_lockspace_t *lockspace, u64 number, struct file *file, return -EINVAL; memset(&info, 0, sizeof(info)); - info.pid = fl->fl_pid; - info.ex = (fl->fl_type == F_WRLCK); + info.pid = fl->fl_core.fl_pid; + info.ex = (fl->fl_core.fl_type == F_WRLCK); info.fsid = ls->ls_global_id; dlm_put_lockspace(ls); info.number = number; info.start = fl->fl_start; info.end = fl->fl_end; - info.owner = (__u64)(long)fl->fl_owner; + info.owner = (__u64)(long) fl->fl_core.fl_owner; rv = do_lock_cancel(&info); switch (rv) { @@ -437,13 +437,13 @@ int dlm_posix_get(dlm_lockspace_t *lockspace, u64 number, struct file *file, } op->info.optype = DLM_PLOCK_OP_GET; - op->info.pid = fl->fl_pid; - op->info.ex = (fl->fl_type == F_WRLCK); + op->info.pid = fl->fl_core.fl_pid; + op->info.ex = (fl->fl_core.fl_type == F_WRLCK); op->info.fsid = ls->ls_global_id; op->info.number = number; op->info.start = fl->fl_start; op->info.end = fl->fl_end; - op->info.owner = (__u64)(long)fl->fl_owner; + op->info.owner = (__u64)(long) fl->fl_core.fl_owner; send_op(op); wait_event(recv_wq, (op->done != 0)); @@ -455,16 +455,16 @@ int dlm_posix_get(dlm_lockspace_t *lockspace, u64 number, struct file *file, rv = op->info.rv; - fl->fl_type = F_UNLCK; + fl->fl_core.fl_type = F_UNLCK; if (rv == -ENOENT) rv = 0; else if (rv > 0) { locks_init_lock(fl); - fl->fl_type = (op->info.ex) ? F_WRLCK : F_RDLCK; - fl->fl_flags = FL_POSIX; - fl->fl_pid = op->info.pid; + fl->fl_core.fl_type = (op->info.ex) ? F_WRLCK : F_RDLCK; + fl->fl_core.fl_flags = FL_POSIX; + fl->fl_core.fl_pid = op->info.pid; if (op->info.nodeid != dlm_our_nodeid()) - fl->fl_pid = -fl->fl_pid; + fl->fl_core.fl_pid = -fl->fl_core.fl_pid; fl->fl_start = op->info.start; fl->fl_end = op->info.end; rv = 0; diff --git a/fs/fuse/file.c b/fs/fuse/file.c index 148a71b8b4d0..13c38696074d 100644 --- a/fs/fuse/file.c +++ b/fs/fuse/file.c @@ -2509,14 +2509,14 @@ static int convert_fuse_file_lock(struct fuse_conn *fc, * translate it into the caller's pid namespace. */ rcu_read_lock(); - fl->fl_pid = pid_nr_ns(find_pid_ns(ffl->pid, fc->pid_ns), &init_pid_ns); + fl->fl_core.fl_pid = pid_nr_ns(find_pid_ns(ffl->pid, fc->pid_ns), &init_pid_ns); rcu_read_unlock(); break; default: return -EIO; } - fl->fl_type = ffl->type; + fl->fl_core.fl_type = ffl->type; return 0; } @@ -2530,10 +2530,10 @@ static void fuse_lk_fill(struct fuse_args *args, struct file *file, memset(inarg, 0, sizeof(*inarg)); inarg->fh = ff->fh; - inarg->owner = fuse_lock_owner_id(fc, fl->fl_owner); + inarg->owner = fuse_lock_owner_id(fc, fl->fl_core.fl_owner); inarg->lk.start = fl->fl_start; inarg->lk.end = fl->fl_end; - inarg->lk.type = fl->fl_type; + inarg->lk.type = fl->fl_core.fl_type; inarg->lk.pid = pid; if (flock) inarg->lk_flags |= FUSE_LK_FLOCK; @@ -2570,8 +2570,8 @@ static int fuse_setlk(struct file *file, struct file_lock *fl, int flock) struct fuse_mount *fm = get_fuse_mount(inode); FUSE_ARGS(args); struct fuse_lk_in inarg; - int opcode = (fl->fl_flags & FL_SLEEP) ? FUSE_SETLKW : FUSE_SETLK; - struct pid *pid = fl->fl_type != F_UNLCK ? task_tgid(current) : NULL; + int opcode = (fl->fl_core.fl_flags & FL_SLEEP) ? FUSE_SETLKW : FUSE_SETLK; + struct pid *pid = fl->fl_core.fl_type != F_UNLCK ? task_tgid(current) : NULL; pid_t pid_nr = pid_nr_ns(pid, fm->fc->pid_ns); int err; @@ -2581,7 +2581,7 @@ static int fuse_setlk(struct file *file, struct file_lock *fl, int flock) } /* Unlock on close is handled by the flush method */ - if ((fl->fl_flags & FL_CLOSE_POSIX) == FL_CLOSE_POSIX) + if ((fl->fl_core.fl_flags & FL_CLOSE_POSIX) == FL_CLOSE_POSIX) return 0; fuse_lk_fill(&args, file, fl, opcode, pid_nr, flock, &inarg); diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c index 992ca4effb50..fdcd29583cc8 100644 --- a/fs/gfs2/file.c +++ b/fs/gfs2/file.c @@ -1440,10 +1440,10 @@ static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl) struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host); struct lm_lockstruct *ls = &sdp->sd_lockstruct; - if (!(fl->fl_flags & FL_POSIX)) + if (!(fl->fl_core.fl_flags & FL_POSIX)) return -ENOLCK; if (gfs2_withdrawing_or_withdrawn(sdp)) { - if (fl->fl_type == F_UNLCK) + if (fl->fl_core.fl_type == F_UNLCK) locks_lock_file_wait(file, fl); return -EIO; } @@ -1451,7 +1451,7 @@ static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl) return dlm_posix_cancel(ls->ls_dlm, ip->i_no_addr, file, fl); else if (IS_GETLK(cmd)) return dlm_posix_get(ls->ls_dlm, ip->i_no_addr, file, fl); - else if (fl->fl_type == F_UNLCK) + else if (fl->fl_core.fl_type == F_UNLCK) return dlm_posix_unlock(ls->ls_dlm, ip->i_no_addr, file, fl); else return dlm_posix_lock(ls->ls_dlm, ip->i_no_addr, file, cmd, fl); @@ -1483,7 +1483,7 @@ static int do_flock(struct file *file, int cmd, struct file_lock *fl) int error = 0; int sleeptime; - state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED; + state = (fl->fl_core.fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED; flags = GL_EXACT | GL_NOPID; if (!IS_SETLKW(cmd)) flags |= LM_FLAG_TRY_1CB; @@ -1495,8 +1495,8 @@ static int do_flock(struct file *file, int cmd, struct file_lock *fl) if (fl_gh->gh_state == state) goto out; locks_init_lock(&request); - request.fl_type = F_UNLCK; - request.fl_flags = FL_FLOCK; + request.fl_core.fl_type = F_UNLCK; + request.fl_core.fl_flags = FL_FLOCK; locks_lock_file_wait(file, &request); gfs2_glock_dq(fl_gh); gfs2_holder_reinit(state, flags, fl_gh); @@ -1557,10 +1557,10 @@ static void do_unflock(struct file *file, struct file_lock *fl) static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl) { - if (!(fl->fl_flags & FL_FLOCK)) + if (!(fl->fl_core.fl_flags & FL_FLOCK)) return -ENOLCK; - if (fl->fl_type == F_UNLCK) { + if (fl->fl_core.fl_type == F_UNLCK) { do_unflock(file, fl); return 0; } else { diff --git a/fs/lockd/clnt4xdr.c b/fs/lockd/clnt4xdr.c index 8161667c976f..ed00bd2869a7 100644 --- a/fs/lockd/clnt4xdr.c +++ b/fs/lockd/clnt4xdr.c @@ -270,7 +270,7 @@ static int decode_nlm4_holder(struct xdr_stream *xdr, struct nlm_res *result) goto out_overflow; exclusive = be32_to_cpup(p++); lock->svid = be32_to_cpup(p); - fl->fl_pid = (pid_t)lock->svid; + fl->fl_core.fl_pid = (pid_t)lock->svid; error = decode_netobj(xdr, &lock->oh); if (unlikely(error)) @@ -280,8 +280,8 @@ static int decode_nlm4_holder(struct xdr_stream *xdr, struct nlm_res *result) if (unlikely(p == NULL)) goto out_overflow; - fl->fl_flags = FL_POSIX; - fl->fl_type = exclusive != 0 ? F_WRLCK : F_RDLCK; + fl->fl_core.fl_flags = FL_POSIX; + fl->fl_core.fl_type = exclusive != 0 ? F_WRLCK : F_RDLCK; p = xdr_decode_hyper(p, &l_offset); xdr_decode_hyper(p, &l_len); nlm4svc_set_file_lock_range(fl, l_offset, l_len); diff --git a/fs/lockd/clntlock.c b/fs/lockd/clntlock.c index 5d85715be763..c15a6d5f1acf 100644 --- a/fs/lockd/clntlock.c +++ b/fs/lockd/clntlock.c @@ -185,7 +185,7 @@ __be32 nlmclnt_grant(const struct sockaddr *addr, const struct nlm_lock *lock) continue; if (!rpc_cmp_addr(nlm_addr(block->b_host), addr)) continue; - if (nfs_compare_fh(NFS_FH(file_inode(fl_blocked->fl_file)), fh) != 0) + if (nfs_compare_fh(NFS_FH(file_inode(fl_blocked->fl_core.fl_file)), fh) != 0) continue; /* Alright, we found a lock. Set the return status * and wake up the caller diff --git a/fs/lockd/clntproc.c b/fs/lockd/clntproc.c index fba6c7fa7474..ac1d07034346 100644 --- a/fs/lockd/clntproc.c +++ b/fs/lockd/clntproc.c @@ -133,7 +133,8 @@ static void nlmclnt_setlockargs(struct nlm_rqst *req, struct file_lock *fl) char *nodename = req->a_host->h_rpcclnt->cl_nodename; nlmclnt_next_cookie(&argp->cookie); - memcpy(&lock->fh, NFS_FH(file_inode(fl->fl_file)), sizeof(struct nfs_fh)); + memcpy(&lock->fh, NFS_FH(file_inode(fl->fl_core.fl_file)), + sizeof(struct nfs_fh)); lock->caller = nodename; lock->oh.data = req->a_owner; lock->oh.len = snprintf(req->a_owner, sizeof(req->a_owner), "%u@%s", @@ -142,7 +143,7 @@ static void nlmclnt_setlockargs(struct nlm_rqst *req, struct file_lock *fl) lock->svid = fl->fl_u.nfs_fl.owner->pid; lock->fl.fl_start = fl->fl_start; lock->fl.fl_end = fl->fl_end; - lock->fl.fl_type = fl->fl_type; + lock->fl.fl_type = fl->fl_core.fl_type; } static void nlmclnt_release_lockargs(struct nlm_rqst *req) @@ -182,7 +183,7 @@ int nlmclnt_proc(struct nlm_host *host, int cmd, struct file_lock *fl, void *dat call->a_callback_data = data; if (IS_SETLK(cmd) || IS_SETLKW(cmd)) { - if (fl->fl_type != F_UNLCK) { + if (fl->fl_core.fl_type != F_UNLCK) { call->a_args.block = IS_SETLKW(cmd) ? 1 : 0; status = nlmclnt_lock(call, fl); } else @@ -432,13 +433,14 @@ nlmclnt_test(struct nlm_rqst *req, struct file_lock *fl) { int status; - status = nlmclnt_call(nfs_file_cred(fl->fl_file), req, NLMPROC_TEST); + status = nlmclnt_call(nfs_file_cred(fl->fl_core.fl_file), req, + NLMPROC_TEST); if (status < 0) goto out; switch (req->a_res.status) { case nlm_granted: - fl->fl_type = F_UNLCK; + fl->fl_core.fl_type = F_UNLCK; break; case nlm_lck_denied: /* @@ -446,8 +448,8 @@ nlmclnt_test(struct nlm_rqst *req, struct file_lock *fl) */ fl->fl_start = req->a_res.lock.fl.fl_start; fl->fl_end = req->a_res.lock.fl.fl_end; - fl->fl_type = req->a_res.lock.fl.fl_type; - fl->fl_pid = -req->a_res.lock.fl.fl_pid; + fl->fl_core.fl_type = req->a_res.lock.fl.fl_type; + fl->fl_core.fl_pid = -req->a_res.lock.fl.fl_pid; break; default: status = nlm_stat_to_errno(req->a_res.status); @@ -485,14 +487,15 @@ static const struct file_lock_operations nlmclnt_lock_ops = { static void nlmclnt_locks_init_private(struct file_lock *fl, struct nlm_host *host) { fl->fl_u.nfs_fl.state = 0; - fl->fl_u.nfs_fl.owner = nlmclnt_find_lockowner(host, fl->fl_owner); + fl->fl_u.nfs_fl.owner = nlmclnt_find_lockowner(host, + fl->fl_core.fl_owner); INIT_LIST_HEAD(&fl->fl_u.nfs_fl.list); fl->fl_ops = &nlmclnt_lock_ops; } static int do_vfs_lock(struct file_lock *fl) { - return locks_lock_file_wait(fl->fl_file, fl); + return locks_lock_file_wait(fl->fl_core.fl_file, fl); } /* @@ -518,11 +521,11 @@ static int do_vfs_lock(struct file_lock *fl) static int nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) { - const struct cred *cred = nfs_file_cred(fl->fl_file); + const struct cred *cred = nfs_file_cred(fl->fl_core.fl_file); struct nlm_host *host = req->a_host; struct nlm_res *resp = &req->a_res; struct nlm_wait block; - unsigned char fl_flags = fl->fl_flags; + unsigned char fl_flags = fl->fl_core.fl_flags; unsigned char fl_type; __be32 b_status; int status = -ENOLCK; @@ -531,9 +534,9 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) goto out; req->a_args.state = nsm_local_state; - fl->fl_flags |= FL_ACCESS; + fl->fl_core.fl_flags |= FL_ACCESS; status = do_vfs_lock(fl); - fl->fl_flags = fl_flags; + fl->fl_core.fl_flags = fl_flags; if (status < 0) goto out; @@ -591,11 +594,11 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) goto again; } /* Ensure the resulting lock will get added to granted list */ - fl->fl_flags |= FL_SLEEP; + fl->fl_core.fl_flags |= FL_SLEEP; if (do_vfs_lock(fl) < 0) printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __func__); up_read(&host->h_rwsem); - fl->fl_flags = fl_flags; + fl->fl_core.fl_flags = fl_flags; status = 0; } if (status < 0) @@ -622,13 +625,13 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) req->a_host->h_addrlen, req->a_res.status); dprintk("lockd: lock attempt ended in fatal error.\n" " Attempting to unlock.\n"); - fl_type = fl->fl_type; - fl->fl_type = F_UNLCK; + fl_type = fl->fl_core.fl_type; + fl->fl_core.fl_type = F_UNLCK; down_read(&host->h_rwsem); do_vfs_lock(fl); up_read(&host->h_rwsem); - fl->fl_type = fl_type; - fl->fl_flags = fl_flags; + fl->fl_core.fl_type = fl_type; + fl->fl_core.fl_flags = fl_flags; nlmclnt_async_call(cred, req, NLMPROC_UNLOCK, &nlmclnt_unlock_ops); return status; } @@ -651,12 +654,13 @@ nlmclnt_reclaim(struct nlm_host *host, struct file_lock *fl, nlmclnt_setlockargs(req, fl); req->a_args.reclaim = 1; - status = nlmclnt_call(nfs_file_cred(fl->fl_file), req, NLMPROC_LOCK); + status = nlmclnt_call(nfs_file_cred(fl->fl_core.fl_file), req, + NLMPROC_LOCK); if (status >= 0 && req->a_res.status == nlm_granted) return 0; printk(KERN_WARNING "lockd: failed to reclaim lock for pid %d " - "(errno %d, status %d)\n", fl->fl_pid, + "(errno %d, status %d)\n", fl->fl_core.fl_pid, status, ntohl(req->a_res.status)); /* @@ -683,26 +687,26 @@ nlmclnt_unlock(struct nlm_rqst *req, struct file_lock *fl) struct nlm_host *host = req->a_host; struct nlm_res *resp = &req->a_res; int status; - unsigned char fl_flags = fl->fl_flags; + unsigned char fl_flags = fl->fl_core.fl_flags; /* * Note: the server is supposed to either grant us the unlock * request, or to deny it with NLM_LCK_DENIED_GRACE_PERIOD. In either * case, we want to unlock. */ - fl->fl_flags |= FL_EXISTS; + fl->fl_core.fl_flags |= FL_EXISTS; down_read(&host->h_rwsem); status = do_vfs_lock(fl); up_read(&host->h_rwsem); - fl->fl_flags = fl_flags; + fl->fl_core.fl_flags = fl_flags; if (status == -ENOENT) { status = 0; goto out; } refcount_inc(&req->a_count); - status = nlmclnt_async_call(nfs_file_cred(fl->fl_file), req, - NLMPROC_UNLOCK, &nlmclnt_unlock_ops); + status = nlmclnt_async_call(nfs_file_cred(fl->fl_core.fl_file), req, + NLMPROC_UNLOCK, &nlmclnt_unlock_ops); if (status < 0) goto out; @@ -795,8 +799,8 @@ static int nlmclnt_cancel(struct nlm_host *host, int block, struct file_lock *fl req->a_args.block = block; refcount_inc(&req->a_count); - status = nlmclnt_async_call(nfs_file_cred(fl->fl_file), req, - NLMPROC_CANCEL, &nlmclnt_cancel_ops); + status = nlmclnt_async_call(nfs_file_cred(fl->fl_core.fl_file), req, + NLMPROC_CANCEL, &nlmclnt_cancel_ops); if (status == 0 && req->a_res.status == nlm_lck_denied) status = -ENOLCK; nlmclnt_release_call(req); diff --git a/fs/lockd/clntxdr.c b/fs/lockd/clntxdr.c index 4df62f635529..b0b87a00cd81 100644 --- a/fs/lockd/clntxdr.c +++ b/fs/lockd/clntxdr.c @@ -265,7 +265,7 @@ static int decode_nlm_holder(struct xdr_stream *xdr, struct nlm_res *result) goto out_overflow; exclusive = be32_to_cpup(p++); lock->svid = be32_to_cpup(p); - fl->fl_pid = (pid_t)lock->svid; + fl->fl_core.fl_pid = (pid_t)lock->svid; error = decode_netobj(xdr, &lock->oh); if (unlikely(error)) @@ -275,8 +275,8 @@ static int decode_nlm_holder(struct xdr_stream *xdr, struct nlm_res *result) if (unlikely(p == NULL)) goto out_overflow; - fl->fl_flags = FL_POSIX; - fl->fl_type = exclusive != 0 ? F_WRLCK : F_RDLCK; + fl->fl_core.fl_flags = FL_POSIX; + fl->fl_core.fl_type = exclusive != 0 ? F_WRLCK : F_RDLCK; l_offset = be32_to_cpup(p++); l_len = be32_to_cpup(p); end = l_offset + l_len - 1; diff --git a/fs/lockd/svclock.c b/fs/lockd/svclock.c index 2dc10900ad1c..520886a4b57e 100644 --- a/fs/lockd/svclock.c +++ b/fs/lockd/svclock.c @@ -157,9 +157,9 @@ nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock) list_for_each_entry(block, &nlm_blocked, b_list) { fl = &block->b_call->a_args.lock.fl; dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%s\n", - block->b_file, fl->fl_pid, + block->b_file, fl->fl_core.fl_pid, (long long)fl->fl_start, - (long long)fl->fl_end, fl->fl_type, + (long long)fl->fl_end, fl->fl_core.fl_type, nlmdbg_cookie2a(&block->b_call->a_args.cookie)); if (block->b_file == file && nlm_compare_locks(fl, &lock->fl)) { kref_get(&block->b_count); @@ -409,7 +409,7 @@ nlmsvc_release_lockowner(struct nlm_lock *lock) void nlmsvc_locks_init_private(struct file_lock *fl, struct nlm_host *host, pid_t pid) { - fl->fl_owner = nlmsvc_find_lockowner(host, pid); + fl->fl_core.fl_owner = nlmsvc_find_lockowner(host, pid); } /* @@ -993,8 +993,8 @@ nlmsvc_grant_reply(struct nlm_cookie *cookie, __be32 status) /* Client doesn't want it, just unlock it */ nlmsvc_unlink_block(block); fl = &block->b_call->a_args.lock.fl; - fl->fl_type = F_UNLCK; - error = vfs_lock_file(fl->fl_file, F_SETLK, fl, NULL); + fl->fl_core.fl_type = F_UNLCK; + error = vfs_lock_file(fl->fl_core.fl_file, F_SETLK, fl, NULL); if (error) pr_warn("lockd: unable to unlock lock rejected by client!\n"); break; diff --git a/fs/lockd/svcsubs.c b/fs/lockd/svcsubs.c index e3b6229e7ae5..61b5c7ef8a12 100644 --- a/fs/lockd/svcsubs.c +++ b/fs/lockd/svcsubs.c @@ -73,7 +73,7 @@ static inline unsigned int file_hash(struct nfs_fh *f) int lock_to_openmode(struct file_lock *lock) { - return (lock->fl_type == F_WRLCK) ? O_WRONLY : O_RDONLY; + return (lock->fl_core.fl_type == F_WRLCK) ? O_WRONLY : O_RDONLY; } /* @@ -181,18 +181,18 @@ static int nlm_unlock_files(struct nlm_file *file, const struct file_lock *fl) struct file_lock lock; locks_init_lock(&lock); - lock.fl_type = F_UNLCK; + lock.fl_core.fl_type = F_UNLCK; lock.fl_start = 0; lock.fl_end = OFFSET_MAX; - lock.fl_owner = fl->fl_owner; - lock.fl_pid = fl->fl_pid; - lock.fl_flags = FL_POSIX; + lock.fl_core.fl_owner = fl->fl_core.fl_owner; + lock.fl_core.fl_pid = fl->fl_core.fl_pid; + lock.fl_core.fl_flags = FL_POSIX; - lock.fl_file = file->f_file[O_RDONLY]; - if (lock.fl_file && vfs_lock_file(lock.fl_file, F_SETLK, &lock, NULL)) + lock.fl_core.fl_file = file->f_file[O_RDONLY]; + if (lock.fl_core.fl_file && vfs_lock_file(lock.fl_core.fl_file, F_SETLK, &lock, NULL)) goto out_err; - lock.fl_file = file->f_file[O_WRONLY]; - if (lock.fl_file && vfs_lock_file(lock.fl_file, F_SETLK, &lock, NULL)) + lock.fl_core.fl_file = file->f_file[O_WRONLY]; + if (lock.fl_core.fl_file && vfs_lock_file(lock.fl_core.fl_file, F_SETLK, &lock, NULL)) goto out_err; return 0; out_err: @@ -225,7 +225,7 @@ nlm_traverse_locks(struct nlm_host *host, struct nlm_file *file, /* update current lock count */ file->f_locks++; - lockhost = ((struct nlm_lockowner *)fl->fl_owner)->host; + lockhost = ((struct nlm_lockowner *) fl->fl_core.fl_owner)->host; if (match(lockhost, host)) { spin_unlock(&flctx->flc_lock); diff --git a/fs/lockd/xdr.c b/fs/lockd/xdr.c index 2fb5748dae0c..4a676a51eb6c 100644 --- a/fs/lockd/xdr.c +++ b/fs/lockd/xdr.c @@ -88,8 +88,8 @@ svcxdr_decode_lock(struct xdr_stream *xdr, struct nlm_lock *lock) return false; locks_init_lock(fl); - fl->fl_flags = FL_POSIX; - fl->fl_type = F_RDLCK; + fl->fl_core.fl_flags = FL_POSIX; + fl->fl_core.fl_type = F_RDLCK; end = start + len - 1; fl->fl_start = s32_to_loff_t(start); if (len == 0 || end < 0) @@ -107,7 +107,7 @@ svcxdr_encode_holder(struct xdr_stream *xdr, const struct nlm_lock *lock) s32 start, len; /* exclusive */ - if (xdr_stream_encode_bool(xdr, fl->fl_type != F_RDLCK) < 0) + if (xdr_stream_encode_bool(xdr, fl->fl_core.fl_type != F_RDLCK) < 0) return false; if (xdr_stream_encode_u32(xdr, lock->svid) < 0) return false; diff --git a/fs/lockd/xdr4.c b/fs/lockd/xdr4.c index 5fcbf30cd275..67e53f91717a 100644 --- a/fs/lockd/xdr4.c +++ b/fs/lockd/xdr4.c @@ -89,8 +89,8 @@ svcxdr_decode_lock(struct xdr_stream *xdr, struct nlm_lock *lock) return false; locks_init_lock(fl); - fl->fl_flags = FL_POSIX; - fl->fl_type = F_RDLCK; + fl->fl_core.fl_flags = FL_POSIX; + fl->fl_core.fl_type = F_RDLCK; nlm4svc_set_file_lock_range(fl, lock->lock_start, lock->lock_len); return true; } @@ -102,7 +102,7 @@ svcxdr_encode_holder(struct xdr_stream *xdr, const struct nlm_lock *lock) s64 start, len; /* exclusive */ - if (xdr_stream_encode_bool(xdr, fl->fl_type != F_RDLCK) < 0) + if (xdr_stream_encode_bool(xdr, fl->fl_core.fl_type != F_RDLCK) < 0) return false; if (xdr_stream_encode_u32(xdr, lock->svid) < 0) return false; diff --git a/fs/locks.c b/fs/locks.c index cc7c117ee192..cd6ffa22a1ce 100644 --- a/fs/locks.c +++ b/fs/locks.c @@ -78,16 +78,16 @@ static bool lease_breaking(struct file_lock *fl) { - return fl->fl_flags & (FL_UNLOCK_PENDING | FL_DOWNGRADE_PENDING); + return fl->fl_core.fl_flags & (FL_UNLOCK_PENDING | FL_DOWNGRADE_PENDING); } static int target_leasetype(struct file_lock *fl) { - if (fl->fl_flags & FL_UNLOCK_PENDING) + if (fl->fl_core.fl_flags & FL_UNLOCK_PENDING) return F_UNLCK; - if (fl->fl_flags & FL_DOWNGRADE_PENDING) + if (fl->fl_core.fl_flags & FL_DOWNGRADE_PENDING) return F_RDLCK; - return fl->fl_type; + return fl->fl_core.fl_type; } static int leases_enable = 1; @@ -207,7 +207,9 @@ 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); + pr_warn("%s: fl_owner=%p fl_flags=0x%x fl_type=0x%x fl_pid=%u\n", list_type, + fl->fl_core.fl_owner, fl->fl_core.fl_flags, + fl->fl_core.fl_type, fl->fl_core.fl_pid); } } @@ -236,12 +238,13 @@ locks_check_ctx_file_list(struct file *filp, struct list_head *list, struct inode *inode = file_inode(filp); list_for_each_entry(fl, list, fl_list) - if (fl->fl_file == filp) + if (fl->fl_core.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); + fl->fl_core.fl_owner, fl->fl_core.fl_flags, + fl->fl_core.fl_type, fl->fl_core.fl_pid); } void @@ -257,11 +260,11 @@ locks_free_lock_context(struct inode *inode) static void locks_init_lock_heads(struct file_lock *fl) { - INIT_HLIST_NODE(&fl->fl_link); - INIT_LIST_HEAD(&fl->fl_list); - INIT_LIST_HEAD(&fl->fl_blocked_requests); - INIT_LIST_HEAD(&fl->fl_blocked_member); - init_waitqueue_head(&fl->fl_wait); + INIT_HLIST_NODE(&fl->fl_core.fl_link); + INIT_LIST_HEAD(&fl->fl_core.fl_list); + INIT_LIST_HEAD(&fl->fl_core.fl_blocked_requests); + INIT_LIST_HEAD(&fl->fl_core.fl_blocked_member); + init_waitqueue_head(&fl->fl_core.fl_wait); } /* Allocate an empty lock structure. */ @@ -278,11 +281,11 @@ EXPORT_SYMBOL_GPL(locks_alloc_lock); void locks_release_private(struct file_lock *fl) { - 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)); + BUG_ON(waitqueue_active(&fl->fl_core.fl_wait)); + BUG_ON(!list_empty(&fl->fl_core.fl_list)); + BUG_ON(!list_empty(&fl->fl_core.fl_blocked_requests)); + BUG_ON(!list_empty(&fl->fl_core.fl_blocked_member)); + BUG_ON(!hlist_unhashed(&fl->fl_core.fl_link)); if (fl->fl_ops) { if (fl->fl_ops->fl_release_private) @@ -292,8 +295,8 @@ void locks_release_private(struct file_lock *fl) if (fl->fl_lmops) { if (fl->fl_lmops->lm_put_owner) { - fl->fl_lmops->lm_put_owner(fl->fl_owner); - fl->fl_owner = NULL; + fl->fl_lmops->lm_put_owner(fl->fl_core.fl_owner); + fl->fl_core.fl_owner = NULL; } fl->fl_lmops = NULL; } @@ -316,9 +319,9 @@ bool locks_owner_has_blockers(struct file_lock_context *flctx, spin_lock(&flctx->flc_lock); list_for_each_entry(fl, &flctx->flc_posix, fl_list) { - if (fl->fl_owner != owner) + if (fl->fl_core.fl_owner != owner) continue; - if (!list_empty(&fl->fl_blocked_requests)) { + if (!list_empty(&fl->fl_core.fl_blocked_requests)) { spin_unlock(&flctx->flc_lock); return true; } @@ -343,7 +346,7 @@ locks_dispose_list(struct list_head *dispose) while (!list_empty(dispose)) { fl = list_first_entry(dispose, struct file_lock, fl_list); - list_del_init(&fl->fl_list); + list_del_init(&fl->fl_core.fl_list); locks_free_lock(fl); } } @@ -360,11 +363,11 @@ EXPORT_SYMBOL(locks_init_lock); */ void locks_copy_conflock(struct file_lock *new, struct file_lock *fl) { - new->fl_owner = fl->fl_owner; - new->fl_pid = fl->fl_pid; - new->fl_file = NULL; - new->fl_flags = fl->fl_flags; - new->fl_type = fl->fl_type; + new->fl_core.fl_owner = fl->fl_core.fl_owner; + new->fl_core.fl_pid = fl->fl_core.fl_pid; + new->fl_core.fl_file = NULL; + new->fl_core.fl_flags = fl->fl_core.fl_flags; + new->fl_core.fl_type = fl->fl_core.fl_type; new->fl_start = fl->fl_start; new->fl_end = fl->fl_end; new->fl_lmops = fl->fl_lmops; @@ -372,7 +375,7 @@ void locks_copy_conflock(struct file_lock *new, struct file_lock *fl) if (fl->fl_lmops) { if (fl->fl_lmops->lm_get_owner) - fl->fl_lmops->lm_get_owner(fl->fl_owner); + fl->fl_lmops->lm_get_owner(fl->fl_core.fl_owner); } } EXPORT_SYMBOL(locks_copy_conflock); @@ -384,7 +387,7 @@ void locks_copy_lock(struct file_lock *new, struct file_lock *fl) locks_copy_conflock(new, fl); - new->fl_file = fl->fl_file; + new->fl_core.fl_file = fl->fl_core.fl_file; new->fl_ops = fl->fl_ops; if (fl->fl_ops) { @@ -403,12 +406,14 @@ static void locks_move_blocks(struct file_lock *new, struct file_lock *fl) * ->fl_blocked_requests, so we don't need a lock to check if it * is empty. */ - if (list_empty(&fl->fl_blocked_requests)) + if (list_empty(&fl->fl_core.fl_blocked_requests)) return; spin_lock(&blocked_lock_lock); - list_splice_init(&fl->fl_blocked_requests, &new->fl_blocked_requests); - list_for_each_entry(f, &new->fl_blocked_requests, fl_blocked_member) - f->fl_blocker = new; + list_splice_init(&fl->fl_core.fl_blocked_requests, + &new->fl_core.fl_blocked_requests); + list_for_each_entry(f, &new->fl_core.fl_blocked_requests, + fl_blocked_member) + f->fl_core.fl_blocker = new; spin_unlock(&blocked_lock_lock); } @@ -429,11 +434,11 @@ static void flock_make_lock(struct file *filp, struct file_lock *fl, int type) { locks_init_lock(fl); - fl->fl_file = filp; - fl->fl_owner = filp; - fl->fl_pid = current->tgid; - fl->fl_flags = FL_FLOCK; - fl->fl_type = type; + fl->fl_core.fl_file = filp; + fl->fl_core.fl_owner = filp; + fl->fl_core.fl_pid = current->tgid; + fl->fl_core.fl_flags = FL_FLOCK; + fl->fl_core.fl_type = type; fl->fl_end = OFFSET_MAX; } @@ -443,7 +448,7 @@ static int assign_type(struct file_lock *fl, int type) case F_RDLCK: case F_WRLCK: case F_UNLCK: - fl->fl_type = type; + fl->fl_core.fl_type = type; break; default: return -EINVAL; @@ -488,10 +493,10 @@ static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl, } else fl->fl_end = OFFSET_MAX; - fl->fl_owner = current->files; - fl->fl_pid = current->tgid; - fl->fl_file = filp; - fl->fl_flags = FL_POSIX; + fl->fl_core.fl_owner = current->files; + fl->fl_core.fl_pid = current->tgid; + fl->fl_core.fl_file = filp; + fl->fl_core.fl_flags = FL_POSIX; fl->fl_ops = NULL; fl->fl_lmops = NULL; @@ -525,7 +530,7 @@ lease_break_callback(struct file_lock *fl) static void lease_setup(struct file_lock *fl, void **priv) { - struct file *filp = fl->fl_file; + struct file *filp = fl->fl_core.fl_file; struct fasync_struct *fa = *priv; /* @@ -553,11 +558,11 @@ static int lease_init(struct file *filp, int type, struct file_lock *fl) if (assign_type(fl, type) != 0) return -EINVAL; - fl->fl_owner = filp; - fl->fl_pid = current->tgid; + fl->fl_core.fl_owner = filp; + fl->fl_core.fl_pid = current->tgid; - fl->fl_file = filp; - fl->fl_flags = FL_LEASE; + fl->fl_core.fl_file = filp; + fl->fl_core.fl_flags = FL_LEASE; fl->fl_start = 0; fl->fl_end = OFFSET_MAX; fl->fl_ops = NULL; @@ -595,7 +600,7 @@ static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2) */ static int posix_same_owner(struct file_lock *fl1, struct file_lock *fl2) { - return fl1->fl_owner == fl2->fl_owner; + return fl1->fl_core.fl_owner == fl2->fl_core.fl_owner; } /* Must be called with the flc_lock held! */ @@ -606,8 +611,8 @@ static void locks_insert_global_locks(struct file_lock *fl) percpu_rwsem_assert_held(&file_rwsem); spin_lock(&fll->lock); - fl->fl_link_cpu = smp_processor_id(); - hlist_add_head(&fl->fl_link, &fll->hlist); + fl->fl_core.fl_link_cpu = smp_processor_id(); + hlist_add_head(&fl->fl_core.fl_link, &fll->hlist); spin_unlock(&fll->lock); } @@ -623,33 +628,34 @@ static void locks_delete_global_locks(struct file_lock *fl) * is done while holding the flc_lock, and new insertions into the list * also require that it be held. */ - if (hlist_unhashed(&fl->fl_link)) + if (hlist_unhashed(&fl->fl_core.fl_link)) return; - fll = per_cpu_ptr(&file_lock_list, fl->fl_link_cpu); + fll = per_cpu_ptr(&file_lock_list, fl->fl_core.fl_link_cpu); spin_lock(&fll->lock); - hlist_del_init(&fl->fl_link); + hlist_del_init(&fl->fl_core.fl_link); spin_unlock(&fll->lock); } static unsigned long posix_owner_key(struct file_lock *fl) { - return (unsigned long)fl->fl_owner; + return (unsigned long) fl->fl_core.fl_owner; } static void locks_insert_global_blocked(struct file_lock *waiter) { lockdep_assert_held(&blocked_lock_lock); - hash_add(blocked_hash, &waiter->fl_link, posix_owner_key(waiter)); + hash_add(blocked_hash, &waiter->fl_core.fl_link, + posix_owner_key(waiter)); } static void locks_delete_global_blocked(struct file_lock *waiter) { lockdep_assert_held(&blocked_lock_lock); - hash_del(&waiter->fl_link); + hash_del(&waiter->fl_core.fl_link); } /* Remove waiter from blocker's block list. @@ -660,28 +666,28 @@ static void locks_delete_global_blocked(struct file_lock *waiter) static void __locks_delete_block(struct file_lock *waiter) { locks_delete_global_blocked(waiter); - list_del_init(&waiter->fl_blocked_member); + list_del_init(&waiter->fl_core.fl_blocked_member); } static void __locks_wake_up_blocks(struct file_lock *blocker) { - while (!list_empty(&blocker->fl_blocked_requests)) { + while (!list_empty(&blocker->fl_core.fl_blocked_requests)) { struct file_lock *waiter; - waiter = list_first_entry(&blocker->fl_blocked_requests, + waiter = list_first_entry(&blocker->fl_core.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); + wake_up(&waiter->fl_core.fl_wait); /* * 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); + smp_store_release(&waiter->fl_core.fl_blocker, NULL); } } @@ -716,12 +722,12 @@ int locks_delete_block(struct file_lock *waiter) * 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)) + if (!smp_load_acquire(&waiter->fl_core.fl_blocker) && + list_empty(&waiter->fl_core.fl_blocked_requests)) return status; spin_lock(&blocked_lock_lock); - if (waiter->fl_blocker) + if (waiter->fl_core.fl_blocker) status = 0; __locks_wake_up_blocks(waiter); __locks_delete_block(waiter); @@ -730,7 +736,7 @@ int locks_delete_block(struct file_lock *waiter) * 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); + smp_store_release(&waiter->fl_core.fl_blocker, NULL); spin_unlock(&blocked_lock_lock); return status; } @@ -757,16 +763,18 @@ static void __locks_insert_block(struct file_lock *blocker, struct file_lock *)) { struct file_lock *fl; - BUG_ON(!list_empty(&waiter->fl_blocked_member)); + BUG_ON(!list_empty(&waiter->fl_core.fl_blocked_member)); new_blocker: - list_for_each_entry(fl, &blocker->fl_blocked_requests, fl_blocked_member) + list_for_each_entry(fl, &blocker->fl_core.fl_blocked_requests, + fl_blocked_member) if (conflict(fl, waiter)) { blocker = fl; goto new_blocker; } - waiter->fl_blocker = blocker; - list_add_tail(&waiter->fl_blocked_member, &blocker->fl_blocked_requests); + waiter->fl_core.fl_blocker = blocker; + list_add_tail(&waiter->fl_core.fl_blocked_member, + &blocker->fl_core.fl_blocked_requests); if (IS_POSIX(blocker) && !IS_OFDLCK(blocker)) locks_insert_global_blocked(waiter); @@ -802,7 +810,7 @@ static void locks_wake_up_blocks(struct file_lock *blocker) * fl_blocked_requests list does not require the flc_lock, so we must * recheck list_empty() after acquiring the blocked_lock_lock. */ - if (list_empty(&blocker->fl_blocked_requests)) + if (list_empty(&blocker->fl_core.fl_blocked_requests)) return; spin_lock(&blocked_lock_lock); @@ -813,7 +821,7 @@ static void locks_wake_up_blocks(struct file_lock *blocker) static void locks_insert_lock_ctx(struct file_lock *fl, struct list_head *before) { - list_add_tail(&fl->fl_list, before); + list_add_tail(&fl->fl_core.fl_list, before); locks_insert_global_locks(fl); } @@ -821,7 +829,7 @@ static void locks_unlink_lock_ctx(struct file_lock *fl) { locks_delete_global_locks(fl); - list_del_init(&fl->fl_list); + list_del_init(&fl->fl_core.fl_list); locks_wake_up_blocks(fl); } @@ -830,7 +838,7 @@ locks_delete_lock_ctx(struct file_lock *fl, struct list_head *dispose) { locks_unlink_lock_ctx(fl); if (dispose) - list_add(&fl->fl_list, dispose); + list_add(&fl->fl_core.fl_list, dispose); else locks_free_lock(fl); } @@ -841,9 +849,9 @@ locks_delete_lock_ctx(struct file_lock *fl, struct list_head *dispose) static bool locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) { - if (sys_fl->fl_type == F_WRLCK) + if (sys_fl->fl_core.fl_type == F_WRLCK) return true; - if (caller_fl->fl_type == F_WRLCK) + if (caller_fl->fl_core.fl_type == F_WRLCK) return true; return false; } @@ -874,7 +882,7 @@ static bool posix_test_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl) { /* F_UNLCK checks any locks on the same fd. */ - if (caller_fl->fl_type == F_UNLCK) { + if (caller_fl->fl_core.fl_type == F_UNLCK) { if (!posix_same_owner(caller_fl, sys_fl)) return false; return locks_overlap(caller_fl, sys_fl); @@ -891,7 +899,7 @@ static bool flock_locks_conflict(struct file_lock *caller_fl, /* FLOCK locks referring to the same filp do not conflict with * each other. */ - if (caller_fl->fl_file == sys_fl->fl_file) + if (caller_fl->fl_core.fl_file == sys_fl->fl_core.fl_file) return false; return locks_conflict(caller_fl, sys_fl); @@ -908,7 +916,7 @@ posix_test_lock(struct file *filp, struct file_lock *fl) ctx = locks_inode_context(inode); if (!ctx || list_empty_careful(&ctx->flc_posix)) { - fl->fl_type = F_UNLCK; + fl->fl_core.fl_type = F_UNLCK; return; } @@ -930,7 +938,7 @@ posix_test_lock(struct file *filp, struct file_lock *fl) locks_copy_conflock(fl, cfl); goto out; } - fl->fl_type = F_UNLCK; + fl->fl_core.fl_type = F_UNLCK; out: spin_unlock(&ctx->flc_lock); return; @@ -979,8 +987,8 @@ static struct file_lock *what_owner_is_waiting_for(struct file_lock *block_fl) hash_for_each_possible(blocked_hash, fl, fl_link, posix_owner_key(block_fl)) { if (posix_same_owner(fl, block_fl)) { - while (fl->fl_blocker) - fl = fl->fl_blocker; + while (fl->fl_core.fl_blocker) + fl = fl->fl_core.fl_blocker; return fl; } } @@ -1027,14 +1035,14 @@ static int flock_lock_inode(struct inode *inode, struct file_lock *request) bool found = false; LIST_HEAD(dispose); - ctx = locks_get_lock_context(inode, request->fl_type); + ctx = locks_get_lock_context(inode, request->fl_core.fl_type); if (!ctx) { - if (request->fl_type != F_UNLCK) + if (request->fl_core.fl_type != F_UNLCK) return -ENOMEM; - return (request->fl_flags & FL_EXISTS) ? -ENOENT : 0; + return (request->fl_core.fl_flags & FL_EXISTS) ? -ENOENT : 0; } - if (!(request->fl_flags & FL_ACCESS) && (request->fl_type != F_UNLCK)) { + if (!(request->fl_core.fl_flags & FL_ACCESS) && (request->fl_core.fl_type != F_UNLCK)) { new_fl = locks_alloc_lock(); if (!new_fl) return -ENOMEM; @@ -1042,21 +1050,21 @@ static int flock_lock_inode(struct inode *inode, struct file_lock *request) percpu_down_read(&file_rwsem); spin_lock(&ctx->flc_lock); - if (request->fl_flags & FL_ACCESS) + if (request->fl_core.fl_flags & FL_ACCESS) goto find_conflict; list_for_each_entry(fl, &ctx->flc_flock, fl_list) { - if (request->fl_file != fl->fl_file) + if (request->fl_core.fl_file != fl->fl_core.fl_file) continue; - if (request->fl_type == fl->fl_type) + if (request->fl_core.fl_type == fl->fl_core.fl_type) goto out; found = true; locks_delete_lock_ctx(fl, &dispose); break; } - if (request->fl_type == F_UNLCK) { - if ((request->fl_flags & FL_EXISTS) && !found) + if (request->fl_core.fl_type == F_UNLCK) { + if ((request->fl_core.fl_flags & FL_EXISTS) && !found) error = -ENOENT; goto out; } @@ -1066,13 +1074,13 @@ static int flock_lock_inode(struct inode *inode, struct file_lock *request) if (!flock_locks_conflict(request, fl)) continue; error = -EAGAIN; - if (!(request->fl_flags & FL_SLEEP)) + if (!(request->fl_core.fl_flags & FL_SLEEP)) goto out; error = FILE_LOCK_DEFERRED; locks_insert_block(fl, request, flock_locks_conflict); goto out; } - if (request->fl_flags & FL_ACCESS) + if (request->fl_core.fl_flags & FL_ACCESS) goto out; locks_copy_lock(new_fl, request); locks_move_blocks(new_fl, request); @@ -1105,9 +1113,9 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, void *owner; void (*func)(void); - ctx = locks_get_lock_context(inode, request->fl_type); + ctx = locks_get_lock_context(inode, request->fl_core.fl_type); if (!ctx) - return (request->fl_type == F_UNLCK) ? 0 : -ENOMEM; + return (request->fl_core.fl_type == F_UNLCK) ? 0 : -ENOMEM; /* * We may need two file_lock structures for this operation, @@ -1115,8 +1123,8 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, * * In some cases we can be sure, that no new locks will be needed */ - if (!(request->fl_flags & FL_ACCESS) && - (request->fl_type != F_UNLCK || + if (!(request->fl_core.fl_flags & FL_ACCESS) && + (request->fl_core.fl_type != F_UNLCK || request->fl_start != 0 || request->fl_end != OFFSET_MAX)) { new_fl = locks_alloc_lock(); new_fl2 = locks_alloc_lock(); @@ -1130,7 +1138,7 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, * there are any, either return error or put the request on the * blocker's list of waiters and the global blocked_hash. */ - if (request->fl_type != F_UNLCK) { + if (request->fl_core.fl_type != F_UNLCK) { list_for_each_entry(fl, &ctx->flc_posix, fl_list) { if (!posix_locks_conflict(request, fl)) continue; @@ -1148,7 +1156,7 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, if (conflock) locks_copy_conflock(conflock, fl); error = -EAGAIN; - if (!(request->fl_flags & FL_SLEEP)) + if (!(request->fl_core.fl_flags & FL_SLEEP)) goto out; /* * Deadlock detection and insertion into the blocked @@ -1173,7 +1181,7 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, /* If we're just looking for a conflict, we're done. */ error = 0; - if (request->fl_flags & FL_ACCESS) + if (request->fl_core.fl_flags & FL_ACCESS) goto out; /* Find the first old lock with the same owner as the new lock */ @@ -1188,7 +1196,7 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, break; /* Detect adjacent or overlapping regions (if same lock type) */ - if (request->fl_type == fl->fl_type) { + if (request->fl_core.fl_type == fl->fl_core.fl_type) { /* In all comparisons of start vs end, use * "start - 1" rather than "end + 1". If end * is OFFSET_MAX, end + 1 will become negative. @@ -1228,7 +1236,7 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, continue; if (fl->fl_start > request->fl_end) break; - if (request->fl_type == F_UNLCK) + if (request->fl_core.fl_type == F_UNLCK) added = true; if (fl->fl_start < request->fl_start) left = fl; @@ -1261,7 +1269,8 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, locks_move_blocks(new_fl, request); request = new_fl; new_fl = NULL; - locks_insert_lock_ctx(request, &fl->fl_list); + locks_insert_lock_ctx(request, + &fl->fl_core.fl_list); locks_delete_lock_ctx(fl, &dispose); added = true; } @@ -1279,8 +1288,8 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, error = 0; if (!added) { - if (request->fl_type == F_UNLCK) { - if (request->fl_flags & FL_EXISTS) + if (request->fl_core.fl_type == F_UNLCK) { + if (request->fl_core.fl_flags & FL_EXISTS) error = -ENOENT; goto out; } @@ -1291,7 +1300,7 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, } locks_copy_lock(new_fl, request); locks_move_blocks(new_fl, request); - locks_insert_lock_ctx(new_fl, &fl->fl_list); + locks_insert_lock_ctx(new_fl, &fl->fl_core.fl_list); fl = new_fl; new_fl = NULL; } @@ -1303,7 +1312,7 @@ static int posix_lock_inode(struct inode *inode, struct file_lock *request, left = new_fl2; new_fl2 = NULL; locks_copy_lock(left, right); - locks_insert_lock_ctx(left, &fl->fl_list); + locks_insert_lock_ctx(left, &fl->fl_core.fl_list); } right->fl_start = request->fl_end + 1; locks_wake_up_blocks(right); @@ -1364,8 +1373,8 @@ static int posix_lock_inode_wait(struct inode *inode, struct file_lock *fl) error = posix_lock_inode(inode, fl, NULL); if (error != FILE_LOCK_DEFERRED) break; - error = wait_event_interruptible(fl->fl_wait, - list_empty(&fl->fl_blocked_member)); + error = wait_event_interruptible(fl->fl_core.fl_wait, + list_empty(&fl->fl_core.fl_blocked_member)); if (error) break; } @@ -1377,10 +1386,10 @@ static void lease_clear_pending(struct file_lock *fl, int arg) { switch (arg) { case F_UNLCK: - fl->fl_flags &= ~FL_UNLOCK_PENDING; + fl->fl_core.fl_flags &= ~FL_UNLOCK_PENDING; fallthrough; case F_RDLCK: - fl->fl_flags &= ~FL_DOWNGRADE_PENDING; + fl->fl_core.fl_flags &= ~FL_DOWNGRADE_PENDING; } } @@ -1394,11 +1403,11 @@ int lease_modify(struct file_lock *fl, int arg, struct list_head *dispose) lease_clear_pending(fl, arg); locks_wake_up_blocks(fl); if (arg == F_UNLCK) { - struct file *filp = fl->fl_file; + struct file *filp = fl->fl_core.fl_file; f_delown(filp); filp->f_owner.signum = 0; - fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync); + fasync_helper(0, fl->fl_core.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; @@ -1440,11 +1449,11 @@ static bool leases_conflict(struct file_lock *lease, struct file_lock *breaker) if (lease->fl_lmops->lm_breaker_owns_lease && lease->fl_lmops->lm_breaker_owns_lease(lease)) return false; - if ((breaker->fl_flags & FL_LAYOUT) != (lease->fl_flags & FL_LAYOUT)) { + if ((breaker->fl_core.fl_flags & FL_LAYOUT) != (lease->fl_core.fl_flags & FL_LAYOUT)) { rc = false; goto trace; } - if ((breaker->fl_flags & FL_DELEG) && (lease->fl_flags & FL_LEASE)) { + if ((breaker->fl_core.fl_flags & FL_DELEG) && (lease->fl_core.fl_flags & FL_LEASE)) { rc = false; goto trace; } @@ -1495,7 +1504,7 @@ int __break_lease(struct inode *inode, unsigned int mode, unsigned int type) new_fl = lease_alloc(NULL, want_write ? F_WRLCK : F_RDLCK); if (IS_ERR(new_fl)) return PTR_ERR(new_fl); - new_fl->fl_flags = type; + new_fl->fl_core.fl_flags = type; /* typically we will check that ctx is non-NULL before calling */ ctx = locks_inode_context(inode); @@ -1523,14 +1532,14 @@ int __break_lease(struct inode *inode, unsigned int mode, unsigned int type) if (!leases_conflict(fl, new_fl)) continue; if (want_write) { - if (fl->fl_flags & FL_UNLOCK_PENDING) + if (fl->fl_core.fl_flags & FL_UNLOCK_PENDING) continue; - fl->fl_flags |= FL_UNLOCK_PENDING; + fl->fl_core.fl_flags |= FL_UNLOCK_PENDING; fl->fl_break_time = break_time; } else { if (lease_breaking(fl)) continue; - fl->fl_flags |= FL_DOWNGRADE_PENDING; + fl->fl_core.fl_flags |= FL_DOWNGRADE_PENDING; fl->fl_downgrade_time = break_time; } if (fl->fl_lmops->lm_break(fl)) @@ -1559,9 +1568,9 @@ int __break_lease(struct inode *inode, unsigned int mode, unsigned int type) percpu_up_read(&file_rwsem); locks_dispose_list(&dispose); - error = wait_event_interruptible_timeout(new_fl->fl_wait, - list_empty(&new_fl->fl_blocked_member), - break_time); + error = wait_event_interruptible_timeout(new_fl->fl_core.fl_wait, + list_empty(&new_fl->fl_core.fl_blocked_member), + break_time); percpu_down_read(&file_rwsem); spin_lock(&ctx->flc_lock); @@ -1608,7 +1617,7 @@ void lease_get_mtime(struct inode *inode, struct timespec64 *time) spin_lock(&ctx->flc_lock); fl = list_first_entry_or_null(&ctx->flc_lease, struct file_lock, fl_list); - if (fl && (fl->fl_type == F_WRLCK)) + if (fl && (fl->fl_core.fl_type == F_WRLCK)) has_lease = true; spin_unlock(&ctx->flc_lock); } @@ -1655,7 +1664,7 @@ int fcntl_getlease(struct file *filp) spin_lock(&ctx->flc_lock); time_out_leases(inode, &dispose); list_for_each_entry(fl, &ctx->flc_lease, fl_list) { - if (fl->fl_file != filp) + if (fl->fl_core.fl_file != filp) continue; type = target_leasetype(fl); break; @@ -1720,7 +1729,7 @@ generic_add_lease(struct file *filp, int arg, struct file_lock **flp, void **pri struct file_lock *fl, *my_fl = NULL, *lease; struct inode *inode = file_inode(filp); struct file_lock_context *ctx; - bool is_deleg = (*flp)->fl_flags & FL_DELEG; + bool is_deleg = (*flp)->fl_core.fl_flags & FL_DELEG; int error; LIST_HEAD(dispose); @@ -1746,7 +1755,7 @@ generic_add_lease(struct file *filp, int arg, struct file_lock **flp, void **pri percpu_down_read(&file_rwsem); spin_lock(&ctx->flc_lock); time_out_leases(inode, &dispose); - error = check_conflicting_open(filp, arg, lease->fl_flags); + error = check_conflicting_open(filp, arg, lease->fl_core.fl_flags); if (error) goto out; @@ -1760,8 +1769,8 @@ generic_add_lease(struct file *filp, int arg, struct file_lock **flp, void **pri */ error = -EAGAIN; list_for_each_entry(fl, &ctx->flc_lease, fl_list) { - if (fl->fl_file == filp && - fl->fl_owner == lease->fl_owner) { + if (fl->fl_core.fl_file == filp && + fl->fl_core.fl_owner == lease->fl_core.fl_owner) { my_fl = fl; continue; } @@ -1776,7 +1785,7 @@ generic_add_lease(struct file *filp, int arg, struct file_lock **flp, void **pri * 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) + if (fl->fl_core.fl_flags & FL_UNLOCK_PENDING) goto out; } @@ -1803,7 +1812,7 @@ generic_add_lease(struct file *filp, int arg, struct file_lock **flp, void **pri * precedes these checks. */ smp_mb(); - error = check_conflicting_open(filp, arg, lease->fl_flags); + error = check_conflicting_open(filp, arg, lease->fl_core.fl_flags); if (error) { locks_unlink_lock_ctx(lease); goto out; @@ -1840,8 +1849,8 @@ static int generic_delete_lease(struct file *filp, void *owner) percpu_down_read(&file_rwsem); spin_lock(&ctx->flc_lock); list_for_each_entry(fl, &ctx->flc_lease, fl_list) { - if (fl->fl_file == filp && - fl->fl_owner == owner) { + if (fl->fl_core.fl_file == filp && + fl->fl_core.fl_owner == owner) { victim = fl; break; } @@ -2017,8 +2026,8 @@ static int flock_lock_inode_wait(struct inode *inode, struct file_lock *fl) error = flock_lock_inode(inode, fl); if (error != FILE_LOCK_DEFERRED) break; - error = wait_event_interruptible(fl->fl_wait, - list_empty(&fl->fl_blocked_member)); + error = wait_event_interruptible(fl->fl_core.fl_wait, + list_empty(&fl->fl_core.fl_blocked_member)); if (error) break; } @@ -2036,7 +2045,7 @@ static int flock_lock_inode_wait(struct inode *inode, struct file_lock *fl) int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl) { int res = 0; - switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) { + switch (fl->fl_core.fl_flags & (FL_POSIX|FL_FLOCK)) { case FL_POSIX: res = posix_lock_inode_wait(inode, fl); break; @@ -2098,13 +2107,13 @@ SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd) flock_make_lock(f.file, &fl, type); - error = security_file_lock(f.file, fl.fl_type); + error = security_file_lock(f.file, fl.fl_core.fl_type); if (error) goto out_putf; can_sleep = !(cmd & LOCK_NB); if (can_sleep) - fl.fl_flags |= FL_SLEEP; + fl.fl_core.fl_flags |= FL_SLEEP; if (f.file->f_op->flock) error = f.file->f_op->flock(f.file, @@ -2130,7 +2139,7 @@ SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd) */ int vfs_test_lock(struct file *filp, struct file_lock *fl) { - WARN_ON_ONCE(filp != fl->fl_file); + WARN_ON_ONCE(filp != fl->fl_core.fl_file); if (filp->f_op->lock) return filp->f_op->lock(filp, F_GETLK, fl); posix_test_lock(filp, fl); @@ -2153,17 +2162,17 @@ static pid_t locks_translate_pid(struct file_lock *fl, struct pid_namespace *ns) if (IS_OFDLCK(fl)) return -1; if (IS_REMOTELCK(fl)) - return fl->fl_pid; + return fl->fl_core.fl_pid; /* * 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; + return (pid_t) fl->fl_core.fl_pid; rcu_read_lock(); - pid = find_pid_ns(fl->fl_pid, &init_pid_ns); + pid = find_pid_ns(fl->fl_core.fl_pid, &init_pid_ns); vnr = pid_nr_ns(pid, ns); rcu_read_unlock(); return vnr; @@ -2186,7 +2195,7 @@ static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl) 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; + flock->l_type = fl->fl_core.fl_type; return 0; } @@ -2198,7 +2207,7 @@ static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl) 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; + flock->l_type = fl->fl_core.fl_type; } #endif @@ -2227,16 +2236,16 @@ int fcntl_getlk(struct file *filp, unsigned int cmd, struct flock *flock) if (flock->l_pid != 0) goto out; - fl->fl_flags |= FL_OFDLCK; - fl->fl_owner = filp; + fl->fl_core.fl_flags |= FL_OFDLCK; + fl->fl_core.fl_owner = filp; } error = vfs_test_lock(filp, fl); if (error) goto out; - flock->l_type = fl->fl_type; - if (fl->fl_type != F_UNLCK) { + flock->l_type = fl->fl_core.fl_type; + if (fl->fl_core.fl_type != F_UNLCK) { error = posix_lock_to_flock(flock, fl); if (error) goto out; @@ -2283,7 +2292,7 @@ int fcntl_getlk(struct file *filp, unsigned int cmd, struct flock *flock) */ int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf) { - WARN_ON_ONCE(filp != fl->fl_file); + WARN_ON_ONCE(filp != fl->fl_core.fl_file); if (filp->f_op->lock) return filp->f_op->lock(filp, cmd, fl); else @@ -2296,7 +2305,7 @@ static int do_lock_file_wait(struct file *filp, unsigned int cmd, { int error; - error = security_file_lock(filp, fl->fl_type); + error = security_file_lock(filp, fl->fl_core.fl_type); if (error) return error; @@ -2304,8 +2313,8 @@ static int do_lock_file_wait(struct file *filp, unsigned int cmd, error = vfs_lock_file(filp, cmd, fl, NULL); if (error != FILE_LOCK_DEFERRED) break; - error = wait_event_interruptible(fl->fl_wait, - list_empty(&fl->fl_blocked_member)); + error = wait_event_interruptible(fl->fl_core.fl_wait, + list_empty(&fl->fl_core.fl_blocked_member)); if (error) break; } @@ -2318,13 +2327,13 @@ static int do_lock_file_wait(struct file *filp, unsigned int cmd, static int check_fmode_for_setlk(struct file_lock *fl) { - switch (fl->fl_type) { + switch (fl->fl_core.fl_type) { case F_RDLCK: - if (!(fl->fl_file->f_mode & FMODE_READ)) + if (!(fl->fl_core.fl_file->f_mode & FMODE_READ)) return -EBADF; break; case F_WRLCK: - if (!(fl->fl_file->f_mode & FMODE_WRITE)) + if (!(fl->fl_core.fl_file->f_mode & FMODE_WRITE)) return -EBADF; } return 0; @@ -2363,8 +2372,8 @@ int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd, goto out; cmd = F_SETLK; - file_lock->fl_flags |= FL_OFDLCK; - file_lock->fl_owner = filp; + file_lock->fl_core.fl_flags |= FL_OFDLCK; + file_lock->fl_core.fl_owner = filp; break; case F_OFD_SETLKW: error = -EINVAL; @@ -2372,11 +2381,11 @@ int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd, goto out; cmd = F_SETLKW; - file_lock->fl_flags |= FL_OFDLCK; - file_lock->fl_owner = filp; + file_lock->fl_core.fl_flags |= FL_OFDLCK; + file_lock->fl_core.fl_owner = filp; fallthrough; case F_SETLKW: - file_lock->fl_flags |= FL_SLEEP; + file_lock->fl_core.fl_flags |= FL_SLEEP; } error = do_lock_file_wait(filp, cmd, file_lock); @@ -2386,8 +2395,8 @@ int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd, * lock that was just acquired. There is no need to do that when we're * unlocking though, or for OFD locks. */ - if (!error && file_lock->fl_type != F_UNLCK && - !(file_lock->fl_flags & FL_OFDLCK)) { + if (!error && file_lock->fl_core.fl_type != F_UNLCK && + !(file_lock->fl_core.fl_flags & FL_OFDLCK)) { struct files_struct *files = current->files; /* * We need that spin_lock here - it prevents reordering between @@ -2398,7 +2407,7 @@ int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd, f = files_lookup_fd_locked(files, fd); spin_unlock(&files->file_lock); if (f != filp) { - file_lock->fl_type = F_UNLCK; + file_lock->fl_core.fl_type = F_UNLCK; error = do_lock_file_wait(filp, cmd, file_lock); WARN_ON_ONCE(error); error = -EBADF; @@ -2437,16 +2446,16 @@ int fcntl_getlk64(struct file *filp, unsigned int cmd, struct flock64 *flock) if (flock->l_pid != 0) goto out; - fl->fl_flags |= FL_OFDLCK; - fl->fl_owner = filp; + fl->fl_core.fl_flags |= FL_OFDLCK; + fl->fl_core.fl_owner = filp; } error = vfs_test_lock(filp, fl); if (error) goto out; - flock->l_type = fl->fl_type; - if (fl->fl_type != F_UNLCK) + flock->l_type = fl->fl_core.fl_type; + if (fl->fl_core.fl_type != F_UNLCK) posix_lock_to_flock64(flock, fl); out: @@ -2486,8 +2495,8 @@ int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd, goto out; cmd = F_SETLK64; - file_lock->fl_flags |= FL_OFDLCK; - file_lock->fl_owner = filp; + file_lock->fl_core.fl_flags |= FL_OFDLCK; + file_lock->fl_core.fl_owner = filp; break; case F_OFD_SETLKW: error = -EINVAL; @@ -2495,11 +2504,11 @@ int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd, goto out; cmd = F_SETLKW64; - file_lock->fl_flags |= FL_OFDLCK; - file_lock->fl_owner = filp; + file_lock->fl_core.fl_flags |= FL_OFDLCK; + file_lock->fl_core.fl_owner = filp; fallthrough; case F_SETLKW64: - file_lock->fl_flags |= FL_SLEEP; + file_lock->fl_core.fl_flags |= FL_SLEEP; } error = do_lock_file_wait(filp, cmd, file_lock); @@ -2509,8 +2518,8 @@ int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd, * lock that was just acquired. There is no need to do that when we're * unlocking though, or for OFD locks. */ - if (!error && file_lock->fl_type != F_UNLCK && - !(file_lock->fl_flags & FL_OFDLCK)) { + if (!error && file_lock->fl_core.fl_type != F_UNLCK && + !(file_lock->fl_core.fl_flags & FL_OFDLCK)) { struct files_struct *files = current->files; /* * We need that spin_lock here - it prevents reordering between @@ -2521,7 +2530,7 @@ int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd, f = files_lookup_fd_locked(files, fd); spin_unlock(&files->file_lock); if (f != filp) { - file_lock->fl_type = F_UNLCK; + file_lock->fl_core.fl_type = F_UNLCK; error = do_lock_file_wait(filp, cmd, file_lock); WARN_ON_ONCE(error); error = -EBADF; @@ -2555,13 +2564,13 @@ void locks_remove_posix(struct file *filp, fl_owner_t owner) return; locks_init_lock(&lock); - lock.fl_type = F_UNLCK; - lock.fl_flags = FL_POSIX | FL_CLOSE; + lock.fl_core.fl_type = F_UNLCK; + lock.fl_core.fl_flags = FL_POSIX | FL_CLOSE; lock.fl_start = 0; lock.fl_end = OFFSET_MAX; - lock.fl_owner = owner; - lock.fl_pid = current->tgid; - lock.fl_file = filp; + lock.fl_core.fl_owner = owner; + lock.fl_core.fl_pid = current->tgid; + lock.fl_core.fl_file = filp; lock.fl_ops = NULL; lock.fl_lmops = NULL; @@ -2584,7 +2593,7 @@ locks_remove_flock(struct file *filp, struct file_lock_context *flctx) return; flock_make_lock(filp, &fl, F_UNLCK); - fl.fl_flags |= FL_CLOSE; + fl.fl_core.fl_flags |= FL_CLOSE; if (filp->f_op->flock) filp->f_op->flock(filp, F_SETLKW, &fl); @@ -2608,7 +2617,7 @@ locks_remove_lease(struct file *filp, struct file_lock_context *ctx) percpu_down_read(&file_rwsem); spin_lock(&ctx->flc_lock); list_for_each_entry_safe(fl, tmp, &ctx->flc_lease, fl_list) - if (filp == fl->fl_file) + if (filp == fl->fl_core.fl_file) lease_modify(fl, F_UNLCK, &dispose); spin_unlock(&ctx->flc_lock); percpu_up_read(&file_rwsem); @@ -2652,7 +2661,7 @@ void locks_remove_file(struct file *filp) */ int vfs_cancel_lock(struct file *filp, struct file_lock *fl) { - WARN_ON_ONCE(filp != fl->fl_file); + WARN_ON_ONCE(filp != fl->fl_core.fl_file); if (filp->f_op->lock) return filp->f_op->lock(filp, F_CANCELLK, fl); return 0; @@ -2706,8 +2715,8 @@ static void lock_get_status(struct seq_file *f, struct file_lock *fl, * init_pid_ns to get saved lock pid value. */ - if (fl->fl_file != NULL) - inode = file_inode(fl->fl_file); + if (fl->fl_core.fl_file != NULL) + inode = file_inode(fl->fl_core.fl_file); seq_printf(f, "%lld: ", id); @@ -2715,7 +2724,7 @@ static void lock_get_status(struct seq_file *f, struct file_lock *fl, seq_printf(f, "%*s", repeat - 1 + (int)strlen(pfx), pfx); if (IS_POSIX(fl)) { - if (fl->fl_flags & FL_ACCESS) + if (fl->fl_core.fl_flags & FL_ACCESS) seq_puts(f, "ACCESS"); else if (IS_OFDLCK(fl)) seq_puts(f, "OFDLCK"); @@ -2727,21 +2736,21 @@ static void lock_get_status(struct seq_file *f, struct file_lock *fl, } else if (IS_FLOCK(fl)) { seq_puts(f, "FLOCK ADVISORY "); } else if (IS_LEASE(fl)) { - if (fl->fl_flags & FL_DELEG) + if (fl->fl_core.fl_flags & FL_DELEG) seq_puts(f, "DELEG "); else seq_puts(f, "LEASE "); if (lease_breaking(fl)) seq_puts(f, "BREAKING "); - else if (fl->fl_file) + else if (fl->fl_core.fl_file) seq_puts(f, "ACTIVE "); else seq_puts(f, "BREAKER "); } else { seq_puts(f, "UNKNOWN UNKNOWN "); } - type = IS_LEASE(fl) ? target_leasetype(fl) : fl->fl_type; + type = IS_LEASE(fl) ? target_leasetype(fl) : fl->fl_core.fl_type; seq_printf(f, "%s ", (type == F_WRLCK) ? "WRITE" : (type == F_RDLCK) ? "READ" : "UNLCK"); @@ -2768,12 +2777,12 @@ 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) + if (node == NULL || node->fl_core.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) + if (list_entry_is_head(tmp, &node->fl_core.fl_blocker->fl_blocked_requests, fl_blocked_member) || tmp == node) { return NULL; } @@ -2804,17 +2813,18 @@ static int locks_show(struct seq_file *f, void *v) else lock_get_status(f, cur, iter->li_pos, "", level); - if (!list_empty(&cur->fl_blocked_requests)) { + if (!list_empty(&cur->fl_core.fl_blocked_requests)) { /* Turn left */ - cur = list_first_entry_or_null(&cur->fl_blocked_requests, - struct file_lock, fl_blocked_member); + cur = list_first_entry_or_null(&cur->fl_core.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; + while (tmp == NULL && cur->fl_core.fl_blocker != NULL) { + cur = cur->fl_core.fl_blocker; level--; tmp = get_next_blocked_member(cur); } @@ -2833,10 +2843,10 @@ static void __show_fd_locks(struct seq_file *f, list_for_each_entry(fl, head, fl_list) { - if (filp != fl->fl_file) + if (filp != fl->fl_core.fl_file) continue; - if (fl->fl_owner != files && - fl->fl_owner != filp) + if (fl->fl_core.fl_owner != files && + fl->fl_core.fl_owner != filp) continue; (*id)++; diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c index fa1a14def45c..31741967ab95 100644 --- a/fs/nfs/delegation.c +++ b/fs/nfs/delegation.c @@ -157,7 +157,7 @@ static int nfs_delegation_claim_locks(struct nfs4_state *state, const nfs4_state spin_lock(&flctx->flc_lock); restart: list_for_each_entry(fl, list, fl_list) { - if (nfs_file_open_context(fl->fl_file)->state != state) + if (nfs_file_open_context(fl->fl_core.fl_file)->state != state) continue; spin_unlock(&flctx->flc_lock); status = nfs4_lock_delegation_recall(fl, state, stateid); diff --git a/fs/nfs/file.c b/fs/nfs/file.c index 8577ccf621f5..94c56c3d9177 100644 --- a/fs/nfs/file.c +++ b/fs/nfs/file.c @@ -720,15 +720,15 @@ do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) { struct inode *inode = filp->f_mapping->host; int status = 0; - unsigned int saved_type = fl->fl_type; + unsigned int saved_type = fl->fl_core.fl_type; /* Try local locking first */ posix_test_lock(filp, fl); - if (fl->fl_type != F_UNLCK) { + if (fl->fl_core.fl_type != F_UNLCK) { /* found a conflict */ goto out; } - fl->fl_type = saved_type; + fl->fl_core.fl_type = saved_type; if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) goto out_noconflict; @@ -740,7 +740,7 @@ do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) out: return status; out_noconflict: - fl->fl_type = F_UNLCK; + fl->fl_core.fl_type = F_UNLCK; goto out; } @@ -765,7 +765,7 @@ do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) * If we're signalled while cleaning up locks on process exit, we * still need to complete the unlock. */ - if (status < 0 && !(fl->fl_flags & FL_CLOSE)) + if (status < 0 && !(fl->fl_core.fl_flags & FL_CLOSE)) return status; } @@ -832,12 +832,12 @@ int nfs_lock(struct file *filp, int cmd, struct file_lock *fl) int is_local = 0; dprintk("NFS: lock(%pD2, t=%x, fl=%x, r=%lld:%lld)\n", - filp, fl->fl_type, fl->fl_flags, + filp, fl->fl_core.fl_type, fl->fl_core.fl_flags, (long long)fl->fl_start, (long long)fl->fl_end); nfs_inc_stats(inode, NFSIOS_VFSLOCK); - if (fl->fl_flags & FL_RECLAIM) + if (fl->fl_core.fl_flags & FL_RECLAIM) return -ENOGRACE; if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL) @@ -851,7 +851,7 @@ int nfs_lock(struct file *filp, int cmd, struct file_lock *fl) if (IS_GETLK(cmd)) ret = do_getlk(filp, cmd, fl, is_local); - else if (fl->fl_type == F_UNLCK) + else if (fl->fl_core.fl_type == F_UNLCK) ret = do_unlk(filp, cmd, fl, is_local); else ret = do_setlk(filp, cmd, fl, is_local); @@ -869,16 +869,16 @@ int nfs_flock(struct file *filp, int cmd, struct file_lock *fl) int is_local = 0; dprintk("NFS: flock(%pD2, t=%x, fl=%x)\n", - filp, fl->fl_type, fl->fl_flags); + filp, fl->fl_core.fl_type, fl->fl_core.fl_flags); - if (!(fl->fl_flags & FL_FLOCK)) + if (!(fl->fl_core.fl_flags & FL_FLOCK)) return -ENOLCK; if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK) is_local = 1; /* We're simulating flock() locks using posix locks on the server */ - if (fl->fl_type == F_UNLCK) + if (fl->fl_core.fl_type == F_UNLCK) return do_unlk(filp, cmd, fl, is_local); return do_setlk(filp, cmd, fl, is_local); } diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c index 2de66e4e8280..d6d8900d8d83 100644 --- a/fs/nfs/nfs3proc.c +++ b/fs/nfs/nfs3proc.c @@ -963,7 +963,7 @@ nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl) struct nfs_open_context *ctx = nfs_file_open_context(filp); int status; - if (fl->fl_flags & FL_CLOSE) { + if (fl->fl_core.fl_flags & FL_CLOSE) { l_ctx = nfs_get_lock_context(ctx); if (IS_ERR(l_ctx)) l_ctx = NULL; diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c index 23819a756508..a5596007b4d9 100644 --- a/fs/nfs/nfs4proc.c +++ b/fs/nfs/nfs4proc.c @@ -6800,7 +6800,7 @@ static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); switch (status) { case 0: - request->fl_type = F_UNLCK; + request->fl_core.fl_type = F_UNLCK; break; case -NFS4ERR_DENIED: status = 0; @@ -7018,8 +7018,8 @@ static struct rpc_task *nfs4_do_unlck(struct file_lock *fl, /* Ensure this is an unlock - when canceling a lock, the * canceled lock is passed in, and it won't be an unlock. */ - fl->fl_type = F_UNLCK; - if (fl->fl_flags & FL_CLOSE) + fl->fl_core.fl_type = F_UNLCK; + if (fl->fl_core.fl_flags & FL_CLOSE) set_bit(NFS_CONTEXT_UNLOCK, &ctx->flags); data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid); @@ -7045,11 +7045,11 @@ static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock * struct rpc_task *task; struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t); int status = 0; - unsigned char fl_flags = request->fl_flags; + unsigned char fl_flags = request->fl_core.fl_flags; status = nfs4_set_lock_state(state, request); /* Unlock _before_ we do the RPC call */ - request->fl_flags |= FL_EXISTS; + request->fl_core.fl_flags |= FL_EXISTS; /* Exclude nfs_delegation_claim_locks() */ mutex_lock(&sp->so_delegreturn_mutex); /* Exclude nfs4_reclaim_open_stateid() - note nesting! */ @@ -7073,14 +7073,16 @@ static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock * status = -ENOMEM; if (IS_ERR(seqid)) goto out; - task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid); + task = nfs4_do_unlck(request, + nfs_file_open_context(request->fl_core.fl_file), + lsp, seqid); status = PTR_ERR(task); if (IS_ERR(task)) goto out; status = rpc_wait_for_completion_task(task); rpc_put_task(task); out: - request->fl_flags = fl_flags; + request->fl_core.fl_flags = fl_flags; trace_nfs4_unlock(request, state, F_SETLK, status); return status; } @@ -7191,7 +7193,7 @@ static void nfs4_lock_done(struct rpc_task *task, void *calldata) renew_lease(NFS_SERVER(d_inode(data->ctx->dentry)), data->timestamp); if (data->arg.new_lock && !data->cancelled) { - data->fl.fl_flags &= ~(FL_SLEEP | FL_ACCESS); + data->fl.fl_core.fl_flags &= ~(FL_SLEEP | FL_ACCESS); if (locks_lock_inode_wait(lsp->ls_state->inode, &data->fl) < 0) goto out_restart; } @@ -7292,7 +7294,8 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *f if (nfs_server_capable(state->inode, NFS_CAP_MOVEABLE)) task_setup_data.flags |= RPC_TASK_MOVEABLE; - data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file), + data = nfs4_alloc_lockdata(fl, + nfs_file_open_context(fl->fl_core.fl_file), fl->fl_u.nfs4_fl.owner, GFP_KERNEL); if (data == NULL) return -ENOMEM; @@ -7398,10 +7401,10 @@ static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock { struct nfs_inode *nfsi = NFS_I(state->inode); struct nfs4_state_owner *sp = state->owner; - unsigned char fl_flags = request->fl_flags; + unsigned char fl_flags = request->fl_core.fl_flags; int status; - request->fl_flags |= FL_ACCESS; + request->fl_core.fl_flags |= FL_ACCESS; status = locks_lock_inode_wait(state->inode, request); if (status < 0) goto out; @@ -7410,7 +7413,7 @@ static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock if (test_bit(NFS_DELEGATED_STATE, &state->flags)) { /* Yes: cache locks! */ /* ...but avoid races with delegation recall... */ - request->fl_flags = fl_flags & ~FL_SLEEP; + request->fl_core.fl_flags = fl_flags & ~FL_SLEEP; status = locks_lock_inode_wait(state->inode, request); up_read(&nfsi->rwsem); mutex_unlock(&sp->so_delegreturn_mutex); @@ -7420,7 +7423,7 @@ static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock mutex_unlock(&sp->so_delegreturn_mutex); status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW); out: - request->fl_flags = fl_flags; + request->fl_core.fl_flags = fl_flags; return status; } @@ -7562,7 +7565,7 @@ nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request) if (!(IS_SETLK(cmd) || IS_SETLKW(cmd))) return -EINVAL; - if (request->fl_type == F_UNLCK) { + if (request->fl_core.fl_type == F_UNLCK) { if (state != NULL) return nfs4_proc_unlck(state, cmd, request); return 0; @@ -7571,7 +7574,7 @@ nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request) if (state == NULL) return -ENOLCK; - if ((request->fl_flags & FL_POSIX) && + if ((request->fl_core.fl_flags & FL_POSIX) && !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags)) return -ENOLCK; @@ -7579,7 +7582,7 @@ nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request) * Don't rely on the VFS having checked the file open mode, * since it won't do this for flock() locks. */ - switch (request->fl_type) { + switch (request->fl_core.fl_type) { case F_RDLCK: if (!(filp->f_mode & FMODE_READ)) return -EBADF; diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c index 9a5d911a7edc..a148b6ac4713 100644 --- a/fs/nfs/nfs4state.c +++ b/fs/nfs/nfs4state.c @@ -980,7 +980,7 @@ int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl) if (fl->fl_ops != NULL) return 0; - lsp = nfs4_get_lock_state(state, fl->fl_owner); + lsp = nfs4_get_lock_state(state, fl->fl_core.fl_owner); if (lsp == NULL) return -ENOMEM; fl->fl_u.nfs4_fl.owner = lsp; @@ -1530,7 +1530,7 @@ static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_ spin_lock(&flctx->flc_lock); restart: list_for_each_entry(fl, list, fl_list) { - if (nfs_file_open_context(fl->fl_file)->state != state) + if (nfs_file_open_context(fl->fl_core.fl_file)->state != state) continue; spin_unlock(&flctx->flc_lock); status = ops->recover_lock(state, fl); diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c index 69406e60f391..25964af5bb80 100644 --- a/fs/nfs/nfs4xdr.c +++ b/fs/nfs/nfs4xdr.c @@ -1305,7 +1305,7 @@ static void encode_link(struct xdr_stream *xdr, const struct qstr *name, struct static inline int nfs4_lock_type(struct file_lock *fl, int block) { - if (fl->fl_type == F_RDLCK) + if (fl->fl_core.fl_type == F_RDLCK) return block ? NFS4_READW_LT : NFS4_READ_LT; return block ? NFS4_WRITEW_LT : NFS4_WRITE_LT; } @@ -5052,10 +5052,10 @@ static int decode_lock_denied (struct xdr_stream *xdr, struct file_lock *fl) fl->fl_end = fl->fl_start + (loff_t)length - 1; if (length == ~(uint64_t)0) fl->fl_end = OFFSET_MAX; - fl->fl_type = F_WRLCK; + fl->fl_core.fl_type = F_WRLCK; if (type & 1) - fl->fl_type = F_RDLCK; - fl->fl_pid = 0; + fl->fl_core.fl_type = F_RDLCK; + fl->fl_core.fl_pid = 0; } p = xdr_decode_hyper(p, &clientid); /* read 8 bytes */ namelen = be32_to_cpup(p); /* read 4 bytes */ /* have read all 32 bytes now */ diff --git a/fs/nfs/write.c b/fs/nfs/write.c index bb79d3a886ae..a096c84c4678 100644 --- a/fs/nfs/write.c +++ b/fs/nfs/write.c @@ -1301,7 +1301,7 @@ static bool is_whole_file_wrlock(struct file_lock *fl) { return fl->fl_start == 0 && fl->fl_end == OFFSET_MAX && - fl->fl_type == F_WRLCK; + fl->fl_core.fl_type == F_WRLCK; } /* If we know the page is up to date, and we're not using byte range locks (or @@ -1341,7 +1341,7 @@ static int nfs_can_extend_write(struct file *file, struct folio *folio, } else if (!list_empty(&flctx->flc_flock)) { fl = list_first_entry(&flctx->flc_flock, struct file_lock, fl_list); - if (fl->fl_type == F_WRLCK) + if (fl->fl_core.fl_type == F_WRLCK) ret = 1; } spin_unlock(&flctx->flc_lock); diff --git a/fs/nfsd/filecache.c b/fs/nfsd/filecache.c index 9cb7f0c33df5..0300dae3e11f 100644 --- a/fs/nfsd/filecache.c +++ b/fs/nfsd/filecache.c @@ -662,8 +662,8 @@ nfsd_file_lease_notifier_call(struct notifier_block *nb, unsigned long arg, struct file_lock *fl = data; /* Only close files for F_SETLEASE leases */ - if (fl->fl_flags & FL_LEASE) - nfsd_file_close_inode(file_inode(fl->fl_file)); + if (fl->fl_core.fl_flags & FL_LEASE) + nfsd_file_close_inode(file_inode(fl->fl_core.fl_file)); return 0; } diff --git a/fs/nfsd/nfs4layouts.c b/fs/nfsd/nfs4layouts.c index 5e8096bc5eaa..4bef3349bd90 100644 --- a/fs/nfsd/nfs4layouts.c +++ b/fs/nfsd/nfs4layouts.c @@ -193,14 +193,15 @@ nfsd4_layout_setlease(struct nfs4_layout_stateid *ls) return -ENOMEM; locks_init_lock(fl); fl->fl_lmops = &nfsd4_layouts_lm_ops; - fl->fl_flags = FL_LAYOUT; - fl->fl_type = F_RDLCK; + fl->fl_core.fl_flags = FL_LAYOUT; + fl->fl_core.fl_type = F_RDLCK; fl->fl_end = OFFSET_MAX; - fl->fl_owner = ls; - fl->fl_pid = current->tgid; - fl->fl_file = ls->ls_file->nf_file; + fl->fl_core.fl_owner = ls; + fl->fl_core.fl_pid = current->tgid; + fl->fl_core.fl_file = ls->ls_file->nf_file; - status = vfs_setlease(fl->fl_file, fl->fl_type, &fl, NULL); + status = vfs_setlease(fl->fl_core.fl_file, fl->fl_core.fl_type, &fl, + NULL); if (status) { locks_free_lock(fl); return status; @@ -731,7 +732,7 @@ nfsd4_layout_lm_break(struct file_lock *fl) * in time: */ fl->fl_break_time = 0; - nfsd4_recall_file_layout(fl->fl_owner); + nfsd4_recall_file_layout(fl->fl_core.fl_owner); return false; } diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c index 2fa54cfd4882..a6089dbcee9d 100644 --- a/fs/nfsd/nfs4state.c +++ b/fs/nfsd/nfs4state.c @@ -4924,7 +4924,7 @@ static void nfsd_break_one_deleg(struct nfs4_delegation *dp) static bool nfsd_break_deleg_cb(struct file_lock *fl) { - struct nfs4_delegation *dp = (struct nfs4_delegation *)fl->fl_owner; + struct nfs4_delegation *dp = (struct nfs4_delegation *) fl->fl_core.fl_owner; struct nfs4_file *fp = dp->dl_stid.sc_file; struct nfs4_client *clp = dp->dl_stid.sc_client; struct nfsd_net *nn; @@ -4962,7 +4962,7 @@ nfsd_break_deleg_cb(struct file_lock *fl) */ static bool nfsd_breaker_owns_lease(struct file_lock *fl) { - struct nfs4_delegation *dl = fl->fl_owner; + struct nfs4_delegation *dl = fl->fl_core.fl_owner; struct svc_rqst *rqst; struct nfs4_client *clp; @@ -4980,7 +4980,7 @@ static int nfsd_change_deleg_cb(struct file_lock *onlist, int arg, struct list_head *dispose) { - struct nfs4_delegation *dp = (struct nfs4_delegation *)onlist->fl_owner; + struct nfs4_delegation *dp = (struct nfs4_delegation *) onlist->fl_core.fl_owner; struct nfs4_client *clp = dp->dl_stid.sc_client; if (arg & F_UNLCK) { @@ -5340,12 +5340,12 @@ static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, if (!fl) return NULL; fl->fl_lmops = &nfsd_lease_mng_ops; - fl->fl_flags = FL_DELEG; - fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK; + fl->fl_core.fl_flags = FL_DELEG; + fl->fl_core.fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK; fl->fl_end = OFFSET_MAX; - fl->fl_owner = (fl_owner_t)dp; - fl->fl_pid = current->tgid; - fl->fl_file = dp->dl_stid.sc_file->fi_deleg_file->nf_file; + fl->fl_core.fl_owner = (fl_owner_t)dp; + fl->fl_core.fl_pid = current->tgid; + fl->fl_core.fl_file = dp->dl_stid.sc_file->fi_deleg_file->nf_file; return fl; } @@ -5533,7 +5533,8 @@ nfs4_set_delegation(struct nfsd4_open *open, struct nfs4_ol_stateid *stp, if (!fl) goto out_clnt_odstate; - status = vfs_setlease(fp->fi_deleg_file->nf_file, fl->fl_type, &fl, NULL); + status = vfs_setlease(fp->fi_deleg_file->nf_file, fl->fl_core.fl_type, + &fl, NULL); if (fl) locks_free_lock(fl); if (status) @@ -7149,7 +7150,7 @@ nfsd4_lm_put_owner(fl_owner_t owner) static bool nfsd4_lm_lock_expirable(struct file_lock *cfl) { - struct nfs4_lockowner *lo = (struct nfs4_lockowner *)cfl->fl_owner; + struct nfs4_lockowner *lo = (struct nfs4_lockowner *) cfl->fl_core.fl_owner; struct nfs4_client *clp = lo->lo_owner.so_client; struct nfsd_net *nn; @@ -7171,7 +7172,7 @@ nfsd4_lm_expire_lock(void) static void nfsd4_lm_notify(struct file_lock *fl) { - struct nfs4_lockowner *lo = (struct nfs4_lockowner *)fl->fl_owner; + struct nfs4_lockowner *lo = (struct nfs4_lockowner *) fl->fl_core.fl_owner; struct net *net = lo->lo_owner.so_client->net; struct nfsd_net *nn = net_generic(net, nfsd_net_id); struct nfsd4_blocked_lock *nbl = container_of(fl, @@ -7208,7 +7209,7 @@ nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny) struct nfs4_lockowner *lo; if (fl->fl_lmops == &nfsd_posix_mng_ops) { - lo = (struct nfs4_lockowner *) fl->fl_owner; + lo = (struct nfs4_lockowner *) fl->fl_core.fl_owner; xdr_netobj_dup(&deny->ld_owner, &lo->lo_owner.so_owner, GFP_KERNEL); if (!deny->ld_owner.data) @@ -7227,7 +7228,7 @@ nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny) if (fl->fl_end != NFS4_MAX_UINT64) deny->ld_length = fl->fl_end - fl->fl_start + 1; deny->ld_type = NFS4_READ_LT; - if (fl->fl_type != F_RDLCK) + if (fl->fl_core.fl_type != F_RDLCK) deny->ld_type = NFS4_WRITE_LT; } @@ -7615,11 +7616,11 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, } file_lock = &nbl->nbl_lock; - file_lock->fl_type = fl_type; - file_lock->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(&lock_sop->lo_owner)); - file_lock->fl_pid = current->tgid; - file_lock->fl_file = nf->nf_file; - file_lock->fl_flags = fl_flags; + file_lock->fl_core.fl_type = fl_type; + file_lock->fl_core.fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(&lock_sop->lo_owner)); + file_lock->fl_core.fl_pid = current->tgid; + file_lock->fl_core.fl_file = nf->nf_file; + file_lock->fl_core.fl_flags = fl_flags; file_lock->fl_lmops = &nfsd_posix_mng_ops; file_lock->fl_start = lock->lk_offset; file_lock->fl_end = last_byte_offset(lock->lk_offset, lock->lk_length); @@ -7737,9 +7738,9 @@ static __be32 nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct err = nfserrno(nfsd_open_break_lease(inode, NFSD_MAY_READ)); if (err) goto out; - lock->fl_file = nf->nf_file; + lock->fl_core.fl_file = nf->nf_file; err = nfserrno(vfs_test_lock(nf->nf_file, lock)); - lock->fl_file = NULL; + lock->fl_core.fl_file = NULL; out: inode_unlock(inode); nfsd_file_put(nf); @@ -7784,11 +7785,11 @@ nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, switch (lockt->lt_type) { case NFS4_READ_LT: case NFS4_READW_LT: - file_lock->fl_type = F_RDLCK; + file_lock->fl_core.fl_type = F_RDLCK; break; case NFS4_WRITE_LT: case NFS4_WRITEW_LT: - file_lock->fl_type = F_WRLCK; + file_lock->fl_core.fl_type = F_WRLCK; break; default: dprintk("NFSD: nfs4_lockt: bad lock type!\n"); @@ -7798,9 +7799,9 @@ nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, lo = find_lockowner_str(cstate->clp, &lockt->lt_owner); if (lo) - file_lock->fl_owner = (fl_owner_t)lo; - file_lock->fl_pid = current->tgid; - file_lock->fl_flags = FL_POSIX; + file_lock->fl_core.fl_owner = (fl_owner_t)lo; + file_lock->fl_core.fl_pid = current->tgid; + file_lock->fl_core.fl_flags = FL_POSIX; file_lock->fl_start = lockt->lt_offset; file_lock->fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length); @@ -7811,7 +7812,7 @@ nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, if (status) goto out; - if (file_lock->fl_type != F_UNLCK) { + if (file_lock->fl_core.fl_type != F_UNLCK) { status = nfserr_denied; nfs4_set_lock_denied(file_lock, &lockt->lt_denied); } @@ -7867,11 +7868,11 @@ nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, goto put_file; } - file_lock->fl_type = F_UNLCK; - file_lock->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(stp->st_stateowner)); - file_lock->fl_pid = current->tgid; - file_lock->fl_file = nf->nf_file; - file_lock->fl_flags = FL_POSIX; + file_lock->fl_core.fl_type = F_UNLCK; + file_lock->fl_core.fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(stp->st_stateowner)); + file_lock->fl_core.fl_pid = current->tgid; + file_lock->fl_core.fl_file = nf->nf_file; + file_lock->fl_core.fl_flags = FL_POSIX; file_lock->fl_lmops = &nfsd_posix_mng_ops; file_lock->fl_start = locku->lu_offset; @@ -7927,7 +7928,7 @@ check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner) if (flctx && !list_empty_careful(&flctx->flc_posix)) { spin_lock(&flctx->flc_lock); list_for_each_entry(fl, &flctx->flc_posix, fl_list) { - if (fl->fl_owner == (fl_owner_t)lowner) { + if (fl->fl_core.fl_owner == (fl_owner_t)lowner) { status = true; break; } @@ -8456,7 +8457,7 @@ nfsd4_deleg_getattr_conflict(struct svc_rqst *rqstp, struct inode *inode) return 0; spin_lock(&ctx->flc_lock); list_for_each_entry(fl, &ctx->flc_lease, fl_list) { - if (fl->fl_flags == FL_LAYOUT) + if (fl->fl_core.fl_flags == FL_LAYOUT) continue; if (fl->fl_lmops != &nfsd_lease_mng_ops) { /* @@ -8464,12 +8465,12 @@ nfsd4_deleg_getattr_conflict(struct svc_rqst *rqstp, struct inode *inode) * we are done; there isn't any write delegation * on this inode */ - if (fl->fl_type == F_RDLCK) + if (fl->fl_core.fl_type == F_RDLCK) break; goto break_lease; } - if (fl->fl_type == F_WRLCK) { - dp = fl->fl_owner; + if (fl->fl_core.fl_type == F_WRLCK) { + dp = fl->fl_core.fl_owner; if (dp->dl_recall.cb_clp == *(rqstp->rq_lease_breaker)) { spin_unlock(&ctx->flc_lock); return 0; diff --git a/fs/ocfs2/locks.c b/fs/ocfs2/locks.c index f37174e79fad..30f7af75d18d 100644 --- a/fs/ocfs2/locks.c +++ b/fs/ocfs2/locks.c @@ -27,7 +27,7 @@ static int ocfs2_do_flock(struct file *file, struct inode *inode, struct ocfs2_file_private *fp = file->private_data; struct ocfs2_lock_res *lockres = &fp->fp_flock; - if (fl->fl_type == F_WRLCK) + if (fl->fl_core.fl_type == F_WRLCK) level = 1; if (!IS_SETLKW(cmd)) trylock = 1; @@ -53,8 +53,8 @@ static int ocfs2_do_flock(struct file *file, struct inode *inode, */ locks_init_lock(&request); - request.fl_type = F_UNLCK; - request.fl_flags = FL_FLOCK; + request.fl_core.fl_type = F_UNLCK; + request.fl_core.fl_flags = FL_FLOCK; locks_lock_file_wait(file, &request); ocfs2_file_unlock(file); @@ -100,14 +100,14 @@ int ocfs2_flock(struct file *file, int cmd, struct file_lock *fl) struct inode *inode = file->f_mapping->host; struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); - if (!(fl->fl_flags & FL_FLOCK)) + if (!(fl->fl_core.fl_flags & FL_FLOCK)) return -ENOLCK; if ((osb->s_mount_opt & OCFS2_MOUNT_LOCALFLOCKS) || ocfs2_mount_local(osb)) return locks_lock_file_wait(file, fl); - if (fl->fl_type == F_UNLCK) + if (fl->fl_core.fl_type == F_UNLCK) return ocfs2_do_funlock(file, cmd, fl); else return ocfs2_do_flock(file, inode, cmd, fl); @@ -118,7 +118,7 @@ int ocfs2_lock(struct file *file, int cmd, struct file_lock *fl) struct inode *inode = file->f_mapping->host; struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); - if (!(fl->fl_flags & FL_POSIX)) + if (!(fl->fl_core.fl_flags & FL_POSIX)) return -ENOLCK; return ocfs2_plock(osb->cconn, OCFS2_I(inode)->ip_blkno, file, cmd, fl); diff --git a/fs/ocfs2/stack_user.c b/fs/ocfs2/stack_user.c index 9b76ee66aeb2..c66a688dea96 100644 --- a/fs/ocfs2/stack_user.c +++ b/fs/ocfs2/stack_user.c @@ -744,7 +744,7 @@ static int user_plock(struct ocfs2_cluster_connection *conn, return dlm_posix_cancel(conn->cc_lockspace, ino, file, fl); else if (IS_GETLK(cmd)) return dlm_posix_get(conn->cc_lockspace, ino, file, fl); - else if (fl->fl_type == F_UNLCK) + else if (fl->fl_core.fl_type == F_UNLCK) return dlm_posix_unlock(conn->cc_lockspace, ino, file, fl); else return dlm_posix_lock(conn->cc_lockspace, ino, file, cmd, fl); diff --git a/fs/smb/client/cifssmb.c b/fs/smb/client/cifssmb.c index 01e89070df5a..7140c2baa652 100644 --- a/fs/smb/client/cifssmb.c +++ b/fs/smb/client/cifssmb.c @@ -2066,20 +2066,20 @@ CIFSSMBPosixLock(const unsigned int xid, struct cifs_tcon *tcon, parm_data = (struct cifs_posix_lock *) ((char *)&pSMBr->hdr.Protocol + data_offset); if (parm_data->lock_type == cpu_to_le16(CIFS_UNLCK)) - pLockData->fl_type = F_UNLCK; + pLockData->fl_core.fl_type = F_UNLCK; else { if (parm_data->lock_type == cpu_to_le16(CIFS_RDLCK)) - pLockData->fl_type = F_RDLCK; + pLockData->fl_core.fl_type = F_RDLCK; else if (parm_data->lock_type == cpu_to_le16(CIFS_WRLCK)) - pLockData->fl_type = F_WRLCK; + pLockData->fl_core.fl_type = F_WRLCK; pLockData->fl_start = le64_to_cpu(parm_data->start); pLockData->fl_end = pLockData->fl_start + (le64_to_cpu(parm_data->length) ? le64_to_cpu(parm_data->length) - 1 : 0); - pLockData->fl_pid = -le32_to_cpu(parm_data->pid); + pLockData->fl_core.fl_pid = -le32_to_cpu(parm_data->pid); } } diff --git a/fs/smb/client/file.c b/fs/smb/client/file.c index 1b4262aff8fa..1305183842fd 100644 --- a/fs/smb/client/file.c +++ b/fs/smb/client/file.c @@ -1312,20 +1312,20 @@ cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length, down_read(&cinode->lock_sem); exist = cifs_find_lock_conflict(cfile, offset, length, type, - flock->fl_flags, &conf_lock, + flock->fl_core.fl_flags, &conf_lock, CIFS_LOCK_OP); if (exist) { flock->fl_start = conf_lock->offset; flock->fl_end = conf_lock->offset + conf_lock->length - 1; - flock->fl_pid = conf_lock->pid; + flock->fl_core.fl_pid = conf_lock->pid; if (conf_lock->type & server->vals->shared_lock_type) - flock->fl_type = F_RDLCK; + flock->fl_core.fl_type = F_RDLCK; else - flock->fl_type = F_WRLCK; + flock->fl_core.fl_type = F_WRLCK; } else if (!cinode->can_cache_brlcks) rc = 1; else - flock->fl_type = F_UNLCK; + flock->fl_core.fl_type = F_UNLCK; up_read(&cinode->lock_sem); return rc; @@ -1401,16 +1401,16 @@ cifs_posix_lock_test(struct file *file, struct file_lock *flock) { int rc = 0; struct cifsInodeInfo *cinode = CIFS_I(file_inode(file)); - unsigned char saved_type = flock->fl_type; + unsigned char saved_type = flock->fl_core.fl_type; - if ((flock->fl_flags & FL_POSIX) == 0) + if ((flock->fl_core.fl_flags & FL_POSIX) == 0) return 1; down_read(&cinode->lock_sem); posix_test_lock(file, flock); - if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) { - flock->fl_type = saved_type; + if (flock->fl_core.fl_type == F_UNLCK && !cinode->can_cache_brlcks) { + flock->fl_core.fl_type = saved_type; rc = 1; } @@ -1431,7 +1431,7 @@ cifs_posix_lock_set(struct file *file, struct file_lock *flock) struct cifsInodeInfo *cinode = CIFS_I(file_inode(file)); int rc = FILE_LOCK_DEFERRED + 1; - if ((flock->fl_flags & FL_POSIX) == 0) + if ((flock->fl_core.fl_flags & FL_POSIX) == 0) return rc; cifs_down_write(&cinode->lock_sem); @@ -1591,12 +1591,12 @@ cifs_push_posix_locks(struct cifsFileInfo *cfile) break; } length = cifs_flock_len(flock); - if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK) + if (flock->fl_core.fl_type == F_RDLCK || flock->fl_core.fl_type == F_SHLCK) type = CIFS_RDLCK; else type = CIFS_WRLCK; lck = list_entry(el, struct lock_to_push, llist); - lck->pid = hash_lockowner(flock->fl_owner); + lck->pid = hash_lockowner(flock->fl_core.fl_owner); lck->netfid = cfile->fid.netfid; lck->length = length; lck->type = type; @@ -1663,42 +1663,43 @@ static void cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock, bool *wait_flag, struct TCP_Server_Info *server) { - if (flock->fl_flags & FL_POSIX) + if (flock->fl_core.fl_flags & FL_POSIX) cifs_dbg(FYI, "Posix\n"); - if (flock->fl_flags & FL_FLOCK) + if (flock->fl_core.fl_flags & FL_FLOCK) cifs_dbg(FYI, "Flock\n"); - if (flock->fl_flags & FL_SLEEP) { + if (flock->fl_core.fl_flags & FL_SLEEP) { cifs_dbg(FYI, "Blocking lock\n"); *wait_flag = true; } - if (flock->fl_flags & FL_ACCESS) + if (flock->fl_core.fl_flags & FL_ACCESS) cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n"); - if (flock->fl_flags & FL_LEASE) + if (flock->fl_core.fl_flags & FL_LEASE) cifs_dbg(FYI, "Lease on file - not implemented yet\n"); - if (flock->fl_flags & + if (flock->fl_core.fl_flags & (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE | FL_CLOSE | FL_OFDLCK))) - cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags); + cifs_dbg(FYI, "Unknown lock flags 0x%x\n", + flock->fl_core.fl_flags); *type = server->vals->large_lock_type; - if (flock->fl_type == F_WRLCK) { + if (flock->fl_core.fl_type == F_WRLCK) { cifs_dbg(FYI, "F_WRLCK\n"); *type |= server->vals->exclusive_lock_type; *lock = 1; - } else if (flock->fl_type == F_UNLCK) { + } else if (flock->fl_core.fl_type == F_UNLCK) { cifs_dbg(FYI, "F_UNLCK\n"); *type |= server->vals->unlock_lock_type; *unlock = 1; /* Check if unlock includes more than one lock range */ - } else if (flock->fl_type == F_RDLCK) { + } else if (flock->fl_core.fl_type == F_RDLCK) { cifs_dbg(FYI, "F_RDLCK\n"); *type |= server->vals->shared_lock_type; *lock = 1; - } else if (flock->fl_type == F_EXLCK) { + } else if (flock->fl_core.fl_type == F_EXLCK) { cifs_dbg(FYI, "F_EXLCK\n"); *type |= server->vals->exclusive_lock_type; *lock = 1; - } else if (flock->fl_type == F_SHLCK) { + } else if (flock->fl_core.fl_type == F_SHLCK) { cifs_dbg(FYI, "F_SHLCK\n"); *type |= server->vals->shared_lock_type; *lock = 1; @@ -1730,7 +1731,7 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type, else posix_lock_type = CIFS_WRLCK; rc = CIFSSMBPosixLock(xid, tcon, netfid, - hash_lockowner(flock->fl_owner), + hash_lockowner(flock->fl_core.fl_owner), flock->fl_start, length, flock, posix_lock_type, wait_flag); return rc; @@ -1747,7 +1748,7 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type, if (rc == 0) { rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type, 0, 1, false); - flock->fl_type = F_UNLCK; + flock->fl_core.fl_type = F_UNLCK; if (rc != 0) cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n", rc); @@ -1755,7 +1756,7 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type, } if (type & server->vals->shared_lock_type) { - flock->fl_type = F_WRLCK; + flock->fl_core.fl_type = F_WRLCK; return 0; } @@ -1767,12 +1768,12 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type, if (rc == 0) { rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type | server->vals->shared_lock_type, 0, 1, false); - flock->fl_type = F_RDLCK; + flock->fl_core.fl_type = F_RDLCK; if (rc != 0) cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n", rc); } else - flock->fl_type = F_WRLCK; + flock->fl_core.fl_type = F_WRLCK; return 0; } @@ -1940,7 +1941,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type, posix_lock_type = CIFS_UNLCK; rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid, - hash_lockowner(flock->fl_owner), + hash_lockowner(flock->fl_core.fl_owner), flock->fl_start, length, NULL, posix_lock_type, wait_flag); goto out; @@ -1950,7 +1951,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type, struct cifsLockInfo *lock; lock = cifs_lock_init(flock->fl_start, length, type, - flock->fl_flags); + flock->fl_core.fl_flags); if (!lock) return -ENOMEM; @@ -1989,7 +1990,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type, rc = server->ops->mand_unlock_range(cfile, flock, xid); out: - if ((flock->fl_flags & FL_POSIX) || (flock->fl_flags & FL_FLOCK)) { + if ((flock->fl_core.fl_flags & FL_POSIX) || (flock->fl_core.fl_flags & FL_FLOCK)) { /* * If this is a request to remove all locks because we * are closing the file, it doesn't matter if the @@ -1998,7 +1999,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type, */ if (rc) { cifs_dbg(VFS, "%s failed rc=%d\n", __func__, rc); - if (!(flock->fl_flags & FL_CLOSE)) + if (!(flock->fl_core.fl_flags & FL_CLOSE)) return rc; } rc = locks_lock_file_wait(file, flock); @@ -2019,7 +2020,7 @@ int cifs_flock(struct file *file, int cmd, struct file_lock *fl) xid = get_xid(); - if (!(fl->fl_flags & FL_FLOCK)) { + if (!(fl->fl_core.fl_flags & FL_FLOCK)) { rc = -ENOLCK; free_xid(xid); return rc; @@ -2070,7 +2071,8 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *flock) xid = get_xid(); cifs_dbg(FYI, "%s: %pD2 cmd=0x%x type=0x%x flags=0x%x r=%lld:%lld\n", __func__, file, cmd, - flock->fl_flags, flock->fl_type, (long long)flock->fl_start, + flock->fl_core.fl_flags, flock->fl_core.fl_type, + (long long)flock->fl_start, (long long)flock->fl_end); cfile = (struct cifsFileInfo *)file->private_data; diff --git a/fs/smb/client/smb2file.c b/fs/smb/client/smb2file.c index e0ee96d69d49..39262617f551 100644 --- a/fs/smb/client/smb2file.c +++ b/fs/smb/client/smb2file.c @@ -228,7 +228,7 @@ smb2_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, * flock and OFD lock are associated with an open * file description, not the process. */ - if (!(flock->fl_flags & (FL_FLOCK | FL_OFDLCK))) + if (!(flock->fl_core.fl_flags & (FL_FLOCK | FL_OFDLCK))) continue; if (cinode->can_cache_brlcks) { /* diff --git a/fs/smb/server/smb2pdu.c b/fs/smb/server/smb2pdu.c index 3143819935dc..439f68cee402 100644 --- a/fs/smb/server/smb2pdu.c +++ b/fs/smb/server/smb2pdu.c @@ -6748,10 +6748,10 @@ struct file_lock *smb_flock_init(struct file *f) locks_init_lock(fl); - fl->fl_owner = f; - fl->fl_pid = current->tgid; - fl->fl_file = f; - fl->fl_flags = FL_POSIX; + fl->fl_core.fl_owner = f; + fl->fl_core.fl_pid = current->tgid; + fl->fl_core.fl_file = f; + fl->fl_core.fl_flags = FL_POSIX; fl->fl_ops = NULL; fl->fl_lmops = NULL; @@ -6768,30 +6768,30 @@ static int smb2_set_flock_flags(struct file_lock *flock, int flags) case SMB2_LOCKFLAG_SHARED: ksmbd_debug(SMB, "received shared request\n"); cmd = F_SETLKW; - flock->fl_type = F_RDLCK; - flock->fl_flags |= FL_SLEEP; + flock->fl_core.fl_type = F_RDLCK; + flock->fl_core.fl_flags |= FL_SLEEP; break; case SMB2_LOCKFLAG_EXCLUSIVE: ksmbd_debug(SMB, "received exclusive request\n"); cmd = F_SETLKW; - flock->fl_type = F_WRLCK; - flock->fl_flags |= FL_SLEEP; + flock->fl_core.fl_type = F_WRLCK; + flock->fl_core.fl_flags |= FL_SLEEP; break; case SMB2_LOCKFLAG_SHARED | SMB2_LOCKFLAG_FAIL_IMMEDIATELY: ksmbd_debug(SMB, "received shared & fail immediately request\n"); cmd = F_SETLK; - flock->fl_type = F_RDLCK; + flock->fl_core.fl_type = F_RDLCK; break; case SMB2_LOCKFLAG_EXCLUSIVE | SMB2_LOCKFLAG_FAIL_IMMEDIATELY: ksmbd_debug(SMB, "received exclusive & fail immediately request\n"); cmd = F_SETLK; - flock->fl_type = F_WRLCK; + flock->fl_core.fl_type = F_WRLCK; break; case SMB2_LOCKFLAG_UNLOCK: ksmbd_debug(SMB, "received unlock request\n"); - flock->fl_type = F_UNLCK; + flock->fl_core.fl_type = F_UNLCK; cmd = F_SETLK; break; } @@ -6829,13 +6829,13 @@ static void smb2_remove_blocked_lock(void **argv) struct file_lock *flock = (struct file_lock *)argv[0]; ksmbd_vfs_posix_lock_unblock(flock); - wake_up(&flock->fl_wait); + wake_up(&flock->fl_core.fl_wait); } static inline bool lock_defer_pending(struct file_lock *fl) { /* check pending lock waiters */ - return waitqueue_active(&fl->fl_wait); + return waitqueue_active(&fl->fl_core.fl_wait); } /** @@ -6926,8 +6926,8 @@ int smb2_lock(struct ksmbd_work *work) list_for_each_entry(cmp_lock, &lock_list, llist) { if (cmp_lock->fl->fl_start <= flock->fl_start && cmp_lock->fl->fl_end >= flock->fl_end) { - if (cmp_lock->fl->fl_type != F_UNLCK && - flock->fl_type != F_UNLCK) { + if (cmp_lock->fl->fl_core.fl_type != F_UNLCK && + flock->fl_core.fl_type != F_UNLCK) { pr_err("conflict two locks in one request\n"); err = -EINVAL; locks_free_lock(flock); @@ -6975,12 +6975,12 @@ int smb2_lock(struct ksmbd_work *work) list_for_each_entry(conn, &conn_list, conns_list) { spin_lock(&conn->llist_lock); list_for_each_entry_safe(cmp_lock, tmp2, &conn->lock_list, clist) { - if (file_inode(cmp_lock->fl->fl_file) != - file_inode(smb_lock->fl->fl_file)) + if (file_inode(cmp_lock->fl->fl_core.fl_file) != + file_inode(smb_lock->fl->fl_core.fl_file)) continue; - if (smb_lock->fl->fl_type == F_UNLCK) { - if (cmp_lock->fl->fl_file == smb_lock->fl->fl_file && + if (smb_lock->fl->fl_core.fl_type == F_UNLCK) { + if (cmp_lock->fl->fl_core.fl_file == smb_lock->fl->fl_core.fl_file && cmp_lock->start == smb_lock->start && cmp_lock->end == smb_lock->end && !lock_defer_pending(cmp_lock->fl)) { @@ -6997,7 +6997,7 @@ int smb2_lock(struct ksmbd_work *work) continue; } - if (cmp_lock->fl->fl_file == smb_lock->fl->fl_file) { + if (cmp_lock->fl->fl_core.fl_file == smb_lock->fl->fl_core.fl_file) { if (smb_lock->flags & SMB2_LOCKFLAG_SHARED) continue; } else { @@ -7039,7 +7039,7 @@ int smb2_lock(struct ksmbd_work *work) } up_read(&conn_list_lock); out_check_cl: - if (smb_lock->fl->fl_type == F_UNLCK && nolock) { + if (smb_lock->fl->fl_core.fl_type == F_UNLCK && nolock) { pr_err("Try to unlock nolocked range\n"); rsp->hdr.Status = STATUS_RANGE_NOT_LOCKED; goto out; @@ -7163,7 +7163,7 @@ int smb2_lock(struct ksmbd_work *work) struct file_lock *rlock = NULL; rlock = smb_flock_init(filp); - rlock->fl_type = F_UNLCK; + rlock->fl_core.fl_type = F_UNLCK; rlock->fl_start = smb_lock->start; rlock->fl_end = smb_lock->end; diff --git a/fs/smb/server/vfs.c b/fs/smb/server/vfs.c index a6961bfe3e13..f7bb6f19492b 100644 --- a/fs/smb/server/vfs.c +++ b/fs/smb/server/vfs.c @@ -340,15 +340,15 @@ static int check_lock_range(struct file *filp, loff_t start, loff_t end, list_for_each_entry(flock, &ctx->flc_posix, fl_list) { /* check conflict locks */ if (flock->fl_end >= start && end >= flock->fl_start) { - if (flock->fl_type == F_RDLCK) { + if (flock->fl_core.fl_type == F_RDLCK) { if (type == WRITE) { pr_err("not allow write by shared lock\n"); error = 1; goto out; } - } else if (flock->fl_type == F_WRLCK) { + } else if (flock->fl_core.fl_type == F_WRLCK) { /* check owner in lock */ - if (flock->fl_file != filp) { + if (flock->fl_core.fl_file != filp) { error = 1; pr_err("not allow rw access by exclusive lock from other opens\n"); goto out; @@ -1837,13 +1837,13 @@ int ksmbd_vfs_copy_file_ranges(struct ksmbd_work *work, void ksmbd_vfs_posix_lock_wait(struct file_lock *flock) { - wait_event(flock->fl_wait, !flock->fl_blocker); + wait_event(flock->fl_core.fl_wait, !flock->fl_core.fl_blocker); } int ksmbd_vfs_posix_lock_wait_timeout(struct file_lock *flock, long timeout) { - return wait_event_interruptible_timeout(flock->fl_wait, - !flock->fl_blocker, + return wait_event_interruptible_timeout(flock->fl_core.fl_wait, + !flock->fl_core.fl_blocker, timeout); } diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h index 9f565416d186..c4b9faa261f7 100644 --- a/include/linux/lockd/lockd.h +++ b/include/linux/lockd/lockd.h @@ -375,12 +375,12 @@ static inline int nlm_privileged_requester(const struct svc_rqst *rqstp) static inline int nlm_compare_locks(const struct file_lock *fl1, const struct file_lock *fl2) { - return file_inode(fl1->fl_file) == file_inode(fl2->fl_file) - && fl1->fl_pid == fl2->fl_pid - && fl1->fl_owner == fl2->fl_owner + return file_inode(fl1->fl_core.fl_file) == file_inode(fl2->fl_core.fl_file) + && fl1->fl_core.fl_pid == fl2->fl_core.fl_pid + && fl1->fl_core.fl_owner == fl2->fl_core.fl_owner && fl1->fl_start == fl2->fl_start && fl1->fl_end == fl2->fl_end - &&(fl1->fl_type == fl2->fl_type || fl2->fl_type == F_UNLCK); + &&(fl1->fl_core.fl_type == fl2->fl_core.fl_type || fl2->fl_core.fl_type == F_UNLCK); } extern const struct lock_manager_operations nlmsvc_lock_operations;
This is the direct result of the changes generated by coccinelle. There is still about 1/4 of the callsites that need to be touched by hand here. Signed-off-by: Jeff Layton <jlayton@kernel.org> --- fs/9p/vfs_file.c | 38 ++--- fs/afs/flock.c | 55 +++--- fs/ceph/locks.c | 66 +++---- fs/dlm/plock.c | 44 ++--- fs/fuse/file.c | 14 +- fs/gfs2/file.c | 16 +- fs/lockd/clnt4xdr.c | 6 +- fs/lockd/clntlock.c | 2 +- fs/lockd/clntproc.c | 60 ++++--- fs/lockd/clntxdr.c | 6 +- fs/lockd/svclock.c | 10 +- fs/lockd/svcsubs.c | 20 +-- fs/lockd/xdr.c | 6 +- fs/lockd/xdr4.c | 6 +- fs/locks.c | 406 +++++++++++++++++++++++--------------------- fs/nfs/delegation.c | 2 +- fs/nfs/file.c | 22 +-- fs/nfs/nfs3proc.c | 2 +- fs/nfs/nfs4proc.c | 35 ++-- fs/nfs/nfs4state.c | 4 +- fs/nfs/nfs4xdr.c | 8 +- fs/nfs/write.c | 4 +- fs/nfsd/filecache.c | 4 +- fs/nfsd/nfs4layouts.c | 15 +- fs/nfsd/nfs4state.c | 73 ++++---- fs/ocfs2/locks.c | 12 +- fs/ocfs2/stack_user.c | 2 +- fs/smb/client/cifssmb.c | 8 +- fs/smb/client/file.c | 72 ++++---- fs/smb/client/smb2file.c | 2 +- fs/smb/server/smb2pdu.c | 44 ++--- fs/smb/server/vfs.c | 12 +- include/linux/lockd/lockd.h | 8 +- 33 files changed, 554 insertions(+), 530 deletions(-)