1/*
2 * Copyright (c) 2000-2011 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
29/*
30 * Copyright (c) 1989, 1993
31 * The Regents of the University of California. All rights reserved.
32 *
33 * This code is derived from software contributed to Berkeley by
34 * Rick Macklem at The University of Guelph.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 * 1. Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
41 * 2. Redistributions in binary form must reproduce the above copyright
42 * notice, this list of conditions and the following disclaimer in the
43 * documentation and/or other materials provided with the distribution.
44 * 3. All advertising materials mentioning features or use of this software
45 * must display the following acknowledgement:
46 * This product includes software developed by the University of
47 * California, Berkeley and its contributors.
48 * 4. Neither the name of the University nor the names of its contributors
49 * may be used to endorse or promote products derived from this software
50 * without specific prior written permission.
51 *
52 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
53 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
54 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
55 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
56 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
57 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
58 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
59 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
60 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
61 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
62 * SUCH DAMAGE.
63 *
64 * @(#)nfsnode.h 8.9 (Berkeley) 5/14/95
65 * FreeBSD-Id: nfsnode.h,v 1.24 1997/10/28 14:06:25 bde Exp $
66 */
67
68
69#ifndef _NFS_NFSNODE_H_
70#define _NFS_NFSNODE_H_
71
72#include <sys/appleapiopts.h>
73
74#ifdef __APPLE_API_PRIVATE
75#ifndef _NFS_NFS_H_
76#include <nfs/nfs.h>
77#endif
78#include <sys/kauth.h>
79
80/*
81 * Silly rename structure that hangs off the nfsnode until the name
82 * can be removed by nfs_vnop_inactive()
83 */
84struct nfs_sillyrename {
85 kauth_cred_t nsr_cred;
86 struct nfsnode *nsr_dnp;
87 int nsr_namlen;
88 char nsr_name[20];
89};
90
91/*
92 * The nfsbuf is the nfs equivalent to a struct buf.
93 */
94struct nfsbuf {
95 LIST_ENTRY(nfsbuf) nb_hash; /* hash chain */
96 LIST_ENTRY(nfsbuf) nb_vnbufs; /* nfsnode's nfsbuf chain */
97 TAILQ_ENTRY(nfsbuf) nb_free; /* free list position if not active. */
98 volatile uint32_t nb_flags; /* NB_* flags. */
99 volatile uint32_t nb_lflags; /* NBL_* flags. */
100 volatile uint32_t nb_refs; /* outstanding references. */
101 uint32_t nb_bufsize; /* buffer size */
102 daddr64_t nb_lblkno; /* logical block number. */
103 uint64_t nb_verf; /* V3 write verifier */
104 int nb_commitlevel; /* lowest write commit level */
105 time_t nb_timestamp; /* buffer timestamp */
106 int nb_error; /* errno value. */
107 u_int32_t nb_valid; /* valid pages in buf */
108 u_int32_t nb_dirty; /* dirty pages in buf */
109 int nb_validoff; /* offset in buffer of valid region. */
110 int nb_validend; /* offset of end of valid region. */
111 int nb_dirtyoff; /* offset in buffer of dirty region. */
112 int nb_dirtyend; /* offset of end of dirty region. */
113 int nb_offio; /* offset in buffer of I/O region. */
114 int nb_endio; /* offset of end of I/O region. */
115 int nb_rpcs; /* Count of RPCs remaining for this buffer. */
116 caddr_t nb_data; /* mapped buffer */
117 nfsnode_t nb_np; /* nfsnode buffer belongs to */
118 kauth_cred_t nb_rcred; /* read credentials reference */
119 kauth_cred_t nb_wcred; /* write credentials reference */
120 void * nb_pagelist; /* upl */
121};
122
123#define NFS_MAXBSIZE (32 * PAGE_SIZE) /* valid/dirty page masks limit buffer size */
124
125#define NFS_A_LOT_OF_NEEDCOMMITS 256 /* max# uncommitted buffers for a node */
126#define NFS_A_LOT_OF_DELAYED_WRITES MAX(nfsbufcnt/8,512) /* max# "delwri" buffers in system */
127
128/*
129 * These flags are kept in b_lflags...
130 * nfs_buf_mutex must be held before examining/updating
131 */
132#define NBL_BUSY 0x00000001 /* I/O in progress. */
133#define NBL_WANTED 0x00000002 /* Process wants this buffer. */
134
135/*
136 * These flags are kept in nb_flags and they're (purposefully)
137 * very similar to the B_* flags for struct buf.
138 * nfs_buf_mutex is not needed to examine/update these.
139 */
140#define NB_STALEWVERF 0x00000001 /* write verifier changed on us */
141#define NB_NEEDCOMMIT 0x00000002 /* buffer needs to be committed */
142#define NB_ASYNC 0x00000004 /* Start I/O, do not wait. */
143#define NB_CACHE 0x00000020 /* buffer data found in the cache */
144#define NB_STABLE 0x00000040 /* write FILESYNC not UNSTABLE */
145#define NB_DELWRI 0x00000080 /* delayed write: dirty range needs to be written */
146#define NB_DONE 0x00000200 /* I/O completed. */
147#define NB_EINTR 0x00000400 /* I/O was interrupted */
148#define NB_ERROR 0x00000800 /* I/O error occurred. */
149#define NB_INVAL 0x00002000 /* Does not contain valid info. */
150#define NB_NCRDAHEAD 0x00004000 /* "nocache readahead" data */
151#define NB_NOCACHE 0x00008000 /* Do not cache block after use. */
152#define NB_WRITE 0x00000000 /* Write buffer (pseudo flag). */
153#define NB_READ 0x00100000 /* Read buffer. */
154#define NB_MULTASYNCRPC 0x00200000 /* multiple async RPCs issued for buffer */
155#define NB_PAGELIST 0x00400000 /* Buffer describes pagelist I/O. */
156#define NB_WRITEINPROG 0x01000000 /* Write in progress. */
157#define NB_META 0x40000000 /* buffer contains meta-data. */
158
159/* Flags for operation type in nfs_buf_get() */
160#define NBLK_READ 0x00000001 /* buffer for read */
161#define NBLK_WRITE 0x00000002 /* buffer for write */
162#define NBLK_META 0x00000004 /* buffer for metadata */
163#define NBLK_OPMASK 0x00000007 /* operation mask */
164/* modifiers for above flags... */
165#define NBLK_NOWAIT 0x40000000 /* don't wait on busy buffer */
166#define NBLK_ONLYVALID 0x80000000 /* only return cached buffer */
167
168/* These flags are used for nfsbuf iterating */
169#define NBI_ITER 0x01 /* iteration in progress */
170#define NBI_ITERWANT 0x02 /* waiting to iterate */
171#define NBI_CLEAN 0x04 /* requesting clean buffers */
172#define NBI_DIRTY 0x08 /* requesting dirty buffers */
173#define NBI_NOWAIT 0x10 /* don't block on NBI_ITER */
174
175/* Flags for nfs_buf_acquire */
176#define NBAC_NOWAIT 0x01 /* Don't wait if buffer is busy */
177#define NBAC_REMOVE 0x02 /* Remove from free list once buffer is acquired */
178
179/* some convenience macros... */
180#define NBOFF(BP) ((off_t)(BP)->nb_lblkno * (off_t)(BP)->nb_bufsize)
181#define NBPGVALID(BP,P) (((BP)->nb_valid >> (P)) & 0x1)
182#define NBPGDIRTY(BP,P) (((BP)->nb_dirty >> (P)) & 0x1)
183#define NBPGVALID_SET(BP,P) ((BP)->nb_valid |= (1 << (P)))
184#define NBPGDIRTY_SET(BP,P) ((BP)->nb_dirty |= (1 << (P)))
185
186#define NBUFSTAMPVALID(BP) ((BP)->nb_timestamp != ~0)
187#define NBUFSTAMPINVALIDATE(BP) ((BP)->nb_timestamp = ~0)
188
189#define NFS_BUF_MAP(BP) \
190 do { \
191 if (!(BP)->nb_data && nfs_buf_map(BP)) \
192 panic("nfs_buf_map failed"); \
193 } while (0)
194
195LIST_HEAD(nfsbuflists, nfsbuf);
196TAILQ_HEAD(nfsbuffreehead, nfsbuf);
197
198extern lck_mtx_t *nfs_buf_mutex;
199extern int nfsbufcnt, nfsbufmin, nfsbufmax, nfsbufmetacnt, nfsbufmetamax;
200extern int nfsbuffreecnt, nfsbuffreemetacnt, nfsbufdelwricnt, nfsneedbuffer;
201extern int nfs_nbdwrite;
202extern struct nfsbuffreehead nfsbuffree, nfsbufdelwri;
203
204#ifdef NFSBUFDEBUG
205#define NFSBUFCNTCHK() \
206 do { \
207 if ( (nfsbufcnt < 0) || \
208 (nfsbufcnt > nfsbufmax) || \
209 (nfsbufmetacnt < 0) || \
210 (nfsbufmetacnt > nfsbufmetamax) || \
211 (nfsbufmetacnt > nfsbufcnt) || \
212 (nfsbuffreecnt < 0) || \
213 (nfsbuffreecnt > nfsbufmax) || \
214 (nfsbuffreecnt > nfsbufcnt) || \
215 (nfsbuffreemetacnt < 0) || \
216 (nfsbuffreemetacnt > nfsbufmax) || \
217 (nfsbuffreemetacnt > nfsbufcnt) || \
218 (nfsbuffreemetacnt > nfsbufmetamax) || \
219 (nfsbuffreemetacnt > nfsbufmetacnt) || \
220 (nfsbufdelwricnt < 0) || \
221 (nfsbufdelwricnt > nfsbufmax) || \
222 (nfsbufdelwricnt > nfsbufcnt) || \
223 (nfs_nbdwrite < 0) || \
224 (nfs_nbdwrite > nfsbufcnt) || \
225 0) \
226 panic("nfsbuf count error: max %d meta %d cnt %d meta %d free %d meta %d delwr %d bdw %d\n", \
227 nfsbufmax, nfsbufmetamax, nfsbufcnt, nfsbufmetacnt, nfsbuffreecnt, nfsbuffreemetacnt, \
228 nfsbufdelwricnt, nfs_nbdwrite); \
229 } while (0)
230#else
231#define NFSBUFCNTCHK()
232#endif
233
234/*
235 * NFS directory buffer
236 *
237 * Each buffer for a directory consists of:
238 *
239 * - a small header
240 * - a packed list of direntry structures
241 * (if RDIRPLUS is enabled, a file handle and attrstamp are
242 * packed after the direntry name.)
243 * - free/unused space
244 * - if RDIRPLUS is enabled, an array of attributes
245 * that is indexed backwards from the end of the buffer.
246 */
247struct nfs_dir_buf_header {
248 uint16_t ndbh_flags; /* flags (see below) */
249 uint16_t ndbh_count; /* # of entries */
250 uint32_t ndbh_entry_end; /* end offset of direntry data */
251 uint32_t ndbh_ncgen; /* name cache generation# */
252 uint32_t ndbh_pad; /* reserved */
253};
254/* ndbh_flags */
255#define NDB_FULL 0x0001 /* buffer has been filled */
256#define NDB_EOF 0x0002 /* buffer contains EOF */
257#define NDB_PLUS 0x0004 /* buffer contains RDIRPLUS data */
258
259#define NFS_DIR_BUF_FIRST_DIRENTRY(BP) \
260 ((struct direntry*)((char*)((BP)->nb_data) + sizeof(*ndbhp)))
261#define NFS_DIR_BUF_NVATTR(BP, IDX) \
262 (&((struct nfs_vattr*)((char*)((BP)->nb_data) + (BP)->nb_bufsize))[-((IDX)+1)])
263#define NFS_DIRENTRY_LEN(namlen) \
264 ((sizeof(struct direntry) + (namlen) - (MAXPATHLEN-1) + 7) & ~7)
265#define NFS_DIRENT_LEN(namlen) \
266 ((sizeof(struct dirent) - (NAME_MAX+1)) + (((namlen) + 1 + 3) &~ 3))
267#define NFS_DIRENTRY_NEXT(DP) \
268 ((struct direntry*)((char*)(DP) + (DP)->d_reclen))
269#define NFS_DIR_COOKIE_POTENTIALLY_TRUNCATED(C) \
270 ((C) && ((((C) >> 32) == 0) || (((C) & 0x80000000ULL) && (((C) >> 32) == 0xffffffff))))
271#define NFS_DIR_COOKIE_SAME32(C1, C2) \
272 (((C1) & 0xffffffffULL) == ((C2) & 0xffffffffULL))
273
274/*
275 * NFS directory cookie cache
276 *
277 * This structure is used to cache cookie-to-buffer mappings for
278 * cookies recently returned from READDIR. The entries are kept in an
279 * array. The most-recently-used (MRU) list is headed by the entry at
280 * index "mru". The index of the next entry in the list is kept in the
281 * "next" array. (An index value of -1 marks an invalid entry.)
282 */
283#define NFSNUMCOOKIES 14
284struct nfsdmap {
285 int8_t free; /* next unused slot */
286 int8_t mru; /* head of MRU list */
287 int8_t next[NFSNUMCOOKIES]; /* MRU list links */
288 struct {
289 uint64_t key; /* cookie */
290 uint64_t lbn; /* lbn of buffer */
291 } cookies[NFSNUMCOOKIES]; /* MRU list entries */
292};
293
294/*
295 * NFS vnode attribute structure
296 */
297#define NFSTIME_ACCESS 0 /* time of last access */
298#define NFSTIME_MODIFY 1 /* time of last modification */
299#define NFSTIME_CHANGE 2 /* time file changed */
300#define NFSTIME_CREATE 3 /* time file created */
301#define NFSTIME_BACKUP 4 /* time of last backup */
302#define NFSTIME_COUNT 5
303
304#define NFS_COMPARE_MTIME(TVP, NVAP, CMP) \
305 (((TVP)->tv_sec == (NVAP)->nva_timesec[NFSTIME_MODIFY]) ? \
306 ((TVP)->tv_nsec CMP (NVAP)->nva_timensec[NFSTIME_MODIFY]) : \
307 ((TVP)->tv_sec CMP (NVAP)->nva_timesec[NFSTIME_MODIFY]))
308#define NFS_COPY_TIME(TVP, NVAP, WHICH) \
309 do { \
310 (TVP)->tv_sec = (NVAP)->nva_timesec[NFSTIME_##WHICH]; \
311 (TVP)->tv_nsec = (NVAP)->nva_timensec[NFSTIME_##WHICH]; \
312 } while (0)
313
314struct nfs_vattr {
315 enum vtype nva_type; /* vnode type (for create) */
316 uint32_t nva_mode; /* file's access mode (and type) */
317 uid_t nva_uid; /* owner user id */
318 gid_t nva_gid; /* owner group id */
319 guid_t nva_uuuid; /* owner user UUID */
320 guid_t nva_guuid; /* owner group UUID */
321 kauth_acl_t nva_acl; /* access control list */
322 nfs_specdata nva_rawdev; /* device the special file represents */
323 uint32_t nva_flags; /* file flags (see below) */
324 uint32_t nva_maxlink; /* maximum # of links (v4) */
325 uint64_t nva_nlink; /* number of references to file */
326 uint64_t nva_fileid; /* file id */
327 nfs_fsid nva_fsid; /* file system id */
328 uint64_t nva_size; /* file size in bytes */
329 uint64_t nva_bytes; /* bytes of disk space held by file */
330 uint64_t nva_change; /* change attribute */
331 int64_t nva_timesec[NFSTIME_COUNT];
332 int32_t nva_timensec[NFSTIME_COUNT];
333 uint32_t nva_bitmap[NFS_ATTR_BITMAP_LEN]; /* attributes that are valid */
334};
335
336/* nva_flags */
337#define NFS_FFLAG_ARCHIVED 0x0001
338#define NFS_FFLAG_HIDDEN 0x0002
339#define NFS_FFLAG_HAS_NAMED_ATTRS 0x0004 /* file has named attributes */
340#define NFS_FFLAG_TRIGGER 0x0008 /* node is a trigger/mirror mount point */
341#define NFS_FFLAG_TRIGGER_REFERRAL 0x0010 /* trigger is a referral */
342#define NFS_FFLAG_IS_ATTR 0x8000 /* file is a named attribute file/directory */
343
344/* flags for nfs_getattr() */
345#define NGA_CACHED 0x0001 /* use cached attributes (if still valid) */
346#define NGA_UNCACHED 0x0002 /* fetch new attributes */
347#define NGA_ACL 0x0004 /* fetch ACL */
348#define NGA_MONITOR 0x0008 /* vnode monitor attr update poll */
349#define NGA_SOFT 0x0010 /* use cached attributes if ETIMEOUT */
350
351/* macros for initting/cleaning up nfs_vattr structures */
352#define NVATTR_INIT(NVAP) \
353 do { \
354 NFS_CLEAR_ATTRIBUTES((NVAP)->nva_bitmap); \
355 (NVAP)->nva_flags = 0; \
356 (NVAP)->nva_acl = NULL; \
357 } while (0)
358#define NVATTR_CLEANUP(NVAP) \
359 do { \
360 NFS_CLEAR_ATTRIBUTES((NVAP)->nva_bitmap); \
361 if ((NVAP)->nva_acl) { \
362 kauth_acl_free((NVAP)->nva_acl); \
363 (NVAP)->nva_acl = NULL; \
364 } \
365 } while (0)
366
367/*
368 * macros for detecting node changes
369 *
370 * These macros help us determine if a file has been changed on the server and
371 * thus whether or not we need to invalidate any cached data.
372 *
373 * For NFSv2/v3, the modification time is used.
374 * For NFSv4, the change attribute is used.
375 */
376#define NFS_CHANGED(VERS, NP, NVAP) \
377 (((VERS) >= NFS_VER4) ? \
378 ((NP)->n_change != (NVAP)->nva_change) : \
379 NFS_COMPARE_MTIME(&(NP)->n_mtime, (NVAP), !=))
380#define NFS_CHANGED_NC(VERS, NP, NVAP) \
381 (((VERS) >= NFS_VER4) ? \
382 ((NP)->n_ncchange != (NVAP)->nva_change) : \
383 NFS_COMPARE_MTIME(&(NP)->n_ncmtime, (NVAP), !=))
384#define NFS_CHANGED_UPDATE(VERS, NP, NVAP) \
385 do { \
386 if ((VERS) >= NFS_VER4) \
387 (NP)->n_change = (NVAP)->nva_change; \
388 else \
389 NFS_COPY_TIME(&(NP)->n_mtime, (NVAP), MODIFY); \
390 } while (0)
391#define NFS_CHANGED_UPDATE_NC(VERS, NP, NVAP) \
392 do { \
393 if ((VERS) >= NFS_VER4) \
394 (NP)->n_ncchange = (NVAP)->nva_change; \
395 else \
396 NFS_COPY_TIME(&(NP)->n_ncmtime, (NVAP), MODIFY); \
397 } while (0)
398
399
400extern lck_grp_t *nfs_open_grp;
401extern uint32_t nfs_open_owner_seqnum, nfs_lock_owner_seqnum;
402
403/*
404 * NFSv4 open owner structure - one per cred per mount
405 */
406struct nfs_open_owner {
407 TAILQ_ENTRY(nfs_open_owner) noo_link; /* List of open owners (on mount) */
408 lck_mtx_t noo_lock; /* owner mutex */
409 struct nfsmount * noo_mount; /* NFS mount */
410 uint32_t noo_refcnt; /* # outstanding references */
411 uint32_t noo_flags; /* see below */
412 kauth_cred_t noo_cred; /* credentials of open owner */
413 uint32_t noo_name; /* unique name used otw */
414 uint32_t noo_seqid; /* client-side sequence ID */
415 TAILQ_HEAD(,nfs_open_file) noo_opens; /* list of open files */
416};
417/* noo_flags */
418#define NFS_OPEN_OWNER_LINK 0x1 /* linked into mount's open owner list */
419#define NFS_OPEN_OWNER_BUSY 0x2 /* open state-modifying operation in progress */
420#define NFS_OPEN_OWNER_WANT 0x4 /* someone else wants to mark busy */
421
422/*
423 * NFS open file structure - one per open owner per nfsnode
424 */
425struct nfs_open_file {
426 lck_mtx_t nof_lock; /* open file mutex */
427 TAILQ_ENTRY(nfs_open_file) nof_link; /* list of open files */
428 TAILQ_ENTRY(nfs_open_file) nof_oolink; /* list of open owner's open files */
429 struct nfs_open_owner * nof_owner; /* open owner */
430 nfsnode_t nof_np; /* nfsnode this open is for */
431 nfs_stateid nof_stateid; /* open stateid */
432 thread_t nof_creator; /* thread that created file */
433 uint32_t nof_opencnt; /* open file count */
434 uint16_t nof_flags; /* see below */
435 uint8_t nof_access:4; /* access mode for this open */
436 uint8_t nof_deny:4; /* deny mode for this open */
437 uint8_t nof_mmap_access:4; /* mmap open access mode */
438 uint8_t nof_mmap_deny:4; /* mmap open deny mode */
439 /* counts of access/deny mode open combinations */
440 uint32_t nof_r; /* read opens (deny none) */
441 uint32_t nof_w; /* write opens (deny none) */
442 uint32_t nof_rw; /* read/write opens (deny none) */
443 uint32_t nof_r_dw; /* read deny-write opens */
444 /* the rest of the counts have a max of 2 (1 for open + 1 for mmap) */
445 uint32_t nof_w_dw:2; /* write deny-write opens (max 2) */
446 uint32_t nof_rw_dw:2; /* read/write deny-write opens (max 2) */
447 uint32_t nof_r_drw:2; /* read deny-read/write opens (max 2) */
448 uint32_t nof_w_drw:2; /* write deny-read/write opens (max 2) */
449 uint32_t nof_rw_drw:2; /* read/write deny-read/write opens (max 2) */
450 /* counts of DELEGATED access/deny mode open combinations */
451 uint32_t nof_d_w_dw:2; /* write deny-write opens (max 2) */
452 uint32_t nof_d_rw_dw:2; /* read/write deny-write opens (max 2) */
453 uint32_t nof_d_r_drw:2; /* read deny-read/write opens (max 2) */
454 uint32_t nof_d_w_drw:2; /* write deny-read/write opens (max 2) */
455 uint32_t nof_d_rw_drw:2; /* read/write deny-read/write opens (max 2) */
456 uint32_t nof_d_r; /* read opens (deny none) */
457 uint32_t nof_d_w; /* write opens (deny none) */
458 uint32_t nof_d_rw; /* read/write opens (deny none) */
459 uint32_t nof_d_r_dw; /* read deny-write opens */
460};
461/* nof_flags */
462#define NFS_OPEN_FILE_BUSY 0x0001 /* open state-modifying operation in progress */
463#define NFS_OPEN_FILE_WANT 0x0002 /* someone else wants to mark busy */
464#define NFS_OPEN_FILE_CREATE 0x0004 /* has an open(RW) from a "CREATE" call */
465#define NFS_OPEN_FILE_NEEDCLOSE 0x0008 /* has an open(R) from an (unopen) VNOP_READ or VNOP_MMAP call */
466#define NFS_OPEN_FILE_SETATTR 0x0020 /* has an open(W) to perform a SETATTR(size) */
467#define NFS_OPEN_FILE_POSIXLOCK 0x0040 /* server supports POSIX locking semantics */
468#define NFS_OPEN_FILE_LOST 0x0080 /* open state has been lost */
469#define NFS_OPEN_FILE_REOPEN 0x0100 /* file needs to be reopened */
470#define NFS_OPEN_FILE_REOPENING 0x0200 /* file is being reopened */
471
472struct nfs_lock_owner;
473/*
474 * NFS file lock
475 *
476 * Each lock request (pending or granted) has an
477 * nfs_file_lock structure representing its state.
478 */
479struct nfs_file_lock {
480 TAILQ_ENTRY(nfs_file_lock) nfl_link; /* List of locks on nfsnode */
481 TAILQ_ENTRY(nfs_file_lock) nfl_lolink; /* List of locks held by locker */
482 struct nfs_lock_owner * nfl_owner; /* lock owner that holds this lock */
483 uint64_t nfl_start; /* starting offset */
484 uint64_t nfl_end; /* ending offset (inclusive) */
485 uint32_t nfl_blockcnt; /* # locks blocked on this lock */
486 uint16_t nfl_flags; /* see below */
487 uint8_t nfl_type; /* lock type: read/write */
488};
489/* nfl_flags */
490#define NFS_FILE_LOCK_ALLOC 0x01 /* lock was allocated */
491#define NFS_FILE_LOCK_STYLE_POSIX 0x02 /* POSIX-style fcntl() lock */
492#define NFS_FILE_LOCK_STYLE_FLOCK 0x04 /* flock(2)-style lock */
493#define NFS_FILE_LOCK_STYLE_MASK 0x06 /* lock style mask */
494#define NFS_FILE_LOCK_WAIT 0x08 /* may block on conflicting locks */
495#define NFS_FILE_LOCK_BLOCKED 0x10 /* request is blocked */
496#define NFS_FILE_LOCK_DEAD 0x20 /* lock (request) no longer exists */
497#define NFS_FILE_LOCK_DELEGATED 0x40 /* lock acquired via delegation */
498
499TAILQ_HEAD(nfs_file_lock_queue, nfs_file_lock);
500
501/*
502 * Calculate length of lock range given the endpoints.
503 * Note that struct flock has "to EOF" reported as 0 but
504 * the NFSv4 protocol has "to EOF" reported as UINT64_MAX.
505 */
506#define NFS_FLOCK_LENGTH(S, E) (((E) == UINT64_MAX) ? 0 : ((E) - (S) + 1))
507#define NFS_LOCK_LENGTH(S, E) (((E) == UINT64_MAX) ? UINT64_MAX : ((E) - (S) + 1))
508
509/*
510 * NFSv4 lock owner structure - per open owner per process per nfsnode
511 *
512 * A lock owner is a process + an nfsnode.
513 *
514 * Note that flock(2) locks technically should have the lock owner be
515 * an fglob pointer instead of a process. However, implementing that
516 * correctly would not be trivial. So, for now, flock(2) locks are
517 * essentially treated like whole-file POSIX locks.
518 */
519struct nfs_lock_owner {
520 lck_mtx_t nlo_lock; /* owner mutex */
521 TAILQ_ENTRY(nfs_lock_owner) nlo_link; /* List of lock owners (on nfsnode) */
522 struct nfs_open_owner * nlo_open_owner; /* corresponding open owner */
523 struct nfs_file_lock_queue nlo_locks; /* list of locks held */
524 struct nfs_file_lock nlo_alock; /* most lockers will only ever have one */
525 struct timeval nlo_pid_start; /* Start time of process id */
526 pid_t nlo_pid; /* lock-owning process ID */
527 uint32_t nlo_refcnt; /* # outstanding references */
528 uint32_t nlo_flags; /* see below */
529 uint32_t nlo_name; /* unique name used otw */
530 uint32_t nlo_seqid; /* client-side sequence ID */
531 uint32_t nlo_stategenid; /* mount state generation ID */
532 nfs_stateid nlo_stateid; /* lock stateid */
533};
534/* nlo_flags */
535#define NFS_LOCK_OWNER_LINK 0x1 /* linked into mount's lock owner list */
536#define NFS_LOCK_OWNER_BUSY 0x2 /* lock state-modifying operation in progress */
537#define NFS_LOCK_OWNER_WANT 0x4 /* someone else wants to mark busy */
538
539/*
540 * The nfsnode is the NFS equivalent of an inode.
541 * There is a unique nfsnode for each NFS vnode.
542 * An nfsnode is 'named' by its file handle. (nget/nfs_node.c)
543 * NB: Hopefully the current order of the fields is such that everything will
544 * be well aligned and, therefore, tightly packed.
545 */
546
547#define NFS_ACCESS_CACHE_SIZE 3
548
549struct nfsnode {
550 lck_mtx_t n_lock; /* nfs node lock */
551 lck_rw_t n_datalock; /* nfs node data lock */
552 void *n_datalockowner;/* nfs node data lock owner (exclusive) */
553 LIST_ENTRY(nfsnode) n_hash; /* Hash chain */
554 LIST_ENTRY(nfsnode) n_monlink; /* list of monitored nodes */
555 u_quad_t n_size; /* Current size of file */
556 u_quad_t n_newsize; /* new size of file (pending update) */
557 u_int64_t n_xid; /* last xid to loadattr */
558 struct nfs_vattr n_vattr; /* Vnode attribute cache */
559 time_t n_attrstamp; /* Attr. cache timestamp */
560 time_t n_aclstamp; /* ACL cache timestamp */
561 time_t n_evtstamp; /* last vnode event timestamp */
562 uint32_t n_events; /* pending vnode events */
563 u_int8_t n_access[NFS_ACCESS_CACHE_SIZE+1]; /* ACCESS cache */
564 uid_t n_accessuid[NFS_ACCESS_CACHE_SIZE]; /* credentials having access */
565 time_t n_accessstamp[NFS_ACCESS_CACHE_SIZE]; /* access cache timestamp */
566 union {
567 struct {
568 struct timespec n3_mtime; /* Prev modify time. */
569 struct timespec n3_ncmtime; /* namecache modify time. */
570 } v3;
571 struct {
572 uint64_t n4_change; /* prev change attribute */
573 uint64_t n4_ncchange; /* namecache change attribute */
574 u_char *n4_attrdirfh; /* associated attr directory fh */
575 struct timeval n4_lastio; /* time of most recent I/O on attr */
576 } v4;
577 } n_un4;
578 vnode_t n_parent; /* this node's parent */
579 u_char *n_fhp; /* NFS File Handle */
580 vnode_t n_vnode; /* associated vnode */
581 mount_t n_mount; /* associated mount (NHINIT) */
582 int n_error; /* Save write error value */
583 union {
584 struct timespec ns_atim; /* Special file times */
585 struct timespec nl_rltim; /* Time of last readlink */
586 daddr64_t nf_lastread; /* last block# read from (for readahead) */
587 uint64_t nd_cookieverf; /* Cookie verifier (dir only) */
588 } n_un1;
589 union {
590 struct timespec ns_mtim; /* Special file times */
591 daddr64_t nf_lastrahead; /* last block# read ahead */
592 uint64_t nd_eofcookie; /* Dir. EOF cookie cache */
593 } n_un2;
594 union {
595 struct nfs_sillyrename *nf_silly;/* Ptr to silly rename struct */
596 struct nfsdmap *nd_cookiecache; /* dir cookie cache */
597 } n_un3;
598 uint32_t n_flag; /* node flags */
599 u_short n_fhsize; /* size in bytes, of fh */
600 u_short n_hflag; /* node hash flags */
601 u_short n_bflag; /* node buffer flags */
602 u_short n_mflag; /* node mount flags */
603 u_char n_fh[NFS_SMALLFH];/* Small File Handle */
604 uint32_t n_auth; /* security flavor used for this node */
605 struct nfsbuflists n_cleanblkhd; /* clean blocklist head */
606 struct nfsbuflists n_dirtyblkhd; /* dirty blocklist head */
607 union {
608 int nf_wrbusy; /* # threads in write/fsync */
609 uint32_t nd_ncgen; /* dir name cache generation# */
610 } n_un5;
611 union {
612 int nf_needcommitcnt;/* # bufs that need committing */
613 daddr64_t nd_lastdbl; /* last dir buf lookup block# */
614 } n_un6;
615 int n_bufiterflags; /* buf iterator flags */
616 union {
617 int nf_numoutput; /* write I/Os in progress */
618 int nd_trigseq; /* vnode trigger seq# */
619 } n_un7;
620 /* open state */
621 lck_mtx_t n_openlock; /* nfs node open lock */
622 uint32_t n_openflags; /* open state flags */
623 uint32_t n_openrefcnt; /* # non-file opens */
624 TAILQ_HEAD(,nfs_open_file) n_opens; /* list of open files */
625 /* lock state */
626 TAILQ_HEAD(, nfs_lock_owner) n_lock_owners; /* list of lock owners */
627 struct nfs_file_lock_queue n_locks; /* list of locks */
628 /* delegation state */
629 nfs_stateid n_dstateid; /* delegation stateid */
630 TAILQ_ENTRY(nfsnode) n_dlink; /* delegation list link */
631 TAILQ_ENTRY(nfsnode) n_dreturn; /* delegation return list link */
632 struct kauth_ace n_dace; /* delegation ACE */
633};
634
635#define NFS_DATA_LOCK_SHARED 1
636#define NFS_DATA_LOCK_EXCLUSIVE 2
637
638#define nfstimespeccmp(tvp, uvp, cmp) \
639 (((tvp)->tv_sec == (uvp)->tv_sec) ? \
640 ((tvp)->tv_nsec cmp (uvp)->tv_nsec) : \
641 ((tvp)->tv_sec cmp (uvp)->tv_sec))
642
643#define CHECK_NEEDCOMMITCNT(np) \
644 do { \
645 if ((np)->n_needcommitcnt < 0) { \
646 printf("nfs: n_needcommitcnt negative\n"); \
647 (np)->n_needcommitcnt = 0; \
648 } \
649 } while (0)
650
651#define n_atim n_un1.ns_atim
652#define n_mtim n_un2.ns_mtim
653#define n_rltim n_un1.nl_rltim
654#define n_lastread n_un1.nf_lastread
655#define n_lastrahead n_un2.nf_lastrahead
656#define n_sillyrename n_un3.nf_silly
657#define n_wrbusy n_un5.nf_wrbusy
658#define n_needcommitcnt n_un6.nf_needcommitcnt
659#define n_numoutput n_un7.nf_numoutput
660#define n_cookieverf n_un1.nd_cookieverf
661#define n_eofcookie n_un2.nd_eofcookie
662#define n_cookiecache n_un3.nd_cookiecache
663#define n_ncgen n_un5.nd_ncgen
664#define n_lastdbl n_un6.nd_lastdbl
665#define n_trigseq n_un7.nd_trigseq
666#define n_mtime n_un4.v3.n3_mtime
667#define n_ncmtime n_un4.v3.n3_ncmtime
668#define n_change n_un4.v4.n4_change
669#define n_ncchange n_un4.v4.n4_ncchange
670#define n_attrdirfh n_un4.v4.n4_attrdirfh
671#define n_lastio n_un4.v4.n4_lastio
672
673/*
674 * Flags for n_flag
675 */
676#define NUPDATESIZE 0x00001 /* size of file needs updating */
677#define NREVOKE 0x00002 /* node revoked */
678#define NMODIFIED 0x00004 /* Might have a modified buffer in bio */
679#define NWRITEERR 0x00008 /* Flag write errors so close will know */
680#define NNEEDINVALIDATE 0x00010 /* need to call vinvalbuf() */
681#define NGETATTRINPROG 0x00020 /* GETATTR RPC in progress */
682#define NGETATTRWANT 0x00040 /* waiting for GETATTR RPC */
683#define NACC 0x00100 /* Special file accessed */
684#define NUPD 0x00200 /* Special file updated */
685#define NCHG 0x00400 /* Special file times changed */
686#define NNEGNCENTRIES 0x00800 /* directory has negative name cache entries */
687#define NBUSY 0x01000 /* node is busy */
688#define NBUSYWANT 0x02000 /* waiting on busy node */
689#define NISDOTZFS 0x04000 /* a ".zfs" directory */
690#define NISDOTZFSCHILD 0x08000 /* a child of a ".zfs" directory */
691#define NISMAPPED 0x10000 /* node is mmapped */
692#define NREFRESH 0x20000 /* node's fh needs to be refreshed */
693#define NREFRESHWANT 0x40000 /* Waiting for fh to be refreshed */
694
695/*
696 * Flags for n_hflag
697 * Note: protected by nfs_node_hash_mutex
698 */
699#define NHHASHED 0x0001 /* node is in hash table */
700#define NHINIT 0x0002 /* node is being initialized */
701#define NHLOCKED 0x0004 /* node is locked (initting or deleting) */
702#define NHLOCKWANT 0x0008 /* someone wants to lock */
703
704/*
705 * Flags for n_bflag
706 * Note: protected by nfs_buf_mutex
707 */
708#define NBFLUSHINPROG 0x0001 /* Avoid multiple calls to nfs_flush() */
709#define NBFLUSHWANT 0x0002 /* waiting for nfs_flush() to complete */
710#define NBINVALINPROG 0x0004 /* Avoid multiple calls to nfs_vinvalbuf() */
711#define NBINVALWANT 0x0008 /* waiting for nfs_vinvalbuf() to complete */
712
713/*
714 * Flags for n_mflag
715 * Note: protected by nfsmount's nm_lock
716 */
717#define NMMONSCANINPROG 0x0001 /* monitored node is currently updating attributes */
718#define NMMONSCANWANT 0x0002 /* waiting for attribute update to complete */
719
720/*
721 * n_openflags
722 * Note: protected by n_openlock
723 */
724#define N_OPENBUSY 0x0001 /* open state is busy - being updated */
725#define N_OPENWANT 0x0002 /* someone wants to mark busy */
726#define N_DELEG_READ 0x0004 /* we have a read delegation */
727#define N_DELEG_WRITE 0x0008 /* we have a write delegation */
728#define N_DELEG_MASK 0x000c /* delegation mask */
729#define N_DELEG_RETURN 0x0010 /* delegation queued for return */
730#define N_DELEG_RETURNING 0x0020 /* delegation being returned */
731
732/* attr/access/ACL cache timestamp macros */
733#define NATTRVALID(np) ((np)->n_attrstamp != ~0)
734#define NATTRINVALIDATE(np) ((np)->n_attrstamp = ~0)
735#define NACCESSVALID(np, slot) (((slot) >= 0) && ((slot) < NFS_ACCESS_CACHE_SIZE) && ((np)->n_accessstamp[(slot)] != ~0))
736#define NACCESSINVALIDATE(np) \
737 do { \
738 int __i; \
739 for (__i=0; __i < NFS_ACCESS_CACHE_SIZE; __i++) \
740 (np)->n_accessstamp[__i] = ~0; \
741 (np)->n_access[NFS_ACCESS_CACHE_SIZE] = 0; \
742 } while (0)
743#define NACLVALID(np) ((np)->n_aclstamp != ~0)
744#define NACLINVALIDATE(np) ((np)->n_aclstamp = ~0)
745
746/*
747 * NFS-specific flags for nfs_vinvalbuf/nfs_flush
748 */
749#define V_IGNORE_WRITEERR 0x8000
750
751/*
752 * Flags for nfs_nget()
753 */
754#define NG_MARKROOT 0x0001 /* mark vnode as root of FS */
755#define NG_MAKEENTRY 0x0002 /* add name cache entry for vnode */
756#define NG_NOCREATE 0x0004 /* don't create a new node, return existing one */
757
758/*
759 * Convert between nfsnode pointers and vnode pointers
760 */
761#define VTONFS(vp) ((nfsnode_t)vnode_fsnode(vp))
762#define NFSTOV(np) ((np)->n_vnode)
763
764/* nfsnode hash table mutex */
765extern lck_mtx_t *nfs_node_hash_mutex;
766
767/*
768 * printf-like helper macro that also outputs node name.
769 */
770#define NP(NP, FMT, ...) \
771 do { \
772 const char *__vname = (NP) ? vnode_getname(NFSTOV(NP)) : NULL; \
773 printf(FMT " %s\n", ##__VA_ARGS__, __vname ? __vname : "???"); \
774 if (__vname) vnode_putname(__vname); \
775 } while (0)
776
777/*
778 * nfsiod structures
779 */
780struct nfsiod {
781 TAILQ_ENTRY(nfsiod) niod_link; /* List of nfsiods */
782 struct nfsmount * niod_nmp; /* mount point for this nfsiod */
783};
784TAILQ_HEAD(nfsiodlist, nfsiod);
785TAILQ_HEAD(nfsiodmountlist, nfsmount);
786extern struct nfsiodlist nfsiodfree, nfsiodwork;
787extern struct nfsiodmountlist nfsiodmounts;
788extern lck_mtx_t *nfsiod_mutex;
789
790#if defined(KERNEL)
791
792typedef int vnop_t(void *);
793extern vnop_t **fifo_nfsv2nodeop_p;
794extern vnop_t **nfsv2_vnodeop_p;
795extern vnop_t **spec_nfsv2nodeop_p;
796extern vnop_t **fifo_nfsv4nodeop_p;
797extern vnop_t **nfsv4_vnodeop_p;
798extern vnop_t **spec_nfsv4nodeop_p;
799
800/*
801 * Prototypes for NFS vnode operations
802 */
803#define nfs_vnop_revoke nop_revoke
804int nfs_vnop_inactive(struct vnop_inactive_args *);
805int nfs_vnop_reclaim(struct vnop_reclaim_args *);
806
807int nfs_node_lock(nfsnode_t);
808int nfs_node_lock_internal(nfsnode_t, int);
809void nfs_node_lock_force(nfsnode_t);
810void nfs_node_unlock(nfsnode_t);
811int nfs_node_lock2(nfsnode_t, nfsnode_t);
812void nfs_node_unlock2(nfsnode_t, nfsnode_t);
813int nfs_node_set_busy(nfsnode_t, thread_t);
814int nfs_node_set_busy2(nfsnode_t, nfsnode_t, thread_t);
815int nfs_node_set_busy4(nfsnode_t, nfsnode_t, nfsnode_t, nfsnode_t, thread_t);
816void nfs_node_clear_busy(nfsnode_t);
817void nfs_node_clear_busy2(nfsnode_t, nfsnode_t);
818void nfs_node_clear_busy4(nfsnode_t, nfsnode_t, nfsnode_t, nfsnode_t);
819void nfs_data_lock(nfsnode_t, int);
820void nfs_data_lock_noupdate(nfsnode_t, int);
821void nfs_data_lock_internal(nfsnode_t, int, int);
822void nfs_data_unlock(nfsnode_t);
823void nfs_data_unlock_noupdate(nfsnode_t);
824void nfs_data_unlock_internal(nfsnode_t, int);
825void nfs_data_update_size(nfsnode_t, int);
826
827/* other stuff */
828int nfs_removeit(struct nfs_sillyrename *);
829int nfs_nget(mount_t,nfsnode_t,struct componentname *,u_char *,int,struct nfs_vattr *,u_int64_t *,uint32_t,int,nfsnode_t*);
830int nfs_mount_is_dirty(mount_t);
831void nfs_dir_cookie_cache(nfsnode_t, uint64_t, uint64_t);
832int nfs_dir_cookie_to_lbn(nfsnode_t, uint64_t, int *, uint64_t *);
833void nfs_invaldir(nfsnode_t);
834uint32_t nfs_dir_buf_freespace(struct nfsbuf *, int);
835
836/* nfsbuf functions */
837void nfs_nbinit(void);
838void nfs_buf_timer(void *, void *);
839void nfs_buf_remfree(struct nfsbuf *);
840boolean_t nfs_buf_is_incore(nfsnode_t, daddr64_t);
841struct nfsbuf * nfs_buf_incore(nfsnode_t, daddr64_t);
842int nfs_buf_get(nfsnode_t, daddr64_t, uint32_t, thread_t, int, struct nfsbuf **);
843int nfs_buf_upl_setup(struct nfsbuf *bp);
844void nfs_buf_upl_check(struct nfsbuf *bp);
845void nfs_buf_normalize_valid_range(nfsnode_t, struct nfsbuf *);
846int nfs_buf_map(struct nfsbuf *);
847void nfs_buf_release(struct nfsbuf *, int);
848int nfs_buf_iowait(struct nfsbuf *);
849void nfs_buf_iodone(struct nfsbuf *);
850void nfs_buf_write_delayed(struct nfsbuf *);
851void nfs_buf_check_write_verifier(nfsnode_t, struct nfsbuf *);
852void nfs_buf_freeup(int);
853void nfs_buf_refget(struct nfsbuf *bp);
854void nfs_buf_refrele(struct nfsbuf *bp);
855void nfs_buf_drop(struct nfsbuf *);
856errno_t nfs_buf_acquire(struct nfsbuf *, int, int, int);
857int nfs_buf_iterprepare(nfsnode_t, struct nfsbuflists *, int);
858void nfs_buf_itercomplete(nfsnode_t, struct nfsbuflists *, int);
859
860int nfs_bioread(nfsnode_t, uio_t, int, vfs_context_t);
861int nfs_buf_readahead(nfsnode_t, int, daddr64_t *, daddr64_t, thread_t, kauth_cred_t);
862int nfs_buf_readdir(struct nfsbuf *, vfs_context_t);
863int nfs_buf_read(struct nfsbuf *);
864void nfs_buf_read_finish(struct nfsbuf *);
865int nfs_buf_read_rpc(struct nfsbuf *, thread_t, kauth_cred_t);
866void nfs_buf_read_rpc_finish(struct nfsreq *);
867int nfs_buf_write(struct nfsbuf *);
868void nfs_buf_write_finish(struct nfsbuf *, thread_t, kauth_cred_t);
869int nfs_buf_write_rpc(struct nfsbuf *, int, thread_t, kauth_cred_t);
870void nfs_buf_write_rpc_finish(struct nfsreq *);
871int nfs_buf_write_dirty_pages(struct nfsbuf *, thread_t, kauth_cred_t);
872
873int nfs_flushcommits(nfsnode_t, int);
874int nfs_flush(nfsnode_t, int, thread_t, int);
875void nfs_buf_delwri_push(int);
876void nfs_buf_delwri_service(void);
877void nfs_buf_delwri_thread(void *, wait_result_t);;
878
879int nfsiod_start(void);
880void nfsiod_terminate(struct nfsiod *);
881void nfsiod_thread(void);
882int nfsiod_continue(int);
883void nfs_asyncio_finish(struct nfsreq *);
884void nfs_asyncio_resend(struct nfsreq *);
885int nfs_async_write_start(struct nfsmount *);
886void nfs_async_write_done(struct nfsmount *);
887
888#endif /* KERNEL */
889
890#endif /* __APPLE_API_PRIVATE */
891#endif /* _NFS_NFSNODE_H_ */
892