home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / linux / nfsd / state.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  10.9 KB  |  311 lines

  1. /*
  2.  *  linux/include/nfsd/state.h
  3.  *
  4.  *  Copyright (c) 2001 The Regents of the University of Michigan.
  5.  *  All rights reserved.
  6.  *
  7.  *  Kendrick Smith <kmsmith@umich.edu>
  8.  *  Andy Adamson <andros@umich.edu>
  9.  *  
  10.  *  Redistribution and use in source and binary forms, with or without
  11.  *  modification, are permitted provided that the following conditions
  12.  *  are met:
  13.  *  
  14.  *  1. Redistributions of source code must retain the above copyright
  15.  *     notice, this list of conditions and the following disclaimer.
  16.  *  2. Redistributions in binary form must reproduce the above copyright
  17.  *     notice, this list of conditions and the following disclaimer in the
  18.  *     documentation and/or other materials provided with the distribution.
  19.  *  3. Neither the name of the University nor the names of its
  20.  *     contributors may be used to endorse or promote products derived
  21.  *     from this software without specific prior written permission.
  22.  *
  23.  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  24.  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  25.  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  26.  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27.  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28.  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29.  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  30.  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  31.  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  32.  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  33.  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34.  *
  35.  */
  36.  
  37. #ifndef _NFSD4_STATE_H
  38. #define _NFSD4_STATE_H
  39.  
  40. #include <linux/list.h>
  41. #include <linux/kref.h>
  42. #include <linux/sunrpc/clnt.h>
  43.  
  44. #define NFS4_OPAQUE_LIMIT 1024
  45. typedef struct {
  46.     u32             cl_boot;
  47.     u32             cl_id;
  48. } clientid_t;
  49.  
  50. typedef struct {
  51.     u32             so_boot;
  52.     u32             so_stateownerid;
  53.     u32             so_fileid;
  54. } stateid_opaque_t;
  55.  
  56. typedef struct {
  57.     u32                     si_generation;
  58.     stateid_opaque_t        si_opaque;
  59. } stateid_t;
  60. #define si_boot           si_opaque.so_boot
  61. #define si_stateownerid   si_opaque.so_stateownerid
  62. #define si_fileid         si_opaque.so_fileid
  63.  
  64.  
  65. struct nfs4_cb_recall {
  66.     u32            cbr_ident;
  67.     int            cbr_trunc;
  68.     stateid_t        cbr_stateid;
  69.     u32            cbr_fhlen;
  70.     u32            cbr_fhval[NFS4_FHSIZE];
  71.     struct nfs4_delegation    *cbr_dp;
  72. };
  73.  
  74. struct nfs4_delegation {
  75.     struct list_head    dl_perfile;
  76.     struct list_head    dl_perclnt;
  77.     struct list_head    dl_recall_lru;  /* delegation recalled */
  78.     atomic_t        dl_count;       /* ref count */
  79.     struct nfs4_client    *dl_client;
  80.     struct nfs4_file    *dl_file;
  81.     struct file_lock    *dl_flock;
  82.     struct file        *dl_vfs_file;
  83.     u32            dl_type;
  84.     time_t            dl_time;
  85.     struct nfs4_cb_recall    dl_recall;
  86. };
  87.  
  88. #define dl_stateid      dl_recall.cbr_stateid
  89. #define dl_fhlen        dl_recall.cbr_fhlen
  90. #define dl_fhval        dl_recall.cbr_fhval
  91.  
  92. /* client delegation callback info */
  93. struct nfs4_callback {
  94.     /* SETCLIENTID info */
  95.     u32                     cb_addr;
  96.     unsigned short          cb_port;
  97.     u32                     cb_prog;
  98.     u32                     cb_ident;
  99.     /* RPC client info */
  100.     atomic_t        cb_set;     /* successful CB_NULL call */
  101.     struct rpc_program      cb_program;
  102.     struct rpc_stat         cb_stat;
  103.     struct rpc_clnt *       cb_client;
  104. };
  105.  
  106. #define HEXDIR_LEN     33 /* hex version of 16 byte md5 of cl_name plus '\0' */
  107.  
  108. /*
  109.  * struct nfs4_client - one per client.  Clientids live here.
  110.  *     o Each nfs4_client is hashed by clientid.
  111.  *
  112.  *     o Each nfs4_clients is also hashed by name 
  113.  *       (the opaque quantity initially sent by the client to identify itself).
  114.  *       
  115.  *    o cl_perclient list is used to ensure no dangling stateowner references
  116.  *      when we expire the nfs4_client
  117.  */
  118. struct nfs4_client {
  119.     struct list_head    cl_idhash;     /* hash by cl_clientid.id */
  120.     struct list_head    cl_strhash;     /* hash by cl_name */
  121.     struct list_head    cl_openowners;
  122.     struct list_head    cl_delegations;
  123.     struct list_head        cl_lru;         /* tail queue */
  124.     struct xdr_netobj    cl_name;     /* id generated by client */
  125.     char                    cl_recdir[HEXDIR_LEN]; /* recovery dir */
  126.     nfs4_verifier        cl_verifier;     /* generated by client */
  127.     time_t                  cl_time;        /* time of last lease renewal */
  128.     u32            cl_addr;     /* client ipaddress */
  129.     struct svc_cred        cl_cred;     /* setclientid principal */
  130.     clientid_t        cl_clientid;    /* generated by server */
  131.     nfs4_verifier        cl_confirm;    /* generated by server */
  132.     struct nfs4_callback    cl_callback;    /* callback info */
  133.     atomic_t        cl_count;    /* ref count */
  134.     u32            cl_firststate;    /* recovery dir creation */
  135. };
  136.  
  137. /* struct nfs4_client_reset
  138.  * one per old client. Populates reset_str_hashtbl. Filled from conf_id_hashtbl
  139.  * upon lease reset, or from upcall to state_daemon (to read in state
  140.  * from non-volitile storage) upon reboot.
  141.  */
  142. struct nfs4_client_reclaim {
  143.     struct list_head    cr_strhash;    /* hash by cr_name */
  144.     char            cr_recdir[HEXDIR_LEN]; /* recover dir */
  145. };
  146.  
  147. static inline void
  148. update_stateid(stateid_t *stateid)
  149. {
  150.     stateid->si_generation++;
  151. }
  152.  
  153. /* A reasonable value for REPLAY_ISIZE was estimated as follows:  
  154.  * The OPEN response, typically the largest, requires 
  155.  *   4(status) + 8(stateid) + 20(changeinfo) + 4(rflags) +  8(verifier) + 
  156.  *   4(deleg. type) + 8(deleg. stateid) + 4(deleg. recall flag) + 
  157.  *   20(deleg. space limit) + ~32(deleg. ace) = 112 bytes 
  158.  */
  159.  
  160. #define NFSD4_REPLAY_ISIZE       112 
  161.  
  162. /*
  163.  * Replay buffer, where the result of the last seqid-mutating operation 
  164.  * is cached. 
  165.  */
  166. struct nfs4_replay {
  167.     u32            rp_status;
  168.     unsigned int        rp_buflen;
  169.     char            *rp_buf;
  170.     unsigned        intrp_allocated;
  171.     int            rp_openfh_len;
  172.     char            rp_openfh[NFS4_FHSIZE];
  173.     char            rp_ibuf[NFSD4_REPLAY_ISIZE];
  174. };
  175.  
  176. /*
  177. * nfs4_stateowner can either be an open_owner, or a lock_owner
  178. *
  179. *    so_idhash:  stateid_hashtbl[] for open owner, lockstateid_hashtbl[]
  180. *         for lock_owner
  181. *    so_strhash: ownerstr_hashtbl[] for open_owner, lock_ownerstr_hashtbl[]
  182. *         for lock_owner
  183. *    so_perclient: nfs4_client->cl_perclient entry - used when nfs4_client
  184. *         struct is reaped.
  185. *    so_perfilestate: heads the list of nfs4_stateid (either open or lock) 
  186. *         and is used to ensure no dangling nfs4_stateid references when we 
  187. *         release a stateowner.
  188. *    so_perlockowner: (open) nfs4_stateid->st_perlockowner entry - used when
  189. *         close is called to reap associated byte-range locks
  190. *    so_close_lru: (open) stateowner is placed on this list instead of being
  191. *         reaped (when so_perfilestate is empty) to hold the last close replay.
  192. *         reaped by laundramat thread after lease period.
  193. */
  194. struct nfs4_stateowner {
  195.     struct kref        so_ref;
  196.     struct list_head        so_idhash;   /* hash by so_id */
  197.     struct list_head        so_strhash;   /* hash by op_name */
  198.     struct list_head        so_perclient;
  199.     struct list_head        so_stateids;
  200.     struct list_head        so_perstateid; /* for lockowners only */
  201.     struct list_head    so_close_lru; /* tail queue */
  202.     time_t            so_time; /* time of placement on so_close_lru */
  203.     int            so_is_open_owner; /* 1=openowner,0=lockowner */
  204.     u32                     so_id;
  205.     struct nfs4_client *    so_client;
  206.     /* after increment in ENCODE_SEQID_OP_TAIL, represents the next
  207.      * sequence id expected from the client: */
  208.     u32                     so_seqid;
  209.     struct xdr_netobj       so_owner;     /* open owner name */
  210.     int                     so_confirmed; /* successful OPEN_CONFIRM? */
  211.     struct nfs4_replay    so_replay;
  212. };
  213.  
  214. /*
  215. *  nfs4_file: a file opened by some number of (open) nfs4_stateowners.
  216. *    o fi_perfile list is used to search for conflicting 
  217. *      share_acces, share_deny on the file.
  218. */
  219. struct nfs4_file {
  220.     struct kref        fi_ref;
  221.     struct list_head        fi_hash;    /* hash by "struct inode *" */
  222.     struct list_head        fi_stateids;
  223.     struct list_head    fi_delegations;
  224.     struct inode        *fi_inode;
  225.     u32                     fi_id;      /* used with stateowner->so_id 
  226.                          * for stateid_hashtbl hash */
  227. };
  228.  
  229. /*
  230. * nfs4_stateid can either be an open stateid or (eventually) a lock stateid
  231. *
  232. * (open)nfs4_stateid: one per (open)nfs4_stateowner, nfs4_file
  233. *
  234. *     st_hash: stateid_hashtbl[] entry or lockstateid_hashtbl entry
  235. *     st_perfile: file_hashtbl[] entry.
  236. *     st_perfile_state: nfs4_stateowner->so_perfilestate
  237. *       st_perlockowner: (open stateid) list of lock nfs4_stateowners
  238. *     st_access_bmap: used only for open stateid
  239. *     st_deny_bmap: used only for open stateid
  240. *    st_openstp: open stateid lock stateid was derived from
  241. *
  242. * XXX: open stateids and lock stateids have diverged sufficiently that
  243. * we should consider defining separate structs for the two cases.
  244. */
  245.  
  246. struct nfs4_stateid {
  247.     struct list_head              st_hash; 
  248.     struct list_head              st_perfile;
  249.     struct list_head              st_perstateowner;
  250.     struct list_head              st_lockowners;
  251.     struct nfs4_stateowner      * st_stateowner;
  252.     struct nfs4_file            * st_file;
  253.     stateid_t                     st_stateid;
  254.     struct file                 * st_vfs_file;
  255.     unsigned long                 st_access_bmap;
  256.     unsigned long                 st_deny_bmap;
  257.     struct nfs4_stateid         * st_openstp;
  258. };
  259.  
  260. /* flags for preprocess_seqid_op() */
  261. #define CHECK_FH                0x00000001
  262. #define CONFIRM                 0x00000002
  263. #define OPEN_STATE              0x00000004
  264. #define LOCK_STATE              0x00000008
  265. #define RD_STATE            0x00000010
  266. #define WR_STATE            0x00000020
  267. #define CLOSE_STATE             0x00000040
  268. #define DELEG_RET               0x00000080
  269.  
  270. #define seqid_mutating_err(err)                       \
  271.     (((err) != nfserr_stale_clientid) &&    \
  272.     ((err) != nfserr_bad_seqid) &&          \
  273.     ((err) != nfserr_stale_stateid) &&      \
  274.     ((err) != nfserr_bad_stateid))
  275.  
  276. extern int nfsd4_renew(clientid_t *clid);
  277. extern int nfs4_preprocess_stateid_op(struct svc_fh *current_fh, 
  278.         stateid_t *stateid, int flags, struct file **filp);
  279. extern void nfs4_lock_state(void);
  280. extern void nfs4_unlock_state(void);
  281. extern int nfs4_in_grace(void);
  282. extern int nfs4_check_open_reclaim(clientid_t *clid);
  283. extern void put_nfs4_client(struct nfs4_client *clp);
  284. extern void nfs4_free_stateowner(struct kref *kref);
  285. extern void nfsd4_probe_callback(struct nfs4_client *clp);
  286. extern void nfsd4_cb_recall(struct nfs4_delegation *dp);
  287. extern void nfs4_put_delegation(struct nfs4_delegation *dp);
  288. extern int nfs4_make_rec_clidname(char *clidname, struct xdr_netobj *clname);
  289. extern void nfsd4_init_recdir(char *recdir_name);
  290. extern int nfsd4_recdir_load(void);
  291. extern void nfsd4_shutdown_recdir(void);
  292. extern int nfs4_client_to_reclaim(const char *name);
  293. extern int nfs4_has_reclaimed_state(const char *name);
  294. extern void nfsd4_recdir_purge_old(void);
  295. extern int nfsd4_create_clid_dir(struct nfs4_client *clp);
  296. extern void nfsd4_remove_clid_dir(struct nfs4_client *clp);
  297.  
  298. static inline void
  299. nfs4_put_stateowner(struct nfs4_stateowner *so)
  300. {
  301.     kref_put(&so->so_ref, nfs4_free_stateowner);
  302. }
  303.  
  304. static inline void
  305. nfs4_get_stateowner(struct nfs4_stateowner *so)
  306. {
  307.     kref_get(&so->so_ref);
  308. }
  309.  
  310. #endif   /* NFSD4_STATE_H */
  311.