|
@@ -42,6 +42,7 @@
|
|
|
#include <linux/sunrpc/clnt.h>
|
|
|
#include "xdr4.h"
|
|
|
#include "vfs.h"
|
|
|
+#include "current_stateid.h"
|
|
|
|
|
|
#define NFSDDBG_FACILITY NFSDDBG_PROC
|
|
|
|
|
@@ -447,37 +448,69 @@ static struct list_head close_lru;
|
|
|
*
|
|
|
* which we should reject.
|
|
|
*/
|
|
|
-static void
|
|
|
-set_access(unsigned int *access, unsigned long bmap) {
|
|
|
+static unsigned int
|
|
|
+bmap_to_share_mode(unsigned long bmap) {
|
|
|
int i;
|
|
|
+ unsigned int access = 0;
|
|
|
|
|
|
- *access = 0;
|
|
|
for (i = 1; i < 4; i++) {
|
|
|
if (test_bit(i, &bmap))
|
|
|
- *access |= i;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-static void
|
|
|
-set_deny(unsigned int *deny, unsigned long bmap) {
|
|
|
- int i;
|
|
|
-
|
|
|
- *deny = 0;
|
|
|
- for (i = 0; i < 4; i++) {
|
|
|
- if (test_bit(i, &bmap))
|
|
|
- *deny |= i ;
|
|
|
+ access |= i;
|
|
|
}
|
|
|
+ return access;
|
|
|
}
|
|
|
|
|
|
-static int
|
|
|
+static bool
|
|
|
test_share(struct nfs4_ol_stateid *stp, struct nfsd4_open *open) {
|
|
|
unsigned int access, deny;
|
|
|
|
|
|
- set_access(&access, stp->st_access_bmap);
|
|
|
- set_deny(&deny, stp->st_deny_bmap);
|
|
|
+ access = bmap_to_share_mode(stp->st_access_bmap);
|
|
|
+ deny = bmap_to_share_mode(stp->st_deny_bmap);
|
|
|
if ((access & open->op_share_deny) || (deny & open->op_share_access))
|
|
|
- return 0;
|
|
|
- return 1;
|
|
|
+ return false;
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/* set share access for a given stateid */
|
|
|
+static inline void
|
|
|
+set_access(u32 access, struct nfs4_ol_stateid *stp)
|
|
|
+{
|
|
|
+ __set_bit(access, &stp->st_access_bmap);
|
|
|
+}
|
|
|
+
|
|
|
+/* clear share access for a given stateid */
|
|
|
+static inline void
|
|
|
+clear_access(u32 access, struct nfs4_ol_stateid *stp)
|
|
|
+{
|
|
|
+ __clear_bit(access, &stp->st_access_bmap);
|
|
|
+}
|
|
|
+
|
|
|
+/* test whether a given stateid has access */
|
|
|
+static inline bool
|
|
|
+test_access(u32 access, struct nfs4_ol_stateid *stp)
|
|
|
+{
|
|
|
+ return test_bit(access, &stp->st_access_bmap);
|
|
|
+}
|
|
|
+
|
|
|
+/* set share deny for a given stateid */
|
|
|
+static inline void
|
|
|
+set_deny(u32 access, struct nfs4_ol_stateid *stp)
|
|
|
+{
|
|
|
+ __set_bit(access, &stp->st_deny_bmap);
|
|
|
+}
|
|
|
+
|
|
|
+/* clear share deny for a given stateid */
|
|
|
+static inline void
|
|
|
+clear_deny(u32 access, struct nfs4_ol_stateid *stp)
|
|
|
+{
|
|
|
+ __clear_bit(access, &stp->st_deny_bmap);
|
|
|
+}
|
|
|
+
|
|
|
+/* test whether a given stateid is denying specific access */
|
|
|
+static inline bool
|
|
|
+test_deny(u32 access, struct nfs4_ol_stateid *stp)
|
|
|
+{
|
|
|
+ return test_bit(access, &stp->st_deny_bmap);
|
|
|
}
|
|
|
|
|
|
static int nfs4_access_to_omode(u32 access)
|
|
@@ -493,6 +526,20 @@ static int nfs4_access_to_omode(u32 access)
|
|
|
BUG();
|
|
|
}
|
|
|
|
|
|
+/* release all access and file references for a given stateid */
|
|
|
+static void
|
|
|
+release_all_access(struct nfs4_ol_stateid *stp)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+
|
|
|
+ for (i = 1; i < 4; i++) {
|
|
|
+ if (test_access(i, stp))
|
|
|
+ nfs4_file_put_access(stp->st_file,
|
|
|
+ nfs4_access_to_omode(i));
|
|
|
+ clear_access(i, stp);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
static void unhash_generic_stateid(struct nfs4_ol_stateid *stp)
|
|
|
{
|
|
|
list_del(&stp->st_perfile);
|
|
@@ -501,16 +548,7 @@ static void unhash_generic_stateid(struct nfs4_ol_stateid *stp)
|
|
|
|
|
|
static void close_generic_stateid(struct nfs4_ol_stateid *stp)
|
|
|
{
|
|
|
- int i;
|
|
|
-
|
|
|
- if (stp->st_access_bmap) {
|
|
|
- for (i = 1; i < 4; i++) {
|
|
|
- if (test_bit(i, &stp->st_access_bmap))
|
|
|
- nfs4_file_put_access(stp->st_file,
|
|
|
- nfs4_access_to_omode(i));
|
|
|
- __clear_bit(i, &stp->st_access_bmap);
|
|
|
- }
|
|
|
- }
|
|
|
+ release_all_access(stp);
|
|
|
put_nfs4_file(stp->st_file);
|
|
|
stp->st_file = NULL;
|
|
|
}
|
|
@@ -885,7 +923,7 @@ static struct nfsd4_session *alloc_init_session(struct svc_rqst *rqstp, struct n
|
|
|
struct nfsd4_session *new;
|
|
|
struct nfsd4_channel_attrs *fchan = &cses->fore_channel;
|
|
|
int numslots, slotsize;
|
|
|
- int status;
|
|
|
+ __be32 status;
|
|
|
int idx;
|
|
|
|
|
|
/*
|
|
@@ -984,7 +1022,8 @@ static inline void
|
|
|
renew_client_locked(struct nfs4_client *clp)
|
|
|
{
|
|
|
if (is_client_expired(clp)) {
|
|
|
- dprintk("%s: client (clientid %08x/%08x) already expired\n",
|
|
|
+ WARN_ON(1);
|
|
|
+ printk("%s: client (clientid %08x/%08x) already expired\n",
|
|
|
__func__,
|
|
|
clp->cl_clientid.cl_boot,
|
|
|
clp->cl_clientid.cl_id);
|
|
@@ -1049,9 +1088,7 @@ free_client(struct nfs4_client *clp)
|
|
|
list_del(&ses->se_perclnt);
|
|
|
nfsd4_put_session_locked(ses);
|
|
|
}
|
|
|
- if (clp->cl_cred.cr_group_info)
|
|
|
- put_group_info(clp->cl_cred.cr_group_info);
|
|
|
- kfree(clp->cl_principal);
|
|
|
+ free_svc_cred(&clp->cl_cred);
|
|
|
kfree(clp->cl_name.data);
|
|
|
kfree(clp);
|
|
|
}
|
|
@@ -1132,12 +1169,21 @@ static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
|
|
|
target->cl_clientid.cl_id = source->cl_clientid.cl_id;
|
|
|
}
|
|
|
|
|
|
-static void copy_cred(struct svc_cred *target, struct svc_cred *source)
|
|
|
+static int copy_cred(struct svc_cred *target, struct svc_cred *source)
|
|
|
{
|
|
|
+ if (source->cr_principal) {
|
|
|
+ target->cr_principal =
|
|
|
+ kstrdup(source->cr_principal, GFP_KERNEL);
|
|
|
+ if (target->cr_principal == NULL)
|
|
|
+ return -ENOMEM;
|
|
|
+ } else
|
|
|
+ target->cr_principal = NULL;
|
|
|
+ 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);
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
static int same_name(const char *n1, const char *n2)
|
|
@@ -1157,11 +1203,31 @@ same_clid(clientid_t *cl1, clientid_t *cl2)
|
|
|
return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
|
|
|
}
|
|
|
|
|
|
-/* XXX what about NGROUP */
|
|
|
+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 (GROUP_AT(g1, i) != GROUP_AT(g2, i))
|
|
|
+ return false;
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
static int
|
|
|
same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
|
|
|
{
|
|
|
- return cr1->cr_uid == cr2->cr_uid;
|
|
|
+ if ((cr1->cr_flavor != cr2->cr_flavor)
|
|
|
+ || (cr1->cr_uid != cr2->cr_uid)
|
|
|
+ || (cr1->cr_gid != cr2->cr_gid)
|
|
|
+ || !groups_equal(cr1->cr_group_info, cr2->cr_group_info))
|
|
|
+ return false;
|
|
|
+ if (cr1->cr_principal == cr2->cr_principal)
|
|
|
+ return true;
|
|
|
+ if (!cr1->cr_principal || !cr2->cr_principal)
|
|
|
+ return false;
|
|
|
+ return 0 == strcmp(cr1->cr_principal, cr1->cr_principal);
|
|
|
}
|
|
|
|
|
|
static void gen_clid(struct nfs4_client *clp)
|
|
@@ -1204,25 +1270,20 @@ static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir,
|
|
|
{
|
|
|
struct nfs4_client *clp;
|
|
|
struct sockaddr *sa = svc_addr(rqstp);
|
|
|
- char *princ;
|
|
|
+ int ret;
|
|
|
|
|
|
clp = alloc_client(name);
|
|
|
if (clp == NULL)
|
|
|
return NULL;
|
|
|
|
|
|
INIT_LIST_HEAD(&clp->cl_sessions);
|
|
|
-
|
|
|
- princ = svc_gss_principal(rqstp);
|
|
|
- if (princ) {
|
|
|
- clp->cl_principal = kstrdup(princ, GFP_KERNEL);
|
|
|
- if (clp->cl_principal == NULL) {
|
|
|
- spin_lock(&client_lock);
|
|
|
- free_client(clp);
|
|
|
- spin_unlock(&client_lock);
|
|
|
- return NULL;
|
|
|
- }
|
|
|
+ ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred);
|
|
|
+ if (ret) {
|
|
|
+ spin_lock(&client_lock);
|
|
|
+ free_client(clp);
|
|
|
+ spin_unlock(&client_lock);
|
|
|
+ return NULL;
|
|
|
}
|
|
|
-
|
|
|
idr_init(&clp->cl_stateids);
|
|
|
memcpy(clp->cl_recdir, recdir, HEXDIR_LEN);
|
|
|
atomic_set(&clp->cl_refcount, 0);
|
|
@@ -1240,8 +1301,6 @@ static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir,
|
|
|
rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
|
|
|
copy_verf(clp, verf);
|
|
|
rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
|
|
|
- clp->cl_flavor = rqstp->rq_flavor;
|
|
|
- copy_cred(&clp->cl_cred, &rqstp->rq_cred);
|
|
|
gen_confirm(clp);
|
|
|
clp->cl_cb_session = NULL;
|
|
|
return clp;
|
|
@@ -1470,18 +1529,32 @@ nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
|
|
|
clid->flags = new->cl_exchange_flags;
|
|
|
}
|
|
|
|
|
|
+static bool client_has_state(struct nfs4_client *clp)
|
|
|
+{
|
|
|
+ /*
|
|
|
+ * Note clp->cl_openowners check isn't quite right: there's no
|
|
|
+ * need to count owners without stateid's.
|
|
|
+ *
|
|
|
+ * Also note we should probably be using this in 4.0 case too.
|
|
|
+ */
|
|
|
+ return !list_empty(&clp->cl_openowners)
|
|
|
+ || !list_empty(&clp->cl_delegations)
|
|
|
+ || !list_empty(&clp->cl_sessions);
|
|
|
+}
|
|
|
+
|
|
|
__be32
|
|
|
nfsd4_exchange_id(struct svc_rqst *rqstp,
|
|
|
struct nfsd4_compound_state *cstate,
|
|
|
struct nfsd4_exchange_id *exid)
|
|
|
{
|
|
|
struct nfs4_client *unconf, *conf, *new;
|
|
|
- int status;
|
|
|
+ __be32 status;
|
|
|
unsigned int strhashval;
|
|
|
char dname[HEXDIR_LEN];
|
|
|
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;
|
|
|
|
|
|
rpc_ntop(sa, addr_str, sizeof(addr_str));
|
|
|
dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
|
|
@@ -1507,71 +1580,63 @@ nfsd4_exchange_id(struct svc_rqst *rqstp,
|
|
|
status = nfs4_make_rec_clidname(dname, &exid->clname);
|
|
|
|
|
|
if (status)
|
|
|
- goto error;
|
|
|
+ return status;
|
|
|
|
|
|
strhashval = clientstr_hashval(dname);
|
|
|
|
|
|
+ /* Cases below refer to rfc 5661 section 18.35.4: */
|
|
|
nfs4_lock_state();
|
|
|
- status = nfs_ok;
|
|
|
-
|
|
|
conf = find_confirmed_client_by_str(dname, strhashval);
|
|
|
if (conf) {
|
|
|
- if (!clp_used_exchangeid(conf)) {
|
|
|
- status = nfserr_clid_inuse; /* XXX: ? */
|
|
|
- goto out;
|
|
|
- }
|
|
|
- if (!same_verf(&verf, &conf->cl_verifier)) {
|
|
|
- /* 18.35.4 case 8 */
|
|
|
- if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
|
|
|
+ bool creds_match = same_creds(&conf->cl_cred, &rqstp->rq_cred);
|
|
|
+ bool verfs_match = same_verf(&verf, &conf->cl_verifier);
|
|
|
+
|
|
|
+ if (update) {
|
|
|
+ if (!clp_used_exchangeid(conf)) { /* buggy client */
|
|
|
+ status = nfserr_inval;
|
|
|
+ goto out;
|
|
|
+ }
|
|
|
+ if (!creds_match) { /* case 9 */
|
|
|
+ status = nfserr_perm;
|
|
|
+ goto out;
|
|
|
+ }
|
|
|
+ if (!verfs_match) { /* case 8 */
|
|
|
status = nfserr_not_same;
|
|
|
goto out;
|
|
|
}
|
|
|
- /* Client reboot: destroy old state */
|
|
|
- expire_client(conf);
|
|
|
- goto out_new;
|
|
|
+ /* case 6 */
|
|
|
+ exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
|
|
|
+ new = conf;
|
|
|
+ goto out_copy;
|
|
|
}
|
|
|
- if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
|
|
|
- /* 18.35.4 case 9 */
|
|
|
- if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
|
|
|
- status = nfserr_perm;
|
|
|
+ if (!creds_match) { /* case 3 */
|
|
|
+ if (client_has_state(conf)) {
|
|
|
+ status = nfserr_clid_inuse;
|
|
|
goto out;
|
|
|
}
|
|
|
expire_client(conf);
|
|
|
goto out_new;
|
|
|
}
|
|
|
- /*
|
|
|
- * Set bit when the owner id and verifier map to an already
|
|
|
- * confirmed client id (18.35.3).
|
|
|
- */
|
|
|
- exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
|
|
|
-
|
|
|
- /*
|
|
|
- * Falling into 18.35.4 case 2, possible router replay.
|
|
|
- * Leave confirmed record intact and return same result.
|
|
|
- */
|
|
|
- copy_verf(conf, &verf);
|
|
|
- new = conf;
|
|
|
- goto out_copy;
|
|
|
+ if (verfs_match) { /* case 2 */
|
|
|
+ conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
|
|
|
+ new = conf;
|
|
|
+ goto out_copy;
|
|
|
+ }
|
|
|
+ /* case 5, client reboot */
|
|
|
+ goto out_new;
|
|
|
}
|
|
|
|
|
|
- /* 18.35.4 case 7 */
|
|
|
- if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
|
|
|
+ if (update) { /* case 7 */
|
|
|
status = nfserr_noent;
|
|
|
goto out;
|
|
|
}
|
|
|
|
|
|
unconf = find_unconfirmed_client_by_str(dname, strhashval);
|
|
|
- if (unconf) {
|
|
|
- /*
|
|
|
- * Possible retry or client restart. Per 18.35.4 case 4,
|
|
|
- * a new unconfirmed record should be generated regardless
|
|
|
- * of whether any properties have changed.
|
|
|
- */
|
|
|
+ if (unconf) /* case 4, possible retry or client restart */
|
|
|
expire_client(unconf);
|
|
|
- }
|
|
|
|
|
|
+ /* case 1 (normal case) */
|
|
|
out_new:
|
|
|
- /* Normal case */
|
|
|
new = create_client(exid->clname, dname, rqstp, &verf);
|
|
|
if (new == NULL) {
|
|
|
status = nfserr_jukebox;
|
|
@@ -1584,7 +1649,7 @@ out_copy:
|
|
|
exid->clientid.cl_boot = new->cl_clientid.cl_boot;
|
|
|
exid->clientid.cl_id = new->cl_clientid.cl_id;
|
|
|
|
|
|
- exid->seqid = 1;
|
|
|
+ exid->seqid = new->cl_cs_slot.sl_seqid + 1;
|
|
|
nfsd4_set_ex_flags(new, exid);
|
|
|
|
|
|
dprintk("nfsd4_exchange_id seqid %d flags %x\n",
|
|
@@ -1593,12 +1658,10 @@ out_copy:
|
|
|
|
|
|
out:
|
|
|
nfs4_unlock_state();
|
|
|
-error:
|
|
|
- dprintk("nfsd4_exchange_id returns %d\n", ntohl(status));
|
|
|
return status;
|
|
|
}
|
|
|
|
|
|
-static int
|
|
|
+static __be32
|
|
|
check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
|
|
|
{
|
|
|
dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
|
|
@@ -1626,7 +1689,7 @@ check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
|
|
|
*/
|
|
|
static void
|
|
|
nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
|
|
|
- struct nfsd4_clid_slot *slot, int nfserr)
|
|
|
+ struct nfsd4_clid_slot *slot, __be32 nfserr)
|
|
|
{
|
|
|
slot->sl_status = nfserr;
|
|
|
memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
|
|
@@ -1657,7 +1720,7 @@ nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
|
|
|
/* seqid, slotID, slotID, slotID, status */ \
|
|
|
5 ) * sizeof(__be32))
|
|
|
|
|
|
-static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs fchannel)
|
|
|
+static bool check_forechannel_attrs(struct nfsd4_channel_attrs fchannel)
|
|
|
{
|
|
|
return fchannel.maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ
|
|
|
|| fchannel.maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ;
|
|
@@ -1673,7 +1736,7 @@ nfsd4_create_session(struct svc_rqst *rqstp,
|
|
|
struct nfsd4_session *new;
|
|
|
struct nfsd4_clid_slot *cs_slot = NULL;
|
|
|
bool confirm_me = false;
|
|
|
- int status = 0;
|
|
|
+ __be32 status = 0;
|
|
|
|
|
|
if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
|
|
|
return nfserr_inval;
|
|
@@ -1686,16 +1749,10 @@ nfsd4_create_session(struct svc_rqst *rqstp,
|
|
|
cs_slot = &conf->cl_cs_slot;
|
|
|
status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
|
|
|
if (status == nfserr_replay_cache) {
|
|
|
- dprintk("Got a create_session replay! seqid= %d\n",
|
|
|
- cs_slot->sl_seqid);
|
|
|
- /* Return the cached reply status */
|
|
|
status = nfsd4_replay_create_session(cr_ses, cs_slot);
|
|
|
goto out;
|
|
|
} else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
|
|
|
status = nfserr_seq_misordered;
|
|
|
- dprintk("Sequence misordered!\n");
|
|
|
- dprintk("Expected seqid= %d but got seqid= %d\n",
|
|
|
- cs_slot->sl_seqid, cr_ses->seqid);
|
|
|
goto out;
|
|
|
}
|
|
|
} else if (unconf) {
|
|
@@ -1704,7 +1761,6 @@ nfsd4_create_session(struct svc_rqst *rqstp,
|
|
|
status = nfserr_clid_inuse;
|
|
|
goto out;
|
|
|
}
|
|
|
-
|
|
|
cs_slot = &unconf->cl_cs_slot;
|
|
|
status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
|
|
|
if (status) {
|
|
@@ -1712,7 +1768,6 @@ nfsd4_create_session(struct svc_rqst *rqstp,
|
|
|
status = nfserr_seq_misordered;
|
|
|
goto out;
|
|
|
}
|
|
|
-
|
|
|
confirm_me = true;
|
|
|
conf = unconf;
|
|
|
} else {
|
|
@@ -1749,8 +1804,14 @@ nfsd4_create_session(struct svc_rqst *rqstp,
|
|
|
|
|
|
/* cache solo and embedded create sessions under the state lock */
|
|
|
nfsd4_cache_create_session(cr_ses, cs_slot, status);
|
|
|
- if (confirm_me)
|
|
|
+ if (confirm_me) {
|
|
|
+ unsigned int hash = clientstr_hashval(unconf->cl_recdir);
|
|
|
+ struct nfs4_client *old =
|
|
|
+ find_confirmed_client_by_str(conf->cl_recdir, hash);
|
|
|
+ if (old)
|
|
|
+ expire_client(old);
|
|
|
move_to_confirmed(conf);
|
|
|
+ }
|
|
|
out:
|
|
|
nfs4_unlock_state();
|
|
|
dprintk("%s returns %d\n", __func__, ntohl(status));
|
|
@@ -1818,7 +1879,7 @@ nfsd4_destroy_session(struct svc_rqst *r,
|
|
|
struct nfsd4_destroy_session *sessionid)
|
|
|
{
|
|
|
struct nfsd4_session *ses;
|
|
|
- u32 status = nfserr_badsession;
|
|
|
+ __be32 status = nfserr_badsession;
|
|
|
|
|
|
/* Notes:
|
|
|
* - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid
|
|
@@ -1914,7 +1975,7 @@ nfsd4_sequence(struct svc_rqst *rqstp,
|
|
|
struct nfsd4_session *session;
|
|
|
struct nfsd4_slot *slot;
|
|
|
struct nfsd4_conn *conn;
|
|
|
- int status;
|
|
|
+ __be32 status;
|
|
|
|
|
|
if (resp->opcnt != 1)
|
|
|
return nfserr_sequence_pos;
|
|
@@ -2008,18 +2069,11 @@ out:
|
|
|
return status;
|
|
|
}
|
|
|
|
|
|
-static inline bool has_resources(struct nfs4_client *clp)
|
|
|
-{
|
|
|
- return !list_empty(&clp->cl_openowners)
|
|
|
- || !list_empty(&clp->cl_delegations)
|
|
|
- || !list_empty(&clp->cl_sessions);
|
|
|
-}
|
|
|
-
|
|
|
__be32
|
|
|
nfsd4_destroy_clientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_destroy_clientid *dc)
|
|
|
{
|
|
|
struct nfs4_client *conf, *unconf, *clp;
|
|
|
- int status = 0;
|
|
|
+ __be32 status = 0;
|
|
|
|
|
|
nfs4_lock_state();
|
|
|
unconf = find_unconfirmed_client(&dc->clientid);
|
|
@@ -2028,7 +2082,7 @@ nfsd4_destroy_clientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *csta
|
|
|
if (conf) {
|
|
|
clp = conf;
|
|
|
|
|
|
- if (!is_client_expired(conf) && has_resources(conf)) {
|
|
|
+ if (!is_client_expired(conf) && client_has_state(conf)) {
|
|
|
status = nfserr_clientid_busy;
|
|
|
goto out;
|
|
|
}
|
|
@@ -2055,7 +2109,7 @@ out:
|
|
|
__be32
|
|
|
nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
|
|
|
{
|
|
|
- int status = 0;
|
|
|
+ __be32 status = 0;
|
|
|
|
|
|
if (rc->rca_one_fs) {
|
|
|
if (!cstate->current_fh.fh_dentry)
|
|
@@ -2106,17 +2160,13 @@ nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
if (status)
|
|
|
return status;
|
|
|
|
|
|
- /*
|
|
|
- * XXX The Duplicate Request Cache (DRC) has been checked (??)
|
|
|
- * We get here on a DRC miss.
|
|
|
- */
|
|
|
-
|
|
|
strhashval = clientstr_hashval(dname);
|
|
|
|
|
|
+ /* Cases below refer to rfc 3530 section 14.2.33: */
|
|
|
nfs4_lock_state();
|
|
|
conf = find_confirmed_client_by_str(dname, strhashval);
|
|
|
if (conf) {
|
|
|
- /* RFC 3530 14.2.33 CASE 0: */
|
|
|
+ /* case 0: */
|
|
|
status = nfserr_clid_inuse;
|
|
|
if (clp_used_exchangeid(conf))
|
|
|
goto out;
|
|
@@ -2129,63 +2179,18 @@ nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
goto out;
|
|
|
}
|
|
|
}
|
|
|
- /*
|
|
|
- * section 14.2.33 of RFC 3530 (under the heading "IMPLEMENTATION")
|
|
|
- * has a description of SETCLIENTID request processing consisting
|
|
|
- * of 5 bullet points, labeled as CASE0 - CASE4 below.
|
|
|
- */
|
|
|
unconf = find_unconfirmed_client_by_str(dname, strhashval);
|
|
|
+ if (unconf)
|
|
|
+ expire_client(unconf);
|
|
|
status = nfserr_jukebox;
|
|
|
- if (!conf) {
|
|
|
- /*
|
|
|
- * RFC 3530 14.2.33 CASE 4:
|
|
|
- * placed first, because it is the normal case
|
|
|
- */
|
|
|
- if (unconf)
|
|
|
- expire_client(unconf);
|
|
|
- new = create_client(clname, dname, rqstp, &clverifier);
|
|
|
- if (new == NULL)
|
|
|
- goto out;
|
|
|
- gen_clid(new);
|
|
|
- } else if (same_verf(&conf->cl_verifier, &clverifier)) {
|
|
|
- /*
|
|
|
- * RFC 3530 14.2.33 CASE 1:
|
|
|
- * probable callback update
|
|
|
- */
|
|
|
- if (unconf) {
|
|
|
- /* Note this is removing unconfirmed {*x***},
|
|
|
- * which is stronger than RFC recommended {vxc**}.
|
|
|
- * This has the advantage that there is at most
|
|
|
- * one {*x***} in either list at any time.
|
|
|
- */
|
|
|
- expire_client(unconf);
|
|
|
- }
|
|
|
- new = create_client(clname, dname, rqstp, &clverifier);
|
|
|
- if (new == NULL)
|
|
|
- goto out;
|
|
|
+ new = create_client(clname, dname, rqstp, &clverifier);
|
|
|
+ if (new == NULL)
|
|
|
+ goto out;
|
|
|
+ if (conf && same_verf(&conf->cl_verifier, &clverifier))
|
|
|
+ /* case 1: probable callback update */
|
|
|
copy_clid(new, conf);
|
|
|
- } else if (!unconf) {
|
|
|
- /*
|
|
|
- * RFC 3530 14.2.33 CASE 2:
|
|
|
- * probable client reboot; state will be removed if
|
|
|
- * confirmed.
|
|
|
- */
|
|
|
- new = create_client(clname, dname, rqstp, &clverifier);
|
|
|
- if (new == NULL)
|
|
|
- goto out;
|
|
|
- gen_clid(new);
|
|
|
- } else {
|
|
|
- /*
|
|
|
- * RFC 3530 14.2.33 CASE 3:
|
|
|
- * probable client reboot; state will be removed if
|
|
|
- * confirmed.
|
|
|
- */
|
|
|
- expire_client(unconf);
|
|
|
- new = create_client(clname, dname, rqstp, &clverifier);
|
|
|
- if (new == NULL)
|
|
|
- goto out;
|
|
|
+ else /* case 4 (new client) or cases 2, 3 (client reboot): */
|
|
|
gen_clid(new);
|
|
|
- }
|
|
|
/*
|
|
|
* XXX: we should probably set this at creation time, and check
|
|
|
* for consistent minorversion use throughout:
|
|
@@ -2203,17 +2208,11 @@ out:
|
|
|
}
|
|
|
|
|
|
|
|
|
-/*
|
|
|
- * Section 14.2.34 of RFC 3530 (under the heading "IMPLEMENTATION") has
|
|
|
- * a description of SETCLIENTID_CONFIRM request processing consisting of 4
|
|
|
- * bullets, labeled as CASE1 - CASE4 below.
|
|
|
- */
|
|
|
__be32
|
|
|
nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
|
|
|
struct nfsd4_compound_state *cstate,
|
|
|
struct nfsd4_setclientid_confirm *setclientid_confirm)
|
|
|
{
|
|
|
- struct sockaddr *sa = svc_addr(rqstp);
|
|
|
struct nfs4_client *conf, *unconf;
|
|
|
nfs4_verifier confirm = setclientid_confirm->sc_confirm;
|
|
|
clientid_t * clid = &setclientid_confirm->sc_clientid;
|
|
@@ -2221,84 +2220,44 @@ nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
|
|
|
|
|
|
if (STALE_CLIENTID(clid))
|
|
|
return nfserr_stale_clientid;
|
|
|
- /*
|
|
|
- * XXX The Duplicate Request Cache (DRC) has been checked (??)
|
|
|
- * We get here on a DRC miss.
|
|
|
- */
|
|
|
-
|
|
|
nfs4_lock_state();
|
|
|
|
|
|
conf = find_confirmed_client(clid);
|
|
|
unconf = find_unconfirmed_client(clid);
|
|
|
-
|
|
|
- status = nfserr_clid_inuse;
|
|
|
- if (conf && !rpc_cmp_addr((struct sockaddr *) &conf->cl_addr, sa))
|
|
|
- goto out;
|
|
|
- if (unconf && !rpc_cmp_addr((struct sockaddr *) &unconf->cl_addr, sa))
|
|
|
- goto out;
|
|
|
-
|
|
|
/*
|
|
|
- * section 14.2.34 of RFC 3530 has a description of
|
|
|
- * SETCLIENTID_CONFIRM request processing consisting
|
|
|
- * of 4 bullet points, labeled as CASE1 - CASE4 below.
|
|
|
+ * We try hard to give out unique clientid's, so if we get an
|
|
|
+ * attempt to confirm the same clientid with a different cred,
|
|
|
+ * there's a bug somewhere. Let's charitably assume it's our
|
|
|
+ * bug.
|
|
|
*/
|
|
|
- if (conf && unconf && same_verf(&confirm, &unconf->cl_confirm)) {
|
|
|
- /*
|
|
|
- * RFC 3530 14.2.34 CASE 1:
|
|
|
- * callback update
|
|
|
- */
|
|
|
- if (!same_creds(&conf->cl_cred, &unconf->cl_cred))
|
|
|
- status = nfserr_clid_inuse;
|
|
|
- else {
|
|
|
- nfsd4_change_callback(conf, &unconf->cl_cb_conn);
|
|
|
- nfsd4_probe_callback(conf);
|
|
|
- expire_client(unconf);
|
|
|
+ status = nfserr_serverfault;
|
|
|
+ if (unconf && !same_creds(&unconf->cl_cred, &rqstp->rq_cred))
|
|
|
+ goto out;
|
|
|
+ if (conf && !same_creds(&conf->cl_cred, &rqstp->rq_cred))
|
|
|
+ goto out;
|
|
|
+ /* cases below refer to rfc 3530 section 14.2.34: */
|
|
|
+ if (!unconf || !same_verf(&confirm, &unconf->cl_confirm)) {
|
|
|
+ if (conf && !unconf) /* case 2: probable retransmit */
|
|
|
status = nfs_ok;
|
|
|
+ else /* case 4: client hasn't noticed we rebooted yet? */
|
|
|
+ status = nfserr_stale_clientid;
|
|
|
+ goto out;
|
|
|
+ }
|
|
|
+ status = nfs_ok;
|
|
|
+ if (conf) { /* case 1: callback update */
|
|
|
+ nfsd4_change_callback(conf, &unconf->cl_cb_conn);
|
|
|
+ nfsd4_probe_callback(conf);
|
|
|
+ expire_client(unconf);
|
|
|
+ } else { /* case 3: normal case; new or rebooted client */
|
|
|
+ unsigned int hash = clientstr_hashval(unconf->cl_recdir);
|
|
|
|
|
|
+ conf = find_confirmed_client_by_str(unconf->cl_recdir, hash);
|
|
|
+ if (conf) {
|
|
|
+ nfsd4_client_record_remove(conf);
|
|
|
+ expire_client(conf);
|
|
|
}
|
|
|
- } else if (conf && !unconf) {
|
|
|
- /*
|
|
|
- * RFC 3530 14.2.34 CASE 2:
|
|
|
- * probable retransmitted request; play it safe and
|
|
|
- * do nothing.
|
|
|
- */
|
|
|
- if (!same_creds(&conf->cl_cred, &rqstp->rq_cred))
|
|
|
- status = nfserr_clid_inuse;
|
|
|
- else
|
|
|
- status = nfs_ok;
|
|
|
- } else if (!conf && unconf
|
|
|
- && same_verf(&unconf->cl_confirm, &confirm)) {
|
|
|
- /*
|
|
|
- * RFC 3530 14.2.34 CASE 3:
|
|
|
- * Normal case; new or rebooted client:
|
|
|
- */
|
|
|
- if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
|
|
|
- status = nfserr_clid_inuse;
|
|
|
- } else {
|
|
|
- unsigned int hash =
|
|
|
- clientstr_hashval(unconf->cl_recdir);
|
|
|
- conf = find_confirmed_client_by_str(unconf->cl_recdir,
|
|
|
- hash);
|
|
|
- if (conf) {
|
|
|
- nfsd4_client_record_remove(conf);
|
|
|
- expire_client(conf);
|
|
|
- }
|
|
|
- move_to_confirmed(unconf);
|
|
|
- conf = unconf;
|
|
|
- nfsd4_probe_callback(conf);
|
|
|
- status = nfs_ok;
|
|
|
- }
|
|
|
- } else if ((!conf || (conf && !same_verf(&conf->cl_confirm, &confirm)))
|
|
|
- && (!unconf || (unconf && !same_verf(&unconf->cl_confirm,
|
|
|
- &confirm)))) {
|
|
|
- /*
|
|
|
- * RFC 3530 14.2.34 CASE 4:
|
|
|
- * Client probably hasn't noticed that we rebooted yet.
|
|
|
- */
|
|
|
- status = nfserr_stale_clientid;
|
|
|
- } else {
|
|
|
- /* check that we have hit one of the cases...*/
|
|
|
- status = nfserr_clid_inuse;
|
|
|
+ move_to_confirmed(unconf);
|
|
|
+ nfsd4_probe_callback(unconf);
|
|
|
}
|
|
|
out:
|
|
|
nfs4_unlock_state();
|
|
@@ -2454,8 +2413,8 @@ static void init_open_stateid(struct nfs4_ol_stateid *stp, struct nfs4_file *fp,
|
|
|
stp->st_file = fp;
|
|
|
stp->st_access_bmap = 0;
|
|
|
stp->st_deny_bmap = 0;
|
|
|
- __set_bit(open->op_share_access, &stp->st_access_bmap);
|
|
|
- __set_bit(open->op_share_deny, &stp->st_deny_bmap);
|
|
|
+ set_access(open->op_share_access, stp);
|
|
|
+ set_deny(open->op_share_deny, stp);
|
|
|
stp->st_openstp = NULL;
|
|
|
}
|
|
|
|
|
@@ -2534,8 +2493,8 @@ nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
|
|
|
ret = nfserr_locked;
|
|
|
/* Search for conflicting share reservations */
|
|
|
list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
|
|
|
- if (test_bit(deny_type, &stp->st_deny_bmap) ||
|
|
|
- test_bit(NFS4_SHARE_DENY_BOTH, &stp->st_deny_bmap))
|
|
|
+ if (test_deny(deny_type, stp) ||
|
|
|
+ test_deny(NFS4_SHARE_DENY_BOTH, stp))
|
|
|
goto out;
|
|
|
}
|
|
|
ret = nfs_ok;
|
|
@@ -2791,7 +2750,7 @@ nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *c
|
|
|
bool new_access;
|
|
|
__be32 status;
|
|
|
|
|
|
- new_access = !test_bit(op_share_access, &stp->st_access_bmap);
|
|
|
+ new_access = !test_access(op_share_access, stp);
|
|
|
if (new_access) {
|
|
|
status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
|
|
|
if (status)
|
|
@@ -2806,8 +2765,8 @@ nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *c
|
|
|
return status;
|
|
|
}
|
|
|
/* remember the open */
|
|
|
- __set_bit(op_share_access, &stp->st_access_bmap);
|
|
|
- __set_bit(open->op_share_deny, &stp->st_deny_bmap);
|
|
|
+ set_access(op_share_access, stp);
|
|
|
+ set_deny(open->op_share_deny, stp);
|
|
|
|
|
|
return nfs_ok;
|
|
|
}
|
|
@@ -3282,18 +3241,18 @@ STALE_STATEID(stateid_t *stateid)
|
|
|
}
|
|
|
|
|
|
static inline int
|
|
|
-access_permit_read(unsigned long access_bmap)
|
|
|
+access_permit_read(struct nfs4_ol_stateid *stp)
|
|
|
{
|
|
|
- return test_bit(NFS4_SHARE_ACCESS_READ, &access_bmap) ||
|
|
|
- test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap) ||
|
|
|
- test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap);
|
|
|
+ return test_access(NFS4_SHARE_ACCESS_READ, stp) ||
|
|
|
+ test_access(NFS4_SHARE_ACCESS_BOTH, stp) ||
|
|
|
+ test_access(NFS4_SHARE_ACCESS_WRITE, stp);
|
|
|
}
|
|
|
|
|
|
static inline int
|
|
|
-access_permit_write(unsigned long access_bmap)
|
|
|
+access_permit_write(struct nfs4_ol_stateid *stp)
|
|
|
{
|
|
|
- return test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap) ||
|
|
|
- test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap);
|
|
|
+ return test_access(NFS4_SHARE_ACCESS_WRITE, stp) ||
|
|
|
+ test_access(NFS4_SHARE_ACCESS_BOTH, stp);
|
|
|
}
|
|
|
|
|
|
static
|
|
@@ -3304,9 +3263,9 @@ __be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags)
|
|
|
/* For lock stateid's, we test the parent open, not the lock: */
|
|
|
if (stp->st_openstp)
|
|
|
stp = stp->st_openstp;
|
|
|
- if ((flags & WR_STATE) && (!access_permit_write(stp->st_access_bmap)))
|
|
|
+ if ((flags & WR_STATE) && !access_permit_write(stp))
|
|
|
goto out;
|
|
|
- if ((flags & RD_STATE) && (!access_permit_read(stp->st_access_bmap)))
|
|
|
+ if ((flags & RD_STATE) && !access_permit_read(stp))
|
|
|
goto out;
|
|
|
status = nfs_ok;
|
|
|
out:
|
|
@@ -3346,7 +3305,7 @@ static bool stateid_generation_after(stateid_t *a, stateid_t *b)
|
|
|
return (s32)a->si_generation - (s32)b->si_generation > 0;
|
|
|
}
|
|
|
|
|
|
-static int check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
|
|
|
+static __be32 check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
|
|
|
{
|
|
|
/*
|
|
|
* When sessions are used the stateid generation number is ignored
|
|
@@ -3655,10 +3614,10 @@ out:
|
|
|
|
|
|
static inline void nfs4_stateid_downgrade_bit(struct nfs4_ol_stateid *stp, u32 access)
|
|
|
{
|
|
|
- if (!test_bit(access, &stp->st_access_bmap))
|
|
|
+ if (!test_access(access, stp))
|
|
|
return;
|
|
|
nfs4_file_put_access(stp->st_file, nfs4_access_to_omode(access));
|
|
|
- __clear_bit(access, &stp->st_access_bmap);
|
|
|
+ clear_access(access, stp);
|
|
|
}
|
|
|
|
|
|
static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_access)
|
|
@@ -3680,12 +3639,12 @@ static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_ac
|
|
|
}
|
|
|
|
|
|
static void
|
|
|
-reset_union_bmap_deny(unsigned long deny, unsigned long *bmap)
|
|
|
+reset_union_bmap_deny(unsigned long deny, struct nfs4_ol_stateid *stp)
|
|
|
{
|
|
|
int i;
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
if ((i & deny) != i)
|
|
|
- __clear_bit(i, bmap);
|
|
|
+ clear_deny(i, stp);
|
|
|
}
|
|
|
}
|
|
|
|
|
@@ -3712,19 +3671,19 @@ nfsd4_open_downgrade(struct svc_rqst *rqstp,
|
|
|
if (status)
|
|
|
goto out;
|
|
|
status = nfserr_inval;
|
|
|
- if (!test_bit(od->od_share_access, &stp->st_access_bmap)) {
|
|
|
- dprintk("NFSD:access not a subset current bitmap: 0x%lx, input access=%08x\n",
|
|
|
+ if (!test_access(od->od_share_access, stp)) {
|
|
|
+ dprintk("NFSD: access not a subset current bitmap: 0x%lx, input access=%08x\n",
|
|
|
stp->st_access_bmap, od->od_share_access);
|
|
|
goto out;
|
|
|
}
|
|
|
- if (!test_bit(od->od_share_deny, &stp->st_deny_bmap)) {
|
|
|
+ if (!test_deny(od->od_share_deny, stp)) {
|
|
|
dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
|
|
|
stp->st_deny_bmap, od->od_share_deny);
|
|
|
goto out;
|
|
|
}
|
|
|
nfs4_stateid_downgrade(stp, od->od_share_access);
|
|
|
|
|
|
- reset_union_bmap_deny(od->od_share_deny, &stp->st_deny_bmap);
|
|
|
+ reset_union_bmap_deny(od->od_share_deny, stp);
|
|
|
|
|
|
update_stateid(&stp->st_stid.sc_stateid);
|
|
|
memcpy(&od->od_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
|
|
@@ -4014,13 +3973,13 @@ static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access)
|
|
|
struct nfs4_file *fp = lock_stp->st_file;
|
|
|
int oflag = nfs4_access_to_omode(access);
|
|
|
|
|
|
- if (test_bit(access, &lock_stp->st_access_bmap))
|
|
|
+ if (test_access(access, lock_stp))
|
|
|
return;
|
|
|
nfs4_file_get_access(fp, oflag);
|
|
|
- __set_bit(access, &lock_stp->st_access_bmap);
|
|
|
+ set_access(access, lock_stp);
|
|
|
}
|
|
|
|
|
|
-__be32 lookup_or_create_lock_state(struct nfsd4_compound_state *cstate, struct nfs4_ol_stateid *ost, struct nfsd4_lock *lock, struct nfs4_ol_stateid **lst, bool *new)
|
|
|
+static __be32 lookup_or_create_lock_state(struct nfsd4_compound_state *cstate, struct nfs4_ol_stateid *ost, struct nfsd4_lock *lock, struct nfs4_ol_stateid **lst, bool *new)
|
|
|
{
|
|
|
struct nfs4_file *fi = ost->st_file;
|
|
|
struct nfs4_openowner *oo = openowner(ost->st_stateowner);
|