hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

NFSv4: Make nfs4_state track O_RDWR, O_RDONLY and O_WRONLY separately 

A closer reading of RFC3530 reveals that OPEN_DOWNGRADE must always
 specify a access modes that have been the argument of a previous OPEN
 operation.
 IOW: doing OPEN(O_RDWR) and then OPEN_DOWNGRADE(O_WRONLY) is forbidden
 unless the user called OPEN(O_WRONLY)

 In order to fix that, we really need to track the three possible open
 states separately.

 Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
This commit is contained in:
Trond Myklebust 2006-01-03 09:55:13 +01:00
parent cdd4e68b5f
commit e761692381
3 changed files with 42 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
fs/nfs/nfs4_fs.h
View File

@ -182,8 +182,9 @@ struct nfs4_state {
nfs4_stateid stateid; nfs4_stateid stateid;
unsigned int nreaders; unsigned int n_rdonly;
unsigned int nwriters; unsigned int n_wronly;
unsigned int n_rdwr;
int state; /* State on the server (R,W, or RW) */ int state; /* State on the server (R,W, or RW) */
atomic_t count; atomic_t count;
}; };

34
fs/nfs/nfs4proc.c
View File

@ -297,6 +297,20 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)
return ret; return ret;
} }
static inline void update_open_stateflags(struct nfs4_state *state, mode_t open_flags)
{
switch (open_flags) {
case FMODE_WRITE:
state->n_wronly++;
break;
case FMODE_READ:
state->n_rdonly++;
break;
case FMODE_READ|FMODE_WRITE:
state->n_rdwr++;
}
}
static void update_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, int open_flags) static void update_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, int open_flags)
{ {
struct inode *inode = state->inode; struct inode *inode = state->inode;
@ -306,10 +320,7 @@ static void update_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid,
spin_lock(&state->owner->so_lock); spin_lock(&state->owner->so_lock);
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
memcpy(&state->stateid, stateid, sizeof(state->stateid)); memcpy(&state->stateid, stateid, sizeof(state->stateid));
if ((open_flags & FMODE_WRITE)) update_open_stateflags(state, open_flags);
state->nwriters++;
if (open_flags & FMODE_READ)
state->nreaders++;
nfs4_state_set_mode_locked(state, state->state | open_flags); nfs4_state_set_mode_locked(state, state->state | open_flags);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
spin_unlock(&state->owner->so_lock); spin_unlock(&state->owner->so_lock);
@ -822,10 +833,7 @@ static int _nfs4_open_delegated(struct inode *inode, int flags, struct rpc_cred
err = -ENOENT; err = -ENOENT;
if ((state->state & open_flags) == open_flags) { if ((state->state & open_flags) == open_flags) {
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
if (open_flags & FMODE_READ) update_open_stateflags(state, open_flags);
state->nreaders++;
if (open_flags & FMODE_WRITE)
state->nwriters++;
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
goto out_ok; goto out_ok;
} else if (state->state != 0) } else if (state->state != 0)
@ -1082,10 +1090,12 @@ static void nfs4_close_prepare(struct rpc_task *task, void *data)
spin_lock(&state->owner->so_lock); spin_lock(&state->owner->so_lock);
spin_lock(&calldata->inode->i_lock); spin_lock(&calldata->inode->i_lock);
mode = old_mode = state->state; mode = old_mode = state->state;
if (state->nreaders == 0) if (state->n_rdwr == 0) {
mode &= ~FMODE_READ; if (state->n_rdonly == 0)
if (state->nwriters == 0) mode &= ~FMODE_READ;
mode &= ~FMODE_WRITE; if (state->n_wronly == 0)
mode &= ~FMODE_WRITE;
}
nfs4_state_set_mode_locked(state, mode); nfs4_state_set_mode_locked(state, mode);
spin_unlock(&calldata->inode->i_lock); spin_unlock(&calldata->inode->i_lock);
spin_unlock(&state->owner->so_lock); spin_unlock(&state->owner->so_lock);

31
fs/nfs/nfs4state.c
View File

@ -349,14 +349,9 @@ nfs4_alloc_open_state(void)
{ {
struct nfs4_state *state; struct nfs4_state *state;
state = kmalloc(sizeof(*state), GFP_KERNEL); state = kzalloc(sizeof(*state), GFP_KERNEL);
if (!state) if (!state)
return NULL; return NULL;
state->state = 0;
state->nreaders = 0;
state->nwriters = 0;
state->flags = 0;
memset(state->stateid.data, 0, sizeof(state->stateid.data));
atomic_set(&state->count, 1); atomic_set(&state->count, 1);
INIT_LIST_HEAD(&state->lock_states); INIT_LIST_HEAD(&state->lock_states);
spin_lock_init(&state->state_lock); spin_lock_init(&state->state_lock);
@ -475,15 +470,23 @@ void nfs4_close_state(struct nfs4_state *state, mode_t mode)
/* Protect against nfs4_find_state() */ /* Protect against nfs4_find_state() */
spin_lock(&owner->so_lock); spin_lock(&owner->so_lock);
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
if (mode & FMODE_READ) switch (mode & (FMODE_READ | FMODE_WRITE)) {
state->nreaders--; case FMODE_READ:
if (mode & FMODE_WRITE) state->n_rdonly--;
state->nwriters--; break;
case FMODE_WRITE:
state->n_wronly--;
break;
case FMODE_READ|FMODE_WRITE:
state->n_rdwr--;
}
oldstate = newstate = state->state; oldstate = newstate = state->state;
if (state->nreaders == 0) if (state->n_rdwr == 0) {
newstate &= ~FMODE_READ; if (state->n_rdonly == 0)
if (state->nwriters == 0) newstate &= ~FMODE_READ;
newstate &= ~FMODE_WRITE; if (state->n_wronly == 0)
newstate &= ~FMODE_WRITE;
}
if (test_bit(NFS_DELEGATED_STATE, &state->flags)) { if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
nfs4_state_set_mode_locked(state, newstate); nfs4_state_set_mode_locked(state, newstate);
oldstate = newstate; oldstate = newstate;