Fix a client tail -f vs server-appended file data corruption case by
[dragonfly.git] / sys / vfs / nfs / nfsnode.h
1 /*
2  * Copyright (c) 1989, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Rick Macklem at The University of Guelph.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by the University of
19  *      California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  *      @(#)nfsnode.h   8.9 (Berkeley) 5/14/95
37  * $FreeBSD: /repoman/r/ncvs/src/sys/nfsclient/nfsnode.h,v 1.43 2004/04/14 23:23:55 peadar Exp $
38  * $DragonFly: src/sys/vfs/nfs/nfsnode.h,v 1.7 2004/04/23 18:01:07 dillon Exp $
39  */
40
41
42 #ifndef _NFS_NFSNODE_H_
43 #define _NFS_NFSNODE_H_
44
45 #if !defined(_NFS_NFS_H_) && !defined(_KERNEL)
46 #include "nfs.h"
47 #endif
48
49 /*
50  * Silly rename structure that hangs off the nfsnode until the name
51  * can be removed by nfs_inactive()
52  */
53 struct sillyrename {
54         struct  ucred *s_cred;
55         struct  vnode *s_dvp;
56         long    s_namlen;
57         char    s_name[20];
58 };
59
60 /*
61  * This structure is used to save the logical directory offset to
62  * NFS cookie mappings.
63  * The mappings are stored in a list headed
64  * by n_cookies, as required.
65  * There is one mapping for each NFS_DIRBLKSIZ bytes of directory information
66  * stored in increasing logical offset byte order.
67  */
68 #define NFSNUMCOOKIES           31
69
70 struct nfsdmap {
71         LIST_ENTRY(nfsdmap)     ndm_list;
72         int                     ndm_eocookie;
73         nfsuint64               ndm_cookies[NFSNUMCOOKIES];
74 };
75
76 /*
77  * The nfsnode is the nfs equivalent to ufs's inode. Any similarity
78  * is purely coincidental.  There is a unique nfsnode allocated for
79  * each active file, each current directory, each mounted-on file,
80  * text file, and the root.
81  *
82  * An nfsnode is 'named' by its file handle. (nget/nfs_node.c)
83  *
84  * File handles are accessed via n_fhp, which will point to n_fh if the
85  * file handle is small enough (<= NFS_SMALLFH).  Otherwise the file handle 
86  * will be allocated.
87  *
88  * DragonFly does not pass ucreds to read and write operations, since such
89  * operations are not possible unless the ucred has already been validated.
90  * Validating ucreds are stored in nfsnode to pass on to NFS read/write RPCs.
91  */
92 struct nfsnode {
93         struct lock             n_lock;
94         LIST_ENTRY(nfsnode)     n_hash;         /* Hash chain */
95         CIRCLEQ_ENTRY(nfsnode)  n_timer;        /* Nqnfs timer chain */
96         u_quad_t                n_size;         /* Current size of file */
97         u_quad_t                n_brev;         /* Modify rev when cached */
98         u_quad_t                n_lrev;         /* Modify rev for lease */
99         struct vattr            n_vattr;        /* Vnode attribute cache */
100         time_t                  n_attrstamp;    /* Attr. cache timestamp */
101         u_int32_t               n_mode;         /* ACCESS mode cache */
102         uid_t                   n_modeuid;      /* credentials having mode */
103         time_t                  n_modestamp;    /* mode cache timestamp */
104         time_t                  n_mtime;        /* Prev modify time. */
105         time_t                  n_ctime;        /* Prev create time. */
106         time_t                  n_expiry;       /* Lease expiry time */
107         nfsfh_t                 *n_fhp;         /* NFS File Handle */
108         struct ucred            *n_rucred;
109         struct ucred            *n_wucred;
110         struct vnode            *n_vnode;       /* associated vnode */
111         struct lockf            *n_lockf;       /* Locking record of file */
112         int                     n_error;        /* Save write error value */
113         union {
114                 struct timespec nf_atim;        /* Special file times */
115                 nfsuint64       nd_cookieverf;  /* Cookie verifier (dir only) */
116         } n_un1;
117         union {
118                 struct timespec nf_mtim;
119                 off_t           nd_direof;      /* Dir. EOF offset cache */
120         } n_un2;
121         union {
122                 struct sillyrename *nf_silly;   /* Ptr to silly rename struct */
123                 LIST_HEAD(, nfsdmap) nd_cook;   /* cookies */
124         } n_un3;
125         short                   n_fhsize;       /* size in bytes, of fh */
126         short                   n_flag;         /* Flag for locking.. */
127         nfsfh_t                 n_fh;           /* Small File Handle */
128         struct lock             n_rslock;
129 };
130
131 #define n_atim          n_un1.nf_atim
132 #define n_mtim          n_un2.nf_mtim
133 #define n_sillyrename   n_un3.nf_silly
134 #define n_cookieverf    n_un1.nd_cookieverf
135 #define n_direofoffset  n_un2.nd_direof
136 #define n_cookies       n_un3.nd_cook
137
138 /*
139  * Flags for n_flag
140  */
141 #define NFLUSHWANT      0x0001  /* Want wakeup from a flush in prog. */
142 #define NFLUSHINPROG    0x0002  /* Avoid multiple calls to vinvalbuf() */
143 #define NMODIFIED       0x0004  /* Might have a modified buffer in bio */
144 #define NWRITEERR       0x0008  /* Flag write errors so close will know */
145 #define NQNFSNONCACHE   0x0020  /* Non-cachable lease */
146 #define NQNFSWRITE      0x0040  /* Write lease */
147 #define NQNFSEVICTED    0x0080  /* Has been evicted */
148 #define NACC            0x0100  /* Special file accessed */
149 #define NUPD            0x0200  /* Special file updated */
150 #define NCHG            0x0400  /* Special file times changed */
151 #define NLOCKED         0x0800  /* node is locked */
152 #define NWANTED         0x0100  /* someone wants to lock */
153 #define NSIZECHANGED    0x2000  /* File size has changed: need cache inval */
154
155 /*
156  * Convert between nfsnode pointers and vnode pointers
157  */
158 #define VTONFS(vp)      ((struct nfsnode *)(vp)->v_data)
159 #define NFSTOV(np)      ((struct vnode *)(np)->n_vnode)
160
161 /*
162  * Queue head for nfsiod's
163  */
164 extern TAILQ_HEAD(nfs_bufq, buf) nfs_bufq;
165 extern struct thread *nfs_iodwant[NFS_MAXASYNCDAEMON];
166 extern struct nfsmount *nfs_iodmount[NFS_MAXASYNCDAEMON];
167
168 #if defined(_KERNEL)
169
170 /*
171  *      nfs_rslock -    Attempt to obtain lock on nfsnode
172  *
173  *      Attempt to obtain a lock on the passed nfsnode, returning ENOLCK
174  *      if the lock could not be obtained due to our having to sleep.  This
175  *      function is generally used to lock around code that modifies an
176  *      NFS file's size.  In order to avoid deadlocks the lock
177  *      should not be obtained while other locks are being held.
178  */
179
180 static __inline
181 int
182 nfs_rslock(struct nfsnode *np, struct thread *td)
183 {
184         return(lockmgr(&np->n_rslock, LK_EXCLUSIVE | LK_CANRECURSE | LK_SLEEPFAIL, NULL, td));
185 }
186
187 static __inline
188 void
189 nfs_rsunlock(struct nfsnode *np, struct thread *td)
190 {
191         (void)lockmgr(&np->n_rslock, LK_RELEASE, NULL, td);
192 }
193
194 static __inline
195 struct ucred *
196 nfs_vpcred(struct vnode *vp, int ndflag)
197 {
198         struct nfsnode *np = VTONFS(vp);
199
200         if (np && (ndflag & ND_WRITE) && np->n_wucred)
201                 return(np->n_wucred);
202         if (np && (ndflag & ND_READ) && np->n_rucred)
203                 return(np->n_rucred);
204         return(VFSTONFS((vp)->v_mount)->nm_cred);
205 }
206
207 extern  vop_t   **fifo_nfsv2nodeop_p;
208 extern  vop_t   **nfsv2_vnodeop_p;
209 extern  vop_t   **spec_nfsv2nodeop_p;
210
211 /*
212  * Prototypes for NFS vnode operations
213  */
214 int     nfs_getpages (struct vop_getpages_args *);
215 int     nfs_putpages (struct vop_putpages_args *);
216 int     nfs_write (struct vop_write_args *);
217 int     nqnfs_vop_lease_check (struct vop_lease_args *);
218 int     nfs_inactive (struct vop_inactive_args *);
219 int     nfs_reclaim (struct vop_reclaim_args *);
220
221 /* other stuff */
222 int     nfs_removeit (struct sillyrename *);
223 int     nfs_nget (struct mount *,nfsfh_t *,int,struct nfsnode **);
224 nfsuint64 *nfs_getcookie (struct nfsnode *, off_t, int);
225 void nfs_invaldir (struct vnode *);
226
227 #define nqnfs_lease_updatetime  nfs_lease_updatetime
228
229 #endif /* _KERNEL */
230
231 #endif