1/*
2 * Copyright (c) 2000-2021 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, 1991, 1993
31 * The Regents of the University of California. All rights reserved.
32 *
33 * Redistribution and use in source and binary forms, with or without
34 * modification, are permitted provided that the following conditions
35 * are met:
36 * 1. Redistributions of source code must retain the above copyright
37 * notice, this list of conditions and the following disclaimer.
38 * 2. Redistributions in binary form must reproduce the above copyright
39 * notice, this list of conditions and the following disclaimer in the
40 * documentation and/or other materials provided with the distribution.
41 * 3. All advertising materials mentioning features or use of this software
42 * must display the following acknowledgement:
43 * This product includes software developed by the University of
44 * California, Berkeley and its contributors.
45 * 4. Neither the name of the University nor the names of its contributors
46 * may be used to endorse or promote products derived from this software
47 * without specific prior written permission.
48 *
49 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59 * SUCH DAMAGE.
60 *
61 * @(#)mount.h 8.21 (Berkeley) 5/20/95
62 */
63/*
64 * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
65 * support for mandatory and extensible security protections. This notice
66 * is included in support of clause 2.2 (b) of the Apple Public License,
67 * Version 2.0.
68 */
69
70
71#ifndef _SYS_MOUNT_H_
72#define _SYS_MOUNT_H_
73
74#include <sys/appleapiopts.h>
75#include <sys/cdefs.h>
76#include <sys/attr.h> /* needed for vol_capabilities_attr_t */
77#include <os/base.h>
78
79#ifndef KERNEL
80#include <stdint.h>
81#include <sys/ucred.h>
82#include <sys/queue.h> /* XXX needed for user builds */
83#include <Availability.h>
84#else
85#include <sys/kernel_types.h>
86#include <uuid/uuid.h>
87#endif
88
89#include <sys/_types/_fsid_t.h> /* file system id type */
90#include <sys/_types/_graftdmg_un.h>
91#include <sys/_types/_mount_t.h>
92#include <sys/_types/_vnode_t.h>
93
94/*
95 * file system statistics
96 */
97
98#define MFSNAMELEN 15 /* length of fs type name, not inc. null */
99#define MFSTYPENAMELEN 16 /* length of fs type name including null */
100
101#if __DARWIN_64_BIT_INO_T
102#define MNAMELEN MAXPATHLEN /* length of buffer for returned name */
103#else /* ! __DARWIN_64_BIT_INO_T */
104#define MNAMELEN 90 /* length of buffer for returned name */
105#endif /* __DARWIN_64_BIT_INO_T */
106
107#define MNT_EXT_ROOT_DATA_VOL 0x00000001 /* Data volume of root volume group */
108#define MNT_EXT_FSKIT 0x00000002 /* this is an FSKit mount */
109
110#define __DARWIN_STRUCT_STATFS64 { \
111 uint32_t f_bsize; /* fundamental file system block size */ \
112 int32_t f_iosize; /* optimal transfer block size */ \
113 uint64_t f_blocks; /* total data blocks in file system */ \
114 uint64_t f_bfree; /* free blocks in fs */ \
115 uint64_t f_bavail; /* free blocks avail to non-superuser */ \
116 uint64_t f_files; /* total file nodes in file system */ \
117 uint64_t f_ffree; /* free file nodes in fs */ \
118 fsid_t f_fsid; /* file system id */ \
119 uid_t f_owner; /* user that mounted the filesystem */ \
120 uint32_t f_type; /* type of filesystem */ \
121 uint32_t f_flags; /* copy of mount exported flags */ \
122 uint32_t f_fssubtype; /* fs sub-type (flavor) */ \
123 char f_fstypename[MFSTYPENAMELEN]; /* fs type name */ \
124 char f_mntonname[MAXPATHLEN]; /* directory on which mounted */ \
125 char f_mntfromname[MAXPATHLEN]; /* mounted filesystem */ \
126 uint32_t f_flags_ext; /* extended flags */ \
127 uint32_t f_reserved[7]; /* For future use */ \
128}
129
130#if !__DARWIN_ONLY_64_BIT_INO_T
131
132struct statfs64 __DARWIN_STRUCT_STATFS64;
133
134#endif /* !__DARWIN_ONLY_64_BIT_INO_T */
135
136#if __DARWIN_64_BIT_INO_T
137
138struct statfs __DARWIN_STRUCT_STATFS64;
139
140#else /* !__DARWIN_64_BIT_INO_T */
141
142/*
143 * LP64 - WARNING - must be kept in sync with struct user_statfs in mount_internal.h.
144 */
145struct statfs {
146 short f_otype; /* TEMPORARY SHADOW COPY OF f_type */
147 short f_oflags; /* TEMPORARY SHADOW COPY OF f_flags */
148 long f_bsize; /* fundamental file system block size */
149 long f_iosize; /* optimal transfer block size */
150 long f_blocks; /* total data blocks in file system */
151 long f_bfree; /* free blocks in fs */
152 long f_bavail; /* free blocks avail to non-superuser */
153 long f_files; /* total file nodes in file system */
154 long f_ffree; /* free file nodes in fs */
155 fsid_t f_fsid; /* file system id */
156 uid_t f_owner; /* user that mounted the filesystem */
157 short f_reserved1; /* spare for later */
158 short f_type; /* type of filesystem */
159 long f_flags; /* copy of mount exported flags */
160 long f_reserved2[2]; /* reserved for future use */
161 char f_fstypename[MFSNAMELEN]; /* fs type name */
162 char f_mntonname[MNAMELEN]; /* directory on which mounted */
163 char f_mntfromname[MNAMELEN];/* mounted filesystem */
164 char f_reserved3; /* For alignment */
165 long f_reserved4[4]; /* For future use */
166};
167
168#endif /* __DARWIN_64_BIT_INO_T */
169
170#pragma pack(4)
171
172struct vfsstatfs {
173 uint32_t f_bsize; /* fundamental file system block size */
174 size_t f_iosize; /* optimal transfer block size */
175 uint64_t f_blocks; /* total data blocks in file system */
176 uint64_t f_bfree; /* free blocks in fs */
177 uint64_t f_bavail; /* free blocks avail to non-superuser */
178 uint64_t f_bused; /* free blocks avail to non-superuser */
179 uint64_t f_files; /* total file nodes in file system */
180 uint64_t f_ffree; /* free file nodes in fs */
181 fsid_t f_fsid; /* file system id */
182 uid_t f_owner; /* user that mounted the filesystem */
183 uint64_t f_flags; /* copy of mount exported flags */
184 char f_fstypename[MFSTYPENAMELEN];/* fs type name inclus */
185 char f_mntonname[MAXPATHLEN];/* directory on which mounted */
186 char f_mntfromname[MAXPATHLEN];/* mounted filesystem */
187 uint32_t f_fssubtype; /* fs sub-type (flavor) */
188 void *f_reserved[2]; /* For future use == 0 */
189};
190
191#pragma pack()
192
193#ifdef KERNEL
194/*
195 * Kernel level support for the VFS_GETATTR(), VFS_SETATTR() for use in
196 * implementation of filesystem KEXTs, and by the vfs_getattr() and
197 * vfs_setattr() KPIs.
198 */
199
200#define VFSATTR_INIT(s) ((s)->f_supported = (s)->f_active = 0LL)
201#define VFSATTR_SET_SUPPORTED(s, a) ((s)->f_supported |= VFSATTR_ ## a)
202#define VFSATTR_IS_SUPPORTED(s, a) ((s)->f_supported & VFSATTR_ ## a)
203#define VFSATTR_CLEAR_ACTIVE(s, a) ((s)->f_active &= ~VFSATTR_ ## a)
204#define VFSATTR_IS_ACTIVE(s, a) ((s)->f_active & VFSATTR_ ## a)
205#define VFSATTR_ALL_SUPPORTED(s) (((s)->f_active & (s)->f_supported) == (s)->f_active)
206#define VFSATTR_WANTED(s, a) ((s)->f_active |= VFSATTR_ ## a)
207#define VFSATTR_RETURN(s, a, x) do { (s)-> a = (x); VFSATTR_SET_SUPPORTED(s, a);} while(0)
208
209#define VFSATTR_f_objcount (1LL<< 0)
210#define VFSATTR_f_filecount (1LL<< 1)
211#define VFSATTR_f_dircount (1LL<< 2)
212#define VFSATTR_f_maxobjcount (1LL<< 3)
213#define VFSATTR_f_bsize (1LL<< 4)
214#define VFSATTR_f_iosize (1LL<< 5)
215#define VFSATTR_f_blocks (1LL<< 6)
216#define VFSATTR_f_bfree (1LL<< 7)
217#define VFSATTR_f_bavail (1LL<< 8)
218#define VFSATTR_f_bused (1LL<< 9)
219#define VFSATTR_f_files (1LL<< 10)
220#define VFSATTR_f_ffree (1LL<< 11)
221#define VFSATTR_f_fsid (1LL<< 12)
222#define VFSATTR_f_owner (1LL<< 13)
223#define VFSATTR_f_capabilities (1LL<< 14)
224#define VFSATTR_f_attributes (1LL<< 15)
225#define VFSATTR_f_create_time (1LL<< 16)
226#define VFSATTR_f_modify_time (1LL<< 17)
227#define VFSATTR_f_access_time (1LL<< 18)
228#define VFSATTR_f_backup_time (1LL<< 19)
229#define VFSATTR_f_fssubtype (1LL<< 20)
230#define VFSATTR_f_vol_name (1LL<< 21)
231#define VFSATTR_f_signature (1LL<< 22)
232#define VFSATTR_f_carbon_fsid (1LL<< 23)
233#define VFSATTR_f_uuid (1LL<< 24)
234#define VFSATTR_f_quota (1LL<< 25)
235#define VFSATTR_f_reserved (1LL<< 26)
236
237
238/*
239 * Argument structure.
240 */
241#pragma pack(4)
242/*
243 * Note: the size of the vfs_attr structure can change.
244 * A kext should only reference the fields that are
245 * marked as active; it should not depend on the actual
246 * size of the structure or attempt to copy it.
247 */
248struct vfs_attr {
249 uint64_t f_supported;
250 uint64_t f_active;
251
252 uint64_t f_objcount; /* number of filesystem objects in volume */
253 uint64_t f_filecount; /* ... files */
254 uint64_t f_dircount; /* ... directories */
255 uint64_t f_maxobjcount; /* maximum number of filesystem objects */
256
257 uint32_t f_bsize; /* block size for the below size values */
258 size_t f_iosize; /* optimal transfer block size */
259 uint64_t f_blocks; /* total data blocks in file system */
260 uint64_t f_bfree; /* free blocks in fs */
261 uint64_t f_bavail; /* free blocks avail to non-superuser */
262 uint64_t f_bused; /* blocks in use */
263 uint64_t f_files; /* total file nodes in file system */
264 uint64_t f_ffree; /* free file nodes in fs */
265 fsid_t f_fsid; /* file system id */
266 uid_t f_owner; /* user that mounted the filesystem */
267
268 vol_capabilities_attr_t f_capabilities;
269 vol_attributes_attr_t f_attributes;
270
271 struct timespec f_create_time; /* creation time */
272 struct timespec f_modify_time; /* last modification time */
273 struct timespec f_access_time; /* time of last access */
274 struct timespec f_backup_time; /* last backup time */
275
276 uint32_t f_fssubtype; /* filesystem subtype */
277
278 char *f_vol_name; /* volume name */
279
280 uint16_t f_signature; /* used for ATTR_VOL_SIGNATURE, Carbon's FSVolumeInfo.signature */
281 uint16_t f_carbon_fsid; /* same as Carbon's FSVolumeInfo.filesystemID */
282 uuid_t f_uuid; /* file system UUID (version 3 or 5), available in 10.6 and later */
283 uint64_t f_quota; /* total quota data blocks in file system */
284 uint64_t f_reserved; /* total reserved data blocks in file system */
285};
286
287#pragma pack()
288
289#endif /* KERNEL */
290
291/*
292 * User specifiable flags.
293 *
294 * Unmount uses MNT_FORCE flag.
295 */
296#define MNT_RDONLY 0x00000001 /* read only filesystem */
297#define MNT_SYNCHRONOUS 0x00000002 /* file system written synchronously */
298#define MNT_NOEXEC 0x00000004 /* can't exec from filesystem */
299#define MNT_NOSUID 0x00000008 /* don't honor setuid bits on fs */
300#define MNT_NODEV 0x00000010 /* don't interpret special files */
301#define MNT_UNION 0x00000020 /* union with underlying filesystem */
302#define MNT_ASYNC 0x00000040 /* file system written asynchronously */
303#define MNT_CPROTECT 0x00000080 /* file system supports content protection */
304
305/*
306 * NFS export related mount flags.
307 */
308#define MNT_EXPORTED 0x00000100 /* file system is exported */
309
310/*
311 * Denotes storage which can be removed from the system by the user.
312 */
313
314#define MNT_REMOVABLE 0x00000200
315
316/*
317 * MAC labeled / "quarantined" flag
318 */
319#define MNT_QUARANTINE 0x00000400 /* file system is quarantined */
320
321/*
322 * Flags set by internal operations.
323 */
324#define MNT_LOCAL 0x00001000 /* filesystem is stored locally */
325#define MNT_QUOTA 0x00002000 /* quotas are enabled on filesystem */
326#define MNT_ROOTFS 0x00004000 /* identifies the root filesystem */
327#define MNT_DOVOLFS 0x00008000 /* FS supports volfs (deprecated flag in Mac OS X 10.5) */
328
329
330#define MNT_DONTBROWSE 0x00100000 /* file system is not appropriate path to user data */
331#define MNT_IGNORE_OWNERSHIP 0x00200000 /* VFS will ignore ownership information on filesystem objects */
332#define MNT_AUTOMOUNTED 0x00400000 /* filesystem was mounted by automounter */
333#define MNT_JOURNALED 0x00800000 /* filesystem is journaled */
334#define MNT_NOUSERXATTR 0x01000000 /* Don't allow user extended attributes */
335#define MNT_DEFWRITE 0x02000000 /* filesystem should defer writes */
336#define MNT_MULTILABEL 0x04000000 /* MAC support for individual labels */
337#define MNT_NOFOLLOW 0x08000000 /* don't follow symlink when resolving mount point */
338#define MNT_NOATIME 0x10000000 /* disable update of file access time */
339#define MNT_SNAPSHOT 0x40000000 /* The mount is a snapshot */
340#define MNT_STRICTATIME 0x80000000 /* enable strict update of file access time */
341#ifdef BSD_KERNEL_PRIVATE
342/* #define MNT_IMGSRC_BY_INDEX 0x20000000 see sys/imgsrc.h */
343#endif /* BSD_KERNEL_PRIVATE */
344
345/* backwards compatibility only */
346#define MNT_UNKNOWNPERMISSIONS MNT_IGNORE_OWNERSHIP
347
348
349/*
350 * XXX I think that this could now become (~(MNT_CMDFLAGS))
351 * but the 'mount' program may need changing to handle this.
352 */
353#define MNT_VISFLAGMASK (MNT_RDONLY | MNT_SYNCHRONOUS | MNT_NOEXEC | \
354 MNT_NOSUID | MNT_NODEV | MNT_UNION | \
355 MNT_ASYNC | MNT_EXPORTED | MNT_QUARANTINE | \
356 MNT_LOCAL | MNT_QUOTA | MNT_REMOVABLE | \
357 MNT_ROOTFS | MNT_DOVOLFS | MNT_DONTBROWSE | \
358 MNT_IGNORE_OWNERSHIP | MNT_AUTOMOUNTED | MNT_JOURNALED | \
359 MNT_NOUSERXATTR | MNT_DEFWRITE | MNT_MULTILABEL | \
360 MNT_NOFOLLOW | MNT_NOATIME | MNT_STRICTATIME | \
361 MNT_SNAPSHOT | MNT_CPROTECT)
362/*
363 * External filesystem command modifier flags.
364 * Unmount can use the MNT_FORCE flag.
365 * XXX These are not STATES and really should be somewhere else.
366 * External filesystem control flags.
367 */
368#define MNT_UPDATE 0x00010000 /* not a real mount, just an update */
369#define MNT_NOBLOCK 0x00020000 /* don't block unmount if not responding */
370#define MNT_RELOAD 0x00040000 /* reload filesystem data */
371#define MNT_FORCE 0x00080000 /* force unmount or readonly change */
372#define MNT_CMDFLAGS (MNT_UPDATE|MNT_NOBLOCK|MNT_RELOAD|MNT_FORCE)
373
374
375
376/*
377 * Sysctl CTL_VFS definitions.
378 *
379 * Second level identifier specifies which filesystem. Second level
380 * identifier VFS_GENERIC returns information about all filesystems.
381 */
382#define VFS_GENERIC 0 /* generic filesystem information */
383#define VFS_NUMMNTOPS 1 /* int: total num of vfs mount/unmount operations */
384/*
385 * Third level identifiers for VFS_GENERIC are given below; third
386 * level identifiers for specific filesystems are given in their
387 * mount specific header files.
388 */
389#define VFS_MAXTYPENUM 1 /* int: highest defined filesystem type */
390#define VFS_CONF 2 /* struct: vfsconf for filesystem given
391 * as next argument */
392
393/*
394 * Flags for various system call interfaces.
395 *
396 * waitfor flags to vfs_sync() and getfsstat()
397 */
398#define MNT_WAIT 1 /* synchronized I/O file integrity completion */
399#define MNT_NOWAIT 2 /* start all I/O, but do not wait for it */
400#define MNT_DWAIT 4 /* synchronized I/O data integrity completion */
401#ifdef KERNEL
402/* only for VFS_SYNC */
403#define MNT_VOLUME 8 /* sync on a single mounted filesystem */
404#endif
405
406
407/* Reserved fields preserve binary compatibility */
408struct vfsconf {
409 uint32_t vfc_reserved1; /* opaque */
410 char vfc_name[MFSNAMELEN]; /* filesystem type name */
411 int vfc_typenum; /* historic filesystem type number */
412 int vfc_refcount; /* number mounted of this type */
413 int vfc_flags; /* permanent flags */
414 uint32_t vfc_reserved2; /* opaque */
415 uint32_t vfc_reserved3; /* opaque */
416};
417
418struct vfsidctl {
419 int vc_vers; /* should be VFSIDCTL_VERS1 (below) */
420 fsid_t vc_fsid; /* fsid to operate on. */
421 void *vc_ptr; /* pointer to data structure. */
422 size_t vc_len; /* sizeof said structure. */
423 u_int32_t vc_spare[12]; /* spare (must be zero). */
424};
425
426
427/* vfsidctl API version. */
428#define VFS_CTL_VERS1 0x01
429
430#ifdef KERNEL
431struct user_vfsidctl {
432 int vc_vers; /* should be VFSIDCTL_VERS1 (below) */
433 fsid_t vc_fsid; /* fsid to operate on. */
434 user_addr_t vc_ptr __attribute((aligned(8))); /* pointer to data structure. */
435 user_size_t vc_len; /* sizeof said structure. */
436 u_int32_t vc_spare[12]; /* spare (must be zero). */
437};
438
439struct user32_vfsidctl {
440 int vc_vers; /* should be VFSIDCTL_VERS1 (below) */
441 fsid_t vc_fsid; /* fsid to operate on. */
442 user32_addr_t vc_ptr; /* pointer to data structure. */
443 user32_size_t vc_len; /* sizeof said structure. */
444 u_int32_t vc_spare[12]; /* spare (must be zero). */
445};
446
447union union_vfsidctl { /* the fields vc_vers and vc_fsid are compatible */
448 struct user32_vfsidctl vc32;
449 struct user_vfsidctl vc64;
450};
451
452#endif /* KERNEL */
453
454/*
455 * New style VFS sysctls, do not reuse/conflict with the namespace for
456 * private sysctls.
457 */
458#define VFS_CTL_OSTATFS 0x00010001 /* old legacy statfs */
459#define VFS_CTL_UMOUNT 0x00010002 /* unmount */
460#define VFS_CTL_QUERY 0x00010003 /* anything wrong? (vfsquery) */
461#define VFS_CTL_NEWADDR 0x00010004 /* reconnect to new address */
462#define VFS_CTL_TIMEO 0x00010005 /* set timeout for vfs notification */
463#define VFS_CTL_NOLOCKS 0x00010006 /* disable file locking */
464#define VFS_CTL_SADDR 0x00010007 /* get server address */
465#define VFS_CTL_DISC 0x00010008 /* server disconnected */
466#define VFS_CTL_SERVERINFO 0x00010009 /* information about fs server */
467#define VFS_CTL_NSTATUS 0x0001000A /* netfs mount status */
468#define VFS_CTL_STATFS64 0x0001000B /* statfs64 */
469
470#ifndef KERNEL
471/*
472 * Automatically select the correct VFS_CTL_*STATFS* flavor based
473 * on what "struct statfs" layout the client will use.
474 */
475#if __DARWIN_64_BIT_INO_T
476#define VFS_CTL_STATFS VFS_CTL_STATFS64
477#else
478#define VFS_CTL_STATFS VFS_CTL_OSTATFS
479#endif
480#endif /* ! KERNEL */
481
482struct vfsquery {
483 u_int32_t vq_flags;
484 u_int32_t vq_spare[31];
485};
486
487struct vfs_server {
488 int32_t vs_minutes; /* minutes until server goes down. */
489 u_int8_t vs_server_name[MAXHOSTNAMELEN * 3]; /* UTF8 server name to display (null terminated) */
490};
491
492/*
493 * NetFS mount status - returned by VFS_CTL_NSTATUS
494 */
495struct netfs_status {
496 u_int32_t ns_status; // Current status of mount (vfsquery flags)
497 char ns_mountopts[512]; // Significant mount options
498 uint32_t ns_waittime; // Time waiting for reply (sec)
499 uint32_t ns_threadcount; // Number of threads blocked on network calls
500 uint64_t ns_threadids[0]; // Thread IDs of those blocked threads
501};
502
503/* vfsquery flags */
504#define VQ_NOTRESP 0x0001 /* server down */
505#define VQ_NEEDAUTH 0x0002 /* server bad auth */
506#define VQ_LOWDISK 0x0004 /* we're low on space */
507#define VQ_MOUNT 0x0008 /* new filesystem arrived */
508#define VQ_UNMOUNT 0x0010 /* filesystem has left */
509#define VQ_DEAD 0x0020 /* filesystem is dead, needs force unmount */
510#define VQ_ASSIST 0x0040 /* filesystem needs assistance from external program */
511#define VQ_NOTRESPLOCK 0x0080 /* server lockd down */
512#define VQ_UPDATE 0x0100 /* filesystem information has changed */
513#define VQ_VERYLOWDISK 0x0200 /* file system has *very* little disk space left */
514#define VQ_SYNCEVENT 0x0400 /* a sync just happened (not set by kernel starting Mac OS X 10.9) */
515#define VQ_SERVEREVENT 0x0800 /* server issued notification/warning */
516#define VQ_QUOTA 0x1000 /* a user quota has been hit */
517#define VQ_NEARLOWDISK 0x2000 /* Above lowdisk and below desired disk space */
518#define VQ_DESIRED_DISK 0x4000 /* the desired disk space */
519#define VQ_FREE_SPACE_CHANGE 0x8000 /* free disk space has significantly changed */
520#define VQ_FLAG10000 0x10000 /* placeholder */
521
522
523#ifdef KERNEL
524
525/* Structure for setting device IO parameters per mount point */
526struct vfsioattr {
527 u_int32_t io_maxreadcnt; /* Max. byte count for read */
528 u_int32_t io_maxwritecnt; /* Max. byte count for write */
529 u_int32_t io_segreadcnt; /* Max. segment count for read */
530 u_int32_t io_segwritecnt; /* Max. segment count for write */
531 u_int32_t io_maxsegreadsize; /* Max. segment read size */
532 u_int32_t io_maxsegwritesize; /* Max. segment write size */
533 u_int32_t io_devblocksize; /* the underlying device block size */
534 u_int32_t io_flags; /* flags for underlying device */
535 union {
536 int64_t io_max_swappin_available;
537 // On 32 bit architectures, we don't have any spare
538 void *io_reserved[2];
539 };
540};
541
542#define VFS_IOATTR_FLAGS_FUA 0x00000001 /* Write-through cache supported */
543#define VFS_IOATTR_FLAGS_UNMAP 0x00000002 /* Unmap (trim) supported */
544#define VFS_IOATTR_FLAGS_SWAPPIN_SUPPORTED 0x00000010 /* Pinning swap file supported */
545
546/*
547 * Filesystem Registration information
548 */
549#define VFS_TBLTHREADSAFE 0x0001 /* Only threadsafe filesystems are supported */
550#define VFS_TBLFSNODELOCK 0x0002 /* Only threadsafe filesystems are supported */
551#define VFS_TBLNOTYPENUM 0x0008
552#define VFS_TBLLOCALVOL 0x0010
553#define VFS_TBL64BITREADY 0x0020
554#define VFS_TBLNATIVEXATTR 0x0040
555#define VFS_TBLDIRLINKS 0x0080
556#define VFS_TBLUNMOUNT_PREFLIGHT 0x0100 /* does a preflight check before unmounting */
557#define VFS_TBLGENERICMNTARGS 0x0200 /* force generic mount args for local fs */
558#define VFS_TBLREADDIR_EXTENDED 0x0400 /* fs supports VNODE_READDIR_EXTENDED */
559#define VFS_TBLNOMACLABEL 0x1000
560#define VFS_TBLVNOP_PAGEINV2 0x2000
561#define VFS_TBLVNOP_PAGEOUTV2 0x4000
562#define VFS_TBLVNOP_NOUPDATEID_RENAME 0x8000 /* vfs should not call vnode_update_ident on rename */
563#define VFS_TBLVNOP_SECLUDE_RENAME 0x10000
564#define VFS_TBLCANMOUNTROOT 0x20000
565
566
567struct vfs_fsentry {
568 struct vfsops * vfe_vfsops; /* vfs operations */
569 int vfe_vopcnt; /* # of vnodeopv_desc being registered (reg, spec, fifo ...) */
570 struct vnodeopv_desc ** vfe_opvdescs; /* null terminated; */
571 int vfe_fstypenum; /* historic filesystem type number */
572 char vfe_fsname[MFSNAMELEN]; /* filesystem type name */
573 uint32_t vfe_flags; /* defines the FS capabilities */
574 void * vfe_reserv[2];/* reserved for future use; set this to zero*/
575};
576
577
578
579struct vfsops {
580 /*!
581 * @field vfs_mount
582 * @abstract Perform filesystem-specific operations required for mounting.
583 * @discussion Typical operations include setting the mount-specific data with vfs_setfsprivate().
584 * Note that if a mount call fails, the filesystem must clean up any state it has constructed, because
585 * vfs-level mount code will not clean it up.
586 * @param mp Mount structure for the newly mounted filesystem.
587 * @param devvp Device that the filesystem is mounted from.
588 * @param data Filesystem-specific data passed down from userspace.
589 * @param context Context to authenticate for mount.
590 * @return 0 for success, else an error code. Once success is returned, the filesystem should be ready to go active;
591 * VFS will not ask again.
592 */
593 int (*vfs_mount)(struct mount *mp, vnode_t devvp, user_addr_t data, vfs_context_t context);
594
595 /*!
596 * @field vfs_start
597 * @abstract Mark a mount as ready to be used.
598 * @discussion After receiving this calldown, a filesystem will be hooked into the mount list and should expect
599 * calls down from the VFS layer.
600 * @param mp Mount structure being activated.
601 * @param flags Unused.
602 * @param context Context to authenticate for mount.
603 * @return Return value is ignored.
604 */
605 int (*vfs_start)(struct mount *mp, int flags, vfs_context_t context);
606
607 /*!
608 * @field vfs_unmount
609 * @abstract Perform filesystem-specific cleanup as part of unmount.
610 * @discussion If the unmount downcall succeeds, VFS considers itself authorized to destroy all
611 * state related to the mount.
612 * @param mp Mount structure to unmount.
613 * @param mntflags MNT_FORCE indicates that we wish to unmount even if there are active vnodes.
614 * @param context Context to authenticate for unmount.
615 * @return 0 for success, else an error code.
616 */
617 int (*vfs_unmount)(struct mount *mp, int mntflags, vfs_context_t context);
618
619 /*!
620 * @field vfs_root
621 * @abstract Get the root vnode of a filesystem.
622 * @discussion Upon success, should return with an iocount held on the root vnode which the caller will
623 * drop with vnode_put().
624 * @param mp Mount for which to get the root.
625 * @param vpp Destination for root vnode.
626 * @param context Context to authenticate for getting the root.
627 * @return 0 for success, else an error code.
628 */
629 int (*vfs_root)(struct mount *mp, struct vnode **vpp, vfs_context_t context);
630
631 /*!
632 * @field vfs_quotactl
633 * @abstract Manipulate quotas for a volume.
634 * @param mp Mount for which to manipulate quotas.
635 * @param cmds Detailed in "quotactl" manual page.
636 * @param uid Detailed in "quotactl" manual page.
637 * @param arg Detailed in "quotactl" manual page.
638 * @param context Context to authenticate for changing quotas.
639 * @return 0 for success, else an error code.
640 */
641 int (*vfs_quotactl)(struct mount *mp, int cmds, uid_t uid, caddr_t arg, vfs_context_t context);
642
643 /*!
644 * @field vfs_getattr
645 * @abstract Get filesystem attributes.
646 * @discussion See VFSATTR_RETURN, VFSATTR_ACTIVE, VFSATTR_SET_SUPPORTED, VFSATTR_WANTED macros.
647 * @param mp Mount for which to get parameters.
648 * @param vfa Container for specifying which attributes are desired and which attributes the filesystem
649 * supports, as well as for returning results.
650 * @param context Context to authenticate for getting filesystem attributes.
651 * @return 0 for success, else an error code.
652 */
653 int (*vfs_getattr)(struct mount *mp, struct vfs_attr *vfa, vfs_context_t context);
654/* int (*vfs_statfs)(struct mount *mp, struct vfsstatfs *sbp, vfs_context_t context);*/
655
656 /*!
657 * @field vfs_sync
658 * @abstract Flush all filesystem data to backing store.
659 * @discussion vfs_sync will be called as part of the sync() system call and during unmount.
660 * @param mp Mountpoint to sync.
661 * @param waitfor MNT_WAIT: flush synchronously, waiting for all data to be written before returning. MNT_NOWAIT: start I/O but do not wait for it.
662 * @param context Context to authenticate for the sync.
663 * @return 0 for success, else an error code.
664 */
665 int (*vfs_sync)(struct mount *mp, int waitfor, vfs_context_t context);
666
667 /*!
668 * @field vfs_vget
669 * @abstract Get a vnode by file id (inode number).
670 * @discussion This routine is chiefly used to build paths to vnodes. Result should be turned with an iocount that the
671 * caller will drop with vnode_put().
672 * @param mp Mount against which to look up inode number.
673 * @param ino File ID for desired file, as found through a readdir.
674 * @param vpp Destination for vnode.
675 * @return 0 for success, else an error code.
676 */
677 int (*vfs_vget)(struct mount *mp, ino64_t ino, struct vnode **vpp, vfs_context_t context);
678
679 /*!
680 * @field vfs_fhtovp
681 * @abstract Get the vnode corresponding to a file handle.
682 * @discussion Filesystems can return handles to files which are independent of their (transient) vnode identities.
683 * vfs_thtovp converts that persistent handle back to a vnode. The vnode should be returned with an iocount which
684 * the caller will drop with vnode_put().
685 * @param mp Mount against which to look up file handle.
686 * @param fhlen Size of file handle structure, as returned by vfs_vptofh.
687 * @param fhp Pointer to handle.
688 * @param vpp Destination for vnode.
689 * @param context Context against which to authenticate the file-handle conversion.
690 * @return 0 for success, else an error code.
691 */
692 int (*vfs_fhtovp)(struct mount *mp, int fhlen, unsigned char *fhp, struct vnode **vpp,
693 vfs_context_t context);
694
695 /*!
696 * @field vfs_vptofh
697 * @abstract Get a persistent handle corresponding to a vnode.
698 * @param vp Vnode against which to obtain the file-handle
699 * @param fhlen Size of buffer provided for handle; set to size of actual handle returned.
700 * @param fhp Pointer to buffer in which to place handle data.
701 * @param context Context against which to authenticate the file-handle request.
702 * @return 0 for success, else an error code.
703 */
704 int (*vfs_vptofh)(struct vnode *vp, int *fhlen, unsigned char *fhp, vfs_context_t context);
705
706 /*!
707 * @field vfs_init
708 * @abstract Prepare a filesystem for having instances mounted.
709 * @discussion This routine is called once, before any particular instance of a filesystem
710 * is mounted; it allows the filesystem to initialize whatever global data structures
711 * are shared across all mounts. If this returns successfully, a filesystem should be ready to have
712 * instances mounted.
713 * @param vfsc Configuration information. Currently, the only useful data are the filesystem name,
714 * typenum, and flags. The flags field will be either 0 or MNT_LOCAL. Many filesystems ignore this
715 * parameter.
716 * @return 0 for success, else an error code.
717 */
718 int (*vfs_init)(struct vfsconf *vfsc);
719
720 /*!
721 * @field vfs_sysctl
722 * @abstract Broad interface for querying and controlling filesystem.
723 * @discussion VFS defines VFS_CTL_QUERY as a generic status request which is answered
724 * with the VQ_* macros in a "struct vfsquery."
725 * A filesystem may also define implementation-specific commands. See "man 3 sysctl"
726 * for the meaning of sysctl parameters.
727 * @param context Context against which to authenticate command.
728 * @return 0 for success, else an error code.
729 */
730 int (*vfs_sysctl)(int *, u_int, user_addr_t, size_t *, user_addr_t, size_t, vfs_context_t context);
731
732 /*!
733 * @field vfs_setattr
734 * @abstract Set filesystem attributes.
735 * @discussion The other side of the vfs_getattr coin. Currently only called to set volume name.
736 * @param mp Mount on which to set attributes.
737 * @param vfa VFS attribute structure containing requested attributes to set and their values. Currently
738 * will only be called with f_vol_name set.
739 * @param context Context against which to authenticate attribute change.
740 * @return 0 for success, else an error code.
741 */
742 int (*vfs_setattr)(struct mount *mp, struct vfs_attr *vfa, vfs_context_t context);
743
744 /*!
745 * @field vfs_ioctl
746 * @abstract File system control operations.
747 * @discussion Unlike vfs_sysctl, this is specific to a particular volume.
748 * @param mp The mount to execute the command on.
749 * @param command Identifier for action to take. The command used here
750 * should be in the same namespace as VNOP ioctl commands.
751 * @param data Pointer to data; this can be an integer constant (of 32 bits
752 * only) or an address to be read from or written to, depending on "command."
753 * If it is an address, it is valid and resides in the kernel; callers of
754 * VFS_IOCTL() are responsible for copying to and from userland.
755 * @param flags Reserved for future use, set to zero
756 * @param context Context against which to authenticate ioctl request.
757 * @return 0 for success, else an error code.
758 */
759 int (*vfs_ioctl)(struct mount *mp, u_long command, caddr_t data,
760 int flags, vfs_context_t context);
761
762 /*!
763 * @field vfs_vget_snapdir
764 * @abstract Get the vnode for the snapshot directory of a filesystem.
765 * @discussion Upon success, should return with an iocount held on the root vnode which the caller will
766 * drop with vnode_put().
767 * @param mp Mount for which to get the root.
768 * @param vpp Destination for snapshot directory vnode.
769 * @param context Context to authenticate for getting the snapshot directory.
770 * @return 0 for success, else an error code.
771 */
772 int (*vfs_vget_snapdir)(struct mount *mp, struct vnode **vpp, vfs_context_t context);
773 void *vfs_reserved5;
774 void *vfs_reserved4;
775 void *vfs_reserved3;
776 void *vfs_reserved2;
777 void *vfs_reserved1;
778};
779
780#ifdef KERNEL
781
782/*
783 * Commands for vfs_ioctl. While they are encoded the same way as for ioctl(2),
784 * there is no generic interface for them from userspace like ioctl(2).
785 */
786struct fs_snapshot_mount_args {
787 mount_t sm_mp;
788 struct componentname *sm_cnp;
789};
790
791#define VFSIOC_MOUNT_SNAPSHOT _IOW('V', 1, struct fs_snapshot_mount_args)
792
793struct fs_snapshot_revert_args {
794 struct componentname *sr_cnp;
795};
796#define VFSIOC_REVERT_SNAPSHOT _IOW('V', 2, struct fs_snapshot_revert_args)
797
798struct fs_snapshot_root_args {
799 struct componentname *sr_cnp;
800};
801#define VFSIOC_ROOT_SNAPSHOT _IOW('V', 3, struct fs_snapshot_root_args)
802
803typedef struct fs_role_mount_args {
804 mount_t root_mp;
805 uint32_t mount_role;
806} fs_role_mount_args_t;
807
808OS_ENUM(vfs_roles, uint32_t,
809 VFS_SYSTEM_ROLE = 1,
810 VFS_RECOVERY_ROLE = 4,
811 VFS_VM_ROLE = 8,
812 VFS_PREBOOT_ROLE = 16,
813 VFS_DATA_ROLE = 64);
814
815#define VFSIOC_MOUNT_BYROLE _IOW('V', 4, fs_role_mount_args_t)
816
817// When this is defined, it is safe to use VFS_RECOVERY_ROLE and
818// VFS_PREBOOT_ROLE.
819#define VFSIOC_MOUNT_BYROLE_has_recovery 1
820
821#endif /* KERNEL */
822
823/*
824 * flags passed into vfs_iterate
825 */
826#ifdef PRIVATE
827#define VFS_ITERATE_TAIL_FIRST (1 << 0)
828#define VFS_ITERATE_CB_DROPREF (1 << 1) // Callback will drop the iterref
829#define VFS_ITERATE_NOSKIP_UNMOUNT (1 << 2) /* Callback will be made on FS in unmount.
830 * The callback cannot make any calls
831 * into the Filesystem when this is set. */
832#endif /* PRIVATE */
833
834/*
835 * return values from callback
836 */
837#define VFS_RETURNED 0 /* done with vnode, reference can be dropped */
838#define VFS_RETURNED_DONE 1 /* done with vnode, reference can be dropped, terminate iteration */
839#define VFS_CLAIMED 2 /* don't drop reference */
840#define VFS_CLAIMED_DONE 3 /* don't drop reference, terminate iteration */
841
842
843__BEGIN_DECLS
844#ifdef BSD_KERNEL_PRIVATE
845extern int VFS_MOUNT(mount_t, vnode_t, user_addr_t, vfs_context_t);
846extern int VFS_START(mount_t, int, vfs_context_t);
847extern int VFS_UNMOUNT(mount_t, int, vfs_context_t);
848extern int VFS_ROOT(mount_t, vnode_t *, vfs_context_t);
849extern int VFS_QUOTACTL(mount_t, int, uid_t, caddr_t, vfs_context_t);
850extern int VFS_GETATTR(mount_t, struct vfs_attr *, vfs_context_t);
851extern int VFS_SETATTR(mount_t, struct vfs_attr *, vfs_context_t);
852extern int VFS_SYNC(mount_t, int, vfs_context_t);
853extern int VFS_VGET(mount_t, ino64_t, vnode_t *, vfs_context_t);
854extern int VFS_FHTOVP(mount_t, int, unsigned char *, vnode_t *, vfs_context_t);
855extern int VFS_VPTOFH(vnode_t, int *, unsigned char *, vfs_context_t);
856extern int VFS_IOCTL(mount_t mp, u_long command, caddr_t data,
857 int flags, vfs_context_t context);
858extern int VFS_VGET_SNAPDIR(mount_t, vnode_t *, vfs_context_t);
859#endif /* BSD_KERNEL_PRIVATE */
860/*
861 * prototypes for exported VFS operations
862 */
863
864/*!
865 * @function vfs_fsadd
866 * @abstract Register a filesystem with VFS.
867 * @discussion Typically called by a filesystem Kernel Extension when it is loaded.
868 * @param vfe Filesystem information: table of vfs operations, list of vnode operation tables,
869 * filesystem type number (can be omitted with VFS_TBLNOTYPENUM flag), name, flags.
870 * @param handle Opaque handle which will be passed to vfs_fsremove.
871 * @return 0 for success, else an error code.
872 */
873int vfs_fsadd(struct vfs_fsentry *vfe, vfstable_t *handle);
874
875/*!
876 * @function vfs_fsremove
877 * @abstract Unregister a filesystem with VFS.
878 * @discussion Typically called by a filesystem Kernel Extension when it is unloaded.
879 * @param handle Handle which was returned by vfs_fsadd.
880 * @return 0 for success, else an error code.
881 */
882int vfs_fsremove(vfstable_t handle);
883
884/*!
885 * @function vfs_iterate
886 * @abstract Iterate over all mountpoints with a callback. Used, for example, by sync().
887 * @param flags Unused.
888 * @param callout Function which takes a mount and arbitrary passed-in "arg," and returns one of VFS_RETURNED_DONE or VFS_CLAIMED_DONE: end
889 * iteration and return success. VFS_RETURNED or VFS_CLAIMED: continue iterating. Anything else: continue iterating.
890 * @param arg Arbitrary data to pass to callback.
891 * @return 0 for success, else an error code.
892 */
893int vfs_iterate(int flags, int (*callout)(struct mount *, void *), void *arg);
894
895/*!
896 * @function vfs_init_io_attributes
897 * @abstract Set I/O attributes on a mountpoint based on device properties.
898 * @param devvp Block device vnode from which a filesystem is being mounted.
899 * @param mp Mountpoint whose I/O parameters to initialize.
900 * @return 0 for success, else an error code.
901 */
902int vfs_init_io_attributes(vnode_t devvp, mount_t mp);
903
904/*!
905 * @function vfs_flags
906 * @abstract Retrieve mount flags.
907 * @discussion Results will be in the bitwise "OR" of MNT_VISFLAGMASK and MNT_CMDFLAGS.
908 * @param mp Mount whose flags to grab.
909 * @return Flags.
910 */
911uint64_t vfs_flags(mount_t mp);
912
913/*!
914 * @function vfs_setflags
915 * @abstract Set flags on a mount.
916 * @discussion Sets mount flags to the bitwise "OR" of their current value and the specified bits. Often
917 * used by a filesystem as part of the mount process.
918 * @param mp Mount whose flags to set.
919 * @param flags Flags to activate. Must be in the bitwise "OR" of MNT_VISFLAGMASK and MNT_CMDFLAGS.
920 */
921void vfs_setflags(mount_t mp, uint64_t flags);
922
923/*!
924 * @function vfs_clearflags
925 * @abstract Clear flags on a mount.
926 * @discussion Sets mount flags to the bitwise "AND" of their current value and the complement of the specified bits.
927 * @param mp Mount whose flags to set.
928 * @param flags Flags to deactivate. Must be in the bitwise "OR" of MNT_VISFLAGMASK and MNT_CMDFLAGS.
929 */
930void vfs_clearflags(mount_t mp, uint64_t flags);
931
932/*!
933 * @function vfs_issynchronous
934 * @abstract Determine if writes to a filesystem occur synchronously.
935 * @param mp Mount to test.
936 * @return Nonzero if writes occur synchronously, else 0.
937 */
938int vfs_issynchronous(mount_t mp);
939
940/*!
941 * @function vfs_iswriteupgrade
942 * @abstract Determine if a filesystem is mounted read-only but a request has been made to upgrade
943 * to read-write.
944 * @param mp Mount to test.
945 * @return Nonzero if a request has been made to update from read-only to read-write, else 0.
946 */
947int vfs_iswriteupgrade(mount_t mp);
948
949/*!
950 * @function vfs_isupdate
951 * @abstract Determine if a mount update is in progress.
952 * @param mp Mount to test.
953 * @return Nonzero if a mount update is in progress, 0 otherwise.
954 */
955int vfs_isupdate(mount_t mp);
956
957/*!
958 * @function vfs_isreload
959 * @abstract Determine if a reload of filesystem data is in progress. This can only be the case
960 * for a read-only filesystem; all data is brought in from secondary storage.
961 * @param mp Mount to test.
962 * @return Nonzero if a request has been made to reload data, else 0.
963 */
964int vfs_isreload(mount_t mp);
965
966/*!
967 * @function vfs_isforce
968 * @abstract Determine if a forced unmount is in progress.
969 * @discussion A forced unmount invalidates open files.
970 * @param mp Mount to test.
971 * @return Nonzero if a request has been made to forcibly unmount, else 0.
972 */
973int vfs_isforce(mount_t mp);
974
975/*!
976 * @function vfs_isunmount
977 * @abstract Determine if an unmount is in progress.
978 * @discussion This is an unsynchronized snapshot of the mount state. It should only be called
979 * if the mount is known to be valid, e.g. there are known to be live files on that volume.
980 * @param mp Mount to test.
981 * @return Nonzero if an unmount is in progress, else zero.
982 */
983int vfs_isunmount(mount_t mp);
984
985/*!
986 * @function vfs_isrdonly
987 * @abstract Determine if a filesystem is mounted read-only.
988 * @param mp Mount to test.
989 * @return Nonzero if filesystem is mounted read-only, else 0.
990 */
991int vfs_isrdonly(mount_t mp);
992
993/*!
994 * @function vfs_isrdwr
995 * @abstract Determine if a filesystem is mounted with writes enabled.
996 * @param mp Mount to test.
997 * @return Nonzero if filesystem is mounted read-write, else 0.
998 */
999int vfs_isrdwr(mount_t mp);
1000
1001/*!
1002 * @function vfs_authopaque
1003 * @abstract Determine if a filesystem's authorization decisions occur remotely.
1004 * @param mp Mount to test.
1005 * @return Nonzero if filesystem authorization is controlled remotely, else 0.
1006 */
1007int vfs_authopaque(mount_t mp);
1008
1009/*!
1010 * @function vfs_authopaqueaccess
1011 * @abstract Check if a filesystem is marked as having reliable remote VNOP_ACCESS support.
1012 * @param mp Mount to test.
1013 * @return Nonzero if VNOP_ACCESS is supported remotely, else 0.
1014 */
1015int vfs_authopaqueaccess(mount_t mp);
1016
1017/*!
1018 * @function vfs_setauthopaque
1019 * @abstract Mark a filesystem as having authorization decisions controlled remotely.
1020 * @param mp Mount to mark.
1021 */
1022void vfs_setauthopaque(mount_t mp);
1023
1024/*!
1025 * @function vfs_setauthopaqueaccess
1026 * @abstract Mark a filesystem as having remote VNOP_ACCESS support.
1027 * @param mp Mount to mark.
1028 */
1029void vfs_setauthopaqueaccess(mount_t mp);
1030
1031/*!
1032 * @function vfs_clearauthopaque
1033 * @abstract Mark a filesystem as not having remote authorization decisions.
1034 * @param mp Mount to mark.
1035 */
1036void vfs_clearauthopaque(mount_t mp);
1037
1038/*!
1039 * @function vfs_clearauthopaque
1040 * @abstract Mark a filesystem as not having remote VNOP_ACCESS support.
1041 * @param mp Mount to mark.
1042 */
1043void vfs_clearauthopaqueaccess(mount_t mp);
1044
1045/*!
1046 * @function vfs_setextendedsecurity
1047 * @abstract Mark a filesystem as supporting security controls beyond POSIX permissions.
1048 * @discussion Specific controls include ACLs, file owner UUIDs, and group UUIDs.
1049 * @param mp Mount to test.
1050 */
1051void vfs_setextendedsecurity(mount_t mp);
1052
1053/*!
1054 * @function vfs_clearextendedsecurity
1055 * @abstract Mark a filesystem as NOT supporting security controls beyond POSIX permissions.
1056 * @discussion Specific controls include ACLs, file owner UUIDs, and group UUIDs.
1057 * @param mp Mount to test.
1058 */
1059void vfs_clearextendedsecurity(mount_t mp);
1060
1061/*!
1062 * @function vfs_setnoswap
1063 * @abstract Mark a filesystem as unable to use swap files.
1064 * @param mp Mount to mark.
1065 */
1066#ifdef KERNEL_PRIVATE
1067void vfs_setnoswap(mount_t mp);
1068#endif
1069
1070/*!
1071 * @function vfs_clearnoswap
1072 * @abstract Mark a filesystem as capable of using swap files.
1073 * @param mp Mount to mark.
1074 */
1075#ifdef KERNEL_PRIVATE
1076void vfs_clearnoswap(mount_t mp);
1077#endif
1078
1079/*!
1080 * @function vfs_setlocklocal
1081 * @abstract Mark a filesystem as using VFS-level advisory locking support.
1082 * @discussion Advisory locking operations will not call down to the filesystem if this flag is set.
1083 * @param mp Mount to mark.
1084 */
1085void vfs_setlocklocal(mount_t mp);
1086
1087/*!
1088 * @function vfs_authcache_ttl
1089 * @abstract Determine the time-to-live of cached authorized credentials for files in this filesystem.
1090 * @discussion If a filesystem is set to allow caching credentials, the VFS layer can authorize
1091 * previously-authorized actions from the same vfs_context_t without calling down to the filesystem (though
1092 * it will not deny based on the cache).
1093 * @param mp Mount for which to check cache lifetime.
1094 * @return Cache lifetime in seconds. CACHED_RIGHT_INFINITE_TTL indicates that credentials never expire.
1095 */
1096int vfs_authcache_ttl(mount_t mp);
1097
1098/*!
1099 * @function vfs_setauthcache_ttl
1100 * @abstract Enable credential caching and set time-to-live of cached authorized credentials for files in this filesystem.
1101 * @discussion If a filesystem is set to allow caching credentials, the VFS layer can authorize
1102 * previously-authorized actions from the same vfs_context_t without calling down to the filesystem (though
1103 * it will not deny based on the cache).
1104 * @param mp Mount for which to set cache lifetime.
1105 */
1106void vfs_setauthcache_ttl(mount_t mp, int ttl);
1107
1108/*!
1109 * @function vfs_clearauthcache_ttl
1110 * @abstract Remove time-to-live controls for cached credentials on a filesytem. Filesystems with remote authorization
1111 * decisions (opaque) will still have KAUTH_VNODE_SEARCH rights cached for a default of CACHED_LOOKUP_RIGHT_TTL seconds.
1112 * @param mp Mount for which to clear cache lifetime.
1113 */
1114void vfs_clearauthcache_ttl(mount_t mp);
1115
1116/*
1117 * return value from vfs_cachedrights_ttl if
1118 * neither MNTK_AUTH_OPAQUE | MNTK_AUTH_CACHE_TTL
1119 * is set in mnt_kern_flag.. it indicates
1120 * that no TTL is being applied to the vnode rights cache
1121 */
1122#define CACHED_RIGHT_INFINITE_TTL ~0
1123
1124/*!
1125 * @function vfs_maxsymlen
1126 * @abstract Get the maximum length of a symbolic link on a filesystem.
1127 * @param mp Mount from which to get symlink length cap.
1128 * @return Max symlink length.
1129 */
1130uint32_t vfs_maxsymlen(mount_t mp);
1131
1132/*!
1133 * @function vfs_setmaxsymlen
1134 * @abstract Set the maximum length of a symbolic link on a filesystem.
1135 * @param mp Mount on which to set symlink length cap.
1136 * @param symlen Length to set.
1137 */
1138void vfs_setmaxsymlen(mount_t mp, uint32_t symlen);
1139
1140/*!
1141 * @function vfs_fsprivate
1142 * @abstract Get filesystem-private mount data.
1143 * @discussion A filesystem generally has an internal mount structure which it attaches to the VFS-level mount structure
1144 * as part of the mounting process.
1145 * @param mp Mount for which to get private data.
1146 * @return Private data.
1147 */
1148void * vfs_fsprivate(mount_t mp);
1149
1150/*!
1151 * @function vfs_setfsprivate
1152 * @abstract Set filesystem-private mount data.
1153 * @discussion A filesystem generally has an internal mount structure which it attaches to the VFS-level mount structure
1154 * as part of the mounting process.
1155 * @param mp Mount for which to set private data.
1156 */
1157void vfs_setfsprivate(mount_t mp, void *mntdata);
1158
1159/*!
1160 * @function vfs_statfs
1161 * @abstract Get information about filesystem status.
1162 * @discussion Each filesystem has a struct vfsstatfs associated with it which is updated as events occur; this function
1163 * returns a pointer to it. Note that the data in the structure will continue to change over time and also that it may
1164 * be quite stale if vfs_update_vfsstat has not been called recently.
1165 * @param mp Mount for which to get vfsstatfs pointer.
1166 * @return Pointer to vfsstatfs.
1167 */
1168struct vfsstatfs * vfs_statfs(mount_t mp);
1169#define VFS_USER_EVENT 0
1170#define VFS_KERNEL_EVENT 1
1171
1172/*!
1173 * @function vfs_update_vfsstat
1174 * @abstract Update cached filesystem status information in the VFS mount structure.
1175 * @discussion Each filesystem has a struct vfsstatfs associated with it which is updated as events occur; this function
1176 * updates it so that the structure pointer returned by vfs_statfs() returns a pointer to fairly recent data.
1177 * @param mp Mount for which to update cached status information.
1178 * @param ctx Context to authenticate against for call down to filesystem.
1179 * @param eventtype VFS_USER_EVENT: need for update is driven by user-level request; perform additional authentication.
1180 * VFS_KERNEL_EVENT: need for update is driven by in-kernel events. Skip extra authentication.
1181 * @return 0 for success, or an error code for authentication failure or problem with call to filesystem to
1182 * request information.
1183 */
1184int vfs_update_vfsstat(mount_t mp, vfs_context_t ctx, int eventtype);
1185
1186/*!
1187 * @function vfs_typenum
1188 * @abstract Get (archaic) filesystem type number.
1189 * @discussion Filesystem type numbers are an old construct; most filesystems just get a number assigned based on
1190 * the order in which they are registered with the system.
1191 * @param mp Mount for which to get type number.
1192 * @return Type number.
1193 */
1194int vfs_typenum(mount_t mp);
1195
1196/*!
1197 * @function vfs_name
1198 * @abstract Copy filesystem name into a buffer.
1199 * @discussion Get filesystem name; this refers to the filesystem type of which a mount is an instantiation,
1200 * rather than a name specific to the mountpoint.
1201 * @param mp Mount for which to get name.
1202 * @param buffer Destination for name; length should be at least MFSNAMELEN.
1203 */
1204void vfs_name(mount_t mp, char *buffer);
1205
1206/*!
1207 * @function vfs_devblocksize
1208 * @abstract Get the block size of the device underlying a mount.
1209 * @param mp Mount for which to get block size.
1210 * @return Block size.
1211 */
1212int vfs_devblocksize(mount_t mp);
1213
1214/*!
1215 * @function vfs_ioattr
1216 * @abstract Get I/O attributes associated with a mounpoint.
1217 * @param mp Mount for which to get attributes. If NULL, system defaults are filled into ioattrp.
1218 * @param ioattrp Destination for results.
1219 */
1220void vfs_ioattr(mount_t mp, struct vfsioattr *ioattrp);
1221
1222/*!
1223 * @function vfs_setioattr
1224 * @abstract Set I/O attributes associated with a mounpoint.
1225 * @param mp Mount for which to set attributes.
1226 * @param ioattrp Structure containing I/O parameters; all fields must be filled in.
1227 */
1228void vfs_setioattr(mount_t mp, struct vfsioattr *ioattrp);
1229
1230/*!
1231 * @function vfs_64bitready
1232 * @abstract Check if the filesystem associated with a mountpoint is marked ready for interaction with 64-bit user processes.
1233 * @param mp Mount to test.
1234 * @return Nonzero if filesystem is ready for 64-bit; 0 otherwise.
1235 */
1236int vfs_64bitready(mount_t mp);
1237
1238
1239#define LK_NOWAIT 1
1240/*!
1241 * @function vfs_busy
1242 * @abstract "Busy" a mountpoint.
1243 * @discussion vfs_busy() will "busy" a mountpoint, preventing unmounts from taking off, by taking its reader-writer lock
1244 * in a shared manner. If a mount is dead,
1245 * it will fail; if an unmount is in progress, depending on flags, it will either fail immediately or block
1246 * until the unmount completes (then failing if the unmount has succeeded, or potentially succeeding if unmounting failed).
1247 * A successful vfs_busy() must be followed by a vfs_unbusy() to release the lock on the mount.
1248 * @param mp Mount to busy.
1249 * @param flags LK_NOWAIT: fail with ENOENT if an unmount is in progress.
1250 * @return 0 for success, with a lock held; an error code otherwise, with no lock held.
1251 */
1252int vfs_busy(mount_t mp, int flags);
1253
1254/*!
1255 * @function vfs_unbusy
1256 * @abstract "Unbusy" a mountpoint by releasing its read-write lock.
1257 * @discussion A successful vfs_busy() must be followed by a vfs_unbusy() to release the lock on the mount.
1258 * @param mp Mount to unbusy.
1259 */
1260void vfs_unbusy(mount_t mp);
1261
1262/*!
1263 * @function vfs_getnewfsid
1264 * @abstract Generate a unique filesystem ID for a mount and store it in the mount structure.
1265 * @discussion Filesystem IDs are returned as part of "struct statfs." This function is typically
1266 * called as part of file-system specific mount code (i.e. through VFS_MOUNT).
1267 * @param mp Mount to set an ID for.
1268 */
1269void vfs_getnewfsid(struct mount *mp);
1270
1271/*!
1272 * @function vfs_getvfs
1273 * @abstract Given a filesystem ID, look up a mount structure.
1274 * @param fsid Filesystem ID to look up.
1275 * @return Mountpoint if found, else NULL. Note unmounting mountpoints can be returned.
1276 */
1277mount_t vfs_getvfs(fsid_t *fsid);
1278
1279/*!
1280 * @function vfs_getvfs_with_vfsops
1281 * @abstract Given a filesystem ID, look up a mount structure, verify the vfsops
1282 * @param fsid Filesystem ID to look up.
1283 * @return Mountpoint if found and the vfsops matches the expected value, else NULL. Note unmounting mountpoints can be returned.
1284 */
1285mount_t vfs_getvfs_with_vfsops(fsid_t *fsid, const struct vfsops *ops);
1286
1287/*!
1288 * @function vfs_mountedon
1289 * @abstract Check whether a given block device has a filesystem mounted on it.
1290 * @discussion Note that this is NOT a check for a covered vnode (the directory upon which
1291 * a filesystem is mounted)--it is a test for whether a block device is being used as the source
1292 * of a filesystem. Note that a block device marked as being mounted on cannot be opened.
1293 * @param vp The vnode to test.
1294 * @return EBUSY if vnode is indeed the source of a filesystem; 0 if it is not.
1295 */
1296int vfs_mountedon(struct vnode *vp);
1297
1298/*!
1299 * @function vfs_unmountbyfsid
1300 * @abstract Find a filesystem by ID and unmount it.
1301 * @param fsid ID of filesystem to unmount, as found through (for example) statfs.
1302 * @param flags MNT_FORCE: forcibly invalidate files open on the mount (though in-flight I/O operations
1303 * will be allowed to complete).
1304 * @param ctx Context against which to authenticate unmount operation.
1305 * @return 0 for succcess, nonero for failure.
1306 */
1307int vfs_unmountbyfsid(fsid_t *fsid, int flags, vfs_context_t ctx);
1308
1309/*!
1310 * @function vfs_event_signal
1311 * @abstract Post a kqueue-style event on a filesystem (EVFILT_FS).
1312 * @param fsid Unused.
1313 * @param event Events to post.
1314 * @param data Unused.
1315 */
1316void vfs_event_signal(fsid_t *fsid, u_int32_t event, intptr_t data);
1317
1318/*!
1319 * @function vfs_event_init
1320 * @abstract This function should not be called by kexts.
1321 */
1322void vfs_event_init(void); /* XXX We should not export this */
1323
1324/*!
1325 * @function vfs_set_root_unmount_cleanly
1326 * @abstract This function should be called by the root file system
1327 * when it is being mounted if the file system state is consistent.
1328 */
1329void vfs_set_root_unmounted_cleanly(void);
1330
1331#ifdef KERNEL_PRIVATE
1332int vfs_getbyid(fsid_t *fsid, ino64_t ino, vnode_t *vpp, vfs_context_t ctx);
1333int vfs_getattr(mount_t mp, struct vfs_attr *vfa, vfs_context_t ctx);
1334int vfs_setattr(mount_t mp, struct vfs_attr *vfa, vfs_context_t ctx);
1335int vfs_extendedsecurity(mount_t);
1336mount_t vfs_getvfs_by_mntonname(char *);
1337vnode_t vfs_vnodecovered(mount_t mp); /* Returns vnode with an iocount that must be released with vnode_put() */
1338vnode_t vfs_devvp(mount_t mp); /* Please see block comment with implementation */
1339int vfs_nativexattrs(mount_t mp); /* whether or not the FS supports EAs natively */
1340void * vfs_mntlabel(mount_t mp); /* Safe to cast to "struct label*"; returns "void*" to limit dependence of mount.h on security headers. */
1341void vfs_setcompoundopen(mount_t mp);
1342void vfs_setfskit(mount_t mp);
1343char * vfs_getfstypenameref_locked(mount_t mp, size_t *lenp);
1344void vfs_getfstypename(mount_t mp, char *buf, size_t buflen);
1345void vfs_setfstypename_locked(mount_t mp, const char *name);
1346void vfs_setfstypename(mount_t mp, const char *name);
1347uint64_t vfs_throttle_mask(mount_t mp);
1348int vfs_isswapmount(mount_t mp);
1349int vfs_context_dataless_materialization_is_prevented(vfs_context_t);
1350boolean_t vfs_context_is_dataless_manipulator(vfs_context_t);
1351boolean_t vfs_context_can_resolve_triggers(vfs_context_t);
1352boolean_t vfs_context_can_break_leases(vfs_context_t);
1353boolean_t vfs_context_allow_fs_blksize_nocache_write(vfs_context_t);
1354void vfs_setmntsystem(mount_t mp);
1355void vfs_setmntsystemdata(mount_t mp);
1356void vfs_setmntswap(mount_t mp);
1357boolean_t vfs_is_basesystem(mount_t mp);
1358boolean_t vfs_iskernelmount(mount_t mp);
1359
1360boolean_t vfs_shutdown_in_progress(void);
1361boolean_t vfs_shutdown_finished(void);
1362void vfs_update_last_completion_time(void);
1363uint64_t vfs_last_completion_time(void);
1364
1365OS_ENUM(bsd_bootfail_mode, uint32_t,
1366 BSD_BOOTFAIL_SEAL_BROKEN = 1,
1367 BSD_BOOTFAIL_MEDIA_MISSING = 2);
1368
1369boolean_t bsd_boot_to_recovery(bsd_bootfail_mode_t mode, uuid_t volume_uuid, boolean_t reboot);
1370
1371struct vnode_trigger_info;
1372
1373/*!
1374 * @function vfs_addtrigger
1375 * @abstract Create an "external" trigger vnode: look up a vnode and mark it as
1376 * a trigger. Can only safely be called in the context of a callback set by
1377 * vfs_settriggercallback(). May only be used on a file which is not already
1378 * marked as a trigger.
1379 * @param relpath Path relative to root of mountpoint at which to mark trigger.
1380 * @param vtip Information about trigger; analogous to "vnode_trigger_param"
1381 * argument to vnode_create.
1382 * @param ctx Authorization context.
1383 */
1384int vfs_addtrigger(mount_t mp, const char *relpath, struct vnode_trigger_info *vtip, vfs_context_t ctx);
1385
1386
1387/*!
1388 * @enum vfs_trigger_callback_op_t
1389 * @abstract Operation to perform after an attempted unmount (successful or otherwise).
1390 * @constant VTC_REPLACE Unmount failed: attempt to replace triggers. Only valid
1391 * VFS operation to perform in this context is vfs_addtrigger().
1392 * @constant VTC_RELEASE Unmount succeeded: release external triggering context.
1393 */
1394typedef enum {
1395 VTC_REPLACE,
1396 VTC_RELEASE
1397} vfs_trigger_callback_op_t;
1398
1399/*!
1400 * @typedef vfs_trigger_callback_t
1401 * @abstract Callback to be passed to vfs_settriggercallback() and invoked from
1402 * unmount context.
1403 * @param mp Mountpoint on which unmount is occurring.
1404 * @param op Operation (see vfs_trigger_callback_op_t)
1405 * @param data Context passed to vfs_settriggercallback()
1406 * @param ctx Authorization context in which unmount is occurring.
1407 */
1408typedef void vfs_trigger_callback_t(mount_t mp, vfs_trigger_callback_op_t op, void *data, vfs_context_t ctx);
1409
1410/*!
1411 * @function vfs_settriggercallback
1412 * @abstract Install a callback to be called after unmount attempts on a volume,
1413 * to restore triggers for failed unmounts and release state for successful ones.
1414 * @discussion Installs a callback which will be called in two situations: a
1415 * failed unmount where vnodes may have been reclaimed and a successful unmount.
1416 * Gives an external trigger-marking entity an opportunity to replace triggers
1417 * which may have been reclaimed. The callback can only be installed (not
1418 * cleared), and only one callback can be installed. The callback will be called
1419 * with a read-write lock held on the mount point; in the VTC_REPLACE case, the
1420 * <em>only</em> valid VFS operation to perform in the context of the callback is
1421 * vfs_addtrigger() on the mountpoint in question. This rwlock is held in order
1422 * to attempt to provide some modicum of coverage from lookups which might find
1423 * missing trigger vnodes and receive spurious ENOENTs. Note that this
1424 * protection is incomplete--current working directories, or traversals up into a
1425 * volume via ".." may still find missing triggers. As of this writing, no
1426 * serialization mechanism exists to do better than this.
1427 * When the "op" is VTC_RELEASE, the mountpoint is going away, and the only valid
1428 * VFS operation is to free the private data pointer if needed. The callback
1429 * will be called immediately, with VTC_REPLACE, from vfs_settriggercallback(),
1430 * if installation is successful.
1431 * @param fsid FSID for filesystem in question.
1432 * @param vtc Callback pointer.
1433 * @param data Context pointer to be passed to callback.
1434 * @param flags Currently unused.
1435 * @param ctx Authorization context.
1436 * @return 0 for success. EBUSY if a trigger has already been installed.
1437 */
1438int vfs_settriggercallback(fsid_t *fsid, vfs_trigger_callback_t vtc, void *data, uint32_t flags, vfs_context_t ctx);
1439
1440/* tags a volume as not supporting extended readdir for NFS exports */
1441void mount_set_noreaddirext(mount_t);
1442
1443/*!
1444 * @function vfs_get_statfs64
1445 * @abstract Get the same information as vfs_statfs(), but in a format suitable
1446 * for copying to userland.
1447 */
1448void vfs_get_statfs64(struct mount *mp, struct statfs64 *sfs);
1449
1450/*!
1451 * @function vfs_mount_id
1452 * @abstract Retrieve the system-wide unique mount ID for a mount point.
1453 * The ID is generated at mount and does not change on remount.
1454 * @param mp Mountpoint for which to get the mount ID.
1455 */
1456uint64_t vfs_mount_id(mount_t mp);
1457
1458/*!
1459 * @function vfs_mount_at_path
1460 * @abstract A wrapper around kernel_mount() to be used only in special
1461 * circumstances.
1462 */
1463int vfs_mount_at_path(const char *fstype, const char *path,
1464 vnode_t pvp, vnode_t vp, void *data, size_t datalen, int mnt_flags,
1465 int flags);
1466
1467#define VFS_MOUNT_FLAG_NOAUTH 0x01 /* Don't check the UID of the directory we are mounting on */
1468#define VFS_MOUNT_FLAG_PERMIT_UNMOUNT 0x02 /* Allow (non-forced) unmounts by users other the one who mounted the volume */
1469#define VFS_MOUNT_FLAG_CURRENT_CONTEXT 0x04 /* Mount using the current VFS context */
1470
1471#endif /* KERNEL_PRIVATE */
1472__END_DECLS
1473
1474#endif /* KERNEL */
1475
1476/*
1477 * Generic file handle
1478 */
1479#define NFS_MAX_FH_SIZE NFSV4_MAX_FH_SIZE
1480#define NFSV4_MAX_FH_SIZE 128
1481#define NFSV3_MAX_FH_SIZE 64
1482#define NFSV2_MAX_FH_SIZE 32
1483struct fhandle {
1484 unsigned int fh_len; /* length of file handle */
1485 unsigned char fh_data[NFS_MAX_FH_SIZE]; /* file handle value */
1486};
1487typedef struct fhandle fhandle_t;
1488
1489/*
1490 * Cryptex authentication
1491 * Note: these 2 enums are used in conjunction, graftdmg_type is used for authentication while grafting
1492 * cryptexes and cryptex_auth_type is currently used for authentication while mounting generic
1493 * cryptexes. We need to make sure we do not use the reserved values in each for a new authentication type.
1494 */
1495// bump up the version for any change that has kext dependency
1496#define CRYPTEX_AUTH_STRUCT_VERSION 1
1497OS_ENUM(graftdmg_type, uint32_t,
1498 GRAFTDMG_CRYPTEX_BOOT = 1,
1499 GRAFTDMG_CRYPTEX_PREBOOT = 2,
1500 GRAFTDMG_CRYPTEX_DOWNLEVEL = 3,
1501 // Reserved: CRYPTEX1_AUTH_ENV_GENERIC = 4,
1502 // Reserved: CRYPTEX1_AUTH_ENV_GENERIC_SUPPLEMENTAL = 5,
1503 GRAFTDMG_CRYPTEX_PDI_NONCE = 6,
1504 GRAFTDMG_CRYPTEX_EFFECTIVE_AP = 7,
1505 // Update this when a new type is added
1506 GRAFTDMG_CRYPTEX_MAX = 7);
1507
1508OS_ENUM(cryptex_auth_type, uint32_t,
1509 // Reserved: GRAFTDMG_CRYPTEX_BOOT = 1,
1510 // Reserved: GRAFTDMG_CRYPTEX_PREBOOT = 2,
1511 // Reserved: GRAFTDMG_CRYPTEX_DOWNLEVEL = 3,
1512 CRYPTEX1_AUTH_ENV_GENERIC = 4,
1513 CRYPTEX1_AUTH_ENV_GENERIC_SUPPLEMENTAL = 5,
1514 CRYPTEX_AUTH_PDI_NONCE = 6,
1515 // Reserved: GRAFTDMG_CRYPTEX_EFFECTIVE_AP = 7
1516 // Update this when a new type is added
1517 CRYPTEX_AUTH_MAX = 7);
1518
1519#ifndef KERNEL
1520
1521__BEGIN_DECLS
1522int fhopen(const struct fhandle *, int);
1523int fstatfs(int, struct statfs *) __DARWIN_INODE64(fstatfs);
1524#if !__DARWIN_ONLY_64_BIT_INO_T
1525int fstatfs64(int, struct statfs64 *) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_NA, __IPHONE_NA);
1526#endif /* !__DARWIN_ONLY_64_BIT_INO_T */
1527int getfh(const char *, fhandle_t *);
1528int getfsstat(struct statfs *, int, int) __DARWIN_INODE64(getfsstat);
1529#if !__DARWIN_ONLY_64_BIT_INO_T
1530int getfsstat64(struct statfs64 *, int, int) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_NA, __IPHONE_NA);
1531#endif /* !__DARWIN_ONLY_64_BIT_INO_T */
1532int getmntinfo(struct statfs **, int) __DARWIN_INODE64(getmntinfo);
1533int getmntinfo_r_np(struct statfs **, int) __DARWIN_INODE64(getmntinfo_r_np)
1534__OSX_AVAILABLE(10.13) __IOS_AVAILABLE(11.0)
1535__TVOS_AVAILABLE(11.0) __WATCHOS_AVAILABLE(4.0);
1536#if !__DARWIN_ONLY_64_BIT_INO_T
1537int getmntinfo64(struct statfs64 **, int) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_NA, __IPHONE_NA);
1538#endif /* !__DARWIN_ONLY_64_BIT_INO_T */
1539int mount(const char *, const char *, int, void *);
1540int fmount(const char *, int, int, void *) __OSX_AVAILABLE(10.13) __IOS_AVAILABLE(11.0) __TVOS_AVAILABLE(11.0) __WATCHOS_AVAILABLE(4.0);
1541int statfs(const char *, struct statfs *) __DARWIN_INODE64(statfs);
1542#if !__DARWIN_ONLY_64_BIT_INO_T
1543int statfs64(const char *, struct statfs64 *) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_NA, __IPHONE_NA);
1544#endif /* !__DARWIN_ONLY_64_BIT_INO_T */
1545int unmount(const char *, int);
1546int getvfsbyname(const char *, struct vfsconf *);
1547#if PRIVATE
1548int pivot_root(const char *, const char *) __OSX_AVAILABLE(10.16);
1549int graftdmg(int, const char *, uint32_t, graftdmg_args_un *) __OSX_AVAILABLE(13.0) __IOS_AVAILABLE(16.0);
1550int ungraftdmg(const char *, uint64_t) __OSX_AVAILABLE(13.0) __IOS_AVAILABLE(16.0);
1551#endif
1552__END_DECLS
1553
1554#endif /* KERNEL */
1555#endif /* !_SYS_MOUNT_H_ */
1556