Split (3)

train · 151k rows

idx int64	func_before string	Vulnerability Classification string	func_after string	patch string	CWE ID string	lines_before string	lines_after string
18,300	int nfs4_proc_fs_locations(struct inode dir, const struct qstr name, struct nfs4_fs_locations fs_locations, struct page page) { struct nfs_server *server = NFS_SERVER(dir); u32 bitmask[2] = { [0] = FATTR4_WORD0_FSID \| FATTR4_WORD0_FS_LOCATIONS, [1] = FATTR4_WORD1_MOUNTED_ON_FILEID, }; struct nfs4_fs_locations_arg args = { .dir_fh = NFS_FH(dir), .name = name, .page = page, .bitmask = bitmask, }; struct rpc_message msg = { .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS], .rpc_argp = &args, .rpc_resp = fs_locations, }; int status; dprintk("%s: start\n", __func__); nfs_fattr_init(&fs_locations->fattr); fs_locations->server = server; fs_locations->nlocations = 0; status = rpc_call_sync(server->client, &msg, 0); dprintk("%s: returned status = %d\n", __func__, status); return status; }	DoS	int nfs4_proc_fs_locations(struct inode dir, const struct qstr name, struct nfs4_fs_locations fs_locations, struct page page) { struct nfs_server *server = NFS_SERVER(dir); u32 bitmask[2] = { [0] = FATTR4_WORD0_FSID \| FATTR4_WORD0_FS_LOCATIONS, [1] = FATTR4_WORD1_MOUNTED_ON_FILEID, }; struct nfs4_fs_locations_arg args = { .dir_fh = NFS_FH(dir), .name = name, .page = page, .bitmask = bitmask, }; struct rpc_message msg = { .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS], .rpc_argp = &args, .rpc_resp = fs_locations, }; int status; dprintk("%s: start\n", __func__); nfs_fattr_init(&fs_locations->fattr); fs_locations->server = server; fs_locations->nlocations = 0; status = rpc_call_sync(server->client, &msg, 0); dprintk("%s: returned status = %d\n", __func__, status); return status; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,301	static ssize_t nfs4_proc_get_acl(struct inode inode, void buf, size_t buflen) { struct nfs_server *server = NFS_SERVER(inode); int ret; if (!nfs4_server_supports_acls(server)) return -EOPNOTSUPP; ret = nfs_revalidate_inode(server, inode); if (ret < 0) return ret; if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL) nfs_zap_acl_cache(inode); ret = nfs4_read_cached_acl(inode, buf, buflen); if (ret != -ENOENT) return ret; return nfs4_get_acl_uncached(inode, buf, buflen); }	DoS	static ssize_t nfs4_proc_get_acl(struct inode inode, void buf, size_t buflen) { struct nfs_server *server = NFS_SERVER(inode); int ret; if (!nfs4_server_supports_acls(server)) return -EOPNOTSUPP; ret = nfs_revalidate_inode(server, inode); if (ret < 0) return ret; if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL) nfs_zap_acl_cache(inode); ret = nfs4_read_cached_acl(inode, buf, buflen); if (ret != -ENOENT) return ret; return nfs4_get_acl_uncached(inode, buf, buflen); }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,302	static int nfs4_proc_get_root(struct nfs_server server, struct nfs_fh fhandle, struct nfs_fsinfo *info) { int status; status = nfs4_lookup_root(server, fhandle, info); if (status == 0) status = nfs4_server_capabilities(server, fhandle); if (status == 0) status = nfs4_do_fsinfo(server, fhandle, info); return nfs4_map_errors(status); }	DoS	static int nfs4_proc_get_root(struct nfs_server server, struct nfs_fh fhandle, struct nfs_fsinfo *info) { int status; status = nfs4_lookup_root(server, fhandle, info); if (status == 0) status = nfs4_server_capabilities(server, fhandle); if (status == 0) status = nfs4_do_fsinfo(server, fhandle, info); return nfs4_map_errors(status); }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,303	nfs4_proc_lock(struct file filp, int cmd, struct file_lock request) { struct nfs_open_context ctx; struct nfs4_state state; unsigned long timeout = NFS4_LOCK_MINTIMEOUT; int status; /* verify open state */ ctx = nfs_file_open_context(filp); state = ctx->state; if (request->fl_start < 0 \|\| request->fl_end < 0) return -EINVAL; if (IS_GETLK(cmd)) return nfs4_proc_getlk(state, F_GETLK, request); if (!(IS_SETLK(cmd) \|\| IS_SETLKW(cmd))) return -EINVAL; if (request->fl_type == F_UNLCK) return nfs4_proc_unlck(state, cmd, request); do { status = nfs4_proc_setlk(state, cmd, request); if ((status != -EAGAIN) \|\| IS_SETLK(cmd)) break; timeout = nfs4_set_lock_task_retry(timeout); status = -ERESTARTSYS; if (signalled()) break; } while(status < 0); return status; }	DoS	nfs4_proc_lock(struct file filp, int cmd, struct file_lock request) { struct nfs_open_context ctx; struct nfs4_state state; unsigned long timeout = NFS4_LOCK_MINTIMEOUT; int status; /* verify open state */ ctx = nfs_file_open_context(filp); state = ctx->state; if (request->fl_start < 0 \|\| request->fl_end < 0) return -EINVAL; if (IS_GETLK(cmd)) return nfs4_proc_getlk(state, F_GETLK, request); if (!(IS_SETLK(cmd) \|\| IS_SETLKW(cmd))) return -EINVAL; if (request->fl_type == F_UNLCK) return nfs4_proc_unlck(state, cmd, request); do { status = nfs4_proc_setlk(state, cmd, request); if ((status != -EAGAIN) \|\| IS_SETLK(cmd)) break; timeout = nfs4_set_lock_task_retry(timeout); status = -ERESTARTSYS; if (signalled()) break; } while(status < 0); return status; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,304	static int nfs4_proc_lookup(struct inode dir, struct qstr name, struct nfs_fh fhandle, struct nfs_fattr fattr) { struct nfs4_exception exception = { }; int err; do { err = nfs4_handle_exception(NFS_SERVER(dir), _nfs4_proc_lookup(dir, name, fhandle, fattr), &exception); } while (exception.retry); return err; }	DoS	static int nfs4_proc_lookup(struct inode dir, struct qstr name, struct nfs_fh fhandle, struct nfs_fattr fattr) { struct nfs4_exception exception = { }; int err; do { err = nfs4_handle_exception(NFS_SERVER(dir), _nfs4_proc_lookup(dir, name, fhandle, fattr), &exception); } while (exception.retry); return err; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,305	static int nfs4_proc_lookupfh(struct nfs_server server, struct nfs_fh dirfh, struct qstr name, struct nfs_fh fhandle, struct nfs_fattr fattr) { struct nfs4_exception exception = { }; int err; do { err = _nfs4_proc_lookupfh(server, dirfh, name, fhandle, fattr); / FIXME: !!!! */ if (err == -NFS4ERR_MOVED) { err = -EREMOTE; break; } err = nfs4_handle_exception(server, err, &exception); } while (exception.retry); return err; }	DoS	static int nfs4_proc_lookupfh(struct nfs_server server, struct nfs_fh dirfh, struct qstr name, struct nfs_fh fhandle, struct nfs_fattr fattr) { struct nfs4_exception exception = { }; int err; do { err = _nfs4_proc_lookupfh(server, dirfh, name, fhandle, fattr); / FIXME: !!!! */ if (err == -NFS4ERR_MOVED) { err = -EREMOTE; break; } err = nfs4_handle_exception(server, err, &exception); } while (exception.retry); return err; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,306	static int nfs4_proc_mknod(struct inode dir, struct dentry dentry, struct iattr *sattr, dev_t rdev) { struct nfs4_exception exception = { }; int err; do { err = nfs4_handle_exception(NFS_SERVER(dir), _nfs4_proc_mknod(dir, dentry, sattr, rdev), &exception); } while (exception.retry); return err; }	DoS	static int nfs4_proc_mknod(struct inode dir, struct dentry dentry, struct iattr *sattr, dev_t rdev) { struct nfs4_exception exception = { }; int err; do { err = nfs4_handle_exception(NFS_SERVER(dir), _nfs4_proc_mknod(dir, dentry, sattr, rdev), &exception); } while (exception.retry); return err; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,307	static void nfs4_proc_read_setup(struct nfs_read_data data, struct rpc_message msg) { data->timestamp = jiffies; msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ]; }	DoS	static void nfs4_proc_read_setup(struct nfs_read_data data, struct rpc_message msg) { data->timestamp = jiffies; msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ]; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,308	static int nfs4_proc_readdir(struct dentry dentry, struct rpc_cred cred, u64 cookie, struct page *page, unsigned int count, int plus) { struct nfs4_exception exception = { }; int err; do { err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode), _nfs4_proc_readdir(dentry, cred, cookie, page, count, plus), &exception); } while (exception.retry); return err; }	DoS	static int nfs4_proc_readdir(struct dentry dentry, struct rpc_cred cred, u64 cookie, struct page *page, unsigned int count, int plus) { struct nfs4_exception exception = { }; int err; do { err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode), _nfs4_proc_readdir(dentry, cred, cookie, page, count, plus), &exception); } while (exception.retry); return err; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,309	int nfs4_proc_renew(struct nfs_client clp, struct rpc_cred cred) { struct rpc_message msg = { .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW], .rpc_argp = clp, .rpc_cred = cred, }; unsigned long now = jiffies; int status; status = rpc_call_sync(clp->cl_rpcclient, &msg, 0); if (status < 0) return status; spin_lock(&clp->cl_lock); if (time_before(clp->cl_last_renewal,now)) clp->cl_last_renewal = now; spin_unlock(&clp->cl_lock); return 0; }	DoS	int nfs4_proc_renew(struct nfs_client clp, struct rpc_cred cred) { struct rpc_message msg = { .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW], .rpc_argp = clp, .rpc_cred = cred, }; unsigned long now = jiffies; int status; status = rpc_call_sync(clp->cl_rpcclient, &msg, 0); if (status < 0) return status; spin_lock(&clp->cl_lock); if (time_before(clp->cl_last_renewal,now)) clp->cl_last_renewal = now; spin_unlock(&clp->cl_lock); return 0; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,310	nfs4_proc_setattr(struct dentry dentry, struct nfs_fattr fattr, struct iattr sattr) { struct inode inode = dentry->d_inode; struct rpc_cred cred = NULL; struct nfs4_state state = NULL; int status; nfs_fattr_init(fattr); /* Search for an existing open(O_WRITE) file / if (sattr->ia_valid & ATTR_FILE) { struct nfs_open_context ctx; ctx = nfs_file_open_context(sattr->ia_file); if (ctx) { cred = ctx->cred; state = ctx->state; } } status = nfs4_do_setattr(inode, cred, fattr, sattr, state); if (status == 0) nfs_setattr_update_inode(inode, sattr); return status; }	DoS	nfs4_proc_setattr(struct dentry dentry, struct nfs_fattr fattr, struct iattr sattr) { struct inode inode = dentry->d_inode; struct rpc_cred cred = NULL; struct nfs4_state state = NULL; int status; nfs_fattr_init(fattr); /* Search for an existing open(O_WRITE) file / if (sattr->ia_valid & ATTR_FILE) { struct nfs_open_context ctx; ctx = nfs_file_open_context(sattr->ia_file); if (ctx) { cred = ctx->cred; state = ctx->state; } } status = nfs4_do_setattr(inode, cred, fattr, sattr, state); if (status == 0) nfs_setattr_update_inode(inode, sattr); return status; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,311	int nfs4_proc_setclientid(struct nfs_client clp, u32 program, unsigned short port, struct rpc_cred cred) { nfs4_verifier sc_verifier; struct nfs4_setclientid setclientid = { .sc_verifier = &sc_verifier, .sc_prog = program, }; struct rpc_message msg = { .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID], .rpc_argp = &setclientid, .rpc_resp = clp, .rpc_cred = cred, }; __be32 p; int loop = 0; int status; p = (__be32)sc_verifier.data; p++ = htonl((u32)clp->cl_boot_time.tv_sec); p = htonl((u32)clp->cl_boot_time.tv_nsec); for(;;) { setclientid.sc_name_len = scnprintf(setclientid.sc_name, sizeof(setclientid.sc_name), "%s/%s %s %s %u", clp->cl_ipaddr, rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR), rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_PROTO), clp->cl_rpcclient->cl_auth->au_ops->au_name, clp->cl_id_uniquifier); setclientid.sc_netid_len = scnprintf(setclientid.sc_netid, sizeof(setclientid.sc_netid), rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_NETID)); setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr, sizeof(setclientid.sc_uaddr), "%s.%u.%u", clp->cl_ipaddr, port >> 8, port & 255); status = rpc_call_sync(clp->cl_rpcclient, &msg, 0); if (status != -NFS4ERR_CLID_INUSE) break; if (signalled()) break; if (loop++ & 1) ssleep(clp->cl_lease_time + 1); else if (++clp->cl_id_uniquifier == 0) break; } return status; }	DoS	int nfs4_proc_setclientid(struct nfs_client clp, u32 program, unsigned short port, struct rpc_cred cred) { nfs4_verifier sc_verifier; struct nfs4_setclientid setclientid = { .sc_verifier = &sc_verifier, .sc_prog = program, }; struct rpc_message msg = { .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID], .rpc_argp = &setclientid, .rpc_resp = clp, .rpc_cred = cred, }; __be32 p; int loop = 0; int status; p = (__be32)sc_verifier.data; p++ = htonl((u32)clp->cl_boot_time.tv_sec); p = htonl((u32)clp->cl_boot_time.tv_nsec); for(;;) { setclientid.sc_name_len = scnprintf(setclientid.sc_name, sizeof(setclientid.sc_name), "%s/%s %s %s %u", clp->cl_ipaddr, rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR), rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_PROTO), clp->cl_rpcclient->cl_auth->au_ops->au_name, clp->cl_id_uniquifier); setclientid.sc_netid_len = scnprintf(setclientid.sc_netid, sizeof(setclientid.sc_netid), rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_NETID)); setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr, sizeof(setclientid.sc_uaddr), "%s.%u.%u", clp->cl_ipaddr, port >> 8, port & 255); status = rpc_call_sync(clp->cl_rpcclient, &msg, 0); if (status != -NFS4ERR_CLID_INUSE) break; if (signalled()) break; if (loop++ & 1) ssleep(clp->cl_lease_time + 1); else if (++clp->cl_id_uniquifier == 0) break; } return status; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,312	int nfs4_proc_setclientid_confirm(struct nfs_client clp, struct rpc_cred cred) { long timeout = 0; int err; do { err = _nfs4_proc_setclientid_confirm(clp, cred); switch (err) { case 0: return err; case -NFS4ERR_RESOURCE: /* The IBM lawyers misread another document! */ case -NFS4ERR_DELAY: err = nfs4_delay(clp->cl_rpcclient, &timeout); } } while (err == 0); return err; }	DoS	int nfs4_proc_setclientid_confirm(struct nfs_client clp, struct rpc_cred cred) { long timeout = 0; int err; do { err = _nfs4_proc_setclientid_confirm(clp, cred); switch (err) { case 0: return err; case -NFS4ERR_RESOURCE: /* The IBM lawyers misread another document! */ case -NFS4ERR_DELAY: err = nfs4_delay(clp->cl_rpcclient, &timeout); } } while (err == 0); return err; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,313	static int nfs4_proc_setlk(struct nfs4_state state, int cmd, struct file_lock request) { struct nfs4_exception exception = { }; int err; do { err = nfs4_handle_exception(NFS_SERVER(state->inode), _nfs4_proc_setlk(state, cmd, request), &exception); } while (exception.retry); return err; }	DoS	static int nfs4_proc_setlk(struct nfs4_state state, int cmd, struct file_lock request) { struct nfs4_exception exception = { }; int err; do { err = nfs4_handle_exception(NFS_SERVER(state->inode), _nfs4_proc_setlk(state, cmd, request), &exception); } while (exception.retry); return err; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,314	static int nfs4_proc_unlck(struct nfs4_state state, int cmd, struct file_lock request) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_seqid seqid; struct nfs4_lock_state lsp; struct rpc_task task; int status = 0; unsigned char fl_flags = request->fl_flags; status = nfs4_set_lock_state(state, request); /* Unlock _before_ we do the RPC call / request->fl_flags \|= FL_EXISTS; down_read(&nfsi->rwsem); if (do_vfs_lock(request->fl_file, request) == -ENOENT) { up_read(&nfsi->rwsem); goto out; } up_read(&nfsi->rwsem); if (status != 0) goto out; / Is this a delegated lock? */ if (test_bit(NFS_DELEGATED_STATE, &state->flags)) goto out; lsp = request->fl_u.nfs4_fl.owner; seqid = nfs_alloc_seqid(&lsp->ls_seqid); status = -ENOMEM; if (seqid == NULL) goto out; task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid); status = PTR_ERR(task); if (IS_ERR(task)) goto out; status = nfs4_wait_for_completion_rpc_task(task); rpc_put_task(task); out: request->fl_flags = fl_flags; return status; }	DoS	static int nfs4_proc_unlck(struct nfs4_state state, int cmd, struct file_lock request) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_seqid seqid; struct nfs4_lock_state lsp; struct rpc_task task; int status = 0; unsigned char fl_flags = request->fl_flags; status = nfs4_set_lock_state(state, request); /* Unlock _before_ we do the RPC call / request->fl_flags \|= FL_EXISTS; down_read(&nfsi->rwsem); if (do_vfs_lock(request->fl_file, request) == -ENOENT) { up_read(&nfsi->rwsem); goto out; } up_read(&nfsi->rwsem); if (status != 0) goto out; / Is this a delegated lock? */ if (test_bit(NFS_DELEGATED_STATE, &state->flags)) goto out; lsp = request->fl_u.nfs4_fl.owner; seqid = nfs_alloc_seqid(&lsp->ls_seqid); status = -ENOMEM; if (seqid == NULL) goto out; task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid); status = PTR_ERR(task); if (IS_ERR(task)) goto out; status = nfs4_wait_for_completion_rpc_task(task); rpc_put_task(task); out: request->fl_flags = fl_flags; return status; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,315	static int nfs4_proc_unlink_done(struct rpc_task task, struct inode dir) { struct nfs_removeres *res = task->tk_msg.rpc_resp; if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN) return 0; update_changeattr(dir, &res->cinfo); nfs_post_op_update_inode(dir, &res->dir_attr); return 1; }	DoS	static int nfs4_proc_unlink_done(struct rpc_task task, struct inode dir) { struct nfs_removeres *res = task->tk_msg.rpc_resp; if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN) return 0; update_changeattr(dir, &res->cinfo); nfs_post_op_update_inode(dir, &res->dir_attr); return 1; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,316	static void nfs4_proc_unlink_setup(struct rpc_message msg, struct inode dir) { struct nfs_server server = NFS_SERVER(dir); struct nfs_removeargs args = msg->rpc_argp; struct nfs_removeres *res = msg->rpc_resp; args->bitmask = server->attr_bitmask; res->server = server; msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE]; }	DoS	static void nfs4_proc_unlink_setup(struct rpc_message msg, struct inode dir) { struct nfs_server server = NFS_SERVER(dir); struct nfs_removeargs args = msg->rpc_argp; struct nfs_removeres *res = msg->rpc_resp; args->bitmask = server->attr_bitmask; res->server = server; msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE]; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,317	static int nfs4_read_done(struct rpc_task task, struct nfs_read_data data) { struct nfs_server *server = NFS_SERVER(data->inode); if (nfs4_async_handle_error(task, server, data->args.context->state) == -EAGAIN) { rpc_restart_call(task); return -EAGAIN; } nfs_invalidate_atime(data->inode); if (task->tk_status > 0) renew_lease(server, data->timestamp); return 0; }	DoS	static int nfs4_read_done(struct rpc_task task, struct nfs_read_data data) { struct nfs_server *server = NFS_SERVER(data->inode); if (nfs4_async_handle_error(task, server, data->args.context->state) == -EAGAIN) { rpc_restart_call(task); return -EAGAIN; } nfs_invalidate_atime(data->inode); if (task->tk_status > 0) renew_lease(server, data->timestamp); return 0; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,318	static int nfs4_recover_expired_lease(struct nfs_server server) { struct nfs_client clp = server->nfs_client; int ret; for (;;) { ret = nfs4_wait_clnt_recover(clp); if (ret != 0) return ret; if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) && !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state)) break; nfs4_schedule_state_recovery(clp); } return 0; }	DoS	static int nfs4_recover_expired_lease(struct nfs_server server) { struct nfs_client clp = server->nfs_client; int ret; for (;;) { ret = nfs4_wait_clnt_recover(clp); if (ret != 0) return ret; if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) && !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state)) break; nfs4_schedule_state_recovery(clp); } return 0; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,319	static void nfs4_setup_readdir(u64 cookie, __be32 verifier, struct dentry dentry, struct nfs4_readdir_arg readdir) { __be32 start, p; BUG_ON(readdir->count < 80); if (cookie > 2) { readdir->cookie = cookie; memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier)); return; } readdir->cookie = 0; memset(&readdir->verifier, 0, sizeof(readdir->verifier)); if (cookie == 2) return; / * NFSv4 servers do not return entries for '.' and '..' * Therefore, we fake these entries here. We let '.' * have cookie 0 and '..' have cookie 1. Note that * when talking to the server, we always send cookie 0 * instead of 1 or 2. / start = p = kmap_atomic(readdir->pages, KM_USER0); if (cookie == 0) { p++ = xdr_one; / next / p++ = xdr_zero; /* cookie, first word / p++ = xdr_one; /* cookie, second word / p++ = xdr_one; /* entry len / memcpy(p, ".\0\0\0", 4); / entry / p++; p++ = xdr_one; /* bitmap length / p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap / p++ = htonl(8); /* attribute buffer length / p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode)); } p++ = xdr_one; /* next / p++ = xdr_zero; /* cookie, first word / p++ = xdr_two; /* cookie, second word / p++ = xdr_two; /* entry len / memcpy(p, "..\0\0", 4); / entry / p++; p++ = xdr_one; /* bitmap length / p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap / p++ = htonl(8); /* attribute buffer length / p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode)); readdir->pgbase = (char )p - (char *)start; readdir->count -= readdir->pgbase; kunmap_atomic(start, KM_USER0); }	DoS	static void nfs4_setup_readdir(u64 cookie, __be32 verifier, struct dentry dentry, struct nfs4_readdir_arg readdir) { __be32 start, p; BUG_ON(readdir->count < 80); if (cookie > 2) { readdir->cookie = cookie; memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier)); return; } readdir->cookie = 0; memset(&readdir->verifier, 0, sizeof(readdir->verifier)); if (cookie == 2) return; / * NFSv4 servers do not return entries for '.' and '..' * Therefore, we fake these entries here. We let '.' * have cookie 0 and '..' have cookie 1. Note that * when talking to the server, we always send cookie 0 * instead of 1 or 2. / start = p = kmap_atomic(readdir->pages, KM_USER0); if (cookie == 0) { p++ = xdr_one; / next / p++ = xdr_zero; /* cookie, first word / p++ = xdr_one; /* cookie, second word / p++ = xdr_one; /* entry len / memcpy(p, ".\0\0\0", 4); / entry / p++; p++ = xdr_one; /* bitmap length / p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap / p++ = htonl(8); /* attribute buffer length / p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode)); } p++ = xdr_one; /* next / p++ = xdr_zero; /* cookie, first word / p++ = xdr_two; /* cookie, second word / p++ = xdr_two; /* entry len / memcpy(p, "..\0\0", 4); / entry / p++; p++ = xdr_one; /* bitmap length / p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap / p++ = htonl(8); /* attribute buffer length / p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode)); readdir->pgbase = (char )p - (char *)start; readdir->count -= readdir->pgbase; kunmap_atomic(start, KM_USER0); }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,320	static int nfs4_wait_bit_killable(void *word) { if (fatal_signal_pending(current)) return -ERESTARTSYS; schedule(); return 0; }	DoS	static int nfs4_wait_bit_killable(void *word) { if (fatal_signal_pending(current)) return -ERESTARTSYS; schedule(); return 0; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,321	static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task) { int ret; ret = rpc_wait_for_completion_task(task); return ret; }	DoS	static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task) { int ret; ret = rpc_wait_for_completion_task(task); return ret; }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,322	static void update_changeattr(struct inode dir, struct nfs4_change_info cinfo) { struct nfs_inode *nfsi = NFS_I(dir); spin_lock(&dir->i_lock); nfsi->cache_validity \|= NFS_INO_INVALID_ATTR\|NFS_INO_REVAL_PAGECACHE\|NFS_INO_INVALID_DATA; if (!cinfo->atomic \|\| cinfo->before != nfsi->change_attr) nfs_force_lookup_revalidate(dir); nfsi->change_attr = cinfo->after; spin_unlock(&dir->i_lock); }	DoS	static void update_changeattr(struct inode dir, struct nfs4_change_info cinfo) { struct nfs_inode *nfsi = NFS_I(dir); spin_lock(&dir->i_lock); nfsi->cache_validity \|= NFS_INO_INVALID_ATTR\|NFS_INO_REVAL_PAGECACHE\|NFS_INO_INVALID_DATA; if (!cinfo->atomic \|\| cinfo->before != nfsi->change_attr) nfs_force_lookup_revalidate(dir); nfsi->change_attr = cinfo->after; spin_unlock(&dir->i_lock); }	@@ -323,7 +323,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata p) } static struct nfs4_opendata nfs4_opendata_alloc(struct path path, - struct nfs4_state_owner sp, int flags, + struct nfs4_state_owner sp, fmode_t fmode, int flags, const struct iattr attrs) { struct dentry parent = dget_parent(path->dentry); @@ -343,7 +343,8 @@ static struct nfs4_opendata nfs4_opendata_alloc(struct path path, p->owner = sp; atomic_inc(&sp->so_count); p->o_arg.fh = NFS_FH(dir); - p->o_arg.open_flags = flags, + p->o_arg.open_flags = flags; + p->o_arg.fmode = fmode & (FMODE_READ\|FMODE_WRITE); p->o_arg.clientid = server->nfs_client->cl_clientid; p->o_arg.id = sp->so_owner_id.id; p->o_arg.name = &p->path.dentry->d_name; @@ -399,10 +400,13 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task task) return ret; } -static int can_open_cached(struct nfs4_state state, int mode) +static int can_open_cached(struct nfs4_state state, fmode_t mode, int open_mode) { int ret = 0; - switch (mode & (FMODE_READ\|FMODE_WRITE\|O_EXCL)) { + + if (open_mode & O_EXCL) + goto out; + switch (mode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: ret \|= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; break; @@ -412,22 +416,23 @@ static int can_open_cached(struct nfs4_state state, int mode) case FMODE_READ\|FMODE_WRITE: ret \|= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; } +out: return ret; } -static int can_open_delegated(struct nfs_delegation delegation, mode_t open_flags) +static int can_open_delegated(struct nfs_delegation delegation, fmode_t fmode) { - if ((delegation->type & open_flags) != open_flags) + if ((delegation->type & fmode) != fmode) return 0; if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) return 0; nfs_mark_delegation_referenced(delegation); return 1; } -static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) +static void update_open_stateflags(struct nfs4_state state, fmode_t fmode) { - switch (open_flags) { + switch (fmode) { case FMODE_WRITE: state->n_wronly++; break; @@ -437,15 +442,15 @@ static void update_open_stateflags(struct nfs4_state state, mode_t open_flags) case FMODE_READ\|FMODE_WRITE: state->n_rdwr++; } - nfs4_state_set_mode_locked(state, state->state \| open_flags); + nfs4_state_set_mode_locked(state, state->state \| fmode); } -static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); - switch (open_flags) { + switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); break; @@ -457,14 +462,14 @@ static void nfs_set_open_stateid_locked(struct nfs4_state state, nfs4_stateid } } -static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, int open_flags) +static void nfs_set_open_stateid(struct nfs4_state state, nfs4_stateid stateid, fmode_t fmode) { write_seqlock(&state->seqlock); - nfs_set_open_stateid_locked(state, stateid, open_flags); + nfs_set_open_stateid_locked(state, stateid, fmode); write_sequnlock(&state->seqlock); } -static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, int open_flags) +static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, const nfs4_stateid deleg_stateid, fmode_t fmode) { /* * Protect the call to nfs4_state_set_mode_locked and @@ -476,20 +481,20 @@ static void __update_open_stateid(struct nfs4_state state, nfs4_stateid open_s set_bit(NFS_DELEGATED_STATE, &state->flags); } if (open_stateid != NULL) - nfs_set_open_stateid_locked(state, open_stateid, open_flags); + nfs_set_open_stateid_locked(state, open_stateid, fmode); write_sequnlock(&state->seqlock); spin_lock(&state->owner->so_lock); - update_open_stateflags(state, open_flags); + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); } -static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, int open_flags) +static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stateid, nfs4_stateid delegation, fmode_t fmode) { struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation deleg_cur; int ret = 0; - open_flags &= (FMODE_READ\|FMODE_WRITE); + fmode &= (FMODE_READ\|FMODE_WRITE); rcu_read_lock(); deleg_cur = rcu_dereference(nfsi->delegation); @@ -498,7 +503,7 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat spin_lock(&deleg_cur->lock); if (nfsi->delegation != deleg_cur \|\| - (deleg_cur->type & open_flags) != open_flags) + (deleg_cur->type & fmode) != fmode) goto no_delegation_unlock; if (delegation == NULL) @@ -507,29 +512,29 @@ static int update_open_stateid(struct nfs4_state state, nfs4_stateid open_stat goto no_delegation_unlock; nfs_mark_delegation_referenced(deleg_cur); - __update_open_stateid(state, open_stateid, &deleg_cur->stateid, open_flags); + __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); ret = 1; no_delegation_unlock: spin_unlock(&deleg_cur->lock); no_delegation: rcu_read_unlock(); if (!ret && open_stateid != NULL) { - __update_open_stateid(state, open_stateid, NULL, open_flags); + __update_open_stateid(state, open_stateid, NULL, fmode); ret = 1; } return ret; } -static void nfs4_return_incompatible_delegation(struct inode inode, mode_t open_flags) +static void nfs4_return_incompatible_delegation(struct inode inode, fmode_t fmode) { struct nfs_delegation delegation; rcu_read_lock(); delegation = rcu_dereference(NFS_I(inode)->delegation); - if (delegation == NULL \|\| (delegation->type & open_flags) == open_flags) { + if (delegation == NULL \|\| (delegation->type & fmode) == fmode) { rcu_read_unlock(); return; } @@ -542,15 +547,16 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) struct nfs4_state state = opendata->state; struct nfs_inode nfsi = NFS_I(state->inode); struct nfs_delegation delegation; - int open_mode = opendata->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL); + int open_mode = opendata->o_arg.open_flags & O_EXCL; + fmode_t fmode = opendata->o_arg.fmode; nfs4_stateid stateid; int ret = -EAGAIN; for (;;) { - if (can_open_cached(state, open_mode)) { + if (can_open_cached(state, fmode, open_mode)) { spin_lock(&state->owner->so_lock); - if (can_open_cached(state, open_mode)) { - update_open_stateflags(state, open_mode); + if (can_open_cached(state, fmode, open_mode)) { + update_open_stateflags(state, fmode); spin_unlock(&state->owner->so_lock); goto out_return_state; } @@ -559,7 +565,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) rcu_read_lock(); delegation = rcu_dereference(nfsi->delegation); if (delegation == NULL \|\| - !can_open_delegated(delegation, open_mode)) { + !can_open_delegated(delegation, fmode)) { rcu_read_unlock(); break; } @@ -572,7 +578,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata) ret = -EAGAIN; /* Try to update the stateid using the delegation / - if (update_open_stateid(state, NULL, &stateid, open_mode)) + if (update_open_stateid(state, NULL, &stateid, fmode)) goto out_return_state; } out: @@ -624,7 +630,7 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data } update_open_stateid(state, &data->o_res.stateid, NULL, - data->o_arg.open_flags); + data->o_arg.fmode); iput(inode); out: return state; @@ -655,20 +661,21 @@ static struct nfs4_opendata nfs4_open_recoverdata_alloc(struct nfs_open_context { struct nfs4_opendata opendata; - opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL); + opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); if (opendata == NULL) return ERR_PTR(-ENOMEM); opendata->state = state; atomic_inc(&state->count); return opendata; } -static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openflags, struct nfs4_state *res) +static int nfs4_open_recover_helper(struct nfs4_opendata opendata, fmode_t fmode, struct nfs4_state *res) { struct nfs4_state newstate; int ret; - opendata->o_arg.open_flags = openflags; + opendata->o_arg.open_flags = 0; + opendata->o_arg.fmode = fmode; memset(&opendata->o_res, 0, sizeof(opendata->o_res)); memset(&opendata->c_res, 0, sizeof(opendata->c_res)); nfs4_init_opendata_res(opendata); @@ -678,7 +685,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata opendata, mode_t openf newstate = nfs4_opendata_to_nfs4_state(opendata); if (IS_ERR(newstate)) return PTR_ERR(newstate); - nfs4_close_state(&opendata->path, newstate, openflags); + nfs4_close_state(&opendata->path, newstate, fmode); res = newstate; return 0; } @@ -734,7 +741,7 @@ static int _nfs4_do_open_reclaim(struct nfs_open_context ctx, struct nfs4_state { struct nfs_delegation delegation; struct nfs4_opendata opendata; - int delegation_type = 0; + fmode_t delegation_type = 0; int status; opendata = nfs4_open_recoverdata_alloc(ctx, state); @@ -847,7 +854,7 @@ static void nfs4_open_confirm_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -911,7 +918,7 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata) if (data->state != NULL) { struct nfs_delegation delegation; - if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ\|FMODE_WRITE\|O_EXCL))) + if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) goto out_no_action; rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); @@ -980,7 +987,7 @@ static void nfs4_open_release(void calldata) goto out_free; state = nfs4_opendata_to_nfs4_state(data); if (!IS_ERR(state)) - nfs4_close_state(&data->path, state, data->o_arg.open_flags); + nfs4_close_state(&data->path, state, data->o_arg.fmode); out_free: nfs4_opendata_put(data); } @@ -1135,7 +1142,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata opendata, struct / * Returns a referenced nfs4_state / -static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) +static int _nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred, struct nfs4_state res) { struct nfs4_state_owner sp; struct nfs4_state state = NULL; @@ -1153,9 +1160,9 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct if (status != 0) goto err_put_state_owner; if (path->dentry->d_inode != NULL) - nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ\|FMODE_WRITE)); + nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); status = -ENOMEM; - opendata = nfs4_opendata_alloc(path, sp, flags, sattr); + opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); if (opendata == NULL) goto err_put_state_owner; @@ -1187,14 +1194,14 @@ static int _nfs4_do_open(struct inode dir, struct path path, int flags, struct } -static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, int flags, struct iattr sattr, struct rpc_cred cred) +static struct nfs4_state nfs4_do_open(struct inode dir, struct path path, fmode_t fmode, int flags, struct iattr sattr, struct rpc_cred cred) { struct nfs4_exception exception = { }; struct nfs4_state res; int status; do { - status = _nfs4_do_open(dir, path, flags, sattr, cred, &res); + status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); if (status == 0) break; /* NOTE: BAD_SEQID means the server and client disagree about the @@ -1332,7 +1339,7 @@ static void nfs4_close_done(struct rpc_task task, void data) case -NFS4ERR_OLD_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_EXPIRED: - if (calldata->arg.open_flags == 0) + if (calldata->arg.fmode == 0) break; default: if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { @@ -1374,10 +1381,10 @@ static void nfs4_close_prepare(struct rpc_task task, void data) nfs_fattr_init(calldata->res.fattr); if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_READ; + calldata->arg.fmode = FMODE_READ; } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; - calldata->arg.open_flags = FMODE_WRITE; + calldata->arg.fmode = FMODE_WRITE; } calldata->timestamp = jiffies; rpc_call_start(task); @@ -1430,7 +1437,7 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); if (calldata->arg.seqid == NULL) goto out_free_calldata; - calldata->arg.open_flags = 0; + calldata->arg.fmode = 0; calldata->arg.bitmask = server->attr_bitmask; calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; @@ -1457,13 +1464,13 @@ int nfs4_do_close(struct path path, struct nfs4_state state, int wait) return status; } -static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state) +static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct nfs4_state state, fmode_t fmode) { struct file filp; int ret; / If the open_intent is for execute, we have an extra check to make / - if (nd->intent.open.flags & FMODE_EXEC) { + if (fmode & FMODE_EXEC) { ret = nfs_may_open(state->inode, state->owner->so_cred, nd->intent.open.flags); @@ -1479,7 +1486,7 @@ static int nfs4_intent_set_file(struct nameidata nd, struct path path, struct } ret = PTR_ERR(filp); out_close: - nfs4_close_sync(path, state, nd->intent.open.flags); + nfs4_close_sync(path, state, fmode & (FMODE_READ\|FMODE_WRITE)); return ret; } @@ -1495,6 +1502,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) struct rpc_cred cred; struct nfs4_state state; struct dentry res; + fmode_t fmode = nd->intent.open.flags & (FMODE_READ \| FMODE_WRITE \| FMODE_EXEC); if (nd->flags & LOOKUP_CREATE) { attr.ia_mode = nd->intent.open.create_mode; @@ -1512,7 +1520,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) parent = dentry->d_parent; /* Protect against concurrent sillydeletes / nfs_block_sillyrename(parent); - state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred); + state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); put_rpccred(cred); if (IS_ERR(state)) { if (PTR_ERR(state) == -ENOENT) { @@ -1527,7 +1535,7 @@ nfs4_atomic_open(struct inode dir, struct dentry dentry, struct nameidata nd) path.dentry = res; nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); nfs_unblock_sillyrename(parent); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return res; } @@ -1540,11 +1548,12 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st }; struct rpc_cred cred; struct nfs4_state state; + fmode_t fmode = openflags & (FMODE_READ \| FMODE_WRITE); cred = rpc_lookup_cred(); if (IS_ERR(cred)) return PTR_ERR(cred); - state = nfs4_do_open(dir, &path, openflags, NULL, cred); + state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); put_rpccred(cred); if (IS_ERR(state)) { switch (PTR_ERR(state)) { @@ -1561,10 +1570,10 @@ nfs4_open_revalidate(struct inode dir, struct dentry dentry, int openflags, st } if (state->inode == dentry->d_inode) { nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); - nfs4_intent_set_file(nd, &path, state); + nfs4_intent_set_file(nd, &path, state, fmode); return 1; } - nfs4_close_sync(&path, state, openflags); + nfs4_close_sync(&path, state, fmode); out_drop: d_drop(dentry); return 0; @@ -1990,14 +1999,15 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, }; struct nfs4_state state; struct rpc_cred cred; + fmode_t fmode = flags & (FMODE_READ \| FMODE_WRITE); int status = 0; cred = rpc_lookup_cred(); if (IS_ERR(cred)) { status = PTR_ERR(cred); goto out; } - state = nfs4_do_open(dir, &path, flags, sattr, cred); + state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); d_drop(dentry); if (IS_ERR(state)) { status = PTR_ERR(state); @@ -2013,9 +2023,9 @@ nfs4_proc_create(struct inode dir, struct dentry dentry, struct iattr sattr, nfs_post_op_update_inode(state->inode, &fattr); } if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) - status = nfs4_intent_set_file(nd, &path, state); + status = nfs4_intent_set_file(nd, &path, state, fmode); else - nfs4_close_sync(&path, state, flags); + nfs4_close_sync(&path, state, fmode); out_putcred: put_rpccred(cred); out:	null	null	null
18,323	__nfs4_find_lock_state(struct nfs4_state state, fl_owner_t fl_owner) { struct nfs4_lock_state pos; list_for_each_entry(pos, &state->lock_states, ls_locks) { if (pos->ls_owner != fl_owner) continue; atomic_inc(&pos->ls_count); return pos; } return NULL; }	DoS	__nfs4_find_lock_state(struct nfs4_state state, fl_owner_t fl_owner) { struct nfs4_lock_state pos; list_for_each_entry(pos, &state->lock_states, ls_locks) { if (pos->ls_owner != fl_owner) continue; atomic_inc(&pos->ls_count); return pos; } return NULL; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,324	__nfs4_find_state_byowner(struct inode inode, struct nfs4_state_owner owner) { struct nfs_inode nfsi = NFS_I(inode); struct nfs4_state state; list_for_each_entry(state, &nfsi->open_states, inode_states) { if (state->owner != owner) continue; if (atomic_inc_not_zero(&state->count)) return state; } return NULL; }	DoS	__nfs4_find_state_byowner(struct inode inode, struct nfs4_state_owner owner) { struct nfs_inode nfsi = NFS_I(inode); struct nfs4_state state; list_for_each_entry(state, &nfsi->open_states, inode_states) { if (state->owner != owner) continue; if (atomic_inc_not_zero(&state->count)) return state; } return NULL; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,325	nfs4_alloc_open_state(void) { struct nfs4_state state; state = kzalloc(sizeof(state), GFP_KERNEL); if (!state) return NULL; atomic_set(&state->count, 1); INIT_LIST_HEAD(&state->lock_states); spin_lock_init(&state->state_lock); seqlock_init(&state->seqlock); return state; }	DoS	nfs4_alloc_open_state(void) { struct nfs4_state state; state = kzalloc(sizeof(state), GFP_KERNEL); if (!state) return NULL; atomic_set(&state->count, 1); INIT_LIST_HEAD(&state->lock_states); spin_lock_init(&state->state_lock); seqlock_init(&state->seqlock); return state; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,326	nfs4_alloc_state_owner(void) { struct nfs4_state_owner sp; sp = kzalloc(sizeof(sp),GFP_KERNEL); if (!sp) return NULL; spin_lock_init(&sp->so_lock); INIT_LIST_HEAD(&sp->so_states); INIT_LIST_HEAD(&sp->so_delegations); rpc_init_wait_queue(&sp->so_sequence.wait, "Seqid_waitqueue"); sp->so_seqid.sequence = &sp->so_sequence; spin_lock_init(&sp->so_sequence.lock); INIT_LIST_HEAD(&sp->so_sequence.list); atomic_set(&sp->so_count, 1); return sp; }	DoS	nfs4_alloc_state_owner(void) { struct nfs4_state_owner sp; sp = kzalloc(sizeof(sp),GFP_KERNEL); if (!sp) return NULL; spin_lock_init(&sp->so_lock); INIT_LIST_HEAD(&sp->so_states); INIT_LIST_HEAD(&sp->so_delegations); rpc_init_wait_queue(&sp->so_sequence.wait, "Seqid_waitqueue"); sp->so_seqid.sequence = &sp->so_sequence; spin_lock_init(&sp->so_sequence.lock); INIT_LIST_HEAD(&sp->so_sequence.list); atomic_set(&sp->so_count, 1); return sp; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,327	static void nfs4_clear_machine_cred(struct nfs_client clp) { struct rpc_cred cred; spin_lock(&clp->cl_lock); cred = clp->cl_machine_cred; clp->cl_machine_cred = NULL; spin_unlock(&clp->cl_lock); if (cred != NULL) put_rpccred(cred); }	DoS	static void nfs4_clear_machine_cred(struct nfs_client clp) { struct rpc_cred cred; spin_lock(&clp->cl_lock); cred = clp->cl_machine_cred; clp->cl_machine_cred = NULL; spin_unlock(&clp->cl_lock); if (cred != NULL) put_rpccred(cred); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,328	static void nfs4_clear_state_manager_bit(struct nfs_client *clp) { smp_mb__before_clear_bit(); clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state); smp_mb__after_clear_bit(); wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING); rpc_wake_up(&clp->cl_rpcwaitq); }	DoS	static void nfs4_clear_state_manager_bit(struct nfs_client *clp) { smp_mb__before_clear_bit(); clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state); smp_mb__after_clear_bit(); wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING); rpc_wake_up(&clp->cl_rpcwaitq); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,329	void nfs4_copy_stateid(nfs4_stateid dst, struct nfs4_state state, fl_owner_t fl_owner) { struct nfs4_lock_state lsp; int seq; do { seq = read_seqbegin(&state->seqlock); memcpy(dst, &state->stateid, sizeof(dst)); } while (read_seqretry(&state->seqlock, seq)); if (test_bit(LK_STATE_IN_USE, &state->flags) == 0) return; spin_lock(&state->state_lock); lsp = __nfs4_find_lock_state(state, fl_owner); if (lsp != NULL && (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0) memcpy(dst, &lsp->ls_stateid, sizeof(*dst)); spin_unlock(&state->state_lock); nfs4_put_lock_state(lsp); }	DoS	void nfs4_copy_stateid(nfs4_stateid dst, struct nfs4_state state, fl_owner_t fl_owner) { struct nfs4_lock_state lsp; int seq; do { seq = read_seqbegin(&state->seqlock); memcpy(dst, &state->stateid, sizeof(dst)); } while (read_seqretry(&state->seqlock, seq)); if (test_bit(LK_STATE_IN_USE, &state->flags) == 0) return; spin_lock(&state->state_lock); lsp = __nfs4_find_lock_state(state, fl_owner); if (lsp != NULL && (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0) memcpy(dst, &lsp->ls_stateid, sizeof(*dst)); spin_unlock(&state->state_lock); nfs4_put_lock_state(lsp); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,330	static int nfs4_do_reclaim(struct nfs_client clp, const struct nfs4_state_recovery_ops ops) { struct rb_node pos; int status = 0; restart: spin_lock(&clp->cl_lock); for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) { struct nfs4_state_owner sp = rb_entry(pos, struct nfs4_state_owner, so_client_node); if (!test_and_clear_bit(ops->owner_flag_bit, &sp->so_flags)) continue; atomic_inc(&sp->so_count); spin_unlock(&clp->cl_lock); status = nfs4_reclaim_open_state(sp, ops); if (status < 0) { set_bit(ops->owner_flag_bit, &sp->so_flags); nfs4_put_state_owner(sp); nfs4_recovery_handle_error(clp, status); return status; } nfs4_put_state_owner(sp); goto restart; } spin_unlock(&clp->cl_lock); return status; }	DoS	static int nfs4_do_reclaim(struct nfs_client clp, const struct nfs4_state_recovery_ops ops) { struct rb_node pos; int status = 0; restart: spin_lock(&clp->cl_lock); for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) { struct nfs4_state_owner sp = rb_entry(pos, struct nfs4_state_owner, so_client_node); if (!test_and_clear_bit(ops->owner_flag_bit, &sp->so_flags)) continue; atomic_inc(&sp->so_count); spin_unlock(&clp->cl_lock); status = nfs4_reclaim_open_state(sp, ops); if (status < 0) { set_bit(ops->owner_flag_bit, &sp->so_flags); nfs4_put_state_owner(sp); nfs4_recovery_handle_error(clp, status); return status; } nfs4_put_state_owner(sp); goto restart; } spin_unlock(&clp->cl_lock); return status; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,331	nfs4_find_state_owner(struct nfs_server server, struct rpc_cred cred) { struct nfs_client clp = server->nfs_client; struct rb_node p = &clp->cl_state_owners.rb_node, parent = NULL; struct nfs4_state_owner sp, res = NULL; while (p != NULL) { parent = p; sp = rb_entry(parent, struct nfs4_state_owner, so_client_node); if (server < sp->so_server) { p = &parent->rb_left; continue; } if (server > sp->so_server) { p = &parent->rb_right; continue; } if (cred < sp->so_cred) p = &parent->rb_left; else if (cred > sp->so_cred) p = &parent->rb_right; else { atomic_inc(&sp->so_count); res = sp; break; } } return res; }	DoS	nfs4_find_state_owner(struct nfs_server server, struct rpc_cred cred) { struct nfs_client clp = server->nfs_client; struct rb_node p = &clp->cl_state_owners.rb_node, parent = NULL; struct nfs4_state_owner sp, res = NULL; while (p != NULL) { parent = p; sp = rb_entry(parent, struct nfs4_state_owner, so_client_node); if (server < sp->so_server) { p = &parent->rb_left; continue; } if (server > sp->so_server) { p = &parent->rb_right; continue; } if (cred < sp->so_cred) p = &parent->rb_left; else if (cred > sp->so_cred) p = &parent->rb_right; else { atomic_inc(&sp->so_count); res = sp; break; } } return res; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,332	static void nfs4_fl_copy_lock(struct file_lock dst, struct file_lock src) { struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner; dst->fl_u.nfs4_fl.owner = lsp; atomic_inc(&lsp->ls_count); }	DoS	static void nfs4_fl_copy_lock(struct file_lock dst, struct file_lock src) { struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner; dst->fl_u.nfs4_fl.owner = lsp; atomic_inc(&lsp->ls_count); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,333	static void nfs4_fl_release_lock(struct file_lock *fl) { nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner); }	DoS	static void nfs4_fl_release_lock(struct file_lock *fl) { nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,334	static void nfs4_free_lock_state(struct nfs4_lock_state lsp) { struct nfs_client clp = lsp->ls_state->owner->so_client; spin_lock(&clp->cl_lock); nfs_free_unique_id(&clp->cl_lockowner_id, &lsp->ls_id); spin_unlock(&clp->cl_lock); rpc_destroy_wait_queue(&lsp->ls_sequence.wait); kfree(lsp); }	DoS	static void nfs4_free_lock_state(struct nfs4_lock_state lsp) { struct nfs_client clp = lsp->ls_state->owner->so_client; spin_lock(&clp->cl_lock); nfs_free_unique_id(&clp->cl_lockowner_id, &lsp->ls_id); spin_unlock(&clp->cl_lock); rpc_destroy_wait_queue(&lsp->ls_sequence.wait); kfree(lsp); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,335	static struct nfs4_lock_state nfs4_get_lock_state(struct nfs4_state state, fl_owner_t owner) { struct nfs4_lock_state lsp, new = NULL; for(;;) { spin_lock(&state->state_lock); lsp = __nfs4_find_lock_state(state, owner); if (lsp != NULL) break; if (new != NULL) { new->ls_state = state; list_add(&new->ls_locks, &state->lock_states); set_bit(LK_STATE_IN_USE, &state->flags); lsp = new; new = NULL; break; } spin_unlock(&state->state_lock); new = nfs4_alloc_lock_state(state, owner); if (new == NULL) return NULL; } spin_unlock(&state->state_lock); if (new != NULL) nfs4_free_lock_state(new); return lsp; }	DoS	static struct nfs4_lock_state nfs4_get_lock_state(struct nfs4_state state, fl_owner_t owner) { struct nfs4_lock_state lsp, new = NULL; for(;;) { spin_lock(&state->state_lock); lsp = __nfs4_find_lock_state(state, owner); if (lsp != NULL) break; if (new != NULL) { new->ls_state = state; list_add(&new->ls_locks, &state->lock_states); set_bit(LK_STATE_IN_USE, &state->flags); lsp = new; new = NULL; break; } spin_unlock(&state->state_lock); new = nfs4_alloc_lock_state(state, owner); if (new == NULL) return NULL; } spin_unlock(&state->state_lock); if (new != NULL) nfs4_free_lock_state(new); return lsp; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,336	static struct rpc_cred nfs4_get_machine_cred_locked(struct nfs_client clp) { struct rpc_cred *cred = NULL; if (clp->cl_machine_cred != NULL) cred = get_rpccred(clp->cl_machine_cred); return cred; }	DoS	static struct rpc_cred nfs4_get_machine_cred_locked(struct nfs_client clp) { struct rpc_cred *cred = NULL; if (clp->cl_machine_cred != NULL) cred = get_rpccred(clp->cl_machine_cred); return cred; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,337	nfs4_get_open_state(struct inode inode, struct nfs4_state_owner owner) { struct nfs4_state state, new; struct nfs_inode nfsi = NFS_I(inode); spin_lock(&inode->i_lock); state = __nfs4_find_state_byowner(inode, owner); spin_unlock(&inode->i_lock); if (state) goto out; new = nfs4_alloc_open_state(); spin_lock(&owner->so_lock); spin_lock(&inode->i_lock); state = __nfs4_find_state_byowner(inode, owner); if (state == NULL && new != NULL) { state = new; state->owner = owner; atomic_inc(&owner->so_count); list_add(&state->inode_states, &nfsi->open_states); state->inode = igrab(inode); spin_unlock(&inode->i_lock); / Note: The reclaim code dictates that we add stateless * and read-only stateids to the end of the list */ list_add_tail(&state->open_states, &owner->so_states); spin_unlock(&owner->so_lock); } else { spin_unlock(&inode->i_lock); spin_unlock(&owner->so_lock); if (new) nfs4_free_open_state(new); } out: return state; }	DoS	nfs4_get_open_state(struct inode inode, struct nfs4_state_owner owner) { struct nfs4_state state, new; struct nfs_inode nfsi = NFS_I(inode); spin_lock(&inode->i_lock); state = __nfs4_find_state_byowner(inode, owner); spin_unlock(&inode->i_lock); if (state) goto out; new = nfs4_alloc_open_state(); spin_lock(&owner->so_lock); spin_lock(&inode->i_lock); state = __nfs4_find_state_byowner(inode, owner); if (state == NULL && new != NULL) { state = new; state->owner = owner; atomic_inc(&owner->so_count); list_add(&state->inode_states, &nfsi->open_states); state->inode = igrab(inode); spin_unlock(&inode->i_lock); / Note: The reclaim code dictates that we add stateless * and read-only stateids to the end of the list */ list_add_tail(&state->open_states, &owner->so_states); spin_unlock(&owner->so_lock); } else { spin_unlock(&inode->i_lock); spin_unlock(&owner->so_lock); if (new) nfs4_free_open_state(new); } out: return state; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,338	struct rpc_cred nfs4_get_renew_cred_locked(struct nfs_client clp) { struct nfs4_state_owner sp; struct rb_node pos; struct rpc_cred *cred = NULL; for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) { sp = rb_entry(pos, struct nfs4_state_owner, so_client_node); if (list_empty(&sp->so_states)) continue; cred = get_rpccred(sp->so_cred); break; } return cred; }	DoS	struct rpc_cred nfs4_get_renew_cred_locked(struct nfs_client clp) { struct nfs4_state_owner sp; struct rb_node pos; struct rpc_cred *cred = NULL; for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) { sp = rb_entry(pos, struct nfs4_state_owner, so_client_node); if (list_empty(&sp->so_states)) continue; cred = get_rpccred(sp->so_cred); break; } return cred; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,339	static struct rpc_cred nfs4_get_setclientid_cred(struct nfs_client clp) { struct nfs4_state_owner sp; struct rb_node pos; struct rpc_cred *cred; spin_lock(&clp->cl_lock); cred = nfs4_get_machine_cred_locked(clp); if (cred != NULL) goto out; pos = rb_first(&clp->cl_state_owners); if (pos != NULL) { sp = rb_entry(pos, struct nfs4_state_owner, so_client_node); cred = get_rpccred(sp->so_cred); } out: spin_unlock(&clp->cl_lock); return cred; }	DoS	static struct rpc_cred nfs4_get_setclientid_cred(struct nfs_client clp) { struct nfs4_state_owner sp; struct rb_node pos; struct rpc_cred *cred; spin_lock(&clp->cl_lock); cred = nfs4_get_machine_cred_locked(clp); if (cred != NULL) goto out; pos = rb_first(&clp->cl_state_owners); if (pos != NULL) { sp = rb_entry(pos, struct nfs4_state_owner, so_client_node); cred = get_rpccred(sp->so_cred); } out: spin_unlock(&clp->cl_lock); return cred; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,340	struct nfs4_state_owner nfs4_get_state_owner(struct nfs_server server, struct rpc_cred cred) { struct nfs_client clp = server->nfs_client; struct nfs4_state_owner sp, new; spin_lock(&clp->cl_lock); sp = nfs4_find_state_owner(server, cred); spin_unlock(&clp->cl_lock); if (sp != NULL) return sp; new = nfs4_alloc_state_owner(); if (new == NULL) return NULL; new->so_client = clp; new->so_server = server; new->so_cred = cred; spin_lock(&clp->cl_lock); sp = nfs4_insert_state_owner(clp, new); spin_unlock(&clp->cl_lock); if (sp == new) get_rpccred(cred); else { rpc_destroy_wait_queue(&new->so_sequence.wait); kfree(new); } return sp; }	DoS	struct nfs4_state_owner nfs4_get_state_owner(struct nfs_server server, struct rpc_cred cred) { struct nfs_client clp = server->nfs_client; struct nfs4_state_owner sp, new; spin_lock(&clp->cl_lock); sp = nfs4_find_state_owner(server, cred); spin_unlock(&clp->cl_lock); if (sp != NULL) return sp; new = nfs4_alloc_state_owner(); if (new == NULL) return NULL; new->so_client = clp; new->so_server = server; new->so_cred = cred; spin_lock(&clp->cl_lock); sp = nfs4_insert_state_owner(clp, new); spin_unlock(&clp->cl_lock); if (sp == new) get_rpccred(cred); else { rpc_destroy_wait_queue(&new->so_sequence.wait); kfree(new); } return sp; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,341	static int nfs4_init_client(struct nfs_client clp, struct rpc_cred cred) { int status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, nfs_callback_tcpport, cred); if (status == 0) status = nfs4_proc_setclientid_confirm(clp, cred); if (status == 0) nfs4_schedule_state_renewal(clp); return status; }	DoS	static int nfs4_init_client(struct nfs_client clp, struct rpc_cred cred) { int status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, nfs_callback_tcpport, cred); if (status == 0) status = nfs4_proc_setclientid_confirm(clp, cred); if (status == 0) nfs4_schedule_state_renewal(clp); return status; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,342	nfs4_insert_state_owner(struct nfs_client clp, struct nfs4_state_owner new) { struct rb_node *p = &clp->cl_state_owners.rb_node, parent = NULL; struct nfs4_state_owner sp; while (p != NULL) { parent = *p; sp = rb_entry(parent, struct nfs4_state_owner, so_client_node); if (new->so_server < sp->so_server) { p = &parent->rb_left; continue; } if (new->so_server > sp->so_server) { p = &parent->rb_right; continue; } if (new->so_cred < sp->so_cred) p = &parent->rb_left; else if (new->so_cred > sp->so_cred) p = &parent->rb_right; else { atomic_inc(&sp->so_count); return sp; } } nfs_alloc_unique_id(&clp->cl_openowner_id, &new->so_owner_id, 1, 64); rb_link_node(&new->so_client_node, parent, p); rb_insert_color(&new->so_client_node, &clp->cl_state_owners); return new; }	DoS	nfs4_insert_state_owner(struct nfs_client clp, struct nfs4_state_owner new) { struct rb_node *p = &clp->cl_state_owners.rb_node, parent = NULL; struct nfs4_state_owner sp; while (p != NULL) { parent = *p; sp = rb_entry(parent, struct nfs4_state_owner, so_client_node); if (new->so_server < sp->so_server) { p = &parent->rb_left; continue; } if (new->so_server > sp->so_server) { p = &parent->rb_right; continue; } if (new->so_cred < sp->so_cred) p = &parent->rb_left; else if (new->so_cred > sp->so_cred) p = &parent->rb_right; else { atomic_inc(&sp->so_count); return sp; } } nfs_alloc_unique_id(&clp->cl_openowner_id, &new->so_owner_id, 1, 64); rb_link_node(&new->so_client_node, parent, p); rb_insert_color(&new->so_client_node, &clp->cl_state_owners); return new; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,343	void nfs4_put_lock_state(struct nfs4_lock_state lsp) { struct nfs4_state state; if (lsp == NULL) return; state = lsp->ls_state; if (!atomic_dec_and_lock(&lsp->ls_count, &state->state_lock)) return; list_del(&lsp->ls_locks); if (list_empty(&state->lock_states)) clear_bit(LK_STATE_IN_USE, &state->flags); spin_unlock(&state->state_lock); nfs4_free_lock_state(lsp); }	DoS	void nfs4_put_lock_state(struct nfs4_lock_state lsp) { struct nfs4_state state; if (lsp == NULL) return; state = lsp->ls_state; if (!atomic_dec_and_lock(&lsp->ls_count, &state->state_lock)) return; list_del(&lsp->ls_locks); if (list_empty(&state->lock_states)) clear_bit(LK_STATE_IN_USE, &state->flags); spin_unlock(&state->state_lock); nfs4_free_lock_state(lsp); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,344	static int nfs4_reclaim_lease(struct nfs_client clp) { struct rpc_cred cred; int status = -ENOENT; cred = nfs4_get_setclientid_cred(clp); if (cred != NULL) { status = nfs4_init_client(clp, cred); put_rpccred(cred); /* Handle case where the user hasn't set up machine creds */ if (status == -EACCES && cred == clp->cl_machine_cred) { nfs4_clear_machine_cred(clp); status = -EAGAIN; } } return status; }	DoS	static int nfs4_reclaim_lease(struct nfs_client clp) { struct rpc_cred cred; int status = -ENOENT; cred = nfs4_get_setclientid_cred(clp); if (cred != NULL) { status = nfs4_init_client(clp, cred); put_rpccred(cred); /* Handle case where the user hasn't set up machine creds */ if (status == -EACCES && cred == clp->cl_machine_cred) { nfs4_clear_machine_cred(clp); status = -EAGAIN; } } return status; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,345	static int nfs4_reclaim_locks(struct nfs4_state state, const struct nfs4_state_recovery_ops ops) { struct inode inode = state->inode; struct nfs_inode nfsi = NFS_I(inode); struct file_lock fl; int status = 0; down_write(&nfsi->rwsem); for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { if (!(fl->fl_flags & (FL_POSIX\|FL_FLOCK))) continue; if (nfs_file_open_context(fl->fl_file)->state != state) continue; status = ops->recover_lock(state, fl); if (status >= 0) continue; switch (status) { default: printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n", __func__, status); case -NFS4ERR_EXPIRED: case -NFS4ERR_NO_GRACE: case -NFS4ERR_RECLAIM_BAD: case -NFS4ERR_RECLAIM_CONFLICT: / kill_proc(fl->fl_pid, SIGLOST, 1); */ break; case -NFS4ERR_STALE_CLIENTID: goto out_err; } } up_write(&nfsi->rwsem); return 0; out_err: up_write(&nfsi->rwsem); return status; }	DoS	static int nfs4_reclaim_locks(struct nfs4_state state, const struct nfs4_state_recovery_ops ops) { struct inode inode = state->inode; struct nfs_inode nfsi = NFS_I(inode); struct file_lock fl; int status = 0; down_write(&nfsi->rwsem); for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { if (!(fl->fl_flags & (FL_POSIX\|FL_FLOCK))) continue; if (nfs_file_open_context(fl->fl_file)->state != state) continue; status = ops->recover_lock(state, fl); if (status >= 0) continue; switch (status) { default: printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n", __func__, status); case -NFS4ERR_EXPIRED: case -NFS4ERR_NO_GRACE: case -NFS4ERR_RECLAIM_BAD: case -NFS4ERR_RECLAIM_CONFLICT: / kill_proc(fl->fl_pid, SIGLOST, 1); */ break; case -NFS4ERR_STALE_CLIENTID: goto out_err; } } up_write(&nfsi->rwsem); return 0; out_err: up_write(&nfsi->rwsem); return status; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,346	static int nfs4_reclaim_open_state(struct nfs4_state_owner sp, const struct nfs4_state_recovery_ops ops) { struct nfs4_state state; struct nfs4_lock_state lock; int status = 0; /* Note: we rely on the sp->so_states list being ordered * so that we always reclaim open(O_RDWR) and/or open(O_WRITE) * states first. * This is needed to ensure that the server won't give us any * read delegations that we have to return if, say, we are * recovering after a network partition or a reboot from a * server that doesn't support a grace period. / restart: spin_lock(&sp->so_lock); list_for_each_entry(state, &sp->so_states, open_states) { if (!test_and_clear_bit(ops->state_flag_bit, &state->flags)) continue; if (state->state == 0) continue; atomic_inc(&state->count); spin_unlock(&sp->so_lock); status = ops->recover_open(sp, state); if (status >= 0) { status = nfs4_reclaim_locks(state, ops); if (status >= 0) { list_for_each_entry(lock, &state->lock_states, ls_locks) { if (!(lock->ls_flags & NFS_LOCK_INITIALIZED)) printk("%s: Lock reclaim failed!\n", __func__); } nfs4_put_open_state(state); goto restart; } } switch (status) { default: printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n", __func__, status); case -ENOENT: case -ESTALE: / * Open state on this file cannot be recovered * All we can do is revert to using the zero stateid. / memset(state->stateid.data, 0, sizeof(state->stateid.data)); / Mark the file as being 'closed' */ state->state = 0; break; case -NFS4ERR_RECLAIM_BAD: case -NFS4ERR_RECLAIM_CONFLICT: nfs4_state_mark_reclaim_nograce(sp->so_client, state); break; case -NFS4ERR_EXPIRED: case -NFS4ERR_NO_GRACE: nfs4_state_mark_reclaim_nograce(sp->so_client, state); case -NFS4ERR_STALE_CLIENTID: goto out_err; } nfs4_put_open_state(state); goto restart; } spin_unlock(&sp->so_lock); return 0; out_err: nfs4_put_open_state(state); return status; }	DoS	static int nfs4_reclaim_open_state(struct nfs4_state_owner sp, const struct nfs4_state_recovery_ops ops) { struct nfs4_state state; struct nfs4_lock_state lock; int status = 0; /* Note: we rely on the sp->so_states list being ordered * so that we always reclaim open(O_RDWR) and/or open(O_WRITE) * states first. * This is needed to ensure that the server won't give us any * read delegations that we have to return if, say, we are * recovering after a network partition or a reboot from a * server that doesn't support a grace period. / restart: spin_lock(&sp->so_lock); list_for_each_entry(state, &sp->so_states, open_states) { if (!test_and_clear_bit(ops->state_flag_bit, &state->flags)) continue; if (state->state == 0) continue; atomic_inc(&state->count); spin_unlock(&sp->so_lock); status = ops->recover_open(sp, state); if (status >= 0) { status = nfs4_reclaim_locks(state, ops); if (status >= 0) { list_for_each_entry(lock, &state->lock_states, ls_locks) { if (!(lock->ls_flags & NFS_LOCK_INITIALIZED)) printk("%s: Lock reclaim failed!\n", __func__); } nfs4_put_open_state(state); goto restart; } } switch (status) { default: printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n", __func__, status); case -ENOENT: case -ESTALE: / * Open state on this file cannot be recovered * All we can do is revert to using the zero stateid. / memset(state->stateid.data, 0, sizeof(state->stateid.data)); / Mark the file as being 'closed' */ state->state = 0; break; case -NFS4ERR_RECLAIM_BAD: case -NFS4ERR_RECLAIM_CONFLICT: nfs4_state_mark_reclaim_nograce(sp->so_client, state); break; case -NFS4ERR_EXPIRED: case -NFS4ERR_NO_GRACE: nfs4_state_mark_reclaim_nograce(sp->so_client, state); case -NFS4ERR_STALE_CLIENTID: goto out_err; } nfs4_put_open_state(state); goto restart; } spin_unlock(&sp->so_lock); return 0; out_err: nfs4_put_open_state(state); return status; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,347	static void nfs4_recovery_handle_error(struct nfs_client *clp, int error) { switch (error) { case -NFS4ERR_CB_PATH_DOWN: nfs_handle_cb_pathdown(clp); break; case -NFS4ERR_STALE_CLIENTID: case -NFS4ERR_LEASE_MOVED: set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); nfs4_state_start_reclaim_reboot(clp); break; case -NFS4ERR_EXPIRED: set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); nfs4_state_start_reclaim_nograce(clp); } }	DoS	static void nfs4_recovery_handle_error(struct nfs_client *clp, int error) { switch (error) { case -NFS4ERR_CB_PATH_DOWN: nfs_handle_cb_pathdown(clp); break; case -NFS4ERR_STALE_CLIENTID: case -NFS4ERR_LEASE_MOVED: set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); nfs4_state_start_reclaim_reboot(clp); break; case -NFS4ERR_EXPIRED: set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); nfs4_state_start_reclaim_nograce(clp); } }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,348	nfs4_remove_state_owner(struct nfs_client clp, struct nfs4_state_owner sp) { if (!RB_EMPTY_NODE(&sp->so_client_node)) rb_erase(&sp->so_client_node, &clp->cl_state_owners); nfs_free_unique_id(&clp->cl_openowner_id, &sp->so_owner_id); }	DoS	nfs4_remove_state_owner(struct nfs_client clp, struct nfs4_state_owner sp) { if (!RB_EMPTY_NODE(&sp->so_client_node)) rb_erase(&sp->so_client_node, &clp->cl_state_owners); nfs_free_unique_id(&clp->cl_openowner_id, &sp->so_owner_id); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,349	static int nfs4_run_state_manager(void ptr) { struct nfs_client clp = ptr; allow_signal(SIGKILL); nfs4_state_manager(clp); nfs_put_client(clp); module_put_and_exit(0); return 0; }	DoS	static int nfs4_run_state_manager(void ptr) { struct nfs_client clp = ptr; allow_signal(SIGKILL); nfs4_state_manager(clp); nfs_put_client(clp); module_put_and_exit(0); return 0; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,350	void nfs4_schedule_state_manager(struct nfs_client clp) { struct task_struct task; if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0) return; __module_get(THIS_MODULE); atomic_inc(&clp->cl_count); task = kthread_run(nfs4_run_state_manager, clp, "%s-manager", rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR)); if (!IS_ERR(task)) return; nfs4_clear_state_manager_bit(clp); nfs_put_client(clp); module_put(THIS_MODULE); }	DoS	void nfs4_schedule_state_manager(struct nfs_client clp) { struct task_struct task; if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0) return; __module_get(THIS_MODULE); atomic_inc(&clp->cl_count); task = kthread_run(nfs4_run_state_manager, clp, "%s-manager", rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR)); if (!IS_ERR(task)) return; nfs4_clear_state_manager_bit(clp); nfs_put_client(clp); module_put(THIS_MODULE); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,351	void nfs4_schedule_state_recovery(struct nfs_client *clp) { if (!clp) return; if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); nfs4_schedule_state_manager(clp); }	DoS	void nfs4_schedule_state_recovery(struct nfs_client *clp) { if (!clp) return; if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); nfs4_schedule_state_manager(clp); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,352	int nfs4_set_lock_state(struct nfs4_state state, struct file_lock fl) { struct nfs4_lock_state *lsp; if (fl->fl_ops != NULL) return 0; lsp = nfs4_get_lock_state(state, fl->fl_owner); if (lsp == NULL) return -ENOMEM; fl->fl_u.nfs4_fl.owner = lsp; fl->fl_ops = &nfs4_fl_lock_ops; return 0; }	DoS	int nfs4_set_lock_state(struct nfs4_state state, struct file_lock fl) { struct nfs4_lock_state *lsp; if (fl->fl_ops != NULL) return 0; lsp = nfs4_get_lock_state(state, fl->fl_owner); if (lsp == NULL) return -ENOMEM; fl->fl_u.nfs4_fl.owner = lsp; fl->fl_ops = &nfs4_fl_lock_ops; return 0; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,353	static void nfs4_state_end_reclaim_nograce(struct nfs_client *clp) { clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state); }	DoS	static void nfs4_state_end_reclaim_nograce(struct nfs_client *clp) { clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,354	static void nfs4_state_end_reclaim_reboot(struct nfs_client clp) { struct nfs4_state_owner sp; struct rb_node pos; struct nfs4_state state; if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) return; for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) { sp = rb_entry(pos, struct nfs4_state_owner, so_client_node); spin_lock(&sp->so_lock); list_for_each_entry(state, &sp->so_states, open_states) { if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags)) continue; nfs4_state_mark_reclaim_nograce(clp, state); } spin_unlock(&sp->so_lock); } nfs_delegation_reap_unclaimed(clp); }	DoS	static void nfs4_state_end_reclaim_reboot(struct nfs_client clp) { struct nfs4_state_owner sp; struct rb_node pos; struct nfs4_state state; if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) return; for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) { sp = rb_entry(pos, struct nfs4_state_owner, so_client_node); spin_lock(&sp->so_lock); list_for_each_entry(state, &sp->so_states, open_states) { if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags)) continue; nfs4_state_mark_reclaim_nograce(clp, state); } spin_unlock(&sp->so_lock); } nfs_delegation_reap_unclaimed(clp); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,355	static void nfs4_state_manager(struct nfs_client clp) { int status = 0; / Ensure exclusive access to NFSv4 state / for(;;) { if (test_and_clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) { / We're going to have to re-establish a clientid / status = nfs4_reclaim_lease(clp); if (status) { set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); if (status == -EAGAIN) continue; goto out_error; } clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); } if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) { status = nfs4_check_lease(clp); if (status != 0) continue; } / First recover reboot state... / if (test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) { status = nfs4_do_reclaim(clp, &nfs4_reboot_recovery_ops); if (status == -NFS4ERR_STALE_CLIENTID) continue; nfs4_state_end_reclaim_reboot(clp); continue; } / Now recover expired state... / if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) { status = nfs4_do_reclaim(clp, &nfs4_nograce_recovery_ops); if (status < 0) { set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state); if (status == -NFS4ERR_STALE_CLIENTID) continue; if (status == -NFS4ERR_EXPIRED) continue; goto out_error; } else nfs4_state_end_reclaim_nograce(clp); continue; } if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) { nfs_client_return_marked_delegations(clp); continue; } nfs4_clear_state_manager_bit(clp); / Did we race with an attempt to give us more work? */ if (clp->cl_state == 0) break; if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0) break; } return; out_error: printk(KERN_WARNING "Error: state manager failed on NFSv4 server %s" " with error %d\n", clp->cl_hostname, -status); if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) nfs4_state_end_reclaim_reboot(clp); nfs4_clear_state_manager_bit(clp); }	DoS	static void nfs4_state_manager(struct nfs_client clp) { int status = 0; / Ensure exclusive access to NFSv4 state / for(;;) { if (test_and_clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) { / We're going to have to re-establish a clientid / status = nfs4_reclaim_lease(clp); if (status) { set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); if (status == -EAGAIN) continue; goto out_error; } clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); } if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) { status = nfs4_check_lease(clp); if (status != 0) continue; } / First recover reboot state... / if (test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) { status = nfs4_do_reclaim(clp, &nfs4_reboot_recovery_ops); if (status == -NFS4ERR_STALE_CLIENTID) continue; nfs4_state_end_reclaim_reboot(clp); continue; } / Now recover expired state... / if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) { status = nfs4_do_reclaim(clp, &nfs4_nograce_recovery_ops); if (status < 0) { set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state); if (status == -NFS4ERR_STALE_CLIENTID) continue; if (status == -NFS4ERR_EXPIRED) continue; goto out_error; } else nfs4_state_end_reclaim_nograce(clp); continue; } if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) { nfs_client_return_marked_delegations(clp); continue; } nfs4_clear_state_manager_bit(clp); / Did we race with an attempt to give us more work? */ if (clp->cl_state == 0) break; if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0) break; } return; out_error: printk(KERN_WARNING "Error: state manager failed on NFSv4 server %s" " with error %d\n", clp->cl_hostname, -status); if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) nfs4_state_end_reclaim_reboot(clp); nfs4_clear_state_manager_bit(clp); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,356	static void nfs4_state_mark_reclaim_helper(struct nfs_client clp, int (mark_reclaim)(struct nfs_client clp, struct nfs4_state state)) { struct nfs4_state_owner sp; struct rb_node pos; struct nfs4_state state; / Reset all sequence ids to zero */ for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) { sp = rb_entry(pos, struct nfs4_state_owner, so_client_node); sp->so_seqid.flags = 0; spin_lock(&sp->so_lock); list_for_each_entry(state, &sp->so_states, open_states) { if (mark_reclaim(clp, state)) nfs4_clear_open_state(state); } spin_unlock(&sp->so_lock); } }	DoS	static void nfs4_state_mark_reclaim_helper(struct nfs_client clp, int (mark_reclaim)(struct nfs_client clp, struct nfs4_state state)) { struct nfs4_state_owner sp; struct rb_node pos; struct nfs4_state state; / Reset all sequence ids to zero */ for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) { sp = rb_entry(pos, struct nfs4_state_owner, so_client_node); sp->so_seqid.flags = 0; spin_lock(&sp->so_lock); list_for_each_entry(state, &sp->so_states, open_states) { if (mark_reclaim(clp, state)) nfs4_clear_open_state(state); } spin_unlock(&sp->so_lock); } }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,357	int nfs4_state_mark_reclaim_nograce(struct nfs_client clp, struct nfs4_state state) { set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags); clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags); set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state); return 1; }	DoS	int nfs4_state_mark_reclaim_nograce(struct nfs_client clp, struct nfs4_state state) { set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags); clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags); set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state); return 1; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,358	static int nfs4_state_mark_reclaim_reboot(struct nfs_client clp, struct nfs4_state state) { set_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); /* Don't recover state that expired before the reboot */ if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) { clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); return 0; } set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags); set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state); return 1; }	DoS	static int nfs4_state_mark_reclaim_reboot(struct nfs_client clp, struct nfs4_state state) { set_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); /* Don't recover state that expired before the reboot */ if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) { clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags); return 0; } set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags); set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state); return 1; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,359	static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp) { nfs_delegation_clear_all(clp); nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce); }	DoS	static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp) { nfs_delegation_clear_all(clp); nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,360	static void nfs4_state_start_reclaim_reboot(struct nfs_client clp) { / Mark all delegations for reclaim */ nfs_delegation_mark_reclaim(clp); nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot); }	DoS	static void nfs4_state_start_reclaim_reboot(struct nfs_client clp) { / Mark all delegations for reclaim */ nfs_delegation_mark_reclaim(clp); nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,361	struct nfs_seqid nfs_alloc_seqid(struct nfs_seqid_counter counter) { struct nfs_seqid new; new = kmalloc(sizeof(new), GFP_KERNEL); if (new != NULL) { new->sequence = counter; INIT_LIST_HEAD(&new->list); } return new; }	DoS	struct nfs_seqid nfs_alloc_seqid(struct nfs_seqid_counter counter) { struct nfs_seqid new; new = kmalloc(sizeof(new), GFP_KERNEL); if (new != NULL) { new->sequence = counter; INIT_LIST_HEAD(&new->list); } return new; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,362	static void nfs_alloc_unique_id(struct rb_root root, struct nfs_unique_id new, __u64 minval, int maxbits) { struct rb_node *p, parent; struct nfs_unique_id pos; __u64 mask = ~0ULL; if (maxbits < 64) mask = (1ULL << maxbits) - 1ULL; / Ensure distribution is more or less flat / get_random_bytes(&new->id, sizeof(new->id)); new->id &= mask; if (new->id < minval) new->id += minval; retry: p = &root->rb_node; parent = NULL; while (p != NULL) { parent = p; pos = rb_entry(parent, struct nfs_unique_id, rb_node); if (new->id < pos->id) p = &(p)->rb_left; else if (new->id > pos->id) p = &(*p)->rb_right; else goto id_exists; } rb_link_node(&new->rb_node, parent, p); rb_insert_color(&new->rb_node, root); return; id_exists: for (;;) { new->id++; if (new->id < minval \|\| (new->id & mask) != new->id) { new->id = minval; break; } parent = rb_next(parent); if (parent == NULL) break; pos = rb_entry(parent, struct nfs_unique_id, rb_node); if (new->id < pos->id) break; } goto retry; }	DoS	static void nfs_alloc_unique_id(struct rb_root root, struct nfs_unique_id new, __u64 minval, int maxbits) { struct rb_node *p, parent; struct nfs_unique_id pos; __u64 mask = ~0ULL; if (maxbits < 64) mask = (1ULL << maxbits) - 1ULL; / Ensure distribution is more or less flat / get_random_bytes(&new->id, sizeof(new->id)); new->id &= mask; if (new->id < minval) new->id += minval; retry: p = &root->rb_node; parent = NULL; while (p != NULL) { parent = p; pos = rb_entry(parent, struct nfs_unique_id, rb_node); if (new->id < pos->id) p = &(p)->rb_left; else if (new->id > pos->id) p = &(*p)->rb_right; else goto id_exists; } rb_link_node(&new->rb_node, parent, p); rb_insert_color(&new->rb_node, root); return; id_exists: for (;;) { new->id++; if (new->id < minval \|\| (new->id & mask) != new->id) { new->id = minval; break; } parent = rb_next(parent); if (parent == NULL) break; pos = rb_entry(parent, struct nfs_unique_id, rb_node); if (new->id < pos->id) break; } goto retry; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,363	static void nfs_delegation_clear_all(struct nfs_client *clp) { nfs_delegation_mark_reclaim(clp); nfs_delegation_reap_unclaimed(clp); }	DoS	static void nfs_delegation_clear_all(struct nfs_client *clp) { nfs_delegation_mark_reclaim(clp); nfs_delegation_reap_unclaimed(clp); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,364	void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid) { nfs_increment_seqid(status, seqid); }	DoS	void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid) { nfs_increment_seqid(status, seqid); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,365	void nfs_increment_open_seqid(int status, struct nfs_seqid seqid) { if (status == -NFS4ERR_BAD_SEQID) { struct nfs4_state_owner sp = container_of(seqid->sequence, struct nfs4_state_owner, so_seqid); nfs4_drop_state_owner(sp); } nfs_increment_seqid(status, seqid); }	DoS	void nfs_increment_open_seqid(int status, struct nfs_seqid seqid) { if (status == -NFS4ERR_BAD_SEQID) { struct nfs4_state_owner sp = container_of(seqid->sequence, struct nfs4_state_owner, so_seqid); nfs4_drop_state_owner(sp); } nfs_increment_seqid(status, seqid); }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,366	static void nfs_increment_seqid(int status, struct nfs_seqid seqid) { BUG_ON(list_first_entry(&seqid->sequence->sequence->list, struct nfs_seqid, list) != seqid); switch (status) { case 0: break; case -NFS4ERR_BAD_SEQID: if (seqid->sequence->flags & NFS_SEQID_CONFIRMED) return; printk(KERN_WARNING "NFS: v4 server returned a bad" " sequence-id error on an" " unconfirmed sequence %p!\n", seqid->sequence); case -NFS4ERR_STALE_CLIENTID: case -NFS4ERR_STALE_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_BADXDR: case -NFS4ERR_RESOURCE: case -NFS4ERR_NOFILEHANDLE: / Non-seqid mutating errors / return; }; / * Note: no locking needed as we are guaranteed to be first * on the sequence list */ seqid->sequence->counter++; }	DoS	static void nfs_increment_seqid(int status, struct nfs_seqid seqid) { BUG_ON(list_first_entry(&seqid->sequence->sequence->list, struct nfs_seqid, list) != seqid); switch (status) { case 0: break; case -NFS4ERR_BAD_SEQID: if (seqid->sequence->flags & NFS_SEQID_CONFIRMED) return; printk(KERN_WARNING "NFS: v4 server returned a bad" " sequence-id error on an" " unconfirmed sequence %p!\n", seqid->sequence); case -NFS4ERR_STALE_CLIENTID: case -NFS4ERR_STALE_STATEID: case -NFS4ERR_BAD_STATEID: case -NFS4ERR_BADXDR: case -NFS4ERR_RESOURCE: case -NFS4ERR_NOFILEHANDLE: / Non-seqid mutating errors / return; }; / * Note: no locking needed as we are guaranteed to be first * on the sequence list */ seqid->sequence->counter++; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,367	int nfs_wait_on_sequence(struct nfs_seqid seqid, struct rpc_task task) { struct rpc_sequence *sequence = seqid->sequence->sequence; int status = 0; spin_lock(&sequence->lock); if (list_empty(&seqid->list)) list_add_tail(&seqid->list, &sequence->list); if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid) goto unlock; rpc_sleep_on(&sequence->wait, task, NULL); status = -EAGAIN; unlock: spin_unlock(&sequence->lock); return status; }	DoS	int nfs_wait_on_sequence(struct nfs_seqid seqid, struct rpc_task task) { struct rpc_sequence *sequence = seqid->sequence->sequence; int status = 0; spin_lock(&sequence->lock); if (list_empty(&seqid->list)) list_add_tail(&seqid->list, &sequence->list); if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid) goto unlock; rpc_sleep_on(&sequence->wait, task, NULL); status = -EAGAIN; unlock: spin_unlock(&sequence->lock); return status; }	@@ -363,18 +363,18 @@ nfs4_alloc_open_state(void) } void -nfs4_state_set_mode_locked(struct nfs4_state state, mode_t mode) +nfs4_state_set_mode_locked(struct nfs4_state state, fmode_t fmode) { - if (state->state == mode) + if (state->state == fmode) return; /* NB! List reordering - see the reclaim code for why. / - if ((mode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { - if (mode & FMODE_WRITE) + if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) { + if (fmode & FMODE_WRITE) list_move(&state->open_states, &state->owner->so_states); else list_move_tail(&state->open_states, &state->owner->so_states); } - state->state = mode; + state->state = fmode; } static struct nfs4_state @@ -454,16 +454,16 @@ void nfs4_put_open_state(struct nfs4_state state) / * Close the current file. / -static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mode, int wait) +static void __nfs4_close(struct path path, struct nfs4_state state, fmode_t fmode, int wait) { struct nfs4_state_owner owner = state->owner; int call_close = 0; - int newstate; + fmode_t newstate; atomic_inc(&owner->so_count); /* Protect against nfs4_find_state() / spin_lock(&owner->so_lock); - switch (mode & (FMODE_READ \| FMODE_WRITE)) { + switch (fmode & (FMODE_READ \| FMODE_WRITE)) { case FMODE_READ: state->n_rdonly--; break; @@ -498,14 +498,14 @@ static void __nfs4_close(struct path path, struct nfs4_state state, mode_t mod nfs4_do_close(path, state, wait); } -void nfs4_close_state(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_state(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 0); + __nfs4_close(path, state, fmode, 0); } -void nfs4_close_sync(struct path path, struct nfs4_state state, mode_t mode) +void nfs4_close_sync(struct path path, struct nfs4_state state, fmode_t fmode) { - __nfs4_close(path, state, mode, 1); + __nfs4_close(path, state, fmode, 1); } /	null	null	null
18,368	static int decode_access(struct xdr_stream xdr, struct nfs4_accessres access) { __be32 *p; uint32_t supp, acc; int status; status = decode_op_hdr(xdr, OP_ACCESS); if (status) return status; READ_BUF(8); READ32(supp); READ32(acc); access->supported = supp; access->access = acc; return 0; }	DoS	static int decode_access(struct xdr_stream xdr, struct nfs4_accessres access) { __be32 *p; uint32_t supp, acc; int status; status = decode_op_hdr(xdr, OP_ACCESS); if (status) return status; READ_BUF(8); READ32(supp); READ32(acc); access->supported = supp; access->access = acc; return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,369	static int decode_ace(struct xdr_stream xdr, void ace, struct nfs_client clp) { __be32 p; unsigned int strlen; char *str; READ_BUF(12); return decode_opaque_inline(xdr, &strlen, &str); }	DoS	static int decode_ace(struct xdr_stream xdr, void ace, struct nfs_client clp) { __be32 p; unsigned int strlen; char *str; READ_BUF(12); return decode_opaque_inline(xdr, &strlen, &str); }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,370	static int decode_attr_aclsupport(struct xdr_stream xdr, uint32_t bitmap, uint32_t res) { __be32 p; res = ACL4_SUPPORT_ALLOW_ACL\|ACL4_SUPPORT_DENY_ACL; if (unlikely(bitmap[0] & (FATTR4_WORD0_ACLSUPPORT - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_ACLSUPPORT)) { READ_BUF(4); READ32(res); bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT; } dprintk("%s: ACLs supported=%u\n", __func__, (unsigned int)*res); return 0; }	DoS	static int decode_attr_aclsupport(struct xdr_stream xdr, uint32_t bitmap, uint32_t res) { __be32 p; res = ACL4_SUPPORT_ALLOW_ACL\|ACL4_SUPPORT_DENY_ACL; if (unlikely(bitmap[0] & (FATTR4_WORD0_ACLSUPPORT - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_ACLSUPPORT)) { READ_BUF(4); READ32(res); bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT; } dprintk("%s: ACLs supported=%u\n", __func__, (unsigned int)*res); return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,371	static int decode_attr_bitmap(struct xdr_stream xdr, uint32_t bitmap) { uint32_t bmlen; __be32 *p; READ_BUF(4); READ32(bmlen); bitmap[0] = bitmap[1] = 0; READ_BUF((bmlen << 2)); if (bmlen > 0) { READ32(bitmap[0]); if (bmlen > 1) READ32(bitmap[1]); } return 0; }	DoS	static int decode_attr_bitmap(struct xdr_stream xdr, uint32_t bitmap) { uint32_t bmlen; __be32 *p; READ_BUF(4); READ32(bmlen); bitmap[0] = bitmap[1] = 0; READ_BUF((bmlen << 2)); if (bmlen > 0) { READ32(bitmap[0]); if (bmlen > 1) READ32(bitmap[1]); } return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,372	static int decode_attr_change(struct xdr_stream xdr, uint32_t bitmap, uint64_t change) { __be32 p; change = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_CHANGE - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_CHANGE)) { READ_BUF(8); READ64(change); bitmap[0] &= ~FATTR4_WORD0_CHANGE; } dprintk("%s: change attribute=%Lu\n", __func__, (unsigned long long)*change); return 0; }	DoS	static int decode_attr_change(struct xdr_stream xdr, uint32_t bitmap, uint64_t change) { __be32 p; change = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_CHANGE - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_CHANGE)) { READ_BUF(8); READ64(change); bitmap[0] &= ~FATTR4_WORD0_CHANGE; } dprintk("%s: change attribute=%Lu\n", __func__, (unsigned long long)*change); return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,373	static int decode_attr_fileid(struct xdr_stream xdr, uint32_t bitmap, uint64_t fileid) { __be32 p; fileid = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEID - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_FILEID)) { READ_BUF(8); READ64(fileid); bitmap[0] &= ~FATTR4_WORD0_FILEID; } dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid); return 0; }	DoS	static int decode_attr_fileid(struct xdr_stream xdr, uint32_t bitmap, uint64_t fileid) { __be32 p; fileid = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEID - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_FILEID)) { READ_BUF(8); READ64(fileid); bitmap[0] &= ~FATTR4_WORD0_FILEID; } dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid); return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,374	static int decode_attr_files_free(struct xdr_stream xdr, uint32_t bitmap, uint64_t res) { __be32 p; int status = 0; res = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_FREE - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_FILES_FREE)) { READ_BUF(8); READ64(res); bitmap[0] &= ~FATTR4_WORD0_FILES_FREE; } dprintk("%s: files free=%Lu\n", __func__, (unsigned long long)*res); return status; }	DoS	static int decode_attr_files_free(struct xdr_stream xdr, uint32_t bitmap, uint64_t res) { __be32 p; int status = 0; res = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_FREE - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_FILES_FREE)) { READ_BUF(8); READ64(res); bitmap[0] &= ~FATTR4_WORD0_FILES_FREE; } dprintk("%s: files free=%Lu\n", __func__, (unsigned long long)*res); return status; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,375	static int decode_attr_files_total(struct xdr_stream xdr, uint32_t bitmap, uint64_t res) { __be32 p; int status = 0; res = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_TOTAL - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_FILES_TOTAL)) { READ_BUF(8); READ64(res); bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL; } dprintk("%s: files total=%Lu\n", __func__, (unsigned long long)*res); return status; }	DoS	static int decode_attr_files_total(struct xdr_stream xdr, uint32_t bitmap, uint64_t res) { __be32 p; int status = 0; res = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_TOTAL - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_FILES_TOTAL)) { READ_BUF(8); READ64(res); bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL; } dprintk("%s: files total=%Lu\n", __func__, (unsigned long long)*res); return status; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,376	static int decode_attr_fs_locations(struct xdr_stream xdr, uint32_t bitmap, struct nfs4_fs_locations res) { int n; __be32 p; int status = -EIO; if (unlikely(bitmap[0] & (FATTR4_WORD0_FS_LOCATIONS -1U))) goto out; status = 0; if (unlikely(!(bitmap[0] & FATTR4_WORD0_FS_LOCATIONS))) goto out; dprintk("%s: fsroot ", __func__); status = decode_pathname(xdr, &res->fs_path); if (unlikely(status != 0)) goto out; READ_BUF(4); READ32(n); if (n <= 0) goto out_eio; res->nlocations = 0; while (res->nlocations < n) { u32 m; struct nfs4_fs_location loc = &res->locations[res->nlocations]; READ_BUF(4); READ32(m); loc->nservers = 0; dprintk("%s: servers ", __func__); while (loc->nservers < m) { struct nfs4_string server = &loc->servers[loc->nservers]; status = decode_opaque_inline(xdr, &server->len, &server->data); if (unlikely(status != 0)) goto out_eio; dprintk("%s ", server->data); if (loc->nservers < NFS4_FS_LOCATION_MAXSERVERS) loc->nservers++; else { unsigned int i; dprintk("%s: using first %u of %u servers " "returned for location %u\n", __func__, NFS4_FS_LOCATION_MAXSERVERS, m, res->nlocations); for (i = loc->nservers; i < m; i++) { unsigned int len; char *data; status = decode_opaque_inline(xdr, &len, &data); if (unlikely(status != 0)) goto out_eio; } } } status = decode_pathname(xdr, &loc->rootpath); if (unlikely(status != 0)) goto out_eio; if (res->nlocations < NFS4_FS_LOCATIONS_MAXENTRIES) res->nlocations++; } out: dprintk("%s: fs_locations done, error = %d\n", __func__, status); return status; out_eio: status = -EIO; goto out; }	DoS	static int decode_attr_fs_locations(struct xdr_stream xdr, uint32_t bitmap, struct nfs4_fs_locations res) { int n; __be32 p; int status = -EIO; if (unlikely(bitmap[0] & (FATTR4_WORD0_FS_LOCATIONS -1U))) goto out; status = 0; if (unlikely(!(bitmap[0] & FATTR4_WORD0_FS_LOCATIONS))) goto out; dprintk("%s: fsroot ", __func__); status = decode_pathname(xdr, &res->fs_path); if (unlikely(status != 0)) goto out; READ_BUF(4); READ32(n); if (n <= 0) goto out_eio; res->nlocations = 0; while (res->nlocations < n) { u32 m; struct nfs4_fs_location loc = &res->locations[res->nlocations]; READ_BUF(4); READ32(m); loc->nservers = 0; dprintk("%s: servers ", __func__); while (loc->nservers < m) { struct nfs4_string server = &loc->servers[loc->nservers]; status = decode_opaque_inline(xdr, &server->len, &server->data); if (unlikely(status != 0)) goto out_eio; dprintk("%s ", server->data); if (loc->nservers < NFS4_FS_LOCATION_MAXSERVERS) loc->nservers++; else { unsigned int i; dprintk("%s: using first %u of %u servers " "returned for location %u\n", __func__, NFS4_FS_LOCATION_MAXSERVERS, m, res->nlocations); for (i = loc->nservers; i < m; i++) { unsigned int len; char *data; status = decode_opaque_inline(xdr, &len, &data); if (unlikely(status != 0)) goto out_eio; } } } status = decode_pathname(xdr, &loc->rootpath); if (unlikely(status != 0)) goto out_eio; if (res->nlocations < NFS4_FS_LOCATIONS_MAXENTRIES) res->nlocations++; } out: dprintk("%s: fs_locations done, error = %d\n", __func__, status); return status; out_eio: status = -EIO; goto out; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,377	static int decode_attr_fsid(struct xdr_stream xdr, uint32_t bitmap, struct nfs_fsid fsid) { __be32 p; fsid->major = 0; fsid->minor = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_FSID - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_FSID)) { READ_BUF(16); READ64(fsid->major); READ64(fsid->minor); bitmap[0] &= ~FATTR4_WORD0_FSID; } dprintk("%s: fsid=(0x%Lx/0x%Lx)\n", __func__, (unsigned long long)fsid->major, (unsigned long long)fsid->minor); return 0; }	DoS	static int decode_attr_fsid(struct xdr_stream xdr, uint32_t bitmap, struct nfs_fsid fsid) { __be32 p; fsid->major = 0; fsid->minor = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_FSID - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_FSID)) { READ_BUF(16); READ64(fsid->major); READ64(fsid->minor); bitmap[0] &= ~FATTR4_WORD0_FSID; } dprintk("%s: fsid=(0x%Lx/0x%Lx)\n", __func__, (unsigned long long)fsid->major, (unsigned long long)fsid->minor); return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,378	static int decode_attr_group(struct xdr_stream xdr, uint32_t bitmap, struct nfs_client clp, uint32_t gid) { uint32_t len; __be32 p; gid = -2; if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER_GROUP - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_OWNER_GROUP)) { READ_BUF(4); READ32(len); READ_BUF(len); if (len < XDR_MAX_NETOBJ) { if (nfs_map_group_to_gid(clp, (char )p, len, gid) != 0) dprintk("%s: nfs_map_group_to_gid failed!\n", __func__); } else dprintk("%s: name too long (%u)!\n", __func__, len); bitmap[1] &= ~FATTR4_WORD1_OWNER_GROUP; } dprintk("%s: gid=%d\n", __func__, (int)gid); return 0; }	DoS	static int decode_attr_group(struct xdr_stream xdr, uint32_t bitmap, struct nfs_client clp, uint32_t gid) { uint32_t len; __be32 p; gid = -2; if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER_GROUP - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_OWNER_GROUP)) { READ_BUF(4); READ32(len); READ_BUF(len); if (len < XDR_MAX_NETOBJ) { if (nfs_map_group_to_gid(clp, (char )p, len, gid) != 0) dprintk("%s: nfs_map_group_to_gid failed!\n", __func__); } else dprintk("%s: name too long (%u)!\n", __func__, len); bitmap[1] &= ~FATTR4_WORD1_OWNER_GROUP; } dprintk("%s: gid=%d\n", __func__, (int)gid); return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,379	static int decode_attr_lease_time(struct xdr_stream xdr, uint32_t bitmap, uint32_t res) { __be32 p; res = 60; if (unlikely(bitmap[0] & (FATTR4_WORD0_LEASE_TIME - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_LEASE_TIME)) { READ_BUF(4); READ32(res); bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME; } dprintk("%s: file size=%u\n", __func__, (unsigned int)*res); return 0; }	DoS	static int decode_attr_lease_time(struct xdr_stream xdr, uint32_t bitmap, uint32_t res) { __be32 p; res = 60; if (unlikely(bitmap[0] & (FATTR4_WORD0_LEASE_TIME - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_LEASE_TIME)) { READ_BUF(4); READ32(res); bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME; } dprintk("%s: file size=%u\n", __func__, (unsigned int)*res); return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,380	static inline int decode_attr_length(struct xdr_stream xdr, uint32_t attrlen, __be32 *savep) { __be32 p; READ_BUF(4); READ32(attrlen); savep = xdr->p; return 0; }	DoS	static inline int decode_attr_length(struct xdr_stream xdr, uint32_t attrlen, __be32 *savep) { __be32 p; READ_BUF(4); READ32(attrlen); savep = xdr->p; return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,381	static int decode_attr_link_support(struct xdr_stream xdr, uint32_t bitmap, uint32_t res) { __be32 p; res = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_LINK_SUPPORT - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_LINK_SUPPORT)) { READ_BUF(4); READ32(res); bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT; } dprintk("%s: link support=%s\n", __func__, *res == 0 ? "false" : "true"); return 0; }	DoS	static int decode_attr_link_support(struct xdr_stream xdr, uint32_t bitmap, uint32_t res) { __be32 p; res = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_LINK_SUPPORT - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_LINK_SUPPORT)) { READ_BUF(4); READ32(res); bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT; } dprintk("%s: link support=%s\n", __func__, *res == 0 ? "false" : "true"); return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,382	static int decode_attr_maxfilesize(struct xdr_stream xdr, uint32_t bitmap, uint64_t res) { __be32 p; int status = 0; res = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXFILESIZE - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_MAXFILESIZE)) { READ_BUF(8); READ64(res); bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE; } dprintk("%s: maxfilesize=%Lu\n", __func__, (unsigned long long)*res); return status; }	DoS	static int decode_attr_maxfilesize(struct xdr_stream xdr, uint32_t bitmap, uint64_t res) { __be32 p; int status = 0; res = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXFILESIZE - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_MAXFILESIZE)) { READ_BUF(8); READ64(res); bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE; } dprintk("%s: maxfilesize=%Lu\n", __func__, (unsigned long long)*res); return status; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,383	static int decode_attr_maxlink(struct xdr_stream xdr, uint32_t bitmap, uint32_t maxlink) { __be32 p; int status = 0; maxlink = 1; if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXLINK - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_MAXLINK)) { READ_BUF(4); READ32(maxlink); bitmap[0] &= ~FATTR4_WORD0_MAXLINK; } dprintk("%s: maxlink=%u\n", __func__, *maxlink); return status; }	DoS	static int decode_attr_maxlink(struct xdr_stream xdr, uint32_t bitmap, uint32_t maxlink) { __be32 p; int status = 0; maxlink = 1; if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXLINK - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_MAXLINK)) { READ_BUF(4); READ32(maxlink); bitmap[0] &= ~FATTR4_WORD0_MAXLINK; } dprintk("%s: maxlink=%u\n", __func__, *maxlink); return status; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,384	static int decode_attr_maxname(struct xdr_stream xdr, uint32_t bitmap, uint32_t maxname) { __be32 p; int status = 0; maxname = 1024; if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXNAME - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_MAXNAME)) { READ_BUF(4); READ32(maxname); bitmap[0] &= ~FATTR4_WORD0_MAXNAME; } dprintk("%s: maxname=%u\n", __func__, *maxname); return status; }	DoS	static int decode_attr_maxname(struct xdr_stream xdr, uint32_t bitmap, uint32_t maxname) { __be32 p; int status = 0; maxname = 1024; if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXNAME - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_MAXNAME)) { READ_BUF(4); READ32(maxname); bitmap[0] &= ~FATTR4_WORD0_MAXNAME; } dprintk("%s: maxname=%u\n", __func__, *maxname); return status; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,385	static int decode_attr_maxread(struct xdr_stream xdr, uint32_t bitmap, uint32_t res) { __be32 p; int status = 0; res = 1024; if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXREAD - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_MAXREAD)) { uint64_t maxread; READ_BUF(8); READ64(maxread); if (maxread > 0x7FFFFFFF) maxread = 0x7FFFFFFF; res = (uint32_t)maxread; bitmap[0] &= ~FATTR4_WORD0_MAXREAD; } dprintk("%s: maxread=%lu\n", __func__, (unsigned long)*res); return status; }	DoS	static int decode_attr_maxread(struct xdr_stream xdr, uint32_t bitmap, uint32_t res) { __be32 p; int status = 0; res = 1024; if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXREAD - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_MAXREAD)) { uint64_t maxread; READ_BUF(8); READ64(maxread); if (maxread > 0x7FFFFFFF) maxread = 0x7FFFFFFF; res = (uint32_t)maxread; bitmap[0] &= ~FATTR4_WORD0_MAXREAD; } dprintk("%s: maxread=%lu\n", __func__, (unsigned long)*res); return status; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,386	static int decode_attr_maxwrite(struct xdr_stream xdr, uint32_t bitmap, uint32_t res) { __be32 p; int status = 0; res = 1024; if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXWRITE - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_MAXWRITE)) { uint64_t maxwrite; READ_BUF(8); READ64(maxwrite); if (maxwrite > 0x7FFFFFFF) maxwrite = 0x7FFFFFFF; res = (uint32_t)maxwrite; bitmap[0] &= ~FATTR4_WORD0_MAXWRITE; } dprintk("%s: maxwrite=%lu\n", __func__, (unsigned long)*res); return status; }	DoS	static int decode_attr_maxwrite(struct xdr_stream xdr, uint32_t bitmap, uint32_t res) { __be32 p; int status = 0; res = 1024; if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXWRITE - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_MAXWRITE)) { uint64_t maxwrite; READ_BUF(8); READ64(maxwrite); if (maxwrite > 0x7FFFFFFF) maxwrite = 0x7FFFFFFF; res = (uint32_t)maxwrite; bitmap[0] &= ~FATTR4_WORD0_MAXWRITE; } dprintk("%s: maxwrite=%lu\n", __func__, (unsigned long)*res); return status; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,387	static int decode_attr_mounted_on_fileid(struct xdr_stream xdr, uint32_t bitmap, uint64_t fileid) { __be32 p; fileid = 0; if (unlikely(bitmap[1] & (FATTR4_WORD1_MOUNTED_ON_FILEID - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)) { READ_BUF(8); READ64(fileid); bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID; } dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid); return 0; }	DoS	static int decode_attr_mounted_on_fileid(struct xdr_stream xdr, uint32_t bitmap, uint64_t fileid) { __be32 p; fileid = 0; if (unlikely(bitmap[1] & (FATTR4_WORD1_MOUNTED_ON_FILEID - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)) { READ_BUF(8); READ64(fileid); bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID; } dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid); return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,388	static int decode_attr_nlink(struct xdr_stream xdr, uint32_t bitmap, uint32_t nlink) { __be32 p; nlink = 1; if (unlikely(bitmap[1] & (FATTR4_WORD1_NUMLINKS - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_NUMLINKS)) { READ_BUF(4); READ32(nlink); bitmap[1] &= ~FATTR4_WORD1_NUMLINKS; } dprintk("%s: nlink=%u\n", __func__, (unsigned int)*nlink); return 0; }	DoS	static int decode_attr_nlink(struct xdr_stream xdr, uint32_t bitmap, uint32_t nlink) { __be32 p; nlink = 1; if (unlikely(bitmap[1] & (FATTR4_WORD1_NUMLINKS - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_NUMLINKS)) { READ_BUF(4); READ32(nlink); bitmap[1] &= ~FATTR4_WORD1_NUMLINKS; } dprintk("%s: nlink=%u\n", __func__, (unsigned int)*nlink); return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,389	static int decode_attr_owner(struct xdr_stream xdr, uint32_t bitmap, struct nfs_client clp, uint32_t uid) { uint32_t len; __be32 p; uid = -2; if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_OWNER)) { READ_BUF(4); READ32(len); READ_BUF(len); if (len < XDR_MAX_NETOBJ) { if (nfs_map_name_to_uid(clp, (char )p, len, uid) != 0) dprintk("%s: nfs_map_name_to_uid failed!\n", __func__); } else dprintk("%s: name too long (%u)!\n", __func__, len); bitmap[1] &= ~FATTR4_WORD1_OWNER; } dprintk("%s: uid=%d\n", __func__, (int)uid); return 0; }	DoS	static int decode_attr_owner(struct xdr_stream xdr, uint32_t bitmap, struct nfs_client clp, uint32_t uid) { uint32_t len; __be32 p; uid = -2; if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_OWNER)) { READ_BUF(4); READ32(len); READ_BUF(len); if (len < XDR_MAX_NETOBJ) { if (nfs_map_name_to_uid(clp, (char )p, len, uid) != 0) dprintk("%s: nfs_map_name_to_uid failed!\n", __func__); } else dprintk("%s: name too long (%u)!\n", __func__, len); bitmap[1] &= ~FATTR4_WORD1_OWNER; } dprintk("%s: uid=%d\n", __func__, (int)uid); return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,390	static int decode_attr_size(struct xdr_stream xdr, uint32_t bitmap, uint64_t size) { __be32 p; size = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_SIZE - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_SIZE)) { READ_BUF(8); READ64(size); bitmap[0] &= ~FATTR4_WORD0_SIZE; } dprintk("%s: file size=%Lu\n", __func__, (unsigned long long)*size); return 0; }	DoS	static int decode_attr_size(struct xdr_stream xdr, uint32_t bitmap, uint64_t size) { __be32 p; size = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_SIZE - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_SIZE)) { READ_BUF(8); READ64(size); bitmap[0] &= ~FATTR4_WORD0_SIZE; } dprintk("%s: file size=%Lu\n", __func__, (unsigned long long)*size); return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,391	static int decode_attr_space_avail(struct xdr_stream xdr, uint32_t bitmap, uint64_t res) { __be32 p; int status = 0; res = 0; if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_AVAIL - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_SPACE_AVAIL)) { READ_BUF(8); READ64(res); bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL; } dprintk("%s: space avail=%Lu\n", __func__, (unsigned long long)*res); return status; }	DoS	static int decode_attr_space_avail(struct xdr_stream xdr, uint32_t bitmap, uint64_t res) { __be32 p; int status = 0; res = 0; if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_AVAIL - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_SPACE_AVAIL)) { READ_BUF(8); READ64(res); bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL; } dprintk("%s: space avail=%Lu\n", __func__, (unsigned long long)*res); return status; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,392	static int decode_attr_space_free(struct xdr_stream xdr, uint32_t bitmap, uint64_t res) { __be32 p; int status = 0; res = 0; if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_FREE - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_SPACE_FREE)) { READ_BUF(8); READ64(res); bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE; } dprintk("%s: space free=%Lu\n", __func__, (unsigned long long)*res); return status; }	DoS	static int decode_attr_space_free(struct xdr_stream xdr, uint32_t bitmap, uint64_t res) { __be32 p; int status = 0; res = 0; if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_FREE - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_SPACE_FREE)) { READ_BUF(8); READ64(res); bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE; } dprintk("%s: space free=%Lu\n", __func__, (unsigned long long)*res); return status; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,393	static int decode_attr_space_total(struct xdr_stream xdr, uint32_t bitmap, uint64_t res) { __be32 p; int status = 0; res = 0; if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_TOTAL - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_SPACE_TOTAL)) { READ_BUF(8); READ64(res); bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL; } dprintk("%s: space total=%Lu\n", __func__, (unsigned long long)*res); return status; }	DoS	static int decode_attr_space_total(struct xdr_stream xdr, uint32_t bitmap, uint64_t res) { __be32 p; int status = 0; res = 0; if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_TOTAL - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_SPACE_TOTAL)) { READ_BUF(8); READ64(res); bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL; } dprintk("%s: space total=%Lu\n", __func__, (unsigned long long)*res); return status; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,394	static int decode_attr_symlink_support(struct xdr_stream xdr, uint32_t bitmap, uint32_t res) { __be32 p; res = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_SYMLINK_SUPPORT - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_SYMLINK_SUPPORT)) { READ_BUF(4); READ32(res); bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT; } dprintk("%s: symlink support=%s\n", __func__, *res == 0 ? "false" : "true"); return 0; }	DoS	static int decode_attr_symlink_support(struct xdr_stream xdr, uint32_t bitmap, uint32_t res) { __be32 p; res = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_SYMLINK_SUPPORT - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_SYMLINK_SUPPORT)) { READ_BUF(4); READ32(res); bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT; } dprintk("%s: symlink support=%s\n", __func__, *res == 0 ? "false" : "true"); return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,395	static int decode_attr_time_access(struct xdr_stream xdr, uint32_t bitmap, struct timespec *time) { int status = 0; time->tv_sec = 0; time->tv_nsec = 0; if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_ACCESS - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_TIME_ACCESS)) { status = decode_attr_time(xdr, time); bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS; } dprintk("%s: atime=%ld\n", __func__, (long)time->tv_sec); return status; }	DoS	static int decode_attr_time_access(struct xdr_stream xdr, uint32_t bitmap, struct timespec *time) { int status = 0; time->tv_sec = 0; time->tv_nsec = 0; if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_ACCESS - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_TIME_ACCESS)) { status = decode_attr_time(xdr, time); bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS; } dprintk("%s: atime=%ld\n", __func__, (long)time->tv_sec); return status; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,396	static int decode_attr_time_metadata(struct xdr_stream xdr, uint32_t bitmap, struct timespec *time) { int status = 0; time->tv_sec = 0; time->tv_nsec = 0; if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_METADATA - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_TIME_METADATA)) { status = decode_attr_time(xdr, time); bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA; } dprintk("%s: ctime=%ld\n", __func__, (long)time->tv_sec); return status; }	DoS	static int decode_attr_time_metadata(struct xdr_stream xdr, uint32_t bitmap, struct timespec *time) { int status = 0; time->tv_sec = 0; time->tv_nsec = 0; if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_METADATA - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_TIME_METADATA)) { status = decode_attr_time(xdr, time); bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA; } dprintk("%s: ctime=%ld\n", __func__, (long)time->tv_sec); return status; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,397	static int decode_attr_time_modify(struct xdr_stream xdr, uint32_t bitmap, struct timespec *time) { int status = 0; time->tv_sec = 0; time->tv_nsec = 0; if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_MODIFY - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_TIME_MODIFY)) { status = decode_attr_time(xdr, time); bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY; } dprintk("%s: mtime=%ld\n", __func__, (long)time->tv_sec); return status; }	DoS	static int decode_attr_time_modify(struct xdr_stream xdr, uint32_t bitmap, struct timespec *time) { int status = 0; time->tv_sec = 0; time->tv_nsec = 0; if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_MODIFY - 1U))) return -EIO; if (likely(bitmap[1] & FATTR4_WORD1_TIME_MODIFY)) { status = decode_attr_time(xdr, time); bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY; } dprintk("%s: mtime=%ld\n", __func__, (long)time->tv_sec); return status; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,398	static int decode_attr_type(struct xdr_stream xdr, uint32_t bitmap, uint32_t type) { __be32 p; type = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_TYPE - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_TYPE)) { READ_BUF(4); READ32(type); if (type < NF4REG \|\| type > NF4NAMEDATTR) { dprintk("%s: bad type %d\n", __func__, type); return -EIO; } bitmap[0] &= ~FATTR4_WORD0_TYPE; } dprintk("%s: type=0%o\n", __func__, nfs_type2fmt[type].nfs2type); return 0; }	DoS	static int decode_attr_type(struct xdr_stream xdr, uint32_t bitmap, uint32_t type) { __be32 p; type = 0; if (unlikely(bitmap[0] & (FATTR4_WORD0_TYPE - 1U))) return -EIO; if (likely(bitmap[0] & FATTR4_WORD0_TYPE)) { READ_BUF(4); READ32(type); if (type < NF4REG \|\| type > NF4NAMEDATTR) { dprintk("%s: bad type %d\n", __func__, type); return -EIO; } bitmap[0] &= ~FATTR4_WORD0_TYPE; } dprintk("%s: type=0%o\n", __func__, nfs_type2fmt[type].nfs2type); return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null
18,399	static int decode_close(struct xdr_stream xdr, struct nfs_closeres res) { __be32 *p; int status; status = decode_op_hdr(xdr, OP_CLOSE); if (status != -EIO) nfs_increment_open_seqid(status, res->seqid); if (status) return status; READ_BUF(NFS4_STATEID_SIZE); COPYMEM(res->stateid.data, NFS4_STATEID_SIZE); return 0; }	DoS	static int decode_close(struct xdr_stream xdr, struct nfs_closeres res) { __be32 *p; int status; status = decode_op_hdr(xdr, OP_CLOSE); if (status != -EIO) nfs_increment_open_seqid(status, res->seqid); if (status) return status; READ_BUF(NFS4_STATEID_SIZE); COPYMEM(res->stateid.data, NFS4_STATEID_SIZE); return 0; }	@@ -953,12 +953,12 @@ static int encode_lookup(struct xdr_stream xdr, const struct qstr name) return 0; } -static void encode_share_access(struct xdr_stream xdr, int open_flags) +static void encode_share_access(struct xdr_stream xdr, fmode_t fmode) { __be32 p; RESERVE_SPACE(8); - switch (open_flags & (FMODE_READ\|FMODE_WRITE)) { + switch (fmode & (FMODE_READ\|FMODE_WRITE)) { case FMODE_READ: WRITE32(NFS4_SHARE_ACCESS_READ); break; @@ -969,7 +969,7 @@ static void encode_share_access(struct xdr_stream xdr, int open_flags) WRITE32(NFS4_SHARE_ACCESS_BOTH); break; default: - BUG(); + WRITE32(0); } WRITE32(0); /* for linux, share_deny = 0 always / } @@ -984,7 +984,7 @@ static inline void encode_openhdr(struct xdr_stream xdr, const struct nfs_opena RESERVE_SPACE(8); WRITE32(OP_OPEN); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); RESERVE_SPACE(28); WRITE64(arg->clientid); WRITE32(16); @@ -1112,7 +1112,7 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea WRITE32(OP_OPEN_DOWNGRADE); WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); WRITE32(arg->seqid->sequence->counter); - encode_share_access(xdr, arg->open_flags); + encode_share_access(xdr, arg->fmode); return 0; }	null	null	null

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.