usr/src/uts/common/nfs/rnode.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 /*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T     */
  27 /*        All Rights Reserved   */
  28
  29 #ifndef _NFS_RNODE_H
  30 #define _NFS_RNODE_H
  31
  32 #include <sys/avl.h>
  33 #include <sys/list.h>
  34 #include <nfs/nfs.h>
  35
  36 #ifdef  __cplusplus
  37 extern "C" {
  38 #endif
  39
  40 typedef enum nfs_access_type {
  41         NFS_ACCESS_UNKNOWN,
  42         NFS_ACCESS_ALLOWED,
  43         NFS_ACCESS_DENIED
  44 } nfs_access_type_t;
  45
  46 typedef struct acache_hash {
  47         struct acache *next;    /* next and prev must be first */
  48         struct acache *prev;
  49         krwlock_t lock;
  50 } acache_hash_t;
  51
  52 typedef struct acache {
  53         struct acache *next;    /* next and prev must be first */
  54         struct acache *prev;
  55         uint32_t known;
  56         uint32_t allowed;
  57         struct rnode *rnode;
  58         cred_t *cred;
  59         struct acache *list;
  60         struct acache_hash *hashq;
  61 } acache_t;
  62
  63 #define NFS_FHANDLE_LEN 72
  64
  65 typedef struct nfs_fhandle {
  66         int fh_len;
  67         char fh_buf[NFS_FHANDLE_LEN];
  68 } nfs_fhandle;
  69
  70 typedef struct rddir_cache {
  71         lloff_t _cookie;        /* cookie used to find this cache entry */
  72         lloff_t _ncookie;       /* cookie used to find the next cache entry */
  73         char *entries;          /* buffer containing dirent entries */
  74         int eof;                /* EOF reached after this request */
  75         int entlen;             /* size of dirent entries in buf */
  76         int buflen;             /* size of the buffer used to store entries */
  77         int flags;              /* control flags, see below */
  78         kcondvar_t cv;          /* cv for blocking */
  79         int error;              /* error from RPC operation */
  80         kmutex_t lock;
  81         uint_t count;           /* reference count */
  82         avl_node_t tree;        /* AVL tree links */
  83 } rddir_cache;
  84
  85 #define nfs_cookie      _cookie._p._l
  86 #define nfs_ncookie     _ncookie._p._l
  87 #define nfs3_cookie     _cookie._f
  88 #define nfs3_ncookie    _ncookie._f
  89
  90 #define RDDIR           0x1     /* readdir operation in progress */
  91 #define RDDIRWAIT       0x2     /* waiting on readdir in progress */
  92 #define RDDIRREQ        0x4     /* a new readdir is required */
  93 #define RDDIRCACHED     0x8     /* entry is in the cache */
  94
  95 #define HAVE_RDDIR_CACHE(rp)    (avl_numnodes(&(rp)->r_dir) > 0)
  96
  97 typedef struct symlink_cache {
  98         char *contents;         /* contents of the symbolic link */
  99         int len;                /* length of the contents */
 100         int size;               /* size of the allocated buffer */
 101 } symlink_cache;
 102
 103 typedef struct commit {
 104         page_t *c_pages;        /* list of pages to commit */
 105         offset3 c_commbase;     /* base offset to do commit from */
 106         count3 c_commlen;       /* len to commit */
 107         kcondvar_t c_cv;        /* condvar for waiting for commit */
 108 } commit_t;
 109
 110 /*
 111  * The various values for the commit states.  These are stored in
 112  * the p_fsdata byte in the page struct.
 113  * NFSv3,4 can use asynchronous writes - the NFS server can send a response
 114  * before storing the data to the stable store (disk). The response contains
 115  * information if the data are on a disk or not. NFS client marks pages
 116  * which are already on the stable store as C_NOCOMMIT. The pages which were
 117  * sent but are not yet on the stable store are only partially 'safe' and are
 118  * marked as C_DELAYCOMMIT, which can be later changed to C_COMMIT if the
 119  * commit operation is in progress. If the NFS server is e.g. rebooted, the
 120  * client needs to resend all the uncommitted data. The client walks all the
 121  * vp->v_pages and if C_DELAYCOMMIT or C_COMMIT is set, the page is marked as
 122  * dirty and thus will be written to the server again.
 123  */
 124 #define C_NOCOMMIT      0       /* no commit is required */
 125 #define C_COMMIT        1       /* a commit is required so do it now */
 126 #define C_DELAYCOMMIT   2       /* a commit is required, but can be delayed */
 127
 128 /*
 129  * The lock manager holds state making it possible for the client
 130  * and server to be out of sync.  For example, if the response from
 131  * the server granting a lock request is lost, the server will think
 132  * the lock is granted and the client will think the lock is lost.
 133  * To deal with this, a list of processes for which the client is
 134  * not sure if the server holds a lock is attached to the rnode.
 135  * When such a process closes the rnode, an unlock request is sent
 136  * to the server to unlock the entire file.
 137  *
 138  * The list is kept as a singularly linked NULL terminated list.
 139  * Because it is  only added to under extreme error conditions, the
 140  * list shouldn't get very big.  DEBUG kernels print a console warning
 141  * when the number of entries on a list go beyond nfs_lmpl_high_water
 142  * an  arbitrary number defined in nfs_add_locking_id()
 143  */
 144 #define RLMPL_PID       1
 145 #define RLMPL_OWNER     2
 146 typedef struct lock_manager_pid_list {
 147         int lmpl_type;
 148         pid_t lmpl_pid;
 149         union {
 150                 pid_t _pid;
 151                 struct {
 152                         int len;
 153                         char *owner;
 154                 } _own;
 155         } un;
 156         struct lock_manager_pid_list *lmpl_next;
 157 } lmpl_t;
 158
 159 #define lmpl_opid un._pid
 160 #define lmpl_own_len un._own.len
 161 #define lmpl_owner un._own.owner
 162
 163 /*
 164  * A homegrown reader/writer lock implementation.  It addresses
 165  * two requirements not addressed by the system primitives.  They
 166  * are that the `enter" operation is optionally interruptible and
 167  * that that they can be re`enter'ed by writers without deadlock.
 168  */
 169 typedef struct nfs_rwlock {
 170         int count;
 171         int waiters;
 172         kthread_t *owner;
 173         kmutex_t lock;
 174         kcondvar_t cv;
 175 } nfs_rwlock_t;
 176
 177 /*
 178  * The format of the hash bucket used to lookup rnodes from a file handle.
 179  */
 180 typedef struct rhashq {
 181         struct rnode *r_hashf;
 182         struct rnode *r_hashb;
 183         krwlock_t r_lock;
 184 } rhashq_t;
 185
 186 /*
 187  * Remote file information structure.
 188  *
 189  * The rnode is the "inode" for remote files.  It contains all the
 190  * information necessary to handle remote file on the client side.
 191  *
 192  * Note on file sizes:  we keep two file sizes in the rnode: the size
 193  * according to the client (r_size) and the size according to the server
 194  * (r_attr.va_size).  They can differ because we modify r_size during a
 195  * write system call (nfs_rdwr), before the write request goes over the
 196  * wire (before the file is actually modified on the server).  If an OTW
 197  * request occurs before the cached data is written to the server the file
 198  * size returned from the server (r_attr.va_size) may not match r_size.
 199  * r_size is the one we use, in general.  r_attr.va_size is only used to
 200  * determine whether or not our cached data is valid.
 201  *
 202  * Each rnode has 3 locks associated with it (not including the rnode
 203  * hash table and free list locks):
 204  *
 205  *      r_rwlock:       Serializes nfs_write and nfs_setattr requests
 206  *                      and allows nfs_read requests to proceed in parallel.
 207  *                      Serializes reads/updates to directories.
 208  *
 209  *      r_lkserlock:    Serializes lock requests with map, write, and
 210  *                      readahead operations.
 211  *
 212  *      r_statelock:    Protects all fields in the rnode except for
 213  *                      those listed below.  This lock is intented
 214  *                      to be held for relatively short periods of
 215  *                      time (not accross entire putpage operations,
 216  *                      for example).
 217  *
 218  * The following members are protected by the mutex rpfreelist_lock:
 219  *      r_freef
 220  *      r_freeb
 221  *
 222  * The following members are protected by the hash bucket rwlock:
 223  *      r_hashf
 224  *      r_hashb
 225  *
 226  * Note: r_modaddr is only accessed when the r_statelock mutex is held.
 227  *      Its value is also controlled via r_rwlock.  It is assumed that
 228  *      there will be only 1 writer active at a time, so it safe to
 229  *      set r_modaddr and release r_statelock as long as the r_rwlock
 230  *      writer lock is held.
 231  *
 232  * r_inmap informs nfsX_read()/write() that there is a call to nfsX_map()
 233  * in progress. nfsX_read()/write() check r_inmap to decide whether
 234  * to perform directio on the file or not. r_inmap is atomically
 235  * incremented in nfsX_map() before the address space routines are
 236  * called and atomically decremented just before nfsX_map() exits.
 237  * r_inmap is not protected by any lock.
 238  *
 239  * r_mapcnt tells that the rnode has mapped pages. r_inmap can be 0
 240  * while the rnode has mapped pages.
 241  *
 242  * 64-bit offsets: the code formerly assumed that atomic reads of
 243  * r_size were safe and reliable; on 32-bit architectures, this is
 244  * not true since an intervening bus cycle from another processor
 245  * could update half of the size field.  The r_statelock must now
 246  * be held whenever any kind of access of r_size is made.
 247  *
 248  * Lock ordering:
 249  *      r_rwlock > r_lkserlock > r_statelock
 250  */
 251 struct exportinfo;      /* defined in nfs/export.h */
 252 struct servinfo;        /* defined in nfs/nfs_clnt.h */
 253 struct failinfo;        /* defined in nfs/nfs_clnt.h */
 254 struct mntinfo;         /* defined in nfs/nfs_clnt.h */
 255
 256 #ifdef _KERNEL
 257
 258 typedef struct rnode {
 259         /* the hash fields must be first to match the rhashq_t */
 260         struct rnode    *r_hashf;       /* hash queue forward pointer */
 261         struct rnode    *r_hashb;       /* hash queue back pointer */
 262         struct rnode    *r_freef;       /* free list forward pointer */
 263         struct rnode    *r_freeb;       /* free list back pointer */
 264         rhashq_t        *r_hashq;       /* pointer to the hash bucket */
 265         vnode_t         *r_vnode;       /* vnode for remote file */
 266         nfs_rwlock_t    r_rwlock;       /* serializes write/setattr requests */
 267         nfs_rwlock_t    r_lkserlock;    /* serialize lock with other ops */
 268         kmutex_t        r_statelock;    /* protects (most of) rnode contents */
 269         nfs_fhandle     r_fh;           /* file handle */
 270         struct servinfo *r_server;      /* current server */
 271         char            *r_path;        /* path to this rnode */
 272         u_offset_t      r_nextr;        /* next byte read offset (read-ahead) */
 273         cred_t          *r_cred;        /* current credentials */
 274         cred_t          *r_unlcred;     /* unlinked credentials */
 275         char            *r_unlname;     /* unlinked file name */
 276         vnode_t         *r_unldvp;      /* parent dir of unlinked file */
 277         len_t           r_size;         /* client's view of file size */
 278         struct vattr    r_attr;         /* cached vnode attributes */
 279         hrtime_t        r_attrtime;     /* time attributes become invalid */
 280         hrtime_t        r_mtime;        /* client time file last modified */
 281         long            r_mapcnt;       /* count of mmapped pages */
 282         uint_t          r_count;        /* # of refs not reflect in v_count */
 283         uint_t          r_awcount;      /* # of outstanding async write */
 284         uint_t          r_gcount;       /* getattrs waiting to flush pages */
 285         ushort_t        r_flags;        /* flags, see below */
 286         short           r_error;        /* async write error */
 287         kcondvar_t      r_cv;           /* condvar for blocked threads */
 288         int             (*r_putapage)   /* address of putapage routine */
 289                 (vnode_t *, page_t *, u_offset_t *, size_t *, int, cred_t *);
 290         avl_tree_t      r_dir;          /* cache of readdir responses */
 291         rddir_cache     *r_direof;      /* pointer to the EOF entry */
 292         symlink_cache   r_symlink;      /* cached readlink response */
 293         writeverf3      r_verf;         /* version 3 write verifier */
 294         u_offset_t      r_modaddr;      /* address for page in writerp */
 295         commit_t        r_commit;       /* commit information */
 296         u_offset_t      r_truncaddr;    /* base for truncate operation */
 297         vsecattr_t      *r_secattr;     /* cached security attributes (acls) */
 298         cookieverf3     r_cookieverf;   /* version 3 readdir cookie verifier */
 299         lmpl_t          *r_lmpl;        /* pids that may be holding locks */
 300         nfs3_pathconf_info *r_pathconf; /* cached pathconf information */
 301         acache_t        *r_acache;      /* list of access cache entries */
 302         kthread_t       *r_serial;      /* id of purging thread */
 303         list_t          r_indelmap;     /* list of delmap callers */
 304         uint_t          r_inmap;        /* to serialize read/write and mmap */
 305 } rnode_t;
 306 #endif /* _KERNEL */
 307
 308 /*
 309  * Flags
 310  */
 311 #define RREADDIRPLUS    0x1     /* issue a READDIRPLUS instead of READDIR */
 312 #define RDIRTY          0x2     /* dirty pages from write operation */
 313 #define RSTALE          0x4     /* file handle is stale */
 314 #define RMODINPROGRESS  0x8     /* page modification happening */
 315 #define RTRUNCATE       0x10    /* truncating, don't commit */
 316 #define RHAVEVERF       0x20    /* have a write verifier to compare against */
 317 #define RCOMMIT         0x40    /* commit in progress */
 318 #define RCOMMITWAIT     0x80    /* someone is waiting to do a commit */
 319 #define RHASHED         0x100   /* rnode is in hash queues */
 320 #define ROUTOFSPACE     0x200   /* an out of space error has happened */
 321 #define RDIRECTIO       0x400   /* bypass the buffer cache */
 322 #define RLOOKUP         0x800   /* a lookup has been performed */
 323 #define RWRITEATTR      0x1000  /* attributes came from WRITE */
 324 #define RINDNLCPURGE    0x2000  /* in the process of purging DNLC references */
 325 #define RDELMAPLIST     0x4000  /* delmap callers tracking for as callback */
 326 #define RINCACHEPURGE   0x8000  /* purging caches due to file size change */
 327
 328 /*
 329  * Convert between vnode and rnode
 330  */
 331 #define RTOV(rp)        ((rp)->r_vnode)
 332 #define VTOR(vp)        ((rnode_t *)((vp)->v_data))
 333
 334 #define VTOFH(vp)       (RTOFH(VTOR(vp)))
 335 #define RTOFH(rp)       ((fhandle_t *)(&(rp)->r_fh.fh_buf))
 336 #define VTOFH3(vp)      (RTOFH3(VTOR(vp)))
 337 #define RTOFH3(rp)      ((nfs_fh3 *)(&(rp)->r_fh))
 338
 339 #ifdef _KERNEL
 340 extern int      nfs_async_readahead(vnode_t *, u_offset_t, caddr_t,
 341                                 struct seg *, cred_t *,
 342                                 void (*)(vnode_t *, u_offset_t,
 343                                 caddr_t, struct seg *, cred_t *));
 344 extern int      nfs_async_putapage(vnode_t *, page_t *, u_offset_t, size_t,
 345                                 int, cred_t *, int (*)(vnode_t *, page_t *,
 346                                 u_offset_t, size_t, int, cred_t *));
 347 extern int      nfs_async_pageio(vnode_t *, page_t *, u_offset_t, size_t,
 348                                 int, cred_t *, int (*)(vnode_t *, page_t *,
 349                                 u_offset_t, size_t, int, cred_t *));
 350 extern void     nfs_async_readdir(vnode_t *, rddir_cache *,
 351                                 cred_t *, int (*)(vnode_t *,
 352                                 rddir_cache *, cred_t *));
 353 extern void     nfs_async_commit(vnode_t *, page_t *, offset3, count3,
 354                                 cred_t *, void (*)(vnode_t *, page_t *,
 355                                 offset3, count3, cred_t *));
 356 extern void     nfs_async_inactive(vnode_t *, cred_t *, void (*)(vnode_t *,
 357                                 cred_t *, caller_context_t *));
 358 extern int      writerp(rnode_t *, caddr_t, int, struct uio *, int);
 359 extern int      nfs_putpages(vnode_t *, u_offset_t, size_t, int, cred_t *);
 360 extern void     nfs_invalidate_pages(vnode_t *, u_offset_t, cred_t *);
 361 extern int      rfs2call(struct mntinfo *, rpcproc_t, xdrproc_t, caddr_t,
 362                         xdrproc_t, caddr_t, cred_t *, int *, enum nfsstat *,
 363                         int, struct failinfo *);
 364 extern int      rfs3call(struct mntinfo *, rpcproc_t, xdrproc_t, caddr_t,
 365                         xdrproc_t, caddr_t, cred_t *, int *, nfsstat3 *,
 366                         int, struct failinfo *);
 367 extern void     nfs_setswaplike(vnode_t *, vattr_t *);
 368 extern vnode_t  *makenfsnode(fhandle_t *, struct nfsfattr *, struct vfs *,
 369                         hrtime_t, cred_t *, char *, char *);
 370 extern vnode_t  *makenfs3node_va(nfs_fh3 *, vattr_t *, struct vfs *, hrtime_t,
 371                         cred_t *, char *, char *);
 372 extern vnode_t  *makenfs3node(nfs_fh3 *, fattr3 *, struct vfs *, hrtime_t,
 373                         cred_t *, char *, char *);
 374 extern void     rp_addfree(rnode_t *, cred_t *);
 375 extern void     rp_rmhash(rnode_t *);
 376 extern int      check_rtable(struct vfs *);
 377 extern void     destroy_rtable(struct vfs *, cred_t *);
 378 extern void     rflush(struct vfs *, cred_t *);
 379 extern nfs_access_type_t nfs_access_check(rnode_t *, uint32_t, cred_t *);
 380 extern void     nfs_access_cache(rnode_t *rp, uint32_t, uint32_t, cred_t *);
 381 extern int      nfs_access_purge_rp(rnode_t *);
 382 extern int      nfs_putapage(vnode_t *, page_t *, u_offset_t *, size_t *,
 383                         int, cred_t *);
 384 extern int      nfs3_putapage(vnode_t *, page_t *, u_offset_t *, size_t *,
 385                         int, cred_t *);
 386 extern void     nfs_printfhandle(nfs_fhandle *);
 387 extern void     nfs_write_error(vnode_t *, int, cred_t *);
 388 extern rddir_cache      *rddir_cache_alloc(int);
 389 extern void             rddir_cache_hold(rddir_cache *);
 390 extern void             rddir_cache_rele(rddir_cache *);
 391 #ifdef DEBUG
 392 extern char             *rddir_cache_buf_alloc(size_t, int);
 393 extern void             rddir_cache_buf_free(void *, size_t);
 394 #endif
 395 extern int      nfs_rw_enter_sig(nfs_rwlock_t *, krw_t, int);
 396 extern int      nfs_rw_tryenter(nfs_rwlock_t *, krw_t);
 397 extern void     nfs_rw_exit(nfs_rwlock_t *);
 398 extern int      nfs_rw_lock_held(nfs_rwlock_t *, krw_t);
 399 extern void     nfs_rw_init(nfs_rwlock_t *, char *, krw_type_t, void *);
 400 extern void     nfs_rw_destroy(nfs_rwlock_t *);
 401 extern int      nfs_directio(vnode_t *, int, cred_t *);
 402 extern int      nfs3_rddir_compar(const void *, const void *);
 403 extern int      nfs_rddir_compar(const void *, const void *);
 404 extern struct zone *nfs_zone(void);
 405 extern zoneid_t nfs_zoneid(void);
 406
 407 #endif
 408
 409 #ifdef  __cplusplus
 410 }
 411 #endif
 412
 413 #endif  /* _NFS_RNODE_H */