| /* |
| * Copyright (c) 2001 The Regents of the University of Michigan. |
| * All rights reserved. |
| * |
| * Kendrick Smith <kmsmith@umich.edu> |
| * Andy Adamson <kandros@umich.edu> |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of the University nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
| * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
| * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| */ |
| |
| #include <linux/file.h> |
| #include <linux/fs.h> |
| #include <linux/slab.h> |
| #include <linux/namei.h> |
| #include <linux/swap.h> |
| #include <linux/pagemap.h> |
| #include <linux/ratelimit.h> |
| #include <linux/sunrpc/svcauth_gss.h> |
| #include <linux/sunrpc/addr.h> |
| #include <linux/jhash.h> |
| #include <linux/string_helpers.h> |
| #include "xdr4.h" |
| #include "xdr4cb.h" |
| #include "vfs.h" |
| #include "current_stateid.h" |
| |
| #include "netns.h" |
| #include "pnfs.h" |
| #include "filecache.h" |
| #include "trace.h" |
| |
| #define NFSDDBG_FACILITY NFSDDBG_PROC |
| |
| #define all_ones {{~0,~0},~0} |
| static const stateid_t one_stateid = { |
| .si_generation = ~0, |
| .si_opaque = all_ones, |
| }; |
| static const stateid_t zero_stateid = { |
| /* all fields zero */ |
| }; |
| static const stateid_t currentstateid = { |
| .si_generation = 1, |
| }; |
| static const stateid_t close_stateid = { |
| .si_generation = 0xffffffffU, |
| }; |
| |
| static u64 current_sessionid = 1; |
| |
| #define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t))) |
| #define ONE_STATEID(stateid) (!memcmp((stateid), &one_stateid, sizeof(stateid_t))) |
| #define CURRENT_STATEID(stateid) (!memcmp((stateid), ¤tstateid, sizeof(stateid_t))) |
| #define CLOSE_STATEID(stateid) (!memcmp((stateid), &close_stateid, sizeof(stateid_t))) |
| |
| /* forward declarations */ |
| static bool check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner); |
| static void nfs4_free_ol_stateid(struct nfs4_stid *stid); |
| void nfsd4_end_grace(struct nfsd_net *nn); |
| static void _free_cpntf_state_locked(struct nfsd_net *nn, struct nfs4_cpntf_state *cps); |
| |
| /* Locking: */ |
| |
| /* |
| * Currently used for the del_recall_lru and file hash table. In an |
| * effort to decrease the scope of the client_mutex, this spinlock may |
| * eventually cover more: |
| */ |
| static DEFINE_SPINLOCK(state_lock); |
| |
| enum nfsd4_st_mutex_lock_subclass { |
| OPEN_STATEID_MUTEX = 0, |
| LOCK_STATEID_MUTEX = 1, |
| }; |
| |
| /* |
| * A waitqueue for all in-progress 4.0 CLOSE operations that are waiting for |
| * the refcount on the open stateid to drop. |
| */ |
| static DECLARE_WAIT_QUEUE_HEAD(close_wq); |
| |
| /* |
| * A waitqueue where a writer to clients/#/ctl destroying a client can |
| * wait for cl_rpc_users to drop to 0 and then for the client to be |
| * unhashed. |
| */ |
| static DECLARE_WAIT_QUEUE_HEAD(expiry_wq); |
| |
| static struct kmem_cache *client_slab; |
| static struct kmem_cache *openowner_slab; |
| static struct kmem_cache *lockowner_slab; |
| static struct kmem_cache *file_slab; |
| static struct kmem_cache *stateid_slab; |
| static struct kmem_cache *deleg_slab; |
| static struct kmem_cache *odstate_slab; |
| |
| static void free_session(struct nfsd4_session *); |
| |
| static const struct nfsd4_callback_ops nfsd4_cb_recall_ops; |
| static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops; |
| |
| static bool is_session_dead(struct nfsd4_session *ses) |
| { |
| return ses->se_flags & NFS4_SESSION_DEAD; |
| } |
| |
| static __be32 mark_session_dead_locked(struct nfsd4_session *ses, int ref_held_by_me) |
| { |
| if (atomic_read(&ses->se_ref) > ref_held_by_me) |
| return nfserr_jukebox; |
| ses->se_flags |= NFS4_SESSION_DEAD; |
| return nfs_ok; |
| } |
| |
| static bool is_client_expired(struct nfs4_client *clp) |
| { |
| return clp->cl_time == 0; |
| } |
| |
| static __be32 get_client_locked(struct nfs4_client *clp) |
| { |
| struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); |
| |
| lockdep_assert_held(&nn->client_lock); |
| |
| if (is_client_expired(clp)) |
| return nfserr_expired; |
| atomic_inc(&clp->cl_rpc_users); |
| return nfs_ok; |
| } |
| |
| /* must be called under the client_lock */ |
| static inline void |
| renew_client_locked(struct nfs4_client *clp) |
| { |
| struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); |
| |
| if (is_client_expired(clp)) { |
| WARN_ON(1); |
| printk("%s: client (clientid %08x/%08x) already expired\n", |
| __func__, |
| clp->cl_clientid.cl_boot, |
| clp->cl_clientid.cl_id); |
| return; |
| } |
| |
| list_move_tail(&clp->cl_lru, &nn->client_lru); |
| clp->cl_time = ktime_get_boottime_seconds(); |
| } |
| |
| static void put_client_renew_locked(struct nfs4_client *clp) |
| { |
| struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); |
| |
| lockdep_assert_held(&nn->client_lock); |
| |
| if (!atomic_dec_and_test(&clp->cl_rpc_users)) |
| return; |
| if (!is_client_expired(clp)) |
| renew_client_locked(clp); |
| else |
| wake_up_all(&expiry_wq); |
| } |
| |
| static void put_client_renew(struct nfs4_client *clp) |
| { |
| struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); |
| |
| if (!atomic_dec_and_lock(&clp->cl_rpc_users, &nn->client_lock)) |
| return; |
| if (!is_client_expired(clp)) |
| renew_client_locked(clp); |
| else |
| wake_up_all(&expiry_wq); |
| spin_unlock(&nn->client_lock); |
| } |
| |
| static __be32 nfsd4_get_session_locked(struct nfsd4_session *ses) |
| { |
| __be32 status; |
| |
| if (is_session_dead(ses)) |
| return nfserr_badsession; |
| status = get_client_locked(ses->se_client); |
| if (status) |
| return status; |
| atomic_inc(&ses->se_ref); |
| return nfs_ok; |
| } |
| |
| static void nfsd4_put_session_locked(struct nfsd4_session *ses) |
| { |
| struct nfs4_client *clp = ses->se_client; |
| struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); |
| |
| lockdep_assert_held(&nn->client_lock); |
| |
| if (atomic_dec_and_test(&ses->se_ref) && is_session_dead(ses)) |
| free_session(ses); |
| put_client_renew_locked(clp); |
| } |
| |
| static void nfsd4_put_session(struct nfsd4_session *ses) |
| { |
| struct nfs4_client *clp = ses->se_client; |
| struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); |
| |
| spin_lock(&nn->client_lock); |
| nfsd4_put_session_locked(ses); |
| spin_unlock(&nn->client_lock); |
| } |
| |
| static struct nfsd4_blocked_lock * |
| find_blocked_lock(struct nfs4_lockowner *lo, struct knfsd_fh *fh, |
| struct nfsd_net *nn) |
| { |
| struct nfsd4_blocked_lock *cur, *found = NULL; |
| |
| spin_lock(&nn->blocked_locks_lock); |
| list_for_each_entry(cur, &lo->lo_blocked, nbl_list) { |
| if (fh_match(fh, &cur->nbl_fh)) { |
| list_del_init(&cur->nbl_list); |
| list_del_init(&cur->nbl_lru); |
| found = cur; |
| break; |
| } |
| } |
| spin_unlock(&nn->blocked_locks_lock); |
| if (found) |
| locks_delete_block(&found->nbl_lock); |
| return found; |
| } |
| |
| static struct nfsd4_blocked_lock * |
| find_or_allocate_block(struct nfs4_lockowner *lo, struct knfsd_fh *fh, |
| struct nfsd_net *nn) |
| { |
| struct nfsd4_blocked_lock *nbl; |
| |
| nbl = find_blocked_lock(lo, fh, nn); |
| if (!nbl) { |
| nbl= kmalloc(sizeof(*nbl), GFP_KERNEL); |
| if (nbl) { |
| INIT_LIST_HEAD(&nbl->nbl_list); |
| INIT_LIST_HEAD(&nbl->nbl_lru); |
| fh_copy_shallow(&nbl->nbl_fh, fh); |
| locks_init_lock(&nbl->nbl_lock); |
| nfsd4_init_cb(&nbl->nbl_cb, lo->lo_owner.so_client, |
| &nfsd4_cb_notify_lock_ops, |
| NFSPROC4_CLNT_CB_NOTIFY_LOCK); |
| } |
| } |
| return nbl; |
| } |
| |
| static void |
| free_blocked_lock(struct nfsd4_blocked_lock *nbl) |
| { |
| locks_delete_block(&nbl->nbl_lock); |
| locks_release_private(&nbl->nbl_lock); |
| kfree(nbl); |
| } |
| |
| static void |
| remove_blocked_locks(struct nfs4_lockowner *lo) |
| { |
| struct nfs4_client *clp = lo->lo_owner.so_client; |
| struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); |
| struct nfsd4_blocked_lock *nbl; |
| LIST_HEAD(reaplist); |
| |
| /* Dequeue all blocked locks */ |
| spin_lock(&nn->blocked_locks_lock); |
| while (!list_empty(&lo->lo_blocked)) { |
| nbl = list_first_entry(&lo->lo_blocked, |
| struct nfsd4_blocked_lock, |
| nbl_list); |
| list_del_init(&nbl->nbl_list); |
| list_move(&nbl->nbl_lru, &reaplist); |
| } |
| spin_unlock(&nn->blocked_locks_lock); |
| |
| /* Now free them */ |
| while (!list_empty(&reaplist)) { |
| nbl = list_first_entry(&reaplist, struct nfsd4_blocked_lock, |
| nbl_lru); |
| list_del_init(&nbl->nbl_lru); |
| free_blocked_lock(nbl); |
| } |
| } |
| |
| static void |
| nfsd4_cb_notify_lock_prepare(struct nfsd4_callback *cb) |
| { |
| struct nfsd4_blocked_lock *nbl = container_of(cb, |
| struct nfsd4_blocked_lock, nbl_cb); |
| locks_delete_block(&nbl->nbl_lock); |
| } |
| |
| static int |
| nfsd4_cb_notify_lock_done(struct nfsd4_callback *cb, struct rpc_task *task) |
| { |
| /* |
| * Since this is just an optimization, we don't try very hard if it |
| * turns out not to succeed. We'll requeue it on NFS4ERR_DELAY, and |
| * just quit trying on anything else. |
| */ |
| switch (task->tk_status) { |
| case -NFS4ERR_DELAY: |
| rpc_delay(task, 1 * HZ); |
| return 0; |
| default: |
| return 1; |
| } |
| } |
| |
| static void |
| nfsd4_cb_notify_lock_release(struct nfsd4_callback *cb) |
| { |
| struct nfsd4_blocked_lock *nbl = container_of(cb, |
| struct nfsd4_blocked_lock, nbl_cb); |
| |
| free_blocked_lock(nbl); |
| } |
| |
| static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops = { |
| .prepare = nfsd4_cb_notify_lock_prepare, |
| .done = nfsd4_cb_notify_lock_done, |
| .release = nfsd4_cb_notify_lock_release, |
| }; |
| |
| static inline struct nfs4_stateowner * |
| nfs4_get_stateowner(struct nfs4_stateowner *sop) |
| { |
| atomic_inc(&sop->so_count); |
| return sop; |
| } |
| |
| static int |
| same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner) |
| { |
| return (sop->so_owner.len == owner->len) && |
| 0 == memcmp(sop->so_owner.data, owner->data, owner->len); |
| } |
| |
| static struct nfs4_openowner * |
| find_openstateowner_str_locked(unsigned int hashval, struct nfsd4_open *open, |
| struct nfs4_client *clp) |
| { |
| struct nfs4_stateowner *so; |
| |
| lockdep_assert_held(&clp->cl_lock); |
| |
| list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[hashval], |
| so_strhash) { |
| if (!so->so_is_open_owner) |
| continue; |
| if (same_owner_str(so, &open->op_owner)) |
| return openowner(nfs4_get_stateowner(so)); |
| } |
| return NULL; |
| } |
| |
| static struct nfs4_openowner * |
| find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open, |
| struct nfs4_client *clp) |
| { |
| struct nfs4_openowner *oo; |
| |
| spin_lock(&clp->cl_lock); |
| oo = find_openstateowner_str_locked(hashval, open, clp); |
| spin_unlock(&clp->cl_lock); |
| return oo; |
| } |
| |
| static inline u32 |
| opaque_hashval(const void *ptr, int nbytes) |
| { |
| unsigned char *cptr = (unsigned char *) ptr; |
| |
| u32 x = 0; |
| while (nbytes--) { |
| x *= 37; |
| x += *cptr++; |
| } |
| return x; |
| } |
| |
| static void nfsd4_free_file_rcu(struct rcu_head *rcu) |
| { |
| struct nfs4_file *fp = container_of(rcu, struct nfs4_file, fi_rcu); |
| |
| kmem_cache_free(file_slab, fp); |
| } |
| |
| void |
| put_nfs4_file(struct nfs4_file *fi) |
| { |
| might_lock(&state_lock); |
| |
| if (refcount_dec_and_lock(&fi->fi_ref, &state_lock)) { |
| hlist_del_rcu(&fi->fi_hash); |
| spin_unlock(&state_lock); |
| WARN_ON_ONCE(!list_empty(&fi->fi_clnt_odstate)); |
| WARN_ON_ONCE(!list_empty(&fi->fi_delegations)); |
| call_rcu(&fi->fi_rcu, nfsd4_free_file_rcu); |
| } |
| } |
| |
| static struct nfsd_file * |
| __nfs4_get_fd(struct nfs4_file *f, int oflag) |
| { |
| if (f->fi_fds[oflag]) |
| return nfsd_file_get(f->fi_fds[oflag]); |
| return NULL; |
| } |
| |
| static struct nfsd_file * |
| find_writeable_file_locked(struct nfs4_file *f) |
| { |
| struct nfsd_file *ret; |
| |
| lockdep_assert_held(&f->fi_lock); |
| |
| ret = __nfs4_get_fd(f, O_WRONLY); |
| if (!ret) |
| ret = __nfs4_get_fd(f, O_RDWR); |
| return ret; |
| } |
| |
| static struct nfsd_file * |
| find_writeable_file(struct nfs4_file *f) |
| { |
| struct nfsd_file *ret; |
| |
| spin_lock(&f->fi_lock); |
| ret = find_writeable_file_locked(f); |
| spin_unlock(&f->fi_lock); |
| |
| return ret; |
| } |
| |
| static struct nfsd_file * |
| find_readable_file_locked(struct nfs4_file *f) |
| { |
| struct nfsd_file *ret; |
| |
| lockdep_assert_held(&f->fi_lock); |
| |
| ret = __nfs4_get_fd(f, O_RDONLY); |
| if (!ret) |
| ret = __nfs4_get_fd(f, O_RDWR); |
| return ret; |
| } |
| |
| static struct nfsd_file * |
| find_readable_file(struct nfs4_file *f) |
| { |
| struct nfsd_file *ret; |
| |
| spin_lock(&f->fi_lock); |
| ret = find_readable_file_locked(f); |
| spin_unlock(&f->fi_lock); |
| |
| return ret; |
| } |
| |
| struct nfsd_file * |
| find_any_file(struct nfs4_file *f) |
| { |
| struct nfsd_file *ret; |
| |
| if (!f) |
| return NULL; |
| spin_lock(&f->fi_lock); |
| ret = __nfs4_get_fd(f, O_RDWR); |
| if (!ret) { |
| ret = __nfs4_get_fd(f, O_WRONLY); |
| if (!ret) |
| ret = __nfs4_get_fd(f, O_RDONLY); |
| } |
| spin_unlock(&f->fi_lock); |
| return ret; |
| } |
| |
| static atomic_long_t num_delegations; |
| unsigned long max_delegations; |
| |
| /* |
| * Open owner state (share locks) |
| */ |
| |
| /* hash tables for lock and open owners */ |
| #define OWNER_HASH_BITS 8 |
| #define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS) |
| #define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1) |
| |
| static unsigned int ownerstr_hashval(struct xdr_netobj *ownername) |
| { |
| unsigned int ret; |
| |
| ret = opaque_hashval(ownername->data, ownername->len); |
| return ret & OWNER_HASH_MASK; |
| } |
| |
| /* hash table for nfs4_file */ |
| #define FILE_HASH_BITS 8 |
| #define FILE_HASH_SIZE (1 << FILE_HASH_BITS) |
| |
| static unsigned int nfsd_fh_hashval(struct knfsd_fh *fh) |
| { |
| return jhash2(fh->fh_base.fh_pad, XDR_QUADLEN(fh->fh_size), 0); |
| } |
| |
| static unsigned int file_hashval(struct knfsd_fh *fh) |
| { |
| return nfsd_fh_hashval(fh) & (FILE_HASH_SIZE - 1); |
| } |
| |
| static struct hlist_head file_hashtbl[FILE_HASH_SIZE]; |
| |
| static void |
| __nfs4_file_get_access(struct nfs4_file *fp, u32 access) |
| { |
| lockdep_assert_held(&fp->fi_lock); |
| |
| if (access & NFS4_SHARE_ACCESS_WRITE) |
| atomic_inc(&fp->fi_access[O_WRONLY]); |
| if (access & NFS4_SHARE_ACCESS_READ) |
| atomic_inc(&fp->fi_access[O_RDONLY]); |
| } |
| |
| static __be32 |
| nfs4_file_get_access(struct nfs4_file *fp, u32 access) |
| { |
| lockdep_assert_held(&fp->fi_lock); |
| |
| /* Does this access mode make sense? */ |
| if (access & ~NFS4_SHARE_ACCESS_BOTH) |
| return nfserr_inval; |
| |
| /* Does it conflict with a deny mode already set? */ |
| if ((access & fp->fi_share_deny) != 0) |
| return nfserr_share_denied; |
| |
| __nfs4_file_get_access(fp, access); |
| return nfs_ok; |
| } |
| |
| static __be32 nfs4_file_check_deny(struct nfs4_file *fp, u32 deny) |
| { |
| /* Common case is that there is no deny mode. */ |
| if (deny) { |
| /* Does this deny mode make sense? */ |
| if (deny & ~NFS4_SHARE_DENY_BOTH) |
| return nfserr_inval; |
| |
| if ((deny & NFS4_SHARE_DENY_READ) && |
| atomic_read(&fp->fi_access[O_RDONLY])) |
| return nfserr_share_denied; |
| |
| if ((deny & NFS4_SHARE_DENY_WRITE) && |
| atomic_read(&fp->fi_access[O_WRONLY])) |
| return nfserr_share_denied; |
| } |
| return nfs_ok; |
| } |
| |
| static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag) |
| { |
| might_lock(&fp->fi_lock); |
| |
| if (atomic_dec_and_lock(&fp->fi_access[oflag], &fp->fi_lock)) { |
| struct nfsd_file *f1 = NULL; |
| struct nfsd_file *f2 = NULL; |
| |
| swap(f1, fp->fi_fds[oflag]); |
| if (atomic_read(&fp->fi_access[1 - oflag]) == 0) |
| swap(f2, fp->fi_fds[O_RDWR]); |
| spin_unlock(&fp->fi_lock); |
| if (f1) |
| nfsd_file_put(f1); |
| if (f2) |
| nfsd_file_put(f2); |
| } |
| } |
| |
| static void nfs4_file_put_access(struct nfs4_file *fp, u32 access) |
| { |
| WARN_ON_ONCE(access & ~NFS4_SHARE_ACCESS_BOTH); |
| |
| if (access & NFS4_SHARE_ACCESS_WRITE) |
| __nfs4_file_put_access(fp, O_WRONLY); |
| if (access & NFS4_SHARE_ACCESS_READ) |
| __nfs4_file_put_access(fp, O_RDONLY); |
| } |
| |
| /* |
| * Allocate a new open/delegation state counter. This is needed for |
| * pNFS for proper return on close semantics. |
| * |
| * Note that we only allocate it for pNFS-enabled exports, otherwise |
| * all pointers to struct nfs4_clnt_odstate are always NULL. |
| */ |
| static struct nfs4_clnt_odstate * |
| alloc_clnt_odstate(struct nfs4_client *clp) |
| { |
| struct nfs4_clnt_odstate *co; |
| |
| co = kmem_cache_zalloc(odstate_slab, GFP_KERNEL); |
| if (co) { |
| co->co_client = clp; |
| refcount_set(&co->co_odcount, 1); |
| } |
| return co; |
| } |
| |
| static void |
| hash_clnt_odstate_locked(struct nfs4_clnt_odstate *co) |
| { |
| struct nfs4_file *fp = co->co_file; |
| |
| lockdep_assert_held(&fp->fi_lock); |
| list_add(&co->co_perfile, &fp->fi_clnt_odstate); |
| } |
| |
| static inline void |
| get_clnt_odstate(struct nfs4_clnt_odstate *co) |
| { |
| if (co) |
| refcount_inc(&co->co_odcount); |
| } |
| |
| static void |
| put_clnt_odstate(struct nfs4_clnt_odstate *co) |
| { |
| struct nfs4_file *fp; |
| |
| if (!co) |
| return; |
| |
| fp = co->co_file; |
| if (refcount_dec_and_lock(&co->co_odcount, &fp->fi_lock)) { |
| list_del(&co->co_perfile); |
| spin_unlock(&fp->fi_lock); |
| |
| nfsd4_return_all_file_layouts(co->co_client, fp); |
| kmem_cache_free(odstate_slab, co); |
| } |
| } |
| |
| static struct nfs4_clnt_odstate * |
| find_or_hash_clnt_odstate(struct nfs4_file *fp, struct nfs4_clnt_odstate *new) |
| { |
| struct nfs4_clnt_odstate *co; |
| struct nfs4_client *cl; |
| |
| if (!new) |
| return NULL; |
| |
| cl = new->co_client; |
| |
| spin_lock(&fp->fi_lock); |
| list_for_each_entry(co, &fp->fi_clnt_odstate, co_perfile) { |
| if (co->co_client == cl) { |
| get_clnt_odstate(co); |
| goto out; |
| } |
| } |
| co = new; |
| co->co_file = fp; |
| hash_clnt_odstate_locked(new); |
| out: |
| spin_unlock(&fp->fi_lock); |
| return co; |
| } |
| |
| struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct kmem_cache *slab, |
| void (*sc_free)(struct nfs4_stid *)) |
| { |
| struct nfs4_stid *stid; |
| int new_id; |
| |
| stid = kmem_cache_zalloc(slab, GFP_KERNEL); |
| if (!stid) |
| return NULL; |
| |
| idr_preload(GFP_KERNEL); |
| spin_lock(&cl->cl_lock); |
| /* Reserving 0 for start of file in nfsdfs "states" file: */ |
| new_id = idr_alloc_cyclic(&cl->cl_stateids, stid, 1, 0, GFP_NOWAIT); |
| spin_unlock(&cl->cl_lock); |
| idr_preload_end(); |
| if (new_id < 0) |
| goto out_free; |
| |
| stid->sc_free = sc_free; |
| stid->sc_client = cl; |
| stid->sc_stateid.si_opaque.so_id = new_id; |
| stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid; |
| /* Will be incremented before return to client: */ |
| refcount_set(&stid->sc_count, 1); |
| spin_lock_init(&stid->sc_lock); |
| INIT_LIST_HEAD(&stid->sc_cp_list); |
| |
| /* |
| * It shouldn't be a problem to reuse an opaque stateid value. |
| * I don't think it is for 4.1. But with 4.0 I worry that, for |
| * example, a stray write retransmission could be accepted by |
| * the server when it should have been rejected. Therefore, |
| * adopt a trick from the sctp code to attempt to maximize the |
| * amount of time until an id is reused, by ensuring they always |
| * "increase" (mod INT_MAX): |
| */ |
| return stid; |
| out_free: |
| kmem_cache_free(slab, stid); |
| return NULL; |
| } |
| |
| /* |
| * Create a unique stateid_t to represent each COPY. |
| */ |
| static int nfs4_init_cp_state(struct nfsd_net *nn, copy_stateid_t *stid, |
| unsigned char sc_type) |
| { |
| int new_id; |
| |
| stid->stid.si_opaque.so_clid.cl_boot = (u32)nn->boot_time; |
| stid->stid.si_opaque.so_clid.cl_id = nn->s2s_cp_cl_id; |
| stid->sc_type = sc_type; |
| |
| idr_preload(GFP_KERNEL); |
| spin_lock(&nn->s2s_cp_lock); |
| new_id = idr_alloc_cyclic(&nn->s2s_cp_stateids, stid, 0, 0, GFP_NOWAIT); |
| stid->stid.si_opaque.so_id = new_id; |
| spin_unlock(&nn->s2s_cp_lock); |
| idr_preload_end(); |
| if (new_id < 0) |
| return 0; |
| return 1; |
| } |
| |
| int nfs4_init_copy_state(struct nfsd_net *nn, struct nfsd4_copy *copy) |
| { |
| return nfs4_init_cp_state(nn, ©->cp_stateid, NFS4_COPY_STID); |
| } |
| |
| struct nfs4_cpntf_state *nfs4_alloc_init_cpntf_state(struct nfsd_net *nn, |
| struct nfs4_stid *p_stid) |
| { |
| struct nfs4_cpntf_state *cps; |
| |
| cps = kzalloc(sizeof(struct nfs4_cpntf_state), GFP_KERNEL); |
| if (!cps) |
| return NULL; |
| cps->cpntf_time = ktime_get_boottime_seconds(); |
| refcount_set(&cps->cp_stateid.sc_count, 1); |
| if (!nfs4_init_cp_state(nn, &cps->cp_stateid, NFS4_COPYNOTIFY_STID)) |
| goto out_free; |
| spin_lock(&nn->s2s_cp_lock); |
| list_add(&cps->cp_list, &p_stid->sc_cp_list); |
| spin_unlock(&nn->s2s_cp_lock); |
| return cps; |
| out_free: |
| kfree(cps); |
| return NULL; |
| } |
| |
| void nfs4_free_copy_state(struct nfsd4_copy *copy) |
| { |
| struct nfsd_net *nn; |
| |
| WARN_ON_ONCE(copy->cp_stateid.sc_type != NFS4_COPY_STID); |
| nn = net_generic(copy->cp_clp->net, nfsd_net_id); |
| spin_lock(&nn->s2s_cp_lock); |
| idr_remove(&nn->s2s_cp_stateids, |
| copy->cp_stateid.stid.si_opaque.so_id); |
| spin_unlock(&nn->s2s_cp_lock); |
| } |
| |
| static void nfs4_free_cpntf_statelist(struct net *net, struct nfs4_stid *stid) |
| { |
| struct nfs4_cpntf_state *cps; |
| struct nfsd_net *nn; |
| |
| nn = net_generic(net, nfsd_net_id); |
| spin_lock(&nn->s2s_cp_lock); |
| while (!list_empty(&stid->sc_cp_list)) { |
| cps = list_first_entry(&stid->sc_cp_list, |
| struct nfs4_cpntf_state, cp_list); |
| _free_cpntf_state_locked(nn, cps); |
| } |
| spin_unlock(&nn->s2s_cp_lock); |
| } |
| |
| static struct nfs4_ol_stateid * nfs4_alloc_open_stateid(struct nfs4_client *clp) |
| { |
| struct nfs4_stid *stid; |
| |
| stid = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_ol_stateid); |
| if (!stid) |
| return NULL; |
| |
| return openlockstateid(stid); |
| } |
| |
| static void nfs4_free_deleg(struct nfs4_stid *stid) |
| { |
| kmem_cache_free(deleg_slab, stid); |
| atomic_long_dec(&num_delegations); |
| } |
| |
| /* |
| * When we recall a delegation, we should be careful not to hand it |
| * out again straight away. |
| * To ensure this we keep a pair of bloom filters ('new' and 'old') |
| * in which the filehandles of recalled delegations are "stored". |
| * If a filehandle appear in either filter, a delegation is blocked. |
| * When a delegation is recalled, the filehandle is stored in the "new" |
| * filter. |
| * Every 30 seconds we swap the filters and clear the "new" one, |
| * unless both are empty of course. |
| * |
| * Each filter is 256 bits. We hash the filehandle to 32bit and use the |
| * low 3 bytes as hash-table indices. |
| * |
| * 'blocked_delegations_lock', which is always taken in block_delegations(), |
| * is used to manage concurrent access. Testing does not need the lock |
| * except when swapping the two filters. |
| */ |
| static DEFINE_SPINLOCK(blocked_delegations_lock); |
| static struct bloom_pair { |
| int entries, old_entries; |
| time64_t swap_time; |
| int new; /* index into 'set' */ |
| DECLARE_BITMAP(set[2], 256); |
| } blocked_delegations; |
| |
| static int delegation_blocked(struct knfsd_fh *fh) |
| { |
| u32 hash; |
| struct bloom_pair *bd = &blocked_delegations; |
| |
| if (bd->entries == 0) |
| return 0; |
| if (ktime_get_seconds() - bd->swap_time > 30) { |
| spin_lock(&blocked_delegations_lock); |
| if (ktime_get_seconds() - bd->swap_time > 30) { |
| bd->entries -= bd->old_entries; |
| bd->old_entries = bd->entries; |
| memset(bd->set[bd->new], 0, |
| sizeof(bd->set[0])); |
| bd->new = 1-bd->new; |
| bd->swap_time = ktime_get_seconds(); |
| } |
| spin_unlock(&blocked_delegations_lock); |
| } |
| hash = jhash(&fh->fh_base, fh->fh_size, 0); |
| if (test_bit(hash&255, bd->set[0]) && |
| test_bit((hash>>8)&255, bd->set[0]) && |
| test_bit((hash>>16)&255, bd->set[0])) |
| return 1; |
| |
| if (test_bit(hash&255, bd->set[1]) && |
| test_bit((hash>>8)&255, bd->set[1]) && |
| test_bit((hash>>16)&255, bd->set[1])) |
| return 1; |
| |
| return 0; |
| } |
| |
| static void block_delegations(struct knfsd_fh *fh) |
| { |
| u32 hash; |
| struct bloom_pair *bd = &blocked_delegations; |
| |
| hash = jhash(&fh->fh_base, fh->fh_size, 0); |
| |
| spin_lock(&blocked_delegations_lock); |
| __set_bit(hash&255, bd->set[bd->new]); |
| __set_bit((hash>>8)&255, bd->set[bd->new]); |
| __set_bit((hash>>16)&255, bd->set[bd->new]); |
| if (bd->entries == 0) |
| bd->swap_time = ktime_get_seconds(); |
| bd->entries += 1; |
| spin_unlock(&blocked_delegations_lock); |
| } |
| |
| static struct nfs4_delegation * |
| alloc_init_deleg(struct nfs4_client *clp, struct nfs4_file *fp, |
| struct svc_fh *current_fh, |
| struct nfs4_clnt_odstate *odstate) |
| { |
| struct nfs4_delegation *dp; |
| long n; |
| |
| dprintk("NFSD alloc_init_deleg\n"); |
| n = atomic_long_inc_return(&num_delegations); |
| if (n < 0 || n > max_delegations) |
| goto out_dec; |
| if (delegation_blocked(¤t_fh->fh_handle)) |
| goto out_dec; |
| dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab, nfs4_free_deleg)); |
| if (dp == NULL) |
| goto out_dec; |
| |
| /* |
| * delegation seqid's are never incremented. The 4.1 special |
| * meaning of seqid 0 isn't meaningful, really, but let's avoid |
| * 0 anyway just for consistency and use 1: |
| */ |
| dp->dl_stid.sc_stateid.si_generation = 1; |
| INIT_LIST_HEAD(&dp->dl_perfile); |
| INIT_LIST_HEAD(&dp->dl_perclnt); |
| INIT_LIST_HEAD(&dp->dl_recall_lru); |
| dp->dl_clnt_odstate = odstate; |
| get_clnt_odstate(odstate); |
| dp->dl_type = NFS4_OPEN_DELEGATE_READ; |
| dp->dl_retries = 1; |
| nfsd4_init_cb(&dp->dl_recall, dp->dl_stid.sc_client, |
| &nfsd4_cb_recall_ops, NFSPROC4_CLNT_CB_RECALL); |
| get_nfs4_file(fp); |
| dp->dl_stid.sc_file = fp; |
| return dp; |
| out_dec: |
| atomic_long_dec(&num_delegations); |
| return NULL; |
| } |
| |
| void |
| nfs4_put_stid(struct nfs4_stid *s) |
| { |
| struct nfs4_file *fp = s->sc_file; |
| struct nfs4_client *clp = s->sc_client; |
| |
| might_lock(&clp->cl_lock); |
| |
| if (!refcount_dec_and_lock(&s->sc_count, &clp->cl_lock)) { |
| wake_up_all(&close_wq); |
| return; |
| } |
| idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id); |
| nfs4_free_cpntf_statelist(clp->net, s); |
| spin_unlock(&clp->cl_lock); |
| s->sc_free(s); |
| if (fp) |
| put_nfs4_file(fp); |
| } |
| |
| void |
| nfs4_inc_and_copy_stateid(stateid_t *dst, struct nfs4_stid *stid) |
| { |
| stateid_t *src = &stid->sc_stateid; |
| |
| spin_lock(&stid->sc_lock); |
| if (unlikely(++src->si_generation == 0)) |
| src->si_generation = 1; |
| memcpy(dst, src, sizeof(*dst)); |
| spin_unlock(&stid->sc_lock); |
| } |
| |
| static void put_deleg_file(struct nfs4_file *fp) |
| { |
| struct nfsd_file *nf = NULL; |
| |
| spin_lock(&fp->fi_lock); |
| if (--fp->fi_delegees == 0) |
| swap(nf, fp->fi_deleg_file); |
| spin_unlock(&fp->fi_lock); |
| |
| if (nf) |
| nfsd_file_put(nf); |
| } |
| |
| static void nfs4_unlock_deleg_lease(struct nfs4_delegation *dp) |
| { |
| struct nfs4_file *fp = dp->dl_stid.sc_file; |
| struct nfsd_file *nf = fp->fi_deleg_file; |
| |
| WARN_ON_ONCE(!fp->fi_delegees); |
| |
| vfs_setlease(nf->nf_file, F_UNLCK, NULL, (void **)&dp); |
| put_deleg_file(fp); |
| } |
| |
| static void destroy_unhashed_deleg(struct nfs4_delegation *dp) |
| { |
| put_clnt_odstate(dp->dl_clnt_odstate); |
| nfs4_unlock_deleg_lease(dp); |
| nfs4_put_stid(&dp->dl_stid); |
| } |
| |
| void nfs4_unhash_stid(struct nfs4_stid *s) |
| { |
| s->sc_type = 0; |
| } |
| |
| /** |
| * nfs4_delegation_exists - Discover if this delegation already exists |
| * @clp: a pointer to the nfs4_client we're granting a delegation to |
| * @fp: a pointer to the nfs4_file we're granting a delegation on |
| * |
| * Return: |
| * On success: true iff an existing delegation is found |
| */ |
| |
| static bool |
| nfs4_delegation_exists(struct nfs4_client *clp, struct nfs4_file *fp) |
| { |
| struct nfs4_delegation *searchdp = NULL; |
| struct nfs4_client *searchclp = NULL; |
| |
| lockdep_assert_held(&state_lock); |
| lockdep_assert_held(&fp->fi_lock); |
| |
| list_for_each_entry(searchdp, &fp->fi_delegations, dl_perfile) { |
| searchclp = searchdp->dl_stid.sc_client; |
| if (clp == searchclp) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * hash_delegation_locked - Add a delegation to the appropriate lists |
| * @dp: a pointer to the nfs4_delegation we are adding. |
| * @fp: a pointer to the nfs4_file we're granting a delegation on |
| * |
| * Return: |
| * On success: NULL if the delegation was successfully hashed. |
| * |
| * On error: -EAGAIN if one was previously granted to this |
| * nfs4_client for this nfs4_file. Delegation is not hashed. |
| * |
| */ |
| |
| static int |
| hash_delegation_locked(struct nfs4_delegation *dp, struct nfs4_file *fp) |
| { |
| struct nfs4_client *clp = dp->dl_stid.sc_client; |
| |
| lockdep_assert_held(&state_lock); |
| lockdep_assert_held(&fp->fi_lock); |
| |
| if (nfs4_delegation_exists(clp, fp)) |
| return -EAGAIN; |
| refcount_inc(&dp->dl_stid.sc_count); |
| dp->dl_stid.sc_type = NFS4_DELEG_STID; |
| list_add(&dp->dl_perfile, &fp->fi_delegations); |
| list_add(&dp->dl_perclnt, &clp->cl_delegations); |
| return 0; |
| } |
| |
| static bool |
| unhash_delegation_locked(struct nfs4_delegation *dp) |
| { |
| struct nfs4_file *fp = dp->dl_stid.sc_file; |
| |
| lockdep_assert_held(&state_lock); |
| |
| if (list_empty(&dp->dl_perfile)) |
| return false; |
| |
| dp->dl_stid.sc_type = NFS4_CLOSED_DELEG_STID; |
| /* Ensure that deleg break won't try to requeue it */ |
| ++dp->dl_time; |
| spin_lock(&fp->fi_lock); |
| list_del_init(&dp->dl_perclnt); |
| list_del_init(&dp->dl_recall_lru); |
| list_del_init(&dp->dl_perfile); |
| spin_unlock(&fp->fi_lock); |
| return true; |
| } |
| |
| static void destroy_delegation(struct nfs4_delegation *dp) |
| { |
| bool unhashed; |
| |
| spin_lock(&state_lock); |
| unhashed = unhash_delegation_locked(dp); |
| spin_unlock(&state_lock); |
| if (unhashed) |
| destroy_unhashed_deleg(dp); |
| } |
| |
| static void revoke_delegation(struct nfs4_delegation *dp) |
| { |
| struct nfs4_client *clp = dp->dl_stid.sc_client; |
| |
| WARN_ON(!list_empty(&dp->dl_recall_lru)); |
| |
| if (clp->cl_minorversion) { |
| dp->dl_stid.sc_type = NFS4_REVOKED_DELEG_STID; |
| refcount_inc(&dp->dl_stid.sc_count); |
| spin_lock(&clp->cl_lock); |
| list_add(&dp->dl_recall_lru, &clp->cl_revoked); |
| spin_unlock(&clp->cl_lock); |
| } |
| destroy_unhashed_deleg(dp); |
| } |
| |
| /* |
| * SETCLIENTID state |
| */ |
| |
| static unsigned int clientid_hashval(u32 id) |
| { |
| return id & CLIENT_HASH_MASK; |
| } |
| |
| static unsigned int clientstr_hashval(struct xdr_netobj name) |
| { |
| return opaque_hashval(name.data, 8) & CLIENT_HASH_MASK; |
| } |
| |
| /* |
| * We store the NONE, READ, WRITE, and BOTH bits separately in the |
| * st_{access,deny}_bmap field of the stateid, in order to track not |
| * only what share bits are currently in force, but also what |
| * combinations of share bits previous opens have used. This allows us |
| * to enforce the recommendation of rfc 3530 14.2.19 that the server |
| * return an error if the client attempt to downgrade to a combination |
| * of share bits not explicable by closing some of its previous opens. |
| * |
| * XXX: This enforcement is actually incomplete, since we don't keep |
| * track of access/deny bit combinations; so, e.g., we allow: |
| * |
| * OPEN allow read, deny write |
| * OPEN allow both, deny none |
| * DOWNGRADE allow read, deny none |
| * |
| * which we should reject. |
| */ |
| static unsigned int |
| bmap_to_share_mode(unsigned long bmap) { |
| int i; |
| unsigned int access = 0; |
| |
| for (i = 1; i < 4; i++) { |
| if (test_bit(i, &bmap)) |
| access |= i; |
| } |
| return access; |
| } |
| |
| /* set share access for a given stateid */ |
| static inline void |
| set_access(u32 access, struct nfs4_ol_stateid *stp) |
| { |
| unsigned char mask = 1 << access; |
| |
| WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH); |
| stp->st_access_bmap |= mask; |
| } |
| |
| /* clear share access for a given stateid */ |
| static inline void |
| clear_access(u32 access, struct nfs4_ol_stateid *stp) |
| { |
| unsigned char mask = 1 << access; |
| |
| WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH); |
| stp->st_access_bmap &= ~mask; |
| } |
| |
| /* test whether a given stateid has access */ |
| static inline bool |
| test_access(u32 access, struct nfs4_ol_stateid *stp) |
| { |
| unsigned char mask = 1 << access; |
| |
| return (bool)(stp->st_access_bmap & mask); |
| } |
| |
| /* set share deny for a given stateid */ |
| static inline void |
| set_deny(u32 deny, struct nfs4_ol_stateid *stp) |
| { |
| unsigned char mask = 1 << deny; |
| |
| WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH); |
| stp->st_deny_bmap |= mask; |
| } |
| |
| /* clear share deny for a given stateid */ |
| static inline void |
| clear_deny(u32 deny, struct nfs4_ol_stateid *stp) |
| { |
| unsigned char mask = 1 << deny; |
| |
| WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH); |
| stp->st_deny_bmap &= ~mask; |
| } |
| |
| /* test whether a given stateid is denying specific access */ |
| static inline bool |
| test_deny(u32 deny, struct nfs4_ol_stateid *stp) |
| { |
| unsigned char mask = 1 << deny; |
| |
| return (bool)(stp->st_deny_bmap & mask); |
| } |
| |
| static int nfs4_access_to_omode(u32 access) |
| { |
| switch (access & NFS4_SHARE_ACCESS_BOTH) { |
| case NFS4_SHARE_ACCESS_READ: |
| return O_RDONLY; |
| case NFS4_SHARE_ACCESS_WRITE: |
| return O_WRONLY; |
| case NFS4_SHARE_ACCESS_BOTH: |
| return O_RDWR; |
| } |
| WARN_ON_ONCE(1); |
| return O_RDONLY; |
| } |
| |
| /* |
| * A stateid that had a deny mode associated with it is being released |
| * or downgraded. Recalculate the deny mode on the file. |
| */ |
| static void |
| recalculate_deny_mode(struct nfs4_file *fp) |
| { |
| struct nfs4_ol_stateid *stp; |
| |
| spin_lock(&fp->fi_lock); |
| fp->fi_share_deny = 0; |
| list_for_each_entry(stp, &fp->fi_stateids, st_perfile) |
| fp->fi_share_deny |= bmap_to_share_mode(stp->st_deny_bmap); |
| spin_unlock(&fp->fi_lock); |
| } |
| |
| static void |
| reset_union_bmap_deny(u32 deny, struct nfs4_ol_stateid *stp) |
| { |
| int i; |
| bool change = false; |
| |
| for (i = 1; i < 4; i++) { |
| if ((i & deny) != i) { |
| change = true; |
| clear_deny(i, stp); |
| } |
| } |
| |
| /* Recalculate per-file deny mode if there was a change */ |
| if (change) |
| recalculate_deny_mode(stp->st_stid.sc_file); |
| } |
| |
| /* release all access and file references for a given stateid */ |
| static void |
| release_all_access(struct nfs4_ol_stateid *stp) |
| { |
| int i; |
| struct nfs4_file *fp = stp->st_stid.sc_file; |
| |
| if (fp && stp->st_deny_bmap != 0) |
| recalculate_deny_mode(fp); |
| |
| for (i = 1; i < 4; i++) { |
| if (test_access(i, stp)) |
| nfs4_file_put_access(stp->st_stid.sc_file, i); |
| clear_access(i, stp); |
| } |
| } |
| |
| static inline void nfs4_free_stateowner(struct nfs4_stateowner *sop) |
| { |
| kfree(sop->so_owner.data); |
| sop->so_ops->so_free(sop); |
| } |
| |
| static void nfs4_put_stateowner(struct nfs4_stateowner *sop) |
| { |
| struct nfs4_client *clp = sop->so_client; |
| |
| might_lock(&clp->cl_lock); |
| |
| if (!atomic_dec_and_lock(&sop->so_count, &clp->cl_lock)) |
| return; |
| sop->so_ops->so_unhash(sop); |
| spin_unlock(&clp->cl_lock); |
| nfs4_free_stateowner(sop); |
| } |
| |
| static bool |
| nfs4_ol_stateid_unhashed(const struct nfs4_ol_stateid *stp) |
| { |
| return list_empty(&stp->st_perfile); |
| } |
| |
| static bool unhash_ol_stateid(struct nfs4_ol_stateid *stp) |
| { |
| struct nfs4_file *fp = stp->st_stid.sc_file; |
| |
| lockdep_assert_held(&stp->st_stateowner->so_client->cl_lock); |
| |
| if (list_empty(&stp->st_perfile)) |
| return false; |
| |
| spin_lock(&fp->fi_lock); |
| list_del_init(&stp->st_perfile); |
| spin_unlock(&fp->fi_lock); |
| list_del(&stp->st_perstateowner); |
| return true; |
| } |
| |
| static void nfs4_free_ol_stateid(struct nfs4_stid *stid) |
| { |
| struct nfs4_ol_stateid *stp = openlockstateid(stid); |
| |
| put_clnt_odstate(stp->st_clnt_odstate); |
| release_all_access(stp); |
| if (stp->st_stateowner) |
| nfs4_put_stateowner(stp->st_stateowner); |
| kmem_cache_free(stateid_slab, stid); |
| } |
| |
| static void nfs4_free_lock_stateid(struct nfs4_stid *stid) |
| { |
| struct nfs4_ol_stateid *stp = openlockstateid(stid); |
| struct nfs4_lockowner *lo = lockowner(stp->st_stateowner); |
| struct nfsd_file *nf; |
| |
| nf = find_any_file(stp->st_stid.sc_file); |
| if (nf) { |
| get_file(nf->nf_file); |
| filp_close(nf->nf_file, (fl_owner_t)lo); |
| nfsd_file_put(nf); |
| } |
| nfs4_free_ol_stateid(stid); |
| } |
| |
| /* |
| * Put the persistent reference to an already unhashed generic stateid, while |
| * holding the cl_lock. If it's the last reference, then put it onto the |
| * reaplist for later destruction. |
| */ |
| static void put_ol_stateid_locked(struct nfs4_ol_stateid *stp, |
| struct list_head *reaplist) |
| { |
| struct nfs4_stid *s = &stp->st_stid; |
| struct nfs4_client *clp = s->sc_client; |
| |
| lockdep_assert_held(&clp->cl_lock); |
| |
| WARN_ON_ONCE(!list_empty(&stp->st_locks)); |
| |
| if (!refcount_dec_and_test(&s->sc_count)) { |
| wake_up_all(&close_wq); |
| return; |
| } |
| |
| idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id); |
| list_add(&stp->st_locks, reaplist); |
| } |
| |
| static bool unhash_lock_stateid(struct nfs4_ol_stateid *stp) |
| { |
| lockdep_assert_held(&stp->st_stid.sc_client->cl_lock); |
| |
| if (!unhash_ol_stateid(stp)) |
| return false; |
| list_del_init(&stp->st_locks); |
| nfs4_unhash_stid(&stp->st_stid); |
| return true; |
| } |
| |
| static void release_lock_stateid(struct nfs4_ol_stateid *stp) |
| { |
| struct nfs4_client *clp = stp->st_stid.sc_client; |
| bool unhashed; |
| |
| spin_lock(&clp->cl_lock); |
| unhashed = unhash_lock_stateid(stp); |
| spin_unlock(&clp->cl_lock); |
| if (unhashed) |
| nfs4_put_stid(&stp->st_stid); |
| } |
| |
| static void unhash_lockowner_locked(struct nfs4_lockowner *lo) |
| { |
| struct nfs4_client *clp = lo->lo_owner.so_client; |
| |
| lockdep_assert_held(&clp->cl_lock); |
| |
| list_del_init(&lo->lo_owner.so_strhash); |
| } |
| |
| /* |
| * Free a list of generic stateids that were collected earlier after being |
| * fully unhashed. |
| */ |
| static void |
| free_ol_stateid_reaplist(struct list_head *reaplist) |
| { |
| struct nfs4_ol_stateid *stp; |
| struct nfs4_file *fp; |
| |
| might_sleep(); |
| |
| while (!list_empty(reaplist)) { |
| stp = list_first_entry(reaplist, struct nfs4_ol_stateid, |
| st_locks); |
| list_del(&stp->st_locks); |
| fp = stp->st_stid.sc_file; |
| stp->st_stid.sc_free(&stp->st_stid); |
| if (fp) |
| put_nfs4_file(fp); |
| } |
| } |
| |
| static void release_open_stateid_locks(struct nfs4_ol_stateid *open_stp, |
| struct list_head *reaplist) |
| { |
| struct nfs4_ol_stateid *stp; |
| |
| lockdep_assert_held(&open_stp->st_stid.sc_client->cl_lock); |
| |
| while (!list_empty(&open_stp->st_locks)) { |
| stp = list_entry(open_stp->st_locks.next, |
| struct nfs4_ol_stateid, st_locks); |
| WARN_ON(!unhash_lock_stateid(stp)); |
| put_ol_stateid_locked(stp, reaplist); |
| } |
| } |
| |
| static bool unhash_open_stateid(struct nfs4_ol_stateid *stp, |
| struct list_head *reaplist) |
| { |
| lockdep_assert_held(&stp->st_stid.sc_client->cl_lock); |
| |
| if (!unhash_ol_stateid(stp)) |
| return false; |
| release_open_stateid_locks(stp, reaplist); |
| return true; |
| } |
| |
| static void release_open_stateid(struct nfs4_ol_stateid *stp) |
| { |
| LIST_HEAD(reaplist); |
| |
| spin_lock(&stp->st_stid.sc_client->cl_lock); |
| if (unhash_open_stateid(stp, &reaplist)) |
| put_ol_stateid_locked(stp, &reaplist); |
| spin_unlock(&stp->st_stid.sc_client->cl_lock); |
| free_ol_stateid_reaplist(&reaplist); |
| } |
| |
| static void unhash_openowner_locked(struct nfs4_openowner *oo) |
| { |
| struct nfs4_client *clp = oo->oo_owner.so_client; |
| |
| lockdep_assert_held(&clp->cl_lock); |
| |
| list_del_init(&oo->oo_owner.so_strhash); |
| list_del_init(&oo->oo_perclient); |
| } |
| |
| static void release_last_closed_stateid(struct nfs4_openowner *oo) |
| { |
| struct nfsd_net *nn = net_generic(oo->oo_owner.so_client->net, |
| nfsd_net_id); |
| struct nfs4_ol_stateid *s; |
| |
| spin_lock(&nn->client_lock); |
| s = oo->oo_last_closed_stid; |
| if (s) { |
| list_del_init(&oo->oo_close_lru); |
| oo->oo_last_closed_stid = NULL; |
| } |
| spin_unlock(&nn->client_lock); |
| if (s) |
| nfs4_put_stid(&s->st_stid); |
| } |
| |
| static void release_openowner(struct nfs4_openowner *oo) |
| { |
| struct nfs4_ol_stateid *stp; |
| struct nfs4_client *clp = oo->oo_owner.so_client; |
| struct list_head reaplist; |
| |
| INIT_LIST_HEAD(&reaplist); |
| |
| spin_lock(&clp->cl_lock); |
| unhash_openowner_locked(oo); |
| while (!list_empty(&oo->oo_owner.so_stateids)) { |
| stp = list_first_entry(&oo->oo_owner.so_stateids, |
| struct nfs4_ol_stateid, st_perstateowner); |
| if (unhash_open_stateid(stp, &reaplist)) |
| put_ol_stateid_locked(stp, &reaplist); |
| } |
| spin_unlock(&clp->cl_lock); |
| free_ol_stateid_reaplist(&reaplist); |
| release_last_closed_stateid(oo); |
| nfs4_put_stateowner(&oo->oo_owner); |
| } |
| |
| static inline int |
| hash_sessionid(struct nfs4_sessionid *sessionid) |
| { |
| struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid; |
| |
| return sid->sequence % SESSION_HASH_SIZE; |
| } |
| |
| #ifdef CONFIG_SUNRPC_DEBUG |
| static inline void |
| dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid) |
| { |
| u32 *ptr = (u32 *)(&sessionid->data[0]); |
| dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]); |
| } |
| #else |
| static inline void |
| dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid) |
| { |
| } |
| #endif |
| |
| /* |
| * Bump the seqid on cstate->replay_owner, and clear replay_owner if it |
| * won't be used for replay. |
| */ |
| void nfsd4_bump_seqid(struct nfsd4_compound_state *cstate, __be32 nfserr) |
| { |
| struct nfs4_stateowner *so = cstate->replay_owner; |
| |
| if (nfserr == nfserr_replay_me) |
| return; |
| |
| if (!seqid_mutating_err(ntohl(nfserr))) { |
| nfsd4_cstate_clear_replay(cstate); |
| return; |
| } |
| if (!so) |
| return; |
| if (so->so_is_open_owner) |
| release_last_closed_stateid(openowner(so)); |
| so->so_seqid++; |
| return; |
| } |
| |
| static void |
| gen_sessionid(struct nfsd4_session *ses) |
| { |
| struct nfs4_client *clp = ses->se_client; |
| struct nfsd4_sessionid *sid; |
| |
| sid = (struct nfsd4_sessionid *)ses->se_sessionid.data; |
| sid->clientid = clp->cl_clientid; |
| sid->sequence = current_sessionid++; |
| sid->reserved = 0; |
| } |
| |
| /* |
| * The protocol defines ca_maxresponssize_cached to include the size of |
| * the rpc header, but all we need to cache is the data starting after |
| * the end of the initial SEQUENCE operation--the rest we regenerate |
| * each time. Therefore we can advertise a ca_maxresponssize_cached |
| * value that is the number of bytes in our cache plus a few additional |
| * bytes. In order to stay on the safe side, and not promise more than |
| * we can cache, those additional bytes must be the minimum possible: 24 |
| * bytes of rpc header (xid through accept state, with AUTH_NULL |
| * verifier), 12 for the compound header (with zero-length tag), and 44 |
| * for the SEQUENCE op response: |
| */ |
| #define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44) |
| |
| static void |
| free_session_slots(struct nfsd4_session *ses) |
| { |
| int i; |
| |
| for (i = 0; i < ses->se_fchannel.maxreqs; i++) { |
| free_svc_cred(&ses->se_slots[i]->sl_cred); |
| kfree(ses->se_slots[i]); |
| } |
| } |
| |
| /* |
| * We don't actually need to cache the rpc and session headers, so we |
| * can allocate a little less for each slot: |
| */ |
| static inline u32 slot_bytes(struct nfsd4_channel_attrs *ca) |
| { |
| u32 size; |
| |
| if (ca->maxresp_cached < NFSD_MIN_HDR_SEQ_SZ) |
| size = 0; |
| else |
| size = ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ; |
| return size + sizeof(struct nfsd4_slot); |
| } |
| |
| /* |
| * XXX: If we run out of reserved DRC memory we could (up to a point) |
| * re-negotiate active sessions and reduce their slot usage to make |
| * room for new connections. For now we just fail the create session. |
| */ |
| static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn) |
| { |
| u32 slotsize = slot_bytes(ca); |
| u32 num = ca->maxreqs; |
| unsigned long avail, total_avail; |
| unsigned int scale_factor; |
| |
| spin_lock(&nfsd_drc_lock); |
| if (nfsd_drc_max_mem > nfsd_drc_mem_used) |
| total_avail = nfsd_drc_max_mem - nfsd_drc_mem_used; |
| else |
| /* We have handed out more space than we chose in |
| * set_max_drc() to allow. That isn't really a |
| * problem as long as that doesn't make us think we |
| * have lots more due to integer overflow. |
| */ |
| total_avail = 0; |
| avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION, total_avail); |
| /* |
| * Never use more than a fraction of the remaining memory, |
| * unless it's the only way to give this client a slot. |
| * The chosen fraction is either 1/8 or 1/number of threads, |
| * whichever is smaller. This ensures there are adequate |
| * slots to support multiple clients per thread. |
| * Give the client one slot even if that would require |
| * over-allocation--it is better than failure. |
| */ |
| scale_factor = max_t(unsigned int, 8, nn->nfsd_serv->sv_nrthreads); |
| |
| avail = clamp_t(unsigned long, avail, slotsize, |
| total_avail/scale_factor); |
| num = min_t(int, num, avail / slotsize); |
| num = max_t(int, num, 1); |
| nfsd_drc_mem_used += num * slotsize; |
| spin_unlock(&nfsd_drc_lock); |
| |
| return num; |
| } |
| |
| static void nfsd4_put_drc_mem(struct nfsd4_channel_attrs *ca) |
| { |
| int slotsize = slot_bytes(ca); |
| |
| spin_lock(&nfsd_drc_lock); |
| nfsd_drc_mem_used -= slotsize * ca->maxreqs; |
| spin_unlock(&nfsd_drc_lock); |
| } |
| |
| static struct nfsd4_session *alloc_session(struct nfsd4_channel_attrs *fattrs, |
| struct nfsd4_channel_attrs *battrs) |
| { |
| int numslots = fattrs->maxreqs; |
| int slotsize = slot_bytes(fattrs); |
| struct nfsd4_session *new; |
| int mem, i; |
| |
| BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *) |
| + sizeof(struct nfsd4_session) > PAGE_SIZE); |
| mem = numslots * sizeof(struct nfsd4_slot *); |
| |
| new = kzalloc(sizeof(*new) + mem, GFP_KERNEL); |
| if (!new) |
| return NULL; |
| /* allocate each struct nfsd4_slot and data cache in one piece */ |
| for (i = 0; i < numslots; i++) { |
| new->se_slots[i] = kzalloc(slotsize, GFP_KERNEL); |
| if (!new->se_slots[i]) |
| goto out_free; |
| } |
| |
| memcpy(&new->se_fchannel, fattrs, sizeof(struct nfsd4_channel_attrs)); |
| memcpy(&new->se_bchannel, battrs, sizeof(struct nfsd4_channel_attrs)); |
| |
| return new; |
| out_free: |
| while (i--) |
| kfree(new->se_slots[i]); |
| kfree(new); |
| return NULL; |
| } |
| |
| static void free_conn(struct nfsd4_conn *c) |
| { |
| svc_xprt_put(c->cn_xprt); |
| kfree(c); |
| } |
| |
| static void nfsd4_conn_lost(struct svc_xpt_user *u) |
| { |
| struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user); |
| struct nfs4_client *clp = c->cn_session->se_client; |
| |
| spin_lock(&clp->cl_lock); |
| if (!list_empty(&c->cn_persession)) { |
| list_del(&c->cn_persession); |
| free_conn(c); |
| } |
| nfsd4_probe_callback(clp); |
| spin_unlock(&clp->cl_lock); |
| } |
| |
| static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags) |
| { |
| struct nfsd4_conn *conn; |
| |
| conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL); |
| if (!conn) |
| return NULL; |
| svc_xprt_get(rqstp->rq_xprt); |
| conn->cn_xprt = rqstp->rq_xprt; |
| conn->cn_flags = flags; |
| INIT_LIST_HEAD(&conn->cn_xpt_user.list); |
| return conn; |
| } |
| |
| static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses) |
| { |
| conn->cn_session = ses; |
| list_add(&conn->cn_persession, &ses->se_conns); |
| } |
| |
| static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses) |
| { |
| struct nfs4_client *clp = ses->se_client; |
| |
| spin_lock(&clp->cl_lock); |
| __nfsd4_hash_conn(conn, ses); |
| spin_unlock(&clp->cl_lock); |
| } |
| |
| static int nfsd4_register_conn(struct nfsd4_conn *conn) |
| { |
| conn->cn_xpt_user.callback = nfsd4_conn_lost; |
| return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user); |
| } |
| |
| static void nfsd4_init_conn(struct svc_rqst *rqstp, struct nfsd4_conn *conn, struct nfsd4_session *ses) |
| { |
| int ret; |
| |
| nfsd4_hash_conn(conn, ses); |
| ret = nfsd4_register_conn(conn); |
| if (ret) |
| /* oops; xprt is already down: */ |
| nfsd4_conn_lost(&conn->cn_xpt_user); |
| /* We may have gained or lost a callback channel: */ |
| nfsd4_probe_callback_sync(ses->se_client); |
| } |
| |
| static struct nfsd4_conn *alloc_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_create_session *cses) |
| { |
| u32 dir = NFS4_CDFC4_FORE; |
| |
| if (cses->flags & SESSION4_BACK_CHAN) |
| dir |= NFS4_CDFC4_BACK; |
| return alloc_conn(rqstp, dir); |
| } |
| |
| /* must be called under client_lock */ |
| static void nfsd4_del_conns(struct nfsd4_session *s) |
| { |
| struct nfs4_client *clp = s->se_client; |
| struct nfsd4_conn *c; |
| |
| spin_lock(&clp->cl_lock); |
| while (!list_empty(&s->se_conns)) { |
| c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession); |
| list_del_init(&c->cn_persession); |
| spin_unlock(&clp->cl_lock); |
| |
| unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user); |
| free_conn(c); |
| |
| spin_lock(&clp->cl_lock); |
| } |
| spin_unlock(&clp->cl_lock); |
| } |
| |
| static void __free_session(struct nfsd4_session *ses) |
| { |
| free_session_slots(ses); |
| kfree(ses); |
| } |
| |
| static void free_session(struct nfsd4_session *ses) |
| { |
| nfsd4_del_conns(ses); |
| nfsd4_put_drc_mem(&ses->se_fchannel); |
| __free_session(ses); |
| } |
| |
| static void init_session(struct svc_rqst *rqstp, struct nfsd4_session *new, struct nfs4_client *clp, struct nfsd4_create_session *cses) |
| { |
| int idx; |
| struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); |
| |
| new->se_client = clp; |
| gen_sessionid(new); |
| |
| INIT_LIST_HEAD(&new->se_conns); |
| |
| new->se_cb_seq_nr = 1; |
| new->se_flags = cses->flags; |
| new->se_cb_prog = cses->callback_prog; |
| new->se_cb_sec = cses->cb_sec; |
| atomic_set(&new->se_ref, 0); |
| idx = hash_sessionid(&new->se_sessionid); |
| list_add(&new->se_hash, &nn->sessionid_hashtbl[idx]); |
| spin_lock(&clp->cl_lock); |
| list_add(&new->se_perclnt, &clp->cl_sessions); |
| spin_unlock(&clp->cl_lock); |
| |
| { |
| struct sockaddr *sa = svc_addr(rqstp); |
| /* |
| * This is a little silly; with sessions there's no real |
| * use for the callback address. Use the peer address |
| * as a reasonable default for now, but consider fixing |
| * the rpc client not to require an address in the |
| * future: |
| */ |
| rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa); |
| clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa); |
| } |
| } |
| |
| /* caller must hold client_lock */ |
| static struct nfsd4_session * |
| __find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net) |
| { |
| struct nfsd4_session *elem; |
| int idx; |
| struct nfsd_net *nn = net_generic(net, nfsd_net_id); |
| |
| lockdep_assert_held(&nn->client_lock); |
| |
| dump_sessionid(__func__, sessionid); |
| idx = hash_sessionid(sessionid); |
| /* Search in the appropriate list */ |
| list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) { |
| if (!memcmp(elem->se_sessionid.data, sessionid->data, |
| NFS4_MAX_SESSIONID_LEN)) { |
| return elem; |
| } |
| } |
| |
| dprintk("%s: session not found\n", __func__); |
| return NULL; |
| } |
| |
| static struct nfsd4_session * |
| find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net, |
| __be32 *ret) |
| { |
| struct nfsd4_session *session; |
| __be32 status = nfserr_badsession; |
| |
| session = __find_in_sessionid_hashtbl(sessionid, net); |
| if (!session) |
| goto out; |
| status = nfsd4_get_session_locked(session); |
| if (status) |
| session = NULL; |
| out: |
| *ret = status; |
| return session; |
| } |
| |
| /* caller must hold client_lock */ |
| static void |
| unhash_session(struct nfsd4_session *ses) |
| { |
| struct nfs4_client *clp = ses->se_client; |
| struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); |
| |
| lockdep_assert_held(&nn->client_lock); |
| |
| list_del(&ses->se_hash); |
| spin_lock(&ses->se_client->cl_lock); |
| list_del(&ses->se_perclnt); |
| spin_unlock(&ses->se_client->cl_lock); |
| } |
| |
| /* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */ |
| static int |
| STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn) |
| { |
| /* |
| * We're assuming the clid was not given out from a boot |
| * precisely 2^32 (about 136 years) before this one. That seems |
| * a safe assumption: |
| */ |
| if (clid->cl_boot == (u32)nn->boot_time) |
| return 0; |
| trace_nfsd_clid_stale(clid); |
| return 1; |
| } |
| |
| /* |
| * XXX Should we use a slab cache ? |
| * This type of memory management is somewhat inefficient, but we use it |
| * anyway since SETCLIENTID is not a common operation. |
| */ |
| static struct nfs4_client *alloc_client(struct xdr_netobj name) |
| { |
| struct nfs4_client *clp; |
| int i; |
| |
| clp = kmem_cache_zalloc(client_slab, GFP_KERNEL); |
| if (clp == NULL) |
| return NULL; |
| xdr_netobj_dup(&clp->cl_name, &name, GFP_KERNEL); |
| if (clp->cl_name.data == NULL) |
| goto err_no_name; |
| clp->cl_ownerstr_hashtbl = kmalloc_array(OWNER_HASH_SIZE, |
| sizeof(struct list_head), |
| GFP_KERNEL); |
| if (!clp->cl_ownerstr_hashtbl) |
| goto err_no_hashtbl; |
| for (i = 0; i < OWNER_HASH_SIZE; i++) |
| INIT_LIST_HEAD(&clp->cl_ownerstr_hashtbl[i]); |
| INIT_LIST_HEAD(&clp->cl_sessions); |
| idr_init(&clp->cl_stateids); |
| atomic_set(&clp->cl_rpc_users, 0); |
| clp->cl_cb_state = NFSD4_CB_UNKNOWN; |
| INIT_LIST_HEAD(&clp->cl_idhash); |
| INIT_LIST_HEAD(&clp->cl_openowners); |
| INIT_LIST_HEAD(&clp->cl_delegations); |
| INIT_LIST_HEAD(&clp->cl_lru); |
| INIT_LIST_HEAD(&clp->cl_revoked); |
| #ifdef CONFIG_NFSD_PNFS |
| INIT_LIST_HEAD(&clp->cl_lo_states); |
| #endif |
| INIT_LIST_HEAD(&clp->async_copies); |
| spin_lock_init(&clp->async_lock); |
| spin_lock_init(&clp->cl_lock); |
| rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table"); |
| return clp; |
| err_no_hashtbl: |
| kfree(clp->cl_name.data); |
| err_no_name: |
| kmem_cache_free(client_slab, clp); |
| return NULL; |
| } |
| |
| static void __free_client(struct kref *k) |
| { |
| struct nfsdfs_client *c = container_of(k, struct nfsdfs_client, cl_ref); |
| struct nfs4_client *clp = container_of(c, struct nfs4_client, cl_nfsdfs); |
| |
| free_svc_cred(&clp->cl_cred); |
| kfree(clp->cl_ownerstr_hashtbl); |
| kfree(clp->cl_name.data); |
| kfree(clp->cl_nii_domain.data); |
| kfree(clp->cl_nii_name.data); |
| idr_destroy(&clp->cl_stateids); |
| kmem_cache_free(client_slab, clp); |
| } |
| |
| static void drop_client(struct nfs4_client *clp) |
| { |
| kref_put(&clp->cl_nfsdfs.cl_ref, __free_client); |
| } |
| |
| static void |
| free_client(struct nfs4_client *clp) |
| { |
| while (!list_empty(&clp->cl_sessions)) { |
| struct nfsd4_session *ses; |
| ses = list_entry(clp->cl_sessions.next, struct nfsd4_session, |
| se_perclnt); |
| list_del(&ses->se_perclnt); |
| WARN_ON_ONCE(atomic_read(&ses->se_ref)); |
| free_session(ses); |
| } |
| rpc_destroy_wait_queue(&clp->cl_cb_waitq); |
| if (clp->cl_nfsd_dentry) { |
| nfsd_client_rmdir(clp->cl_nfsd_dentry); |
| clp->cl_nfsd_dentry = NULL; |
| wake_up_all(&expiry_wq); |
| } |
| drop_client(clp); |
| } |
| |
| /* must be called under the client_lock */ |
| static void |
| unhash_client_locked(struct nfs4_client *clp) |
| { |
| struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); |
| struct nfsd4_session *ses; |
| |
| lockdep_assert_held(&nn->client_lock); |
| |
| /* Mark the client as expired! */ |
| clp->cl_time = 0; |
| /* Make it invisible */ |
| if (!list_empty(&clp->cl_idhash)) { |
| list_del_init(&clp->cl_idhash); |
| if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags)) |
| rb_erase(&clp->cl_namenode, &nn->conf_name_tree); |
| else |
| rb_erase(&clp->cl_namenode, &nn->unconf_name_tree); |
| } |
| list_del_init(&clp->cl_lru); |
| spin_lock(&clp->cl_lock); |
| list_for_each_entry(ses, &clp->cl_sessions, se_perclnt) |
| list_del_init(&ses->se_hash); |
| spin_unlock(&clp->cl_lock); |
| } |
| |
| static void |
| unhash_client(struct nfs4_client *clp) |
| { |
| struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); |
| |
| spin_lock(&nn->client_lock); |
| unhash_client_locked(clp); |
| spin_unlock(&nn->client_lock); |
| } |
| |
| static __be32 mark_client_expired_locked(struct nfs4_client *clp) |
| { |
| if (atomic_read(&clp->cl_rpc_users)) |
| return nfserr_jukebox; |
| unhash_client_locked(clp); |
| return nfs_ok; |
| } |
| |
| static void |
| __destroy_client(struct nfs4_client *clp) |
| { |
| int i; |
| struct nfs4_openowner *oo; |
| struct nfs4_delegation *dp; |
| struct list_head reaplist; |
| |
| INIT_LIST_HEAD(&reaplist); |
| spin_lock(&state_lock); |
| while (!list_empty(&clp->cl_delegations)) { |
| dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt); |
| WARN_ON(!unhash_delegation_locked(dp)); |
| list_add(&dp->dl_recall_lru, &reaplist); |
| } |
| spin_unlock(&state_lock); |
| while (!list_empty(&reaplist)) { |
| dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru); |
| list_del_init(&dp->dl_recall_lru); |
| destroy_unhashed_deleg(dp); |
| } |
| while (!list_empty(&clp->cl_revoked)) { |
| dp = list_entry(clp->cl_revoked.next, struct nfs4_delegation, dl_recall_lru); |
| list_del_init(&dp->dl_recall_lru); |
| nfs4_put_stid(&dp->dl_stid); |
| } |
| while (!list_empty(&clp->cl_openowners)) { |
| oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient); |
| nfs4_get_stateowner(&oo->oo_owner); |
| release_openowner(oo); |
| } |
| for (i = 0; i < OWNER_HASH_SIZE; i++) { |
| struct nfs4_stateowner *so, *tmp; |
| |
| list_for_each_entry_safe(so, tmp, &clp->cl_ownerstr_hashtbl[i], |
| so_strhash) { |
| /* Should be no openowners at this point */ |
| WARN_ON_ONCE(so->so_is_open_owner); |
| remove_blocked_locks(lockowner(so)); |
| } |
| } |
| nfsd4_return_all_client_layouts(clp); |
| nfsd4_shutdown_copy(clp); |
| nfsd4_shutdown_callback(clp); |
| if (clp->cl_cb_conn.cb_xprt) |
| svc_xprt_put(clp->cl_cb_conn.cb_xprt); |
| free_client(clp); |
| wake_up_all(&expiry_wq); |
| } |
| |
| static void |
| destroy_client(struct nfs4_client *clp) |
| { |
| unhash_client(clp); |
| __destroy_client(clp); |
| } |
| |
| static void inc_reclaim_complete(struct nfs4_client *clp) |
| { |
| struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); |
| |
| if (!nn->track_reclaim_completes) |
| return; |
| if (!nfsd4_find_reclaim_client(clp->cl_name, nn)) |
| return; |
| if (atomic_inc_return(&nn->nr_reclaim_complete) == |
| nn->reclaim_str_hashtbl_size) { |
| printk(KERN_INFO "NFSD: all clients done reclaiming, ending NFSv4 grace period (net %x)\n", |
| clp->net->ns.inum); |
| nfsd4_end_grace(nn); |
| } |
| } |
| |
| static void expire_client(struct nfs4_client *clp) |
| { |
| unhash_client(clp); |
| nfsd4_client_record_remove(clp); |
| __destroy_client(clp); |
| } |
| |
| static void copy_verf(struct nfs4_client *target, nfs4_verifier *source) |
| { |
| memcpy(target->cl_verifier.data, source->data, |
| sizeof(target->cl_verifier.data)); |
| } |
| |
| static void copy_clid(struct nfs4_client *target, struct nfs4_client *source) |
| { |
| target->cl_clientid.cl_boot = source->cl_clientid.cl_boot; |
| target->cl_clientid.cl_id = source->cl_clientid.cl_id; |
| } |
| |
| static int copy_cred(struct svc_cred *target, struct svc_cred *source) |
| { |
| target->cr_principal = kstrdup(source->cr_principal, GFP_KERNEL); |
| target->cr_raw_principal = kstrdup(source->cr_raw_principal, |
| GFP_KERNEL); |
| target->cr_targ_princ = kstrdup(source->cr_targ_princ, GFP_KERNEL); |
| if ((source->cr_principal && !target->cr_principal) || |
| (source->cr_raw_principal && !target->cr_raw_principal) || |
| (source->cr_targ_princ && !target->cr_targ_princ)) |
| return -ENOMEM; |
| |
| target->cr_flavor = source->cr_flavor; |
| target->cr_uid = source->cr_uid; |
| target->cr_gid = source->cr_gid; |
| target->cr_group_info = source->cr_group_info; |
| get_group_info(target->cr_group_info); |
| target->cr_gss_mech = source->cr_gss_mech; |
| if (source->cr_gss_mech) |
| gss_mech_get(source->cr_gss_mech); |
| return 0; |
| } |
| |
| static int |
| compare_blob(const struct xdr_netobj *o1, const struct xdr_netobj *o2) |
| { |
| if (o1->len < o2->len) |
| return -1; |
| if (o1->len > o2->len) |
| return 1; |
| return memcmp(o1->data, o2->data, o1->len); |
| } |
| |
| static int |
| same_verf(nfs4_verifier *v1, nfs4_verifier *v2) |
| { |
| return 0 == memcmp(v1->data, v2->data, sizeof(v1->data)); |
| } |
| |
| static int |
| same_clid(clientid_t *cl1, clientid_t *cl2) |
| { |
| return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id); |
| } |
| |
| static bool groups_equal(struct group_info *g1, struct group_info *g2) |
| { |
| int i; |
| |
| if (g1->ngroups != g2->ngroups) |
| return false; |
| for (i=0; i<g1->ngroups; i++) |
| if (!gid_eq(g1->gid[i], g2->gid[i])) |
| return false; |
| return true; |
| } |
| |
| /* |
| * RFC 3530 language requires clid_inuse be returned when the |
| * "principal" associated with a requests differs from that previously |
| * used. We use uid, gid's, and gss principal string as our best |
| * approximation. We also don't want to allow non-gss use of a client |
| * established using gss: in theory cr_principal should catch that |
| * change, but in practice cr_principal can be null even in the gss case |
| * since gssd doesn't always pass down a principal string. |
| */ |
| static bool is_gss_cred(struct svc_cred *cr) |
| { |
| /* Is cr_flavor one of the gss "pseudoflavors"?: */ |
| return (cr->cr_flavor > RPC_AUTH_MAXFLAVOR); |
| } |
| |
| |
| static bool |
| same_creds(struct svc_cred *cr1, struct svc_cred *cr2) |
| { |
| if ((is_gss_cred(cr1) != is_gss_cred(cr2)) |
| || (!uid_eq(cr1->cr_uid, cr2->cr_uid)) |
| || (!gid_eq(cr1->cr_gid, cr2->cr_gid)) |
| || !groups_equal(cr1->cr_group_info, cr2->cr_group_info)) |
| return false; |
| /* XXX: check that cr_targ_princ fields match ? */ |
| if (cr1->cr_principal == cr2->cr_principal) |
| return true; |
| if (!cr1->cr_principal || !cr2->cr_principal) |
| return false; |
| return 0 == strcmp(cr1->cr_principal, cr2->cr_principal); |
| } |
| |
| static bool svc_rqst_integrity_protected(struct svc_rqst *rqstp) |
| { |
| struct svc_cred *cr = &rqstp->rq_cred; |
| u32 service; |
| |
| if (!cr->cr_gss_mech) |
| return false; |
| service = gss_pseudoflavor_to_service(cr->cr_gss_mech, cr->cr_flavor); |
| return service == RPC_GSS_SVC_INTEGRITY || |
| service == RPC_GSS_SVC_PRIVACY; |
| } |
| |
| bool nfsd4_mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp) |
| { |
| struct svc_cred *cr = &rqstp->rq_cred; |
| |
| if (!cl->cl_mach_cred) |
| return true; |
| if (cl->cl_cred.cr_gss_mech != cr->cr_gss_mech) |
| return false; |
| if (!svc_rqst_integrity_protected(rqstp)) |
| return false; |
| if (cl->cl_cred.cr_raw_principal) |
| return 0 == strcmp(cl->cl_cred.cr_raw_principal, |
| cr->cr_raw_principal); |
| if (!cr->cr_principal) |
| return false; |
| return 0 == strcmp(cl->cl_cred.cr_principal, cr->cr_principal); |
| } |
| |
| static void gen_confirm(struct nfs4_client *clp, struct nfsd_net *nn) |
| { |
| __be32 verf[2]; |
| |
| /* |
| * This is opaque to client, so no need to byte-swap. Use |
| * __force to keep sparse happy |
| */ |
| verf[0] = (__force __be32)(u32)ktime_get_real_seconds(); |
| verf[1] = (__force __be32)nn->clverifier_counter++; |
| memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data)); |
| } |
| |
| static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn) |
| { |
| clp->cl_clientid.cl_boot = (u32)nn->boot_time; |
| clp->cl_clientid.cl_id = nn->clientid_counter++; |
| gen_confirm(clp, nn); |
| } |
| |
| static struct nfs4_stid * |
| find_stateid_locked(struct nfs4_client *cl, stateid_t *t) |
| { |
| struct nfs4_stid *ret; |
| |
| ret = idr_find(&cl->cl_stateids, t->si_opaque.so_id); |
| if (!ret || !ret->sc_type) |
| return NULL; |
| return ret; |
| } |
| |
| static struct nfs4_stid * |
| find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask) |
| { |
| struct nfs4_stid *s; |
| |
| spin_lock(&cl->cl_lock); |
| s = find_stateid_locked(cl, t); |
| if (s != NULL) { |
| if (typemask & s->sc_type) |
| refcount_inc(&s->sc_count); |
| else |
| s = NULL; |
| } |
| spin_unlock(&cl->cl_lock); |
| return s; |
| } |
| |
| static struct nfs4_client *get_nfsdfs_clp(struct inode *inode) |
| { |
| struct nfsdfs_client *nc; |
| nc = get_nfsdfs_client(inode); |
| if (!nc) |
| return NULL; |
| return container_of(nc, struct nfs4_client, cl_nfsdfs); |
| } |
| |
| static void seq_quote_mem(struct seq_file *m, char *data, int len) |
| { |
| seq_printf(m, "\""); |
| seq_escape_mem_ascii(m, data, len); |
| seq_printf(m, "\""); |
| } |
| |
| static int client_info_show(struct seq_file *m, void *v) |
| { |
| struct inode *inode = m->private; |
| struct nfs4_client *clp; |
| u64 clid; |
| |
| clp = get_nfsdfs_clp(inode); |
| if (!clp) |
| return -ENXIO; |
| memcpy(&clid, &clp->cl_clientid, sizeof(clid)); |
| seq_printf(m, "clientid: 0x%llx\n", clid); |
| seq_printf(m, "address: \"%pISpc\"\n", (struct sockaddr *)&clp->cl_addr); |
| seq_printf(m, "name: "); |
| seq_quote_mem(m, clp->cl_name.data, clp->cl_name.len); |
| seq_printf(m, "\nminor version: %d\n", clp->cl_minorversion); |
| if (clp->cl_nii_domain.data) { |
| seq_printf(m, "Implementation domain: "); |
| seq_quote_mem(m, clp->cl_nii_domain.data, |
| clp->cl_nii_domain.len); |
| seq_printf(m, "\nImplementation name: "); |
| seq_quote_mem(m, clp->cl_nii_name.data, clp->cl_nii_name.len); |
| seq_printf(m, "\nImplementation time: [%lld, %ld]\n", |
| clp->cl_nii_time.tv_sec, clp->cl_nii_time.tv_nsec); |
| } |
| drop_client(clp); |
| |
| return 0; |
| } |
| |
| static int client_info_open(struct inode *inode, struct file *file) |
| { |
| return single_open(file, client_info_show, inode); |
| } |
| |
| static const struct file_operations client_info_fops = { |
| .open = client_info_open, |
| .read = seq_read, |
| .llseek = seq_lseek, |
| .release = single_release, |
| }; |
| |
| static void *states_start(struct seq_file *s, loff_t *pos) |
| __acquires(&clp->cl_lock) |
| { |
| struct nfs4_client *clp = s->private; |
| unsigned long id = *pos; |
| void *ret; |
| |
| spin_lock(&clp->cl_lock); |
| ret = idr_get_next_ul(&clp->cl_stateids, &id); |
| *pos = id; |
| return ret; |
| } |
| |
| static void *states_next(struct seq_file *s, void *v, loff_t *pos) |
| { |
| struct nfs4_client *clp = s->private; |
| unsigned long id = *pos; |
| void *ret; |
| |
| id = *pos; |
| id++; |
| ret = idr_get_next_ul(&clp->cl_stateids, &id); |
| *pos = id; |
| return ret; |
| } |
| |
| static void states_stop(struct seq_file *s, void *v) |
| __releases(&clp->cl_lock) |
| { |
| struct nfs4_client *clp = s->private; |
| |
| spin_unlock(&clp->cl_lock); |
| } |
| |
| static void nfs4_show_fname(struct seq_file *s, struct nfsd_file *f) |
| { |
| seq_printf(s, "filename: \"%pD2\"", f->nf_file); |
| } |
| |
| static void nfs4_show_superblock(struct seq_file *s, struct nfsd_file *f) |
| { |
| struct inode *inode = f->nf_inode; |
| |
| seq_printf(s, "superblock: \"%02x:%02x:%ld\"", |
| MAJOR(inode->i_sb->s_dev), |
| MINOR(inode->i_sb->s_dev), |
| inode->i_ino); |
| } |
| |
| static void nfs4_show_owner(struct seq_file *s, struct nfs4_stateowner *oo) |
| { |
| seq_printf(s, "owner: "); |
| seq_quote_mem(s, oo->so_owner.data, oo->so_owner.len); |
| } |
| |
| static void nfs4_show_stateid(struct seq_file *s, stateid_t *stid) |
| { |
| seq_printf(s, "0x%.8x", stid->si_generation); |
| seq_printf(s, "%12phN", &stid->si_opaque); |
| } |
| |
| static int nfs4_show_open(struct seq_file *s, struct nfs4_stid *st) |
| { |
| struct nfs4_ol_stateid *ols; |
| struct nfs4_file *nf; |
| struct nfsd_file *file; |
| struct nfs4_stateowner *oo; |
| unsigned int access, deny; |
| |
| if (st->sc_type != NFS4_OPEN_STID && st->sc_type != NFS4_LOCK_STID) |
| return 0; /* XXX: or SEQ_SKIP? */ |
| ols = openlockstateid(st); |
| oo = ols->st_stateowner; |
| nf = st->sc_file; |
| file = find_any_file(nf); |
| |
| seq_printf(s, "- "); |
| nfs4_show_stateid(s, &st->sc_stateid); |
| seq_printf(s, ": { type: open, "); |
| |
| access = bmap_to_share_mode(ols->st_access_bmap); |
| deny = bmap_to_share_mode(ols->st_deny_bmap); |
| |
| seq_printf(s, "access: %s%s, ", |
| access & NFS4_SHARE_ACCESS_READ ? "r" : "-", |
| access & NFS4_SHARE_ACCESS_WRITE ? "w" : "-"); |
| seq_printf(s, "deny: %s%s, ", |
| deny & NFS4_SHARE_ACCESS_READ ? "r" : "-", |
| deny & NFS4_SHARE_ACCESS_WRITE ? "w" : "-"); |
| |
| nfs4_show_superblock(s, file); |
| seq_printf(s, ", "); |
| nfs4_show_fname(s, file); |
| seq_printf(s, ", "); |
| nfs4_show_owner(s, oo); |
| seq_printf(s, " }\n"); |
| nfsd_file_put(file); |
| |
| return 0; |
| } |
| |
| static int nfs4_show_lock(struct seq_file *s, struct nfs4_stid *st) |
| { |
| struct nfs4_ol_stateid *ols; |
| struct nfs4_file *nf; |
| struct nfsd_file *file; |
| struct nfs4_stateowner *oo; |
| |
| ols = openlockstateid(st); |
| oo = ols->st_stateowner; |
| nf = st->sc_file; |
| file = find_any_file(nf); |
| |
| seq_printf(s, "- "); |
| nfs4_show_stateid(s, &st->sc_stateid); |
| seq_printf(s, ": { type: lock, "); |
| |
| /* |
| * Note: a lock stateid isn't really the same thing as a lock, |
| * it's the locking state held by one owner on a file, and there |
| * may be multiple (or no) lock ranges associated with it. |
| * (Same for the matter is true of open stateids.) |
| */ |
| |
| nfs4_show_superblock(s, file); |
| /* XXX: open stateid? */ |
| seq_printf(s, ", "); |
| nfs4_show_fname(s, file); |
| seq_printf(s, ", "); |
| nfs4_show_owner(s, oo); |
| seq_printf(s, " }\n"); |
| nfsd_file_put(file); |
| |
| return 0; |
| } |
| |
| static int nfs4_show_deleg(struct seq_file *s, struct nfs4_stid *st) |
| { |
| struct nfs4_delegation *ds; |
| struct nfs4_file *nf; |
| struct nfsd_file *file; |
| |
| ds = delegstateid(st); |
| nf = st->sc_file; |
| file = nf->fi_deleg_file; |
| |
| seq_printf(s, "- "); |
| nfs4_show_stateid(s, &st->sc_stateid); |
| seq_printf(s, ": { type: deleg, "); |
| |
| /* Kinda dead code as long as we only support read delegs: */ |
| seq_printf(s, "access: %s, ", |
| ds->dl_type == NFS4_OPEN_DELEGATE_READ ? "r" : "w"); |
| |
| /* XXX: lease time, whether it's being recalled. */ |
| |
| nfs4_show_superblock(s, file); |
| seq_printf(s, ", "); |
| nfs4_show_fname(s, file); |
| seq_printf(s, " }\n"); |
| |
| return 0; |
| } |
| |
| static int nfs4_show_layout(struct seq_file *s, struct nfs4_stid *st) |
| { |
| struct nfs4_layout_stateid *ls; |
| struct nfsd_file *file; |
| |
| ls = container_of(st, struct nfs4_layout_stateid, ls_stid); |
| file = ls->ls_file; |
| |
| seq_printf(s, "- "); |
| nfs4_show_stateid(s, &st->sc_stateid); |
| seq_printf(s, ": { type: layout, "); |
| |
| /* XXX: What else would be useful? */ |
| |
| nfs4_show_superblock(s, file); |
| seq_printf(s, ", "); |
| nfs4_show_fname(s, file); |
| seq_printf(s, " }\n"); |
| |
| return 0; |
| } |
| |
| static int states_show(struct seq_file *s, void *v) |
| { |
| struct nfs4_stid *st = v; |
| |
| switch (st->sc_type) { |
| case NFS4_OPEN_STID: |
| return nfs4_show_open(s, st); |
| case NFS4_LOCK_STID: |
| return nfs4_show_lock(s, st); |
| case NFS4_DELEG_STID: |
| return nfs4_show_deleg(s, st); |
| case NFS4_LAYOUT_STID: |
| return nfs4_show_layout(s, st); |
| default: |
| return 0; /* XXX: or SEQ_SKIP? */ |
| } |
| /* XXX: copy stateids? */ |
| } |
| |
| static struct seq_operations states_seq_ops = { |
| .start = states_start, |
| .next = states_next, |
| .stop = states_stop, |
| .show = states_show |
| }; |
| |
| static int client_states_open(struct inode *inode, struct file *file) |
| { |
| struct seq_file *s; |
| struct nfs4_client *clp; |
| int ret; |
| |
| clp = get_nfsdfs_clp(inode); |
| if (!clp) |
| return -ENXIO; |
| |
| ret = seq_open(file, &states_seq_ops); |
| if (ret) |
| return ret; |
| s = file->private_data; |
| s->private = clp; |
| return 0; |
| } |
| |
| static int client_opens_release(struct inode *inode, struct file *file) |
| { |
| struct seq_file *m = file->private_data; |
| struct nfs4_client *clp = m->private; |
| |
| /* XXX: alternatively, we could get/drop in seq start/stop */ |
| drop_client(clp); |
| return 0; |
| } |
| |
| static const struct file_operations client_states_fops = { |
| .open = client_states_open, |
| .read = seq_read, |
| .llseek = seq_lseek, |
| .release = client_opens_release, |
| }; |
| |
| /* |
| * Normally we refuse to destroy clients that are in use, but here the |
| * administrator is telling us to just do it. We also want to wait |
| * so the caller has a guarantee that the client's locks are gone by |
| * the time the write returns: |
| */ |
| static void force_expire_client(struct nfs4_client *clp) |
| { |
| struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); |
| bool already_expired; |
| |
| spin_lock(&clp->cl_lock); |
| clp->cl_time = 0; |
| spin_unlock(&clp->cl_lock); |
| |
| wait_event(expiry_wq, atomic_read(&clp->cl_rpc_users) == 0); |
| spin_lock(&nn->client_lock); |
| already_expired = list_empty(&clp->cl_lru); |
| if (!already_expired) |
| unhash_client_locked(clp); |
| spin_unlock(&nn->client_lock); |
| |
| if (!already_expired) |
| expire_client(clp); |
| else |
| wait_event(expiry_wq, clp->cl_nfsd_dentry == NULL); |
| } |
| |
| static ssize_t client_ctl_write(struct file *file, const char __user *buf, |
| size_t size, loff_t *pos) |
| { |
| char *data; |
| struct nfs4_client *clp; |
| |
| data = simple_transaction_get(file, buf, size); |
| if (IS_ERR(data)) |
| return PTR_ERR(data); |
| if (size != 7 || 0 != memcmp(data, "expire\n", 7)) |
| return -EINVAL; |
| clp = get_nfsdfs_clp(file_inode(file)); |
| if (!clp) |
| return -ENXIO; |
| force_expire_client(clp); |
| drop_client(clp); |
| return 7; |
| } |
| |
| static const struct file_operations client_ctl_fops = { |
| .write = client_ctl_write, |
| .release = simple_transaction_release, |
| }; |
| |
| static const struct tree_descr client_files[] = { |
| [0] = {"info", &client_info_fops, S_IRUSR}, |
| [1] = {"states", &client_states_fops, S_IRUSR}, |
| [2] = {"ctl", &client_ctl_fops, S_IWUSR}, |
| [3] = {""}, |
| }; |
| |
| static struct nfs4_client *create_client(struct xdr_netobj name, |
| struct svc_rqst *rqstp, nfs4_verifier *verf) |
| { |
| struct nfs4_client *clp; |
| struct sockaddr *sa = svc_addr(rqstp); |
| int ret; |
| struct net *net = SVC_NET(rqstp); |
| struct nfsd_net *nn = net_generic(net, nfsd_net_id); |
| |
| clp = alloc_client(name); |
| if (clp == NULL) |
| return NULL; |
| |
| ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred); |
| if (ret) { |
| free_client(clp); |
| return NULL; |
| } |
| gen_clid(clp, nn); |
| kref_init(&clp->cl_nfsdfs.cl_ref); |
| nfsd4_init_cb(&clp->cl_cb_null, clp, NULL, NFSPROC4_CLNT_CB_NULL); |
| clp->cl_time = ktime_get_boottime_seconds(); |
| clear_bit(0, &clp->cl_cb_slot_busy); |
| copy_verf(clp, verf); |
| memcpy(&clp->cl_addr, sa, sizeof(struct sockaddr_storage)); |
| clp->cl_cb_session = NULL; |
| clp->net = net; |
| clp->cl_nfsd_dentry = nfsd_client_mkdir(nn, &clp->cl_nfsdfs, |
| clp->cl_clientid.cl_id - nn->clientid_base, |
| client_files); |
| if (!clp->cl_nfsd_dentry) { |
| free_client(clp); |
| return NULL; |
| } |
| return clp; |
| } |
| |
| static void |
| add_clp_to_name_tree(struct nfs4_client *new_clp, struct rb_root *root) |
| { |
| struct rb_node **new = &(root->rb_node), *parent = NULL; |
| struct nfs4_client *clp; |
| |
| while (*new) { |
| clp = rb_entry(*new, struct nfs4_client, cl_namenode); |
| parent = *new; |
| |
| if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0) |
| new = &((*new)->rb_left); |
| else |
| new = &((*new)->rb_right); |
| } |
| |
| rb_link_node(&new_clp->cl_namenode, parent, new); |
| rb_insert_color(&new_clp->cl_namenode, root); |
| } |
| |
| static struct nfs4_client * |
| find_clp_in_name_tree(struct xdr_netobj *name, struct rb_root *root) |
| { |
| int cmp; |
| struct rb_node *node = root->rb_node; |
| struct nfs4_client *clp; |
| |
| while (node) { |
| clp = rb_entry(node, struct nfs4_client, cl_namenode); |
| cmp = compare_blob(&clp->cl_name, name); |
| if (cmp > 0) |
| node = node->rb_left; |
| else if (cmp < 0) |
| node = node->rb_right; |
| else |
| return clp; |
| } |
| return NULL; |
| } |
| |
| static void |
| add_to_unconfirmed(struct nfs4_client *clp) |
| { |
| unsigned int idhashval; |
| struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); |
| |
| lockdep_assert_held(&nn->client_lock); |
| |
| clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags); |
| add_clp_to_name_tree(clp, &nn->unconf_name_tree); |
| idhashval = clientid_hashval(clp->cl_clientid.cl_id); |
| list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]); |
| renew_client_locked(clp); |
| } |
| |
| static void |
| move_to_confirmed(struct nfs4_client *clp) |
| { |
| unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id); |
| struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); |
| |
| lockdep_assert_held(&nn->client_lock); |
| |
| dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp); |
| list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]); |
| rb_erase(&clp->cl_namenode, &nn->unconf_name_tree); |
| add_clp_to_name_tree(clp, &nn->conf_name_tree); |
| set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags); |
| renew_client_locked(clp); |
| } |
| |
| static struct nfs4_client * |
| find_client_in_id_table(struct list_head *tbl, clientid_t *clid, bool sessions) |
| { |
| struct nfs4_client *clp; |
| unsigned int idhashval = clientid_hashval(clid->cl_id); |
| |
| list_for_each_entry(clp, &tbl[idhashval], cl_idhash) { |
| if (same_clid(&clp->cl_clientid, clid)) { |
| if ((bool)clp->cl_minorversion != sessions) |
| return NULL; |
| renew_client_locked(clp); |
| return clp; |
| } |
| } |
| return NULL; |
| } |
| |
| static struct nfs4_client * |
| find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn) |
| { |
| struct list_head *tbl = nn->conf_id_hashtbl; |
| |
| lockdep_assert_held(&nn->client_lock); |
| return find_client_in_id_table(tbl, clid, sessions); |
| } |
| |
| static struct nfs4_client * |
| find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn) |
| { |
| struct list_head *tbl = nn->unconf_id_hashtbl; |
| |
| lockdep_assert_held(&nn->client_lock); |
| return find_client_in_id_table(tbl, clid, sessions); |
| } |
| |
| static bool clp_used_exchangeid(struct nfs4_client *clp) |
| { |
| return clp->cl_exchange_flags != 0; |
| } |
| |
| static struct nfs4_client * |
| find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn) |
| { |
| lockdep_assert_held(&nn->client_lock); |
| return find_clp_in_name_tree(name, &nn->conf_name_tree); |
| } |
| |
| static struct nfs4_client * |
| find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn) |
| { |
| lockdep_assert_held(&nn->client_lock); |
| return find_clp_in_name_tree(name, &nn->unconf_name_tree); |
| } |
| |
| static void |
| gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp) |
| { |
| struct nfs4_cb_conn *conn = &clp->cl_cb_conn; |
| struct sockaddr *sa = svc_addr(rqstp); |
| u32 scopeid = rpc_get_scope_id(sa); |
| unsigned short expected_family; |
| |
| /* Currently, we only support tcp and tcp6 for the callback channel */ |
| if (se->se_callback_netid_len == 3 && |
| !memcmp(se->se_callback_netid_val, "tcp", 3)) |
| expected_family = AF_INET; |
| else if (se->se_callback_netid_len == 4 && |
| !memcmp(se->se_callback_netid_val, "tcp6", 4)) |
| expected_family = AF_INET6; |
| else |
| goto out_err; |
| |
| conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val, |
| se->se_callback_addr_len, |
| (struct sockaddr *)&conn->cb_addr, |
| sizeof(conn->cb_addr)); |
| |
| if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family) |
| goto out_err; |
| |
| if (conn->cb_addr.ss_family == AF_INET6) |
| ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid; |
| |
| conn->cb_prog = se->se_callback_prog; |
| conn->cb_ident = se->se_callback_ident; |
| memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen); |
| trace_nfsd_cb_args(clp, conn); |
| return; |
| out_err: |
| conn->cb_addr.ss_family = AF_UNSPEC; |
| conn->cb_addrlen = 0; |
| trace_nfsd_cb_nodelegs(clp); |
| return; |
| } |
| |
| /* |
| * Cache a reply. nfsd4_check_resp_size() has bounded the cache size. |
| */ |
| static void |
| nfsd4_store_cache_entry(struct nfsd4_compoundres *resp) |
| { |
| struct xdr_buf *buf = resp->xdr.buf; |
| struct nfsd4_slot *slot = resp->cstate.slot; |
| unsigned int base; |
| |
| dprintk("--> %s slot %p\n", __func__, slot); |
| |
| slot->sl_flags |= NFSD4_SLOT_INITIALIZED; |
| slot->sl_opcnt = resp->opcnt; |
| slot->sl_status = resp->cstate.status; |
| free_svc_cred(&slot->sl_cred); |
| copy_cred(&slot->sl_cred, &resp->rqstp->rq_cred); |
| |
| if (!nfsd4_cache_this(resp)) { |
| slot->sl_flags &= ~NFSD4_SLOT_CACHED; |
| return; |
| } |
| slot->sl_flags |= NFSD4_SLOT_CACHED; |
| |
| base = resp->cstate.data_offset; |
| slot->sl_datalen = buf->len - base; |
| if (read_bytes_from_xdr_buf(buf, base, slot->sl_data, slot->sl_datalen)) |
| WARN(1, "%s: sessions DRC could not cache compound\n", |
| __func__); |
| return; |
| } |
| |
| /* |
| * Encode the replay sequence operation from the slot values. |
| * If cachethis is FALSE encode the uncached rep error on the next |
| * operation which sets resp->p and increments resp->opcnt for |
| * nfs4svc_encode_compoundres. |
| * |
| */ |
| static __be32 |
| nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args, |
| struct nfsd4_compoundres *resp) |
| { |
| struct nfsd4_op *op; |
| struct nfsd4_slot *slot = resp->cstate.slot; |
| |
| /* Encode the replayed sequence operation */ |
| op = &args->ops[resp->opcnt - 1]; |
| nfsd4_encode_operation(resp, op); |
| |
| if (slot->sl_flags & NFSD4_SLOT_CACHED) |
| return op->status; |
| if (args->opcnt == 1) { |
| /* |
| * The original operation wasn't a solo sequence--we |
| * always cache those--so this retry must not match the |
| * original: |
| */ |
| op->status = nfserr_seq_false_retry; |
| } else { |
| op = &args->ops[resp->opcnt++]; |
| op->status = nfserr_retry_uncached_rep; |
| nfsd4_encode_operation(resp, op); |
| } |
| return op->status; |
| } |
| |
| /* |
| * The sequence operation is not cached because we can use the slot and |
| * session values. |
| */ |
| static __be32 |
| nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp, |
| struct nfsd4_sequence *seq) |
| { |
| struct nfsd4_slot *slot = resp->cstate.slot; |
| struct xdr_stream *xdr = &resp->xdr; |
| __be32 *p; |
| __be32 status; |
| |
| dprintk("--> %s slot %p\n", __func__, slot); |
| |
| status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp); |
| if (status) |
| return status; |
| |
| p = xdr_reserve_space(xdr, slot->sl_datalen); |
| if (!p) { |
| WARN_ON_ONCE(1); |
| return nfserr_serverfault; |
| } |
| xdr_encode_opaque_fixed(p, slot->sl_data, slot->sl_datalen); |
| xdr_commit_encode(xdr); |
| |
| resp->opcnt = slot->sl_opcnt; |
| return slot->sl_status; |
| } |
| |
| /* |
| * Set the exchange_id flags returned by the server. |
| */ |
| static void |
| nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid) |
| { |
| #ifdef CONFIG_NFSD_PNFS |
| new->cl_exchange_flags |= EXCHGID4_FLAG_USE_PNFS_MDS; |
| #else |
| new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS; |
| #endif |
| |
| /* Referrals are supported, Migration is not. */ |
| new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER; |
| |
| /* set the wire flags to return to client. */ |
| clid->flags = new->cl_exchange_flags; |
| } |
| |
| static bool client_has_openowners(struct nfs4_client *clp) |
| { |
| struct nfs4_openowner *oo; |
| |
| list_for_each_entry(oo, &clp->cl_openowners, oo_perclient) { |
| if (!list_empty(&oo->oo_owner.so_stateids)) |
| return true; |
| } |
| return false; |
| } |
| |
| static bool client_has_state(struct nfs4_client *clp) |
| { |
| return client_has_openowners(clp) |
| #ifdef CONFIG_NFSD_PNFS |
| || !list_empty(&clp->cl_lo_states) |
| #endif |
| || !list_empty(&clp->cl_delegations) |
| || !list_empty(&clp->cl_sessions) |
| || !list_empty(&clp->async_copies); |
| } |
| |
| static __be32 copy_impl_id(struct nfs4_client *clp, |
| struct nfsd4_exchange_id *exid) |
| { |
| if (!exid->nii_domain.data) |
| return 0; |
| xdr_netobj_dup(&clp->cl_nii_domain, &exid->nii_domain, GFP_KERNEL); |
| if (!clp->cl_nii_domain.data) |
| return nfserr_jukebox; |
| xdr_netobj_dup(&clp->cl_nii_name, &exid->nii_name, GFP_KERNEL); |
| if (!clp->cl_nii_name.data) |
| return nfserr_jukebox; |
| clp->cl_nii_time = exid->nii_time; |
| return 0; |
| } |
| |
| __be32 |
| nfsd4_exchange_id(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
| union nfsd4_op_u *u) |
| { |
| struct nfsd4_exchange_id *exid = &u->exchange_id; |
| struct nfs4_client *conf, *new; |
| struct nfs4_client *unconf = NULL; |
| __be32 status; |
| char addr_str[INET6_ADDRSTRLEN]; |
| nfs4_verifier verf = exid->verifier; |
| struct sockaddr *sa = svc_addr(rqstp); |
| bool update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A; |
| struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); |
| |
| rpc_ntop(sa, addr_str, sizeof(addr_str)); |
| dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p " |
| "ip_addr=%s flags %x, spa_how %d\n", |
| __func__, rqstp, exid, exid->clname.len, exid->clname.data, |
| addr_str, exid->flags, exid->spa_how); |
| |
| if (exid->flags & ~EXCHGID4_FLAG_MASK_A) |
| return nfserr_inval; |
| |
| new = create_client(exid->clname, rqstp, &verf); |
| if (new == NULL) |
| return nfserr_jukebox; |
| status = copy_impl_id(new, exid); |
| if (status) |
| goto out_nolock; |
| |
| switch (exid->spa_how) { |
| case SP4_MACH_CRED: |
| exid->spo_must_enforce[0] = 0; |
| exid->spo_must_enforce[1] = ( |
| 1 << (OP_BIND_CONN_TO_SESSION - 32) | |
| 1 << (OP_EXCHANGE_ID - 32) | |
| 1 << (OP_CREATE_SESSION - 32) | |
| 1 << (OP_DESTROY_SESSION - 32) | |
|