2005-06-22 10:16:21 -07:00
|
|
|
/*
|
|
|
|
|
* linux/fs/nfs/nfs4_fs.h
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2005 Trond Myklebust
|
|
|
|
|
*
|
|
|
|
|
* NFSv4-specific filesystem definitions and declarations
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef __LINUX_FS_NFS_NFS4_FS_H
|
|
|
|
|
#define __LINUX_FS_NFS_NFS4_FS_H
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_NFS_V4
|
|
|
|
|
|
|
|
|
|
struct idmap;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* In a seqid-mutating op, this macro controls which error return
|
|
|
|
|
* values trigger incrementation of the seqid.
|
|
|
|
|
*
|
|
|
|
|
* from rfc 3010:
|
|
|
|
|
* The client MUST monotonically increment the sequence number for the
|
|
|
|
|
* CLOSE, LOCK, LOCKU, OPEN, OPEN_CONFIRM, and OPEN_DOWNGRADE
|
|
|
|
|
* operations. This is true even in the event that the previous
|
|
|
|
|
* operation that used the sequence number received an error. The only
|
|
|
|
|
* exception to this rule is if the previous operation received one of
|
|
|
|
|
* the following errors: NFSERR_STALE_CLIENTID, NFSERR_STALE_STATEID,
|
|
|
|
|
* NFSERR_BAD_STATEID, NFSERR_BAD_SEQID, NFSERR_BADXDR,
|
|
|
|
|
* NFSERR_RESOURCE, NFSERR_NOFILEHANDLE.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
#define seqid_mutating_err(err) \
|
|
|
|
|
(((err) != NFSERR_STALE_CLIENTID) && \
|
|
|
|
|
((err) != NFSERR_STALE_STATEID) && \
|
|
|
|
|
((err) != NFSERR_BAD_STATEID) && \
|
|
|
|
|
((err) != NFSERR_BAD_SEQID) && \
|
|
|
|
|
((err) != NFSERR_BAD_XDR) && \
|
|
|
|
|
((err) != NFSERR_RESOURCE) && \
|
|
|
|
|
((err) != NFSERR_NOFILEHANDLE))
|
|
|
|
|
|
|
|
|
|
enum nfs4_client_state {
|
2008-12-23 13:21:48 -07:00
|
|
|
NFS4CLNT_MANAGER_RUNNING = 0,
|
2008-12-23 13:21:42 -07:00
|
|
|
NFS4CLNT_CHECK_LEASE,
|
2006-01-03 01:55:24 -07:00
|
|
|
NFS4CLNT_LEASE_EXPIRED,
|
2008-12-23 13:21:41 -07:00
|
|
|
NFS4CLNT_RECLAIM_REBOOT,
|
|
|
|
|
NFS4CLNT_RECLAIM_NOGRACE,
|
2008-12-23 13:21:47 -07:00
|
|
|
NFS4CLNT_DELEGRETURN,
|
2009-12-04 13:55:05 -07:00
|
|
|
NFS4CLNT_SESSION_RESET,
|
2010-01-20 14:06:27 -07:00
|
|
|
NFS4CLNT_RECALL_SLOT,
|
2005-06-22 10:16:21 -07:00
|
|
|
};
|
|
|
|
|
|
2010-06-16 06:52:26 -07:00
|
|
|
enum nfs4_session_state {
|
2010-06-16 06:52:27 -07:00
|
|
|
NFS4_SESSION_INITING,
|
2010-06-16 06:52:26 -07:00
|
|
|
NFS4_SESSION_DRAINING,
|
|
|
|
|
};
|
|
|
|
|
|
2010-06-16 06:52:26 -07:00
|
|
|
struct nfs4_minor_version_ops {
|
|
|
|
|
u32 minor_version;
|
|
|
|
|
|
|
|
|
|
int (*call_sync)(struct nfs_server *server,
|
|
|
|
|
struct rpc_message *msg,
|
|
|
|
|
struct nfs4_sequence_args *args,
|
|
|
|
|
struct nfs4_sequence_res *res,
|
|
|
|
|
int cache_reply);
|
2010-06-16 06:52:27 -07:00
|
|
|
int (*validate_stateid)(struct nfs_delegation *,
|
|
|
|
|
const nfs4_stateid *);
|
2010-06-16 06:52:27 -07:00
|
|
|
const struct nfs4_state_recovery_ops *reboot_recovery_ops;
|
|
|
|
|
const struct nfs4_state_recovery_ops *nograce_recovery_ops;
|
|
|
|
|
const struct nfs4_state_maintenance_ops *state_renewal_ops;
|
2010-06-16 06:52:26 -07:00
|
|
|
};
|
|
|
|
|
|
NFSv4: Add functions to order RPC calls
NFSv4 file state-changing functions such as OPEN, CLOSE, LOCK,... are all
labelled with "sequence identifiers" in order to prevent the server from
reordering RPC requests, as this could cause its file state to
become out of sync with the client.
Currently the NFS client code enforces this ordering locally using
semaphores to restrict access to structures until the RPC call is done.
This, of course, only works with synchronous RPC calls, since the
user process must first grab the semaphore.
By dropping semaphores, and instead teaching the RPC engine to hold
the RPC calls until they are ready to be sent, we can extend this
process to work nicely with asynchronous RPC calls too.
This patch adds a new list called "rpc_sequence" that defines the order
of the RPC calls to be sent. We add one such list for each state_owner.
When an RPC call is ready to be sent, it checks if it is top of the
rpc_sequence list. If so, it proceeds. If not, it goes back to sleep,
and loops until it hits top of the list.
Once the RPC call has completed, it can then bump the sequence id counter,
and remove itself from the rpc_sequence list, and then wake up the next
sleeper.
Note that the state_owner sequence ids and lock_owner sequence ids are
all indexed to the same rpc_sequence list, so OPEN, LOCK,... requests
are all ordered w.r.t. each other.
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2005-10-18 14:20:12 -07:00
|
|
|
/*
|
|
|
|
|
* struct rpc_sequence ensures that RPC calls are sent in the exact
|
|
|
|
|
* order that they appear on the list.
|
|
|
|
|
*/
|
|
|
|
|
struct rpc_sequence {
|
|
|
|
|
struct rpc_wait_queue wait; /* RPC call delay queue */
|
|
|
|
|
spinlock_t lock; /* Protects the list */
|
|
|
|
|
struct list_head list; /* Defines sequence of RPC calls */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define NFS_SEQID_CONFIRMED 1
|
|
|
|
|
struct nfs_seqid_counter {
|
|
|
|
|
struct rpc_sequence *sequence;
|
|
|
|
|
int flags;
|
|
|
|
|
u32 counter;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct nfs_seqid {
|
|
|
|
|
struct nfs_seqid_counter *sequence;
|
2005-10-20 14:22:41 -07:00
|
|
|
struct list_head list;
|
NFSv4: Add functions to order RPC calls
NFSv4 file state-changing functions such as OPEN, CLOSE, LOCK,... are all
labelled with "sequence identifiers" in order to prevent the server from
reordering RPC requests, as this could cause its file state to
become out of sync with the client.
Currently the NFS client code enforces this ordering locally using
semaphores to restrict access to structures until the RPC call is done.
This, of course, only works with synchronous RPC calls, since the
user process must first grab the semaphore.
By dropping semaphores, and instead teaching the RPC engine to hold
the RPC calls until they are ready to be sent, we can extend this
process to work nicely with asynchronous RPC calls too.
This patch adds a new list called "rpc_sequence" that defines the order
of the RPC calls to be sent. We add one such list for each state_owner.
When an RPC call is ready to be sent, it checks if it is top of the
rpc_sequence list. If so, it proceeds. If not, it goes back to sleep,
and loops until it hits top of the list.
Once the RPC call has completed, it can then bump the sequence id counter,
and remove itself from the rpc_sequence list, and then wake up the next
sleeper.
Note that the state_owner sequence ids and lock_owner sequence ids are
all indexed to the same rpc_sequence list, so OPEN, LOCK,... requests
are all ordered w.r.t. each other.
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2005-10-18 14:20:12 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static inline void nfs_confirm_seqid(struct nfs_seqid_counter *seqid, int status)
|
|
|
|
|
{
|
|
|
|
|
if (seqid_mutating_err(-status))
|
|
|
|
|
seqid->flags |= NFS_SEQID_CONFIRMED;
|
|
|
|
|
}
|
|
|
|
|
|
2007-07-02 10:58:33 -07:00
|
|
|
struct nfs_unique_id {
|
|
|
|
|
struct rb_node rb_node;
|
|
|
|
|
__u64 id;
|
|
|
|
|
};
|
|
|
|
|
|
2005-06-22 10:16:21 -07:00
|
|
|
/*
|
|
|
|
|
* NFS4 state_owners and lock_owners are simply labels for ordered
|
|
|
|
|
* sequences of RPC calls. Their sole purpose is to provide once-only
|
|
|
|
|
* semantics by allowing the server to identify replayed requests.
|
|
|
|
|
*/
|
|
|
|
|
struct nfs4_state_owner {
|
2007-07-02 10:58:33 -07:00
|
|
|
struct nfs_unique_id so_owner_id;
|
2007-07-06 07:53:21 -07:00
|
|
|
struct nfs_server *so_server;
|
2007-07-02 10:58:33 -07:00
|
|
|
struct rb_node so_client_node;
|
2005-06-22 10:16:21 -07:00
|
|
|
|
|
|
|
|
struct rpc_cred *so_cred; /* Associated cred */
|
2007-07-02 10:58:33 -07:00
|
|
|
|
|
|
|
|
spinlock_t so_lock;
|
|
|
|
|
atomic_t so_count;
|
2008-12-23 13:21:43 -07:00
|
|
|
unsigned long so_flags;
|
2005-06-22 10:16:21 -07:00
|
|
|
struct list_head so_states;
|
NFSv4: Add functions to order RPC calls
NFSv4 file state-changing functions such as OPEN, CLOSE, LOCK,... are all
labelled with "sequence identifiers" in order to prevent the server from
reordering RPC requests, as this could cause its file state to
become out of sync with the client.
Currently the NFS client code enforces this ordering locally using
semaphores to restrict access to structures until the RPC call is done.
This, of course, only works with synchronous RPC calls, since the
user process must first grab the semaphore.
By dropping semaphores, and instead teaching the RPC engine to hold
the RPC calls until they are ready to be sent, we can extend this
process to work nicely with asynchronous RPC calls too.
This patch adds a new list called "rpc_sequence" that defines the order
of the RPC calls to be sent. We add one such list for each state_owner.
When an RPC call is ready to be sent, it checks if it is top of the
rpc_sequence list. If so, it proceeds. If not, it goes back to sleep,
and loops until it hits top of the list.
Once the RPC call has completed, it can then bump the sequence id counter,
and remove itself from the rpc_sequence list, and then wake up the next
sleeper.
Note that the state_owner sequence ids and lock_owner sequence ids are
all indexed to the same rpc_sequence list, so OPEN, LOCK,... requests
are all ordered w.r.t. each other.
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2005-10-18 14:20:12 -07:00
|
|
|
struct nfs_seqid_counter so_seqid;
|
|
|
|
|
struct rpc_sequence so_sequence;
|
2005-06-22 10:16:21 -07:00
|
|
|
};
|
|
|
|
|
|
2008-12-23 13:21:43 -07:00
|
|
|
enum {
|
|
|
|
|
NFS_OWNER_RECLAIM_REBOOT,
|
|
|
|
|
NFS_OWNER_RECLAIM_NOGRACE
|
|
|
|
|
};
|
|
|
|
|
|
2009-12-09 02:50:14 -07:00
|
|
|
#define NFS_LOCK_NEW 0
|
|
|
|
|
#define NFS_LOCK_RECLAIM 1
|
|
|
|
|
#define NFS_LOCK_EXPIRED 2
|
|
|
|
|
|
2005-06-22 10:16:21 -07:00
|
|
|
/*
|
|
|
|
|
* struct nfs4_state maintains the client-side state for a given
|
|
|
|
|
* (state_owner,inode) tuple (OPEN) or state_owner (LOCK).
|
|
|
|
|
*
|
|
|
|
|
* OPEN:
|
|
|
|
|
* In order to know when to OPEN_DOWNGRADE or CLOSE the state on the server,
|
|
|
|
|
* we need to know how many files are open for reading or writing on a
|
|
|
|
|
* given inode. This information too is stored here.
|
|
|
|
|
*
|
|
|
|
|
* LOCK: one nfs4_state (LOCK) to hold the lock stateid nfs4_state(OPEN)
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
struct nfs4_lock_state {
|
|
|
|
|
struct list_head ls_locks; /* Other lock stateids */
|
2005-06-22 10:16:32 -07:00
|
|
|
struct nfs4_state * ls_state; /* Pointer to open state */
|
2005-06-22 10:16:21 -07:00
|
|
|
fl_owner_t ls_owner; /* POSIX lock owner */
|
|
|
|
|
#define NFS_LOCK_INITIALIZED 1
|
|
|
|
|
int ls_flags;
|
NFSv4: Add functions to order RPC calls
NFSv4 file state-changing functions such as OPEN, CLOSE, LOCK,... are all
labelled with "sequence identifiers" in order to prevent the server from
reordering RPC requests, as this could cause its file state to
become out of sync with the client.
Currently the NFS client code enforces this ordering locally using
semaphores to restrict access to structures until the RPC call is done.
This, of course, only works with synchronous RPC calls, since the
user process must first grab the semaphore.
By dropping semaphores, and instead teaching the RPC engine to hold
the RPC calls until they are ready to be sent, we can extend this
process to work nicely with asynchronous RPC calls too.
This patch adds a new list called "rpc_sequence" that defines the order
of the RPC calls to be sent. We add one such list for each state_owner.
When an RPC call is ready to be sent, it checks if it is top of the
rpc_sequence list. If so, it proceeds. If not, it goes back to sleep,
and loops until it hits top of the list.
Once the RPC call has completed, it can then bump the sequence id counter,
and remove itself from the rpc_sequence list, and then wake up the next
sleeper.
Note that the state_owner sequence ids and lock_owner sequence ids are
all indexed to the same rpc_sequence list, so OPEN, LOCK,... requests
are all ordered w.r.t. each other.
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2005-10-18 14:20:12 -07:00
|
|
|
struct nfs_seqid_counter ls_seqid;
|
2008-01-10 14:07:54 -07:00
|
|
|
struct rpc_sequence ls_sequence;
|
2007-07-02 10:58:33 -07:00
|
|
|
struct nfs_unique_id ls_id;
|
2005-06-22 10:16:21 -07:00
|
|
|
nfs4_stateid ls_stateid;
|
|
|
|
|
atomic_t ls_count;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* bits for nfs4_state->flags */
|
|
|
|
|
enum {
|
|
|
|
|
LK_STATE_IN_USE,
|
2007-07-05 15:07:55 -07:00
|
|
|
NFS_DELEGATED_STATE, /* Current stateid is delegation */
|
|
|
|
|
NFS_O_RDONLY_STATE, /* OPEN stateid has read-only state */
|
|
|
|
|
NFS_O_WRONLY_STATE, /* OPEN stateid has write-only state */
|
|
|
|
|
NFS_O_RDWR_STATE, /* OPEN stateid has read/write state */
|
2008-12-23 13:21:41 -07:00
|
|
|
NFS_STATE_RECLAIM_REBOOT, /* OPEN stateid server rebooted */
|
|
|
|
|
NFS_STATE_RECLAIM_NOGRACE, /* OPEN stateid needs to recover state */
|
2010-01-26 13:42:30 -07:00
|
|
|
NFS_STATE_POSIX_LOCKS, /* Posix locks are supported */
|
2005-06-22 10:16:21 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct nfs4_state {
|
|
|
|
|
struct list_head open_states; /* List of states for the same state_owner */
|
|
|
|
|
struct list_head inode_states; /* List of states for the same inode */
|
|
|
|
|
struct list_head lock_states; /* List of subservient lock stateids */
|
|
|
|
|
|
|
|
|
|
struct nfs4_state_owner *owner; /* Pointer to the open owner */
|
|
|
|
|
struct inode *inode; /* Pointer to the inode */
|
|
|
|
|
|
|
|
|
|
unsigned long flags; /* Do we hold any locks? */
|
2005-06-22 10:16:32 -07:00
|
|
|
spinlock_t state_lock; /* Protects the lock_states list */
|
2005-06-22 10:16:21 -07:00
|
|
|
|
2007-07-09 07:45:42 -07:00
|
|
|
seqlock_t seqlock; /* Protects the stateid/open_stateid */
|
2007-07-05 15:07:55 -07:00
|
|
|
nfs4_stateid stateid; /* Current stateid: may be delegation */
|
|
|
|
|
nfs4_stateid open_stateid; /* OPEN stateid */
|
2005-06-22 10:16:21 -07:00
|
|
|
|
2007-07-09 07:45:42 -07:00
|
|
|
/* The following 3 fields are protected by owner->so_lock */
|
2007-07-05 15:07:55 -07:00
|
|
|
unsigned int n_rdonly; /* Number of read-only references */
|
|
|
|
|
unsigned int n_wronly; /* Number of write-only references */
|
|
|
|
|
unsigned int n_rdwr; /* Number of read/write references */
|
2008-12-23 13:21:56 -07:00
|
|
|
fmode_t state; /* State on the server (R,W, or RW) */
|
2005-06-22 10:16:21 -07:00
|
|
|
atomic_t count;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct nfs4_exception {
|
|
|
|
|
long timeout;
|
|
|
|
|
int retry;
|
2008-12-23 13:21:46 -07:00
|
|
|
struct nfs4_state *state;
|
2005-06-22 10:16:21 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct nfs4_state_recovery_ops {
|
2008-12-23 13:21:43 -07:00
|
|
|
int owner_flag_bit;
|
2008-12-23 13:21:41 -07:00
|
|
|
int state_flag_bit;
|
2005-06-22 10:16:21 -07:00
|
|
|
int (*recover_open)(struct nfs4_state_owner *, struct nfs4_state *);
|
|
|
|
|
int (*recover_lock)(struct nfs4_state *, struct file_lock *);
|
2009-04-01 06:22:47 -07:00
|
|
|
int (*establish_clid)(struct nfs_client *, struct rpc_cred *);
|
2009-04-01 06:22:48 -07:00
|
|
|
struct rpc_cred * (*get_clid_cred)(struct nfs_client *);
|
2009-12-05 14:08:41 -07:00
|
|
|
int (*reclaim_complete)(struct nfs_client *);
|
2005-06-22 10:16:21 -07:00
|
|
|
};
|
|
|
|
|
|
2009-04-01 06:22:44 -07:00
|
|
|
struct nfs4_state_maintenance_ops {
|
|
|
|
|
int (*sched_state_renewal)(struct nfs_client *, struct rpc_cred *);
|
2009-04-01 06:22:46 -07:00
|
|
|
struct rpc_cred * (*get_state_renewal_cred_locked)(struct nfs_client *);
|
2009-04-01 06:22:45 -07:00
|
|
|
int (*renew_lease)(struct nfs_client *, struct rpc_cred *);
|
2009-04-01 06:22:44 -07:00
|
|
|
};
|
|
|
|
|
|
2009-02-19 22:51:22 -07:00
|
|
|
extern const struct dentry_operations nfs4_dentry_operations;
|
2007-02-12 01:55:39 -07:00
|
|
|
extern const struct inode_operations nfs4_dir_inode_operations;
|
2005-06-22 10:16:22 -07:00
|
|
|
|
|
|
|
|
/* inode.c */
|
|
|
|
|
extern ssize_t nfs4_getxattr(struct dentry *, const char *, void *, size_t);
|
|
|
|
|
extern int nfs4_setxattr(struct dentry *, const char *, const void *, size_t, int);
|
|
|
|
|
extern ssize_t nfs4_listxattr(struct dentry *, char *, size_t);
|
|
|
|
|
|
2005-06-22 10:16:21 -07:00
|
|
|
|
|
|
|
|
/* nfs4proc.c */
|
2010-04-16 13:43:06 -07:00
|
|
|
extern int nfs4_proc_setclientid(struct nfs_client *, u32, unsigned short, struct rpc_cred *, struct nfs4_setclientid_res *);
|
|
|
|
|
extern int nfs4_proc_setclientid_confirm(struct nfs_client *, struct nfs4_setclientid_res *arg, struct rpc_cred *);
|
2009-12-04 13:52:24 -07:00
|
|
|
extern int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred);
|
2006-08-22 17:06:08 -07:00
|
|
|
extern int nfs4_proc_async_renew(struct nfs_client *, struct rpc_cred *);
|
|
|
|
|
extern int nfs4_proc_renew(struct nfs_client *, struct rpc_cred *);
|
2009-04-01 06:22:47 -07:00
|
|
|
extern int nfs4_init_clientid(struct nfs_client *, struct rpc_cred *);
|
2009-12-04 13:52:24 -07:00
|
|
|
extern int nfs41_init_clientid(struct nfs_client *, struct rpc_cred *);
|
2010-05-13 09:51:01 -07:00
|
|
|
extern int nfs4_do_close(struct path *path, struct nfs4_state *state, gfp_t gfp_mask, int wait);
|
2005-10-18 14:20:17 -07:00
|
|
|
extern struct dentry *nfs4_atomic_open(struct inode *, struct dentry *, struct nameidata *);
|
|
|
|
|
extern int nfs4_open_revalidate(struct inode *, struct dentry *, int, struct nameidata *);
|
2006-06-09 06:34:19 -07:00
|
|
|
extern int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle);
|
2007-07-17 18:52:39 -07:00
|
|
|
extern int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name,
|
2006-06-09 06:34:23 -07:00
|
|
|
struct nfs4_fs_locations *fs_locations, struct page *page);
|
2005-06-22 10:16:21 -07:00
|
|
|
|
2009-04-01 06:21:53 -07:00
|
|
|
#if defined(CONFIG_NFS_V4_1)
|
2010-06-16 06:52:26 -07:00
|
|
|
static inline struct nfs4_session *nfs4_get_session(const struct nfs_server *server)
|
|
|
|
|
{
|
|
|
|
|
return server->nfs_client->cl_session;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern int nfs4_setup_sequence(const struct nfs_server *server,
|
2009-04-01 06:22:15 -07:00
|
|
|
struct nfs4_sequence_args *args, struct nfs4_sequence_res *res,
|
|
|
|
|
int cache_reply, struct rpc_task *task);
|
2009-04-01 06:21:53 -07:00
|
|
|
extern void nfs4_destroy_session(struct nfs4_session *session);
|
|
|
|
|
extern struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp);
|
2009-12-05 17:32:11 -07:00
|
|
|
extern int nfs4_proc_create_session(struct nfs_client *);
|
2009-04-01 06:22:39 -07:00
|
|
|
extern int nfs4_proc_destroy_session(struct nfs4_session *);
|
2009-07-21 13:48:07 -07:00
|
|
|
extern int nfs4_init_session(struct nfs_server *server);
|
2009-12-06 10:23:46 -07:00
|
|
|
extern int nfs4_proc_get_lease_time(struct nfs_client *clp,
|
|
|
|
|
struct nfs_fsinfo *fsinfo);
|
2009-04-01 06:22:15 -07:00
|
|
|
#else /* CONFIG_NFS_v4_1 */
|
2010-06-16 06:52:26 -07:00
|
|
|
static inline struct nfs4_session *nfs4_get_session(const struct nfs_server *server)
|
|
|
|
|
{
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int nfs4_setup_sequence(const struct nfs_server *server,
|
2009-04-01 06:22:15 -07:00
|
|
|
struct nfs4_sequence_args *args, struct nfs4_sequence_res *res,
|
|
|
|
|
int cache_reply, struct rpc_task *task)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2009-07-21 13:48:07 -07:00
|
|
|
|
|
|
|
|
static inline int nfs4_init_session(struct nfs_server *server)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2009-04-01 06:21:53 -07:00
|
|
|
#endif /* CONFIG_NFS_V4_1 */
|
2005-06-22 10:16:21 -07:00
|
|
|
|
2010-06-16 06:52:26 -07:00
|
|
|
extern const struct nfs4_minor_version_ops *nfs_v4_minor_ops[];
|
2009-04-01 06:22:44 -07:00
|
|
|
|
2005-06-22 10:16:21 -07:00
|
|
|
extern const u32 nfs4_fattr_bitmap[2];
|
|
|
|
|
extern const u32 nfs4_statfs_bitmap[2];
|
|
|
|
|
extern const u32 nfs4_pathconf_bitmap[2];
|
|
|
|
|
extern const u32 nfs4_fsinfo_bitmap[2];
|
2006-06-09 06:34:25 -07:00
|
|
|
extern const u32 nfs4_fs_locations_bitmap[2];
|
2005-06-22 10:16:21 -07:00
|
|
|
|
|
|
|
|
/* nfs4renewd.c */
|
2006-08-22 17:06:08 -07:00
|
|
|
extern void nfs4_schedule_state_renewal(struct nfs_client *);
|
2005-06-22 10:16:21 -07:00
|
|
|
extern void nfs4_renewd_prepare_shutdown(struct nfs_server *);
|
2006-08-22 17:06:08 -07:00
|
|
|
extern void nfs4_kill_renewd(struct nfs_client *);
|
2006-11-22 07:55:48 -07:00
|
|
|
extern void nfs4_renew_state(struct work_struct *);
|
2005-06-22 10:16:21 -07:00
|
|
|
|
|
|
|
|
/* nfs4state.c */
|
2009-04-01 06:22:46 -07:00
|
|
|
struct rpc_cred *nfs4_get_setclientid_cred(struct nfs_client *clp);
|
2008-12-23 13:21:41 -07:00
|
|
|
struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp);
|
2009-04-01 06:22:46 -07:00
|
|
|
#if defined(CONFIG_NFS_V4_1)
|
|
|
|
|
struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp);
|
2009-04-01 06:22:49 -07:00
|
|
|
struct rpc_cred *nfs4_get_exchange_id_cred(struct nfs_client *clp);
|
2009-04-01 06:22:46 -07:00
|
|
|
#endif /* CONFIG_NFS_V4_1 */
|
2005-06-22 10:16:21 -07:00
|
|
|
|
|
|
|
|
extern struct nfs4_state_owner * nfs4_get_state_owner(struct nfs_server *, struct rpc_cred *);
|
|
|
|
|
extern void nfs4_put_state_owner(struct nfs4_state_owner *);
|
|
|
|
|
extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state_owner *);
|
|
|
|
|
extern void nfs4_put_open_state(struct nfs4_state *);
|
2008-12-23 13:21:56 -07:00
|
|
|
extern void nfs4_close_state(struct path *, struct nfs4_state *, fmode_t);
|
|
|
|
|
extern void nfs4_close_sync(struct path *, struct nfs4_state *, fmode_t);
|
|
|
|
|
extern void nfs4_state_set_mode_locked(struct nfs4_state *, fmode_t);
|
2006-08-22 17:06:08 -07:00
|
|
|
extern void nfs4_schedule_state_recovery(struct nfs_client *);
|
2008-12-23 13:21:50 -07:00
|
|
|
extern void nfs4_schedule_state_manager(struct nfs_client *);
|
2008-12-23 13:21:46 -07:00
|
|
|
extern int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state);
|
2010-01-26 13:42:47 -07:00
|
|
|
extern int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state);
|
2009-12-05 11:46:14 -07:00
|
|
|
extern void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags);
|
2010-01-20 14:06:27 -07:00
|
|
|
extern void nfs41_handle_recall_slot(struct nfs_client *clp);
|
2005-10-18 14:20:15 -07:00
|
|
|
extern void nfs4_put_lock_state(struct nfs4_lock_state *lsp);
|
2005-06-22 10:16:32 -07:00
|
|
|
extern int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl);
|
2005-06-22 10:16:21 -07:00
|
|
|
extern void nfs4_copy_stateid(nfs4_stateid *, struct nfs4_state *, fl_owner_t);
|
|
|
|
|
|
2010-05-13 09:51:01 -07:00
|
|
|
extern struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask);
|
NFSv4: Add functions to order RPC calls
NFSv4 file state-changing functions such as OPEN, CLOSE, LOCK,... are all
labelled with "sequence identifiers" in order to prevent the server from
reordering RPC requests, as this could cause its file state to
become out of sync with the client.
Currently the NFS client code enforces this ordering locally using
semaphores to restrict access to structures until the RPC call is done.
This, of course, only works with synchronous RPC calls, since the
user process must first grab the semaphore.
By dropping semaphores, and instead teaching the RPC engine to hold
the RPC calls until they are ready to be sent, we can extend this
process to work nicely with asynchronous RPC calls too.
This patch adds a new list called "rpc_sequence" that defines the order
of the RPC calls to be sent. We add one such list for each state_owner.
When an RPC call is ready to be sent, it checks if it is top of the
rpc_sequence list. If so, it proceeds. If not, it goes back to sleep,
and loops until it hits top of the list.
Once the RPC call has completed, it can then bump the sequence id counter,
and remove itself from the rpc_sequence list, and then wake up the next
sleeper.
Note that the state_owner sequence ids and lock_owner sequence ids are
all indexed to the same rpc_sequence list, so OPEN, LOCK,... requests
are all ordered w.r.t. each other.
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2005-10-18 14:20:12 -07:00
|
|
|
extern int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task);
|
|
|
|
|
extern void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid);
|
|
|
|
|
extern void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid);
|
2009-12-15 12:47:36 -07:00
|
|
|
extern void nfs_release_seqid(struct nfs_seqid *seqid);
|
NFSv4: Add functions to order RPC calls
NFSv4 file state-changing functions such as OPEN, CLOSE, LOCK,... are all
labelled with "sequence identifiers" in order to prevent the server from
reordering RPC requests, as this could cause its file state to
become out of sync with the client.
Currently the NFS client code enforces this ordering locally using
semaphores to restrict access to structures until the RPC call is done.
This, of course, only works with synchronous RPC calls, since the
user process must first grab the semaphore.
By dropping semaphores, and instead teaching the RPC engine to hold
the RPC calls until they are ready to be sent, we can extend this
process to work nicely with asynchronous RPC calls too.
This patch adds a new list called "rpc_sequence" that defines the order
of the RPC calls to be sent. We add one such list for each state_owner.
When an RPC call is ready to be sent, it checks if it is top of the
rpc_sequence list. If so, it proceeds. If not, it goes back to sleep,
and loops until it hits top of the list.
Once the RPC call has completed, it can then bump the sequence id counter,
and remove itself from the rpc_sequence list, and then wake up the next
sleeper.
Note that the state_owner sequence ids and lock_owner sequence ids are
all indexed to the same rpc_sequence list, so OPEN, LOCK,... requests
are all ordered w.r.t. each other.
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2005-10-18 14:20:12 -07:00
|
|
|
extern void nfs_free_seqid(struct nfs_seqid *seqid);
|
|
|
|
|
|
2005-06-22 10:16:21 -07:00
|
|
|
extern const nfs4_stateid zero_stateid;
|
|
|
|
|
|
|
|
|
|
/* nfs4xdr.c */
|
2006-10-19 23:28:49 -07:00
|
|
|
extern __be32 *nfs4_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus);
|
2005-06-22 10:16:21 -07:00
|
|
|
extern struct rpc_procinfo nfs4_procedures[];
|
|
|
|
|
|
|
|
|
|
struct nfs4_mount_data;
|
|
|
|
|
|
|
|
|
|
/* callback_xdr.c */
|
|
|
|
|
extern struct svc_version nfs4_callback_version1;
|
2009-12-05 11:19:01 -07:00
|
|
|
extern struct svc_version nfs4_callback_version4;
|
2005-06-22 10:16:21 -07:00
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
2007-06-05 07:31:33 -07:00
|
|
|
#define nfs4_close_state(a, b, c) do { } while (0)
|
2007-10-19 18:41:49 -07:00
|
|
|
#define nfs4_close_sync(a, b, c) do { } while (0)
|
2005-06-22 10:16:21 -07:00
|
|
|
|
|
|
|
|
#endif /* CONFIG_NFS_V4 */
|
|
|
|
|
#endif /* __LINUX_FS_NFS_NFS4_FS.H */
|