xref: /titanic_52/usr/src/uts/common/nfs/rnode.h (revision 3f7d54a6b84904c8f4d8daa4c7b577bede7df8b9)
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 */
414