2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2001 The Regents of the University of Michigan.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Kendrick Smith <kmsmith@umich.edu>
|
|
|
|
* Andy Adamson <andros@umich.edu>
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
*
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. Neither the name of the University nor the names of its
|
|
|
|
* contributors may be used to endorse or promote products derived
|
|
|
|
* from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
|
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
|
|
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _NFSD4_STATE_H
|
|
|
|
#define _NFSD4_STATE_H
|
|
|
|
|
2011-09-24 05:01:19 +08:00
|
|
|
#include <linux/idr.h>
|
2010-06-07 06:37:16 +08:00
|
|
|
#include <linux/sunrpc/svc_xprt.h>
|
2009-12-05 08:36:06 +08:00
|
|
|
#include "nfsfh.h"
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
u32 cl_boot;
|
|
|
|
u32 cl_id;
|
|
|
|
} clientid_t;
|
|
|
|
|
|
|
|
typedef struct {
|
2011-09-16 03:02:41 +08:00
|
|
|
clientid_t so_clid;
|
|
|
|
u32 so_id;
|
2005-04-17 06:20:36 +08:00
|
|
|
} stateid_opaque_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
u32 si_generation;
|
|
|
|
stateid_opaque_t si_opaque;
|
|
|
|
} stateid_t;
|
|
|
|
|
2009-10-19 18:04:53 +08:00
|
|
|
#define STATEID_FMT "(%08x/%08x/%08x/%08x)"
|
|
|
|
#define STATEID_VAL(s) \
|
2011-09-16 03:02:41 +08:00
|
|
|
(s)->si_opaque.so_clid.cl_boot, \
|
|
|
|
(s)->si_opaque.so_clid.cl_id, \
|
|
|
|
(s)->si_opaque.so_id, \
|
2009-10-19 18:04:53 +08:00
|
|
|
(s)->si_generation
|
|
|
|
|
2010-02-19 00:27:24 +08:00
|
|
|
struct nfsd4_callback {
|
2010-06-01 06:21:37 +08:00
|
|
|
void *cb_op;
|
|
|
|
struct nfs4_client *cb_clp;
|
2011-01-11 05:44:41 +08:00
|
|
|
struct list_head cb_per_client;
|
2010-06-01 06:21:37 +08:00
|
|
|
u32 cb_minorversion;
|
2010-05-17 04:47:08 +08:00
|
|
|
struct rpc_message cb_msg;
|
|
|
|
const struct rpc_call_ops *cb_ops;
|
2010-03-04 03:52:55 +08:00
|
|
|
struct work_struct cb_work;
|
2011-01-11 05:44:41 +08:00
|
|
|
bool cb_done;
|
2010-02-19 00:27:24 +08:00
|
|
|
};
|
|
|
|
|
2011-09-09 00:07:44 +08:00
|
|
|
struct nfs4_stid {
|
2014-07-21 21:34:58 +08:00
|
|
|
atomic_t sc_count;
|
2011-09-09 00:07:44 +08:00
|
|
|
#define NFS4_OPEN_STID 1
|
|
|
|
#define NFS4_LOCK_STID 2
|
|
|
|
#define NFS4_DELEG_STID 4
|
2011-09-17 08:12:38 +08:00
|
|
|
/* For an open stateid kept around *only* to process close replays: */
|
|
|
|
#define NFS4_CLOSED_STID 8
|
2013-04-10 05:02:51 +08:00
|
|
|
/* For a deleg stateid kept around only to process free_stateid's: */
|
|
|
|
#define NFS4_REVOKED_DELEG_STID 16
|
2014-07-16 22:31:59 +08:00
|
|
|
#define NFS4_CLOSED_DELEG_STID 32
|
2011-09-17 08:12:38 +08:00
|
|
|
unsigned char sc_type;
|
2011-09-09 00:07:44 +08:00
|
|
|
stateid_t sc_stateid;
|
2011-09-24 05:20:02 +08:00
|
|
|
struct nfs4_client *sc_client;
|
2011-09-09 00:07:44 +08:00
|
|
|
};
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
struct nfs4_delegation {
|
2011-10-17 23:14:48 +08:00
|
|
|
struct nfs4_stid dl_stid; /* must be first field */
|
2005-06-24 13:04:17 +08:00
|
|
|
struct list_head dl_perfile;
|
|
|
|
struct list_head dl_perclnt;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct list_head dl_recall_lru; /* delegation recalled */
|
|
|
|
struct nfs4_file *dl_file;
|
|
|
|
u32 dl_type;
|
|
|
|
time_t dl_time;
|
2009-05-02 07:50:00 +08:00
|
|
|
/* For recall: */
|
2009-05-02 08:11:12 +08:00
|
|
|
int dl_retries;
|
2010-02-19 00:27:24 +08:00
|
|
|
struct nfsd4_callback dl_recall;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/* client delegation callback info */
|
2009-04-30 07:09:19 +08:00
|
|
|
struct nfs4_cb_conn {
|
2005-04-17 06:20:36 +08:00
|
|
|
/* SETCLIENTID info */
|
2009-08-15 00:57:57 +08:00
|
|
|
struct sockaddr_storage cb_addr;
|
2010-12-15 13:09:01 +08:00
|
|
|
struct sockaddr_storage cb_saddr;
|
2009-08-15 00:57:57 +08:00
|
|
|
size_t cb_addrlen;
|
2010-10-20 05:31:50 +08:00
|
|
|
u32 cb_prog; /* used only in 4.0 case;
|
|
|
|
per-session otherwise */
|
2009-06-16 09:20:53 +08:00
|
|
|
u32 cb_ident; /* minorversion 0 only */
|
2010-03-09 01:37:27 +08:00
|
|
|
struct svc_xprt *cb_xprt; /* minorversion 1 only */
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2011-09-09 21:06:12 +08:00
|
|
|
static inline struct nfs4_delegation *delegstateid(struct nfs4_stid *s)
|
|
|
|
{
|
|
|
|
return container_of(s, struct nfs4_delegation, dl_stid);
|
|
|
|
}
|
|
|
|
|
2009-08-28 20:45:01 +08:00
|
|
|
/* Maximum number of slots per session. 160 is useful for long haul TCP */
|
|
|
|
#define NFSD_MAX_SLOTS_PER_SESSION 160
|
2009-04-03 13:28:28 +08:00
|
|
|
/* Maximum number of operations per session compound */
|
|
|
|
#define NFSD_MAX_OPS_PER_COMPOUND 16
|
2009-08-28 20:45:04 +08:00
|
|
|
/* Maximum session per slot cache size */
|
2014-03-13 03:17:18 +08:00
|
|
|
#define NFSD_SLOT_CACHE_SIZE 2048
|
2009-08-28 20:45:01 +08:00
|
|
|
/* Maximum number of NFSD_SLOT_CACHE_SIZE slots per session */
|
|
|
|
#define NFSD_CACHE_SIZE_SLOTS_PER_SESSION 32
|
|
|
|
#define NFSD_MAX_MEM_PER_SESSION \
|
|
|
|
(NFSD_CACHE_SIZE_SLOTS_PER_SESSION * NFSD_SLOT_CACHE_SIZE)
|
2009-04-03 13:28:15 +08:00
|
|
|
|
2009-04-03 13:27:43 +08:00
|
|
|
struct nfsd4_slot {
|
2009-08-28 20:45:04 +08:00
|
|
|
u32 sl_seqid;
|
|
|
|
__be32 sl_status;
|
|
|
|
u32 sl_datalen;
|
2012-02-14 05:39:00 +08:00
|
|
|
u16 sl_opcnt;
|
|
|
|
#define NFSD4_SLOT_INUSE (1 << 0)
|
|
|
|
#define NFSD4_SLOT_CACHETHIS (1 << 1)
|
2012-02-14 05:56:19 +08:00
|
|
|
#define NFSD4_SLOT_INITIALIZED (1 << 2)
|
2012-02-14 05:39:00 +08:00
|
|
|
u8 sl_flags;
|
2009-08-28 20:45:04 +08:00
|
|
|
char sl_data[];
|
2009-04-03 13:27:43 +08:00
|
|
|
};
|
|
|
|
|
2009-06-16 09:19:13 +08:00
|
|
|
struct nfsd4_channel_attrs {
|
|
|
|
u32 headerpadsz;
|
|
|
|
u32 maxreq_sz;
|
|
|
|
u32 maxresp_sz;
|
|
|
|
u32 maxresp_cached;
|
|
|
|
u32 maxops;
|
|
|
|
u32 maxreqs;
|
|
|
|
u32 nr_rdma_attrs;
|
|
|
|
u32 rdma_attrs;
|
|
|
|
};
|
|
|
|
|
2012-03-28 02:50:26 +08:00
|
|
|
struct nfsd4_cb_sec {
|
2012-11-06 05:01:48 +08:00
|
|
|
u32 flavor; /* (u32)(-1) used to mean "no valid flavor" */
|
2013-02-02 22:24:49 +08:00
|
|
|
kuid_t uid;
|
|
|
|
kgid_t gid;
|
2012-03-28 02:50:26 +08:00
|
|
|
};
|
|
|
|
|
2009-07-24 07:02:16 +08:00
|
|
|
struct nfsd4_create_session {
|
|
|
|
clientid_t clientid;
|
|
|
|
struct nfs4_sessionid sessionid;
|
|
|
|
u32 seqid;
|
|
|
|
u32 flags;
|
|
|
|
struct nfsd4_channel_attrs fore_channel;
|
|
|
|
struct nfsd4_channel_attrs back_channel;
|
|
|
|
u32 callback_prog;
|
2012-03-28 02:50:26 +08:00
|
|
|
struct nfsd4_cb_sec cb_sec;
|
2009-07-24 07:02:16 +08:00
|
|
|
};
|
|
|
|
|
2012-11-02 06:09:48 +08:00
|
|
|
struct nfsd4_backchannel_ctl {
|
|
|
|
u32 bc_cb_program;
|
|
|
|
struct nfsd4_cb_sec bc_cb_sec;
|
|
|
|
};
|
|
|
|
|
2010-10-05 11:12:59 +08:00
|
|
|
struct nfsd4_bind_conn_to_session {
|
|
|
|
struct nfs4_sessionid sessionid;
|
|
|
|
u32 dir;
|
|
|
|
};
|
|
|
|
|
2009-07-24 07:02:16 +08:00
|
|
|
/* The single slot clientid cache structure */
|
|
|
|
struct nfsd4_clid_slot {
|
|
|
|
u32 sl_seqid;
|
|
|
|
__be32 sl_status;
|
|
|
|
struct nfsd4_create_session sl_cr_ses;
|
|
|
|
};
|
|
|
|
|
2010-06-07 06:12:14 +08:00
|
|
|
struct nfsd4_conn {
|
|
|
|
struct list_head cn_persession;
|
|
|
|
struct svc_xprt *cn_xprt;
|
2010-06-07 06:37:16 +08:00
|
|
|
struct svc_xpt_user cn_xpt_user;
|
|
|
|
struct nfsd4_session *cn_session;
|
2010-06-07 06:12:14 +08:00
|
|
|
/* CDFC4_FORE, CDFC4_BACK: */
|
|
|
|
unsigned char cn_flags;
|
|
|
|
};
|
|
|
|
|
2009-04-03 13:27:43 +08:00
|
|
|
struct nfsd4_session {
|
2013-03-20 00:05:39 +08:00
|
|
|
atomic_t se_ref;
|
2009-04-03 13:27:43 +08:00
|
|
|
struct list_head se_hash; /* hash by sessionid */
|
|
|
|
struct list_head se_perclnt;
|
2013-03-20 00:05:39 +08:00
|
|
|
/* See SESSION4_PERSIST, etc. for standard flags; this is internal-only: */
|
|
|
|
#define NFS4_SESSION_DEAD 0x010
|
2009-04-03 13:27:43 +08:00
|
|
|
u32 se_flags;
|
2010-05-12 05:13:41 +08:00
|
|
|
struct nfs4_client *se_client;
|
2009-04-03 13:27:43 +08:00
|
|
|
struct nfs4_sessionid se_sessionid;
|
2009-06-16 09:19:13 +08:00
|
|
|
struct nfsd4_channel_attrs se_fchannel;
|
|
|
|
struct nfsd4_channel_attrs se_bchannel;
|
2012-03-28 02:50:26 +08:00
|
|
|
struct nfsd4_cb_sec se_cb_sec;
|
2010-06-07 06:12:14 +08:00
|
|
|
struct list_head se_conns;
|
2010-10-20 05:31:50 +08:00
|
|
|
u32 se_cb_prog;
|
2010-06-15 07:01:57 +08:00
|
|
|
u32 se_cb_seq_nr;
|
2009-08-28 20:45:04 +08:00
|
|
|
struct nfsd4_slot *se_slots[]; /* forward channel slots */
|
2009-04-03 13:27:43 +08:00
|
|
|
};
|
|
|
|
|
2009-04-03 13:27:52 +08:00
|
|
|
/* formatted contents of nfs4_sessionid */
|
|
|
|
struct nfsd4_sessionid {
|
|
|
|
clientid_t clientid;
|
|
|
|
u32 sequence;
|
|
|
|
u32 reserved;
|
|
|
|
};
|
|
|
|
|
2005-06-24 13:03:52 +08:00
|
|
|
#define HEXDIR_LEN 33 /* hex version of 16 byte md5 of cl_name plus '\0' */
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* struct nfs4_client - one per client. Clientids live here.
|
|
|
|
* o Each nfs4_client is hashed by clientid.
|
|
|
|
*
|
|
|
|
* o Each nfs4_clients is also hashed by name
|
|
|
|
* (the opaque quantity initially sent by the client to identify itself).
|
|
|
|
*
|
|
|
|
* o cl_perclient list is used to ensure no dangling stateowner references
|
|
|
|
* when we expire the nfs4_client
|
|
|
|
*/
|
|
|
|
struct nfs4_client {
|
|
|
|
struct list_head cl_idhash; /* hash by cl_clientid.id */
|
2012-11-13 04:00:56 +08:00
|
|
|
struct rb_node cl_namenode; /* link into by-name trees */
|
2005-06-24 13:04:17 +08:00
|
|
|
struct list_head cl_openowners;
|
2011-09-24 05:01:19 +08:00
|
|
|
struct idr cl_stateids; /* stateid lookup */
|
2005-06-24 13:04:17 +08:00
|
|
|
struct list_head cl_delegations;
|
2013-04-10 05:02:51 +08:00
|
|
|
struct list_head cl_revoked; /* unacknowledged, revoked 4.1 state */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct list_head cl_lru; /* tail queue */
|
|
|
|
struct xdr_netobj cl_name; /* id generated by client */
|
|
|
|
nfs4_verifier cl_verifier; /* generated by client */
|
|
|
|
time_t cl_time; /* time of last lease renewal */
|
2009-08-15 00:57:56 +08:00
|
|
|
struct sockaddr_storage cl_addr; /* client ipaddress */
|
2013-04-14 02:27:29 +08:00
|
|
|
bool cl_mach_cred; /* SP4_MACH_CRED in force */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct svc_cred cl_cred; /* setclientid principal */
|
|
|
|
clientid_t cl_clientid; /* generated by server */
|
|
|
|
nfs4_verifier cl_confirm; /* generated by server */
|
2010-10-20 07:36:51 +08:00
|
|
|
u32 cl_minorversion;
|
2009-04-03 13:27:46 +08:00
|
|
|
|
2010-03-09 01:37:27 +08:00
|
|
|
/* for v4.0 and v4.1 callbacks: */
|
|
|
|
struct nfs4_cb_conn cl_cb_conn;
|
2012-03-21 21:52:02 +08:00
|
|
|
#define NFSD4_CLIENT_CB_UPDATE (0)
|
|
|
|
#define NFSD4_CLIENT_CB_KILL (1)
|
|
|
|
#define NFSD4_CLIENT_STABLE (2) /* client on stable storage */
|
|
|
|
#define NFSD4_CLIENT_RECLAIM_COMPLETE (3) /* reclaim_complete done */
|
2012-11-13 04:00:56 +08:00
|
|
|
#define NFSD4_CLIENT_CONFIRMED (4) /* client is confirmed */
|
2012-03-21 21:52:02 +08:00
|
|
|
#define NFSD4_CLIENT_CB_FLAG_MASK (1 << NFSD4_CLIENT_CB_UPDATE | \
|
|
|
|
1 << NFSD4_CLIENT_CB_KILL)
|
|
|
|
unsigned long cl_flags;
|
2012-11-02 04:31:02 +08:00
|
|
|
struct rpc_cred *cl_cb_cred;
|
2010-03-09 01:37:27 +08:00
|
|
|
struct rpc_clnt *cl_cb_client;
|
2010-06-05 08:04:45 +08:00
|
|
|
u32 cl_cb_ident;
|
2010-05-01 06:51:44 +08:00
|
|
|
#define NFSD4_CB_UP 0
|
|
|
|
#define NFSD4_CB_UNKNOWN 1
|
|
|
|
#define NFSD4_CB_DOWN 2
|
2011-10-20 10:12:58 +08:00
|
|
|
#define NFSD4_CB_FAULT 3
|
2010-05-01 06:51:44 +08:00
|
|
|
int cl_cb_state;
|
2010-05-27 05:52:14 +08:00
|
|
|
struct nfsd4_callback cl_cb_null;
|
2010-06-15 10:26:31 +08:00
|
|
|
struct nfsd4_session *cl_cb_session;
|
2011-01-11 05:44:41 +08:00
|
|
|
struct list_head cl_callbacks; /* list of in-progress callbacks */
|
2010-03-09 01:37:27 +08:00
|
|
|
|
2010-06-05 08:04:45 +08:00
|
|
|
/* for all client information that callback code might need: */
|
|
|
|
spinlock_t cl_lock;
|
|
|
|
|
2009-04-03 13:27:46 +08:00
|
|
|
/* for nfs41 */
|
|
|
|
struct list_head cl_sessions;
|
2009-07-24 07:02:16 +08:00
|
|
|
struct nfsd4_clid_slot cl_cs_slot; /* create_session slot */
|
2009-04-03 13:28:01 +08:00
|
|
|
u32 cl_exchange_flags;
|
2010-05-12 05:13:29 +08:00
|
|
|
/* number of rpc's in progress over an associated session: */
|
|
|
|
atomic_t cl_refcount;
|
2009-09-10 17:25:59 +08:00
|
|
|
|
|
|
|
/* for nfs41 callbacks */
|
2009-09-10 17:26:25 +08:00
|
|
|
/* We currently support a single back channel with a single slot */
|
|
|
|
unsigned long cl_cb_slot_busy;
|
|
|
|
struct rpc_wait_queue cl_cb_waitq; /* backchannel callers may */
|
|
|
|
/* wait here for slots */
|
2012-11-14 23:21:10 +08:00
|
|
|
struct net *net;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/* struct nfs4_client_reset
|
|
|
|
* one per old client. Populates reset_str_hashtbl. Filled from conf_id_hashtbl
|
|
|
|
* upon lease reset, or from upcall to state_daemon (to read in state
|
|
|
|
* from non-volitile storage) upon reboot.
|
|
|
|
*/
|
|
|
|
struct nfs4_client_reclaim {
|
|
|
|
struct list_head cr_strhash; /* hash by cr_name */
|
2012-11-13 04:00:55 +08:00
|
|
|
struct nfs4_client *cr_clp; /* pointer to associated clp */
|
2005-06-24 13:03:52 +08:00
|
|
|
char cr_recdir[HEXDIR_LEN]; /* recover dir */
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
update_stateid(stateid_t *stateid)
|
|
|
|
{
|
|
|
|
stateid->si_generation++;
|
2011-08-23 23:03:29 +08:00
|
|
|
/* Wraparound recommendation from 3530bis-13 9.1.3.2: */
|
|
|
|
if (stateid->si_generation == 0)
|
|
|
|
stateid->si_generation = 1;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* A reasonable value for REPLAY_ISIZE was estimated as follows:
|
|
|
|
* The OPEN response, typically the largest, requires
|
|
|
|
* 4(status) + 8(stateid) + 20(changeinfo) + 4(rflags) + 8(verifier) +
|
|
|
|
* 4(deleg. type) + 8(deleg. stateid) + 4(deleg. recall flag) +
|
|
|
|
* 20(deleg. space limit) + ~32(deleg. ace) = 112 bytes
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define NFSD4_REPLAY_ISIZE 112
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Replay buffer, where the result of the last seqid-mutating operation
|
|
|
|
* is cached.
|
|
|
|
*/
|
|
|
|
struct nfs4_replay {
|
2006-10-20 14:28:59 +08:00
|
|
|
__be32 rp_status;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int rp_buflen;
|
|
|
|
char *rp_buf;
|
2009-02-03 06:23:10 +08:00
|
|
|
struct knfsd_fh rp_openfh;
|
2005-04-17 06:20:36 +08:00
|
|
|
char rp_ibuf[NFSD4_REPLAY_ISIZE];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct nfs4_stateowner {
|
|
|
|
struct list_head so_strhash; /* hash by op_name */
|
2005-06-24 13:04:17 +08:00
|
|
|
struct list_head so_stateids;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct nfs4_client * so_client;
|
2005-07-08 08:59:20 +08:00
|
|
|
/* after increment in ENCODE_SEQID_OP_TAIL, represents the next
|
|
|
|
* sequence id expected from the client: */
|
|
|
|
u32 so_seqid;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct xdr_netobj so_owner; /* open owner name */
|
|
|
|
struct nfs4_replay so_replay;
|
2011-10-13 04:58:21 +08:00
|
|
|
bool so_is_open_owner;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2011-07-31 11:33:59 +08:00
|
|
|
struct nfs4_openowner {
|
|
|
|
struct nfs4_stateowner oo_owner; /* must be first field */
|
|
|
|
struct list_head oo_perclient;
|
2011-09-28 23:47:20 +08:00
|
|
|
/*
|
|
|
|
* We keep around openowners a little while after last close,
|
|
|
|
* which saves clients from having to confirm, and allows us to
|
|
|
|
* handle close replays if they come soon enough. The close_lru
|
|
|
|
* is a list of such openowners, to be reaped by the laundromat
|
|
|
|
* thread eventually if they remain unused:
|
|
|
|
*/
|
|
|
|
struct list_head oo_close_lru;
|
2011-09-17 05:42:48 +08:00
|
|
|
struct nfs4_ol_stateid *oo_last_closed_stid;
|
2011-07-31 11:33:59 +08:00
|
|
|
time_t oo_time; /* time of placement on so_close_lru */
|
2011-09-13 00:24:13 +08:00
|
|
|
#define NFS4_OO_CONFIRMED 1
|
2011-10-14 03:12:59 +08:00
|
|
|
#define NFS4_OO_NEW 4
|
2011-09-13 00:24:13 +08:00
|
|
|
unsigned char oo_flags;
|
2011-07-31 11:33:59 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct nfs4_lockowner {
|
|
|
|
struct nfs4_stateowner lo_owner; /* must be first element */
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline struct nfs4_openowner * openowner(struct nfs4_stateowner *so)
|
|
|
|
{
|
|
|
|
return container_of(so, struct nfs4_openowner, oo_owner);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct nfs4_lockowner * lockowner(struct nfs4_stateowner *so)
|
|
|
|
{
|
|
|
|
return container_of(so, struct nfs4_lockowner, lo_owner);
|
|
|
|
}
|
|
|
|
|
2012-08-06 23:00:27 +08:00
|
|
|
/* nfs4_file: a file opened by some number of (open) nfs4_stateowners. */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct nfs4_file {
|
2009-02-23 06:51:34 +08:00
|
|
|
atomic_t fi_ref;
|
2014-07-11 02:07:25 +08:00
|
|
|
spinlock_t fi_lock;
|
2013-04-02 21:01:59 +08:00
|
|
|
struct hlist_node fi_hash; /* hash by "struct inode *" */
|
2005-06-24 13:03:08 +08:00
|
|
|
struct list_head fi_stateids;
|
|
|
|
struct list_head fi_delegations;
|
2010-07-08 23:02:09 +08:00
|
|
|
/* One each for O_RDONLY, O_WRONLY, O_RDWR: */
|
|
|
|
struct file * fi_fds[3];
|
|
|
|
/*
|
2011-09-28 23:37:56 +08:00
|
|
|
* Each open or lock stateid contributes 0-4 to the counts
|
|
|
|
* below depending on which bits are set in st_access_bitmap:
|
|
|
|
* 1 to fi_access[O_RDONLY] if NFS4_SHARE_ACCES_READ is set
|
|
|
|
* + 1 to fi_access[O_WRONLY] if NFS4_SHARE_ACCESS_WRITE is set
|
|
|
|
* + 1 to both of the above if NFS4_SHARE_ACCESS_BOTH is set.
|
2010-07-08 23:02:09 +08:00
|
|
|
*/
|
2011-03-18 00:52:33 +08:00
|
|
|
atomic_t fi_access[2];
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-11 02:07:34 +08:00
|
|
|
u32 fi_share_deny;
|
2011-02-01 08:20:39 +08:00
|
|
|
struct file *fi_deleg_file;
|
|
|
|
struct file_lock *fi_lease;
|
|
|
|
atomic_t fi_delegees;
|
2014-07-24 04:17:38 +08:00
|
|
|
struct knfsd_fh fi_fhandle;
|
2007-07-17 19:04:40 +08:00
|
|
|
bool fi_had_conflict;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2011-09-09 00:07:44 +08:00
|
|
|
/* "ol" stands for "Open or Lock". Better suggestions welcome. */
|
2011-09-08 04:06:42 +08:00
|
|
|
struct nfs4_ol_stateid {
|
2011-10-17 23:14:48 +08:00
|
|
|
struct nfs4_stid st_stid; /* must be first field */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct list_head st_perfile;
|
2005-06-24 13:04:17 +08:00
|
|
|
struct list_head st_perstateowner;
|
2014-06-30 23:48:38 +08:00
|
|
|
struct list_head st_locks;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct nfs4_stateowner * st_stateowner;
|
|
|
|
struct nfs4_file * st_file;
|
2014-07-11 02:07:30 +08:00
|
|
|
unsigned char st_access_bmap;
|
|
|
|
unsigned char st_deny_bmap;
|
2011-09-08 04:06:42 +08:00
|
|
|
struct nfs4_ol_stateid * st_openstp;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2011-09-08 04:06:42 +08:00
|
|
|
static inline struct nfs4_ol_stateid *openlockstateid(struct nfs4_stid *s)
|
|
|
|
{
|
|
|
|
return container_of(s, struct nfs4_ol_stateid, st_stid);
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* flags for preprocess_seqid_op() */
|
|
|
|
#define RD_STATE 0x00000010
|
|
|
|
#define WR_STATE 0x00000020
|
|
|
|
|
2009-04-03 13:28:41 +08:00
|
|
|
struct nfsd4_compound_state;
|
2012-07-25 20:57:45 +08:00
|
|
|
struct nfsd_net;
|
2009-04-03 13:28:41 +08:00
|
|
|
|
2012-07-25 20:57:22 +08:00
|
|
|
extern __be32 nfs4_preprocess_stateid_op(struct net *net,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
2005-04-17 06:20:36 +08:00
|
|
|
stateid_t *stateid, int flags, struct file **filp);
|
|
|
|
extern void nfs4_lock_state(void);
|
|
|
|
extern void nfs4_unlock_state(void);
|
2012-11-14 23:21:16 +08:00
|
|
|
void nfs4_remove_reclaim_record(struct nfs4_client_reclaim *, struct nfsd_net *);
|
|
|
|
extern void nfs4_release_reclaim(struct nfsd_net *);
|
|
|
|
extern struct nfs4_client_reclaim *nfsd4_find_reclaim_client(const char *recdir,
|
|
|
|
struct nfsd_net *nn);
|
2014-06-30 23:48:47 +08:00
|
|
|
extern __be32 nfs4_check_open_reclaim(clientid_t *clid,
|
|
|
|
struct nfsd4_compound_state *cstate, struct nfsd_net *nn);
|
2009-09-16 06:07:35 +08:00
|
|
|
extern int set_callback_cred(void);
|
2014-07-16 22:31:57 +08:00
|
|
|
void nfsd4_run_cb_null(struct work_struct *w);
|
|
|
|
void nfsd4_run_cb_recall(struct work_struct *w);
|
2010-10-20 05:56:52 +08:00
|
|
|
extern void nfsd4_probe_callback(struct nfs4_client *clp);
|
2010-12-10 04:52:19 +08:00
|
|
|
extern void nfsd4_probe_callback_sync(struct nfs4_client *clp);
|
2010-10-20 05:56:52 +08:00
|
|
|
extern void nfsd4_change_callback(struct nfs4_client *clp, struct nfs4_cb_conn *);
|
2005-04-17 06:20:36 +08:00
|
|
|
extern void nfsd4_cb_recall(struct nfs4_delegation *dp);
|
2010-03-04 03:52:55 +08:00
|
|
|
extern int nfsd4_create_callback_queue(void);
|
|
|
|
extern void nfsd4_destroy_callback_queue(void);
|
2010-06-05 08:04:45 +08:00
|
|
|
extern void nfsd4_shutdown_callback(struct nfs4_client *);
|
2014-07-16 22:31:57 +08:00
|
|
|
extern void nfsd4_prepare_cb_recall(struct nfs4_delegation *dp);
|
2005-04-17 06:20:36 +08:00
|
|
|
extern void nfs4_put_delegation(struct nfs4_delegation *dp);
|
2012-11-14 23:21:16 +08:00
|
|
|
extern struct nfs4_client_reclaim *nfs4_client_to_reclaim(const char *name,
|
|
|
|
struct nfsd_net *nn);
|
|
|
|
extern bool nfs4_has_reclaimed_state(const char *name, struct nfsd_net *nn);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-03-22 04:42:43 +08:00
|
|
|
/* nfs4recover operations */
|
|
|
|
extern int nfsd4_client_tracking_init(struct net *net);
|
|
|
|
extern void nfsd4_client_tracking_exit(struct net *net);
|
|
|
|
extern void nfsd4_client_record_create(struct nfs4_client *clp);
|
|
|
|
extern void nfsd4_client_record_remove(struct nfs4_client *clp);
|
|
|
|
extern int nfsd4_client_record_check(struct nfs4_client *clp);
|
2012-11-14 23:22:12 +08:00
|
|
|
extern void nfsd4_record_grace_done(struct nfsd_net *nn, time_t boot_time);
|
2012-11-27 22:35:10 +08:00
|
|
|
|
|
|
|
/* nfs fault injection functions */
|
|
|
|
#ifdef CONFIG_NFSD_FAULT_INJECTION
|
|
|
|
int nfsd_fault_inject_init(void);
|
|
|
|
void nfsd_fault_inject_cleanup(void);
|
2012-11-30 00:40:43 +08:00
|
|
|
u64 nfsd_for_n_state(u64, u64 (*)(struct nfs4_client *, u64));
|
2012-11-30 00:40:46 +08:00
|
|
|
struct nfs4_client *nfsd_find_client(struct sockaddr_storage *, size_t);
|
2012-11-30 00:40:43 +08:00
|
|
|
|
|
|
|
u64 nfsd_forget_client(struct nfs4_client *, u64);
|
|
|
|
u64 nfsd_forget_client_locks(struct nfs4_client*, u64);
|
|
|
|
u64 nfsd_forget_client_openowners(struct nfs4_client *, u64);
|
|
|
|
u64 nfsd_forget_client_delegations(struct nfs4_client *, u64);
|
|
|
|
u64 nfsd_recall_client_delegations(struct nfs4_client *, u64);
|
2012-11-30 00:40:44 +08:00
|
|
|
|
|
|
|
u64 nfsd_print_client(struct nfs4_client *, u64);
|
|
|
|
u64 nfsd_print_client_locks(struct nfs4_client *, u64);
|
|
|
|
u64 nfsd_print_client_openowners(struct nfs4_client *, u64);
|
|
|
|
u64 nfsd_print_client_delegations(struct nfs4_client *, u64);
|
2012-11-27 22:35:10 +08:00
|
|
|
#else /* CONFIG_NFSD_FAULT_INJECTION */
|
|
|
|
static inline int nfsd_fault_inject_init(void) { return 0; }
|
|
|
|
static inline void nfsd_fault_inject_cleanup(void) {}
|
|
|
|
#endif /* CONFIG_NFSD_FAULT_INJECTION */
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif /* NFSD4_STATE_H */
|