1/*
2 * Copyright (c) 2000-2016 Apple Computer, 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/*
29 * Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved
30 * Copyright (c) 1992, 1993, 1994, 1995
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/*
62 * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
63 * support for mandatory and extensible security protections. This notice
64 * is included in support of clause 2.2 (b) of the Apple Public License,
65 * Version 2.0.
66 */
67
68/*
69 * Warning: This file is generated automatically.
70 * (Modifications made here may easily be lost!)
71 *
72 * Created by the script:
73 * @(#)vnode_if.sh 8.7 (Berkeley) 5/11/95
74 */
75
76
77#ifndef _SYS_VNODE_IF_H_
78#define _SYS_VNODE_IF_H_
79
80#include <sys/appleapiopts.h>
81#include <sys/cdefs.h>
82#include <sys/kernel_types.h>
83#include <sys/buf.h>
84#ifdef BSD_KERNEL_PRIVATE
85#include <sys/vm.h>
86#endif
87#include <mach/memory_object_types.h>
88
89
90#pragma clang diagnostic push
91#pragma clang diagnostic ignored "-Wdocumentation"
92
93#ifdef KERNEL
94
95extern struct vnodeop_desc vnop_default_desc;
96extern struct vnodeop_desc vnop_lookup_desc;
97#ifdef KERNEL_PRIVATE
98extern struct vnodeop_desc vnop_compound_open_desc;
99extern struct vnodeop_desc vnop_compound_remove_desc;
100extern struct vnodeop_desc vnop_compound_rename_desc;
101extern struct vnodeop_desc vnop_compound_mkdir_desc;
102extern struct vnodeop_desc vnop_compound_rmdir_desc;
103#endif /* KERNEL_PRIVATE */
104extern struct vnodeop_desc vnop_create_desc;
105extern struct vnodeop_desc vnop_whiteout_desc; // obsolete
106extern struct vnodeop_desc vnop_mknod_desc;
107extern struct vnodeop_desc vnop_open_desc;
108extern struct vnodeop_desc vnop_close_desc;
109extern struct vnodeop_desc vnop_access_desc;
110extern struct vnodeop_desc vnop_getattr_desc;
111extern struct vnodeop_desc vnop_setattr_desc;
112extern struct vnodeop_desc vnop_read_desc;
113extern struct vnodeop_desc vnop_write_desc;
114extern struct vnodeop_desc vnop_ioctl_desc;
115extern struct vnodeop_desc vnop_select_desc;
116extern struct vnodeop_desc vnop_exchange_desc;
117extern struct vnodeop_desc vnop_revoke_desc;
118extern struct vnodeop_desc vnop_mmap_check_desc;
119extern struct vnodeop_desc vnop_mmap_desc;
120extern struct vnodeop_desc vnop_mnomap_desc;
121extern struct vnodeop_desc vnop_fsync_desc;
122extern struct vnodeop_desc vnop_remove_desc;
123extern struct vnodeop_desc vnop_link_desc;
124extern struct vnodeop_desc vnop_rename_desc;
125extern struct vnodeop_desc vnop_renamex_desc;
126extern struct vnodeop_desc vnop_mkdir_desc;
127extern struct vnodeop_desc vnop_rmdir_desc;
128extern struct vnodeop_desc vnop_symlink_desc;
129extern struct vnodeop_desc vnop_readdir_desc;
130extern struct vnodeop_desc vnop_readdirattr_desc;
131extern struct vnodeop_desc vnop_getattrlistbulk_desc;
132extern struct vnodeop_desc vnop_readlink_desc;
133extern struct vnodeop_desc vnop_inactive_desc;
134extern struct vnodeop_desc vnop_reclaim_desc;
135extern struct vnodeop_desc vnop_print_desc;
136extern struct vnodeop_desc vnop_pathconf_desc;
137extern struct vnodeop_desc vnop_advlock_desc;
138extern struct vnodeop_desc vnop_truncate_desc;
139extern struct vnodeop_desc vnop_allocate_desc;
140extern struct vnodeop_desc vnop_pagein_desc;
141extern struct vnodeop_desc vnop_pageout_desc;
142extern struct vnodeop_desc vnop_searchfs_desc;
143extern struct vnodeop_desc vnop_copyfile_desc;
144extern struct vnodeop_desc vnop_clonefile_desc;
145extern struct vnodeop_desc vnop_blktooff_desc;
146extern struct vnodeop_desc vnop_offtoblk_desc;
147extern struct vnodeop_desc vnop_blockmap_desc;
148extern struct vnodeop_desc vnop_strategy_desc;
149extern struct vnodeop_desc vnop_bwrite_desc;
150#ifdef KERNEL_PRIVATE
151extern struct vnodeop_desc vnop_verify_desc;
152#endif
153
154#ifdef __APPLE_API_UNSTABLE
155
156#if NAMEDSTREAMS
157extern struct vnodeop_desc vnop_getnamedstream_desc;
158extern struct vnodeop_desc vnop_makenamedstream_desc;
159extern struct vnodeop_desc vnop_removenamedstream_desc;
160#endif
161
162#endif
163
164#ifdef KERNEL_PRIVATE
165/*
166 * This pair of functions register and unregister callout with
167 * buffer_cache_gc() code path. This callout enables underlying
168 * fs to kick off any memory reclamation that would be otherwise
169 * satisfied by buffer_cache_gc(). callout() will be called in the
170 * vm_pageout code path, so precautions should be taken to not
171 * allocate memory or take any locks which might have memory
172 * allocation behind them. callout() can be called with first parameter
173 * set to false, in which case memory reclamation should be
174 * limited in scope. In case of the first parameter set to true, fs
175 * MUST free some memory if possible. Second parameter to the
176 * register function will be passed as a second parameter to the
177 * callout() as is.
178 * fs_buffer_cache_gc_unregister() second parameter will be used
179 * to distinguish between same callout() and this parameter should
180 * match the one passed during registration. It will unregister all
181 * instances of the matching callout() and argument from the callout
182 * list.
183 */
184
185
186extern int fs_buffer_cache_gc_register(void (* callout)(int, void *), void *);
187extern int fs_buffer_cache_gc_unregister(void (* callout)(int, void *), void *);
188#endif
189
190__BEGIN_DECLS
191
192struct vnop_lookup_args {
193 struct vnodeop_desc *a_desc;
194 vnode_t a_dvp;
195 vnode_t *a_vpp;
196 struct componentname *a_cnp;
197 vfs_context_t a_context;
198};
199
200/*!
201 * @function VNOP_LOOKUP
202 * @abstract Call down to a filesystem to look for a directory entry by name.
203 * @discussion VNOP_LOOKUP is the key pathway through which VFS asks a filesystem to find a file. The vnode
204 * should be returned with an iocount to be dropped by the caller. A VNOP_LOOKUP() calldown can come without
205 * a preceding VNOP_OPEN().
206 * @param dvp Directory in which to look up file.
207 * @param vpp Destination for found vnode.
208 * @param cnp Structure describing filename to find, reason for lookup, and various other data.
209 * @param ctx Context against which to authenticate lookup request.
210 * @return 0 for success or a filesystem-specific error.
211 */
212#ifdef XNU_KERNEL_PRIVATE
213extern errno_t VNOP_LOOKUP(vnode_t, vnode_t *, struct componentname *, vfs_context_t);
214#endif /* XNU_KERNEL_PRIVATE */
215
216struct vnop_create_args {
217 struct vnodeop_desc *a_desc;
218 vnode_t a_dvp;
219 vnode_t *a_vpp;
220 struct componentname *a_cnp;
221 struct vnode_attr *a_vap;
222 vfs_context_t a_context;
223};
224
225/*!
226 * @function VNOP_CREATE
227 * @abstract Call down to a filesystem to create a regular file (VREG).
228 * @discussion If file creation succeeds, "vpp" should be returned with an iocount to be dropped by the caller.
229 * A VNOP_CREATE() calldown can come without a preceding VNOP_OPEN().
230 * @param dvp Directory in which to create file.
231 * @param vpp Destination for vnode for newly created file.
232 * @param cnp Description of filename to create.
233 * @param vap File creation properties, as seen in vnode_getattr(). Manipulated with VATTR_ISACTIVE, VATTR_RETURN,
234 * VATTR_SET_SUPPORTED, and so forth.
235 * @param ctx Context against which to authenticate file creation.
236 * @return 0 for success or a filesystem-specific error.
237 */
238#ifdef XNU_KERNEL_PRIVATE
239extern errno_t VNOP_CREATE(vnode_t, vnode_t *, struct componentname *, struct vnode_attr *, vfs_context_t);
240#endif /* XNU_KERNEL_PRIVATE */
241
242struct vnop_whiteout_args {
243 struct vnodeop_desc *a_desc;
244 vnode_t a_dvp;
245 struct componentname *a_cnp;
246 int a_flags;
247 vfs_context_t a_context;
248};
249
250/*!
251 * @function VNOP_WHITEOUT
252 * @abstract Obsolete - no longer supported.
253 * @discussion Whiteouts are used to support the union filesystem, whereby one filesystem is mounted "transparently"
254 * on top of another. A whiteout in the upper layer of a union mount is a "deletion" of a file in the lower layer;
255 * lookups will catch the whiteout and fail, setting ISWHITEOUT in the componentname structure, even if an underlying
256 * file of the same name exists. The whiteout vnop is used for creation, deletion, and checking whether a directory
257 * supports whiteouts (see flags).
258 * also support the LOOKUP flag, which is used to test whether a directory supports whiteouts.
259 * @param dvp Directory in which to create.
260 * @param cnp Name information for whiteout.
261 * @param flags CREATE: create a whiteout. LOOKUP: check whether a directory supports whiteouts, DELETE: remove a whiteout.
262 * @param ctx Context against which to authenticate whiteout creation.
263 * @return 0 for success or a filesystem-specific error. Returning 0 for LOOKUP indicates that a directory does support whiteouts.
264 */
265#ifdef XNU_KERNEL_PRIVATE
266extern errno_t VNOP_WHITEOUT(vnode_t, struct componentname *, int, vfs_context_t);
267#endif /* XNU_KERNEL_PRIVATE */
268
269struct vnop_mknod_args {
270 struct vnodeop_desc *a_desc;
271 vnode_t a_dvp;
272 vnode_t *a_vpp;
273 struct componentname *a_cnp;
274 struct vnode_attr *a_vap;
275 vfs_context_t a_context;
276};
277
278/*!
279 * @function VNOP_MKNOD
280 * @abstract Call down to a filesystem to create a special file.
281 * @discussion The mknod vnop is used to create character and block device files, named pipe (FIFO) files, and named sockets.
282 * The newly created file should be returned with an iocount which will be dropped by the caller. A VNOP_MKNOD() call
283 * can come down without a preceding VNOP_OPEN().
284 * @param dvp Directory in which to create the special file.
285 * @param vpp Destination for newly created vnode.
286 * @param cnp Name information for new file.
287 * @param vap Attributes for new file, including type.
288 * @param ctx Context against which to authenticate node creation.
289 * @return 0 for success or a filesystem-specific error.
290 */
291#ifdef XNU_KERNEL_PRIVATE
292extern errno_t VNOP_MKNOD(vnode_t, vnode_t *, struct componentname *, struct vnode_attr *, vfs_context_t);
293#endif /* XNU_KERNEL_PRIVATE */
294
295struct vnop_open_args {
296 struct vnodeop_desc *a_desc;
297 vnode_t a_vp;
298 int a_mode;
299 vfs_context_t a_context;
300};
301
302#ifdef KERNEL_PRIVATE
303struct vnop_compound_open_args {
304 struct vnodeop_desc *a_desc;
305
306 vnode_t a_dvp; /* Directory in which to open/create */
307 vnode_t *a_vpp; /* Resulting vnode */
308 int a_fmode; /* Open mode */
309 struct componentname *a_cnp; /* Path to look up */
310 struct vnode_attr *a_vap; /* Attributes with which to create, if appropriate */
311 uint32_t a_flags; /* VNOP-control flags */
312 uint32_t *a_status; /* Information about results */
313
314 vfs_context_t a_context; /* Authorization context */
315
316 int (*a_open_create_authorizer)( /* Authorizer for create case */
317 vnode_t dvp, /* Directory in which to create */
318 struct componentname *cnp, /* As passed to VNOP */
319 struct vnode_attr *vap, /* As passed to VNOP */
320 vfs_context_t ctx, /* Context */
321 void *reserved); /* Who knows */
322
323 int (*a_open_existing_authorizer)( /* Authorizer for preexisting case */
324 vnode_t vp, /* vp to open */
325 struct componentname *cnp, /* Lookup state */
326 int fmode, /* As passed to VNOP */
327 vfs_context_t ctx, /* Context */
328 void *reserved); /* Who knows */
329
330 void *a_reserved;
331};
332
333/* Results */
334#define COMPOUND_OPEN_STATUS_DID_CREATE 0x00000001
335#endif /* KERNEL_PRIVATE */
336
337/*!
338 * @function VNOP_OPEN
339 * @abstract Call down to a filesystem to open a file.
340 * @discussion The open vnop gives a filesystem a chance to initialize a file for
341 * operations like reading, writing, and ioctls. VFS promises to send down exactly one VNOP_CLOSE()
342 * for each VNOP_OPEN().
343 * @param vp File to open.
344 * @param mode FREAD and/or FWRITE.
345 * @param ctx Context against which to authenticate open.
346 * @return 0 for success or a filesystem-specific error.
347 */
348#ifdef XNU_KERNEL_PRIVATE
349extern errno_t VNOP_OPEN(vnode_t, int, vfs_context_t);
350#endif /* XNU_KERNEL_PRIVATE */
351
352#ifdef BSD_KERNEL_PRIVATE
353struct nameidata;
354extern int VNOP_COMPOUND_OPEN(vnode_t dvp, vnode_t *vpp, struct nameidata *ndp, int32_t flags, int32_t fmode, uint32_t *status, struct vnode_attr *vap, vfs_context_t ctx);
355#endif
356
357struct vnop_close_args {
358 struct vnodeop_desc *a_desc;
359 vnode_t a_vp;
360 int a_fflag;
361 vfs_context_t a_context;
362};
363
364/*!
365 * @function VNOP_CLOSE
366 * @abstract Call down to a filesystem to close a file.
367 * @discussion The close vnop gives a filesystem a chance to release state set up
368 * by a VNOP_OPEN(). VFS promises to send down exactly one VNOP_CLOSE() for each VNOP_OPEN().
369 * @param vp File to close.
370 * @param fflag FREAD and/or FWRITE; in the case of a file opened with open(2), fflag corresponds
371 * to how the file was opened.
372 * @param ctx Context against which to authenticate close.
373 * @return 0 for success or a filesystem-specific error.
374 */
375#ifdef XNU_KERNEL_PRIVATE
376extern errno_t VNOP_CLOSE(vnode_t, int, vfs_context_t);
377#endif /* XNU_KERNEL_PRIVATE */
378
379struct vnop_access_args {
380 struct vnodeop_desc *a_desc;
381 vnode_t a_vp;
382 int a_action;
383 vfs_context_t a_context;
384};
385
386/*!
387 * @function VNOP_ACCESS
388 * @abstract Call down to a filesystem to see if a kauth-style operation is permitted.
389 * @discussion VNOP_ACCESS is currently only called on filesystems which mark themselves
390 * as doing their authentication remotely (vfs_setauthopaque(), vfs_authopaque()). A VNOP_ACCESS()
391 * calldown may come without any preceding VNOP_OPEN().
392 * @param vp File to authorize action for.
393 * @param action kauth-style action to be checked for permissions, e.g. KAUTH_VNODE_DELETE.
394 * @param ctx Context against which to authenticate action.
395 * @return 0 for success or a filesystem-specific error.
396 */
397#ifdef XNU_KERNEL_PRIVATE
398extern errno_t VNOP_ACCESS(vnode_t, int, vfs_context_t);
399#endif /* XNU_KERNEL_PRIVATE */
400
401struct vnop_getattr_args {
402 struct vnodeop_desc *a_desc;
403 vnode_t a_vp;
404 struct vnode_attr *a_vap;
405 vfs_context_t a_context;
406};
407
408/*!
409 * @function VNOP_GETATTR
410 * @abstract Call down to a filesystem to get vnode attributes.
411 * @discussion Supported attributes ("Yes, I am returning this information") are set with VATTR_SET_SUPPORTED.
412 * Which attributes have been requested is checked with VATTR_IS_ACTIVE. Attributes
413 * are returned with VATTR_RETURN. It is through VNOP_GETATTR that routines like stat() get their information.
414 * A VNOP_GETATTR() calldown may come without any preceding VNOP_OPEN().
415 * @param vp The vnode whose attributes to get.
416 * @param vap Container for which attributes are requested, which attributes are supported by the filesystem, and attribute values.
417 * @param ctx Context against which to authenticate request for attributes.
418 * @return 0 for success or a filesystem-specific error. VNOP_GETATTR() can return success even if not
419 * all requested attributes were returned; returning an error-value should indicate that something went wrong, rather than that
420 * some attribute is not supported.
421 */
422#ifdef XNU_KERNEL_PRIVATE
423extern errno_t VNOP_GETATTR(vnode_t, struct vnode_attr *, vfs_context_t);
424#endif /* XNU_KERNEL_PRIVATE */
425
426struct vnop_setattr_args {
427 struct vnodeop_desc *a_desc;
428 vnode_t a_vp;
429 struct vnode_attr *a_vap;
430 vfs_context_t a_context;
431};
432
433/*!
434 * @function VNOP_SETATTR
435 * @abstract Call down to a filesystem to set vnode attributes.
436 * @discussion Supported attributes ("Yes, I am setting this attribute.") are set with VATTR_SET_SUPPORTED.
437 * Requested attributes are checked with VATTR_IS_ACTIVE. Attribute values are accessed directly through
438 * structure fields. VNOP_SETATTR() is the core of the KPI function vnode_setattr(), which is used by chmod(),
439 * chown(), truncate(), and many others. A VNOP_SETATTR() call may come without any preceding VNOP_OPEN().
440 * @param vp The vnode whose attributes to set.
441 * @param vap Container for which attributes are to be set and their desired values, as well as for the filesystem to
442 * return information about which attributes were successfully set.
443 * @param ctx Context against which to authenticate request for attribute change.
444 * @return 0 for success or a filesystem-specific error. VNOP_SETATTR() can return success even if not
445 * all requested attributes were set; returning an error-value should indicate that something went wrong, rather than that
446 * some attribute is not supported.
447 */
448#ifdef XNU_KERNEL_PRIVATE
449extern errno_t VNOP_SETATTR(vnode_t, struct vnode_attr *, vfs_context_t);
450#endif /* XNU_KERNEL_PRIVATE */
451
452struct vnop_read_args {
453 struct vnodeop_desc *a_desc;
454 vnode_t a_vp;
455 struct uio *a_uio;
456 int a_ioflag;
457 vfs_context_t a_context;
458};
459
460/*!
461 * @function VNOP_READ
462 * @abstract Call down to a filesystem to read file data.
463 * @discussion VNOP_READ() is where the hard work of of the read() system call happens. The filesystem may use
464 * the buffer cache, the cluster layer, or an alternative method to get its data; uio routines will be used to see that data
465 * is copied to the correct virtual address in the correct address space and will update its uio argument
466 * to indicate how much data has been moved.
467 * @param vp The vnode to read from.
468 * @param uio Description of request, including file offset, amount of data requested, destination address for data,
469 * and whether that destination is in kernel or user space.
470 * @param ioflag IO flags as defined in vnode.h, e.g. IO_SYNC, IO_NODELOCKED
471 * @param ctx Context against which to authenticate read request.
472 * @return 0 for success or a filesystem-specific error. VNOP_READ() can return success even if less data was
473 * read than originally requested; returning an error value should indicate that something actually went wrong.
474 */
475extern errno_t VNOP_READ(vnode_t vp, struct uio *uio, int ioflag, vfs_context_t ctx);
476
477struct vnop_write_args {
478 struct vnodeop_desc *a_desc;
479 vnode_t a_vp;
480 struct uio *a_uio;
481 int a_ioflag;
482 vfs_context_t a_context;
483};
484
485/*!
486 * @function VNOP_WRITE
487 * @abstract Call down to the filesystem to write file data.
488 * @discussion VNOP_WRITE() is to write() as VNOP_READ() is to read(). The filesystem may use
489 * the buffer cache, the cluster layer, or an alternative method to write its data; uio routines will be used to see that data
490 * is copied to the correct virtual address in the correct address space and will update its uio argument
491 * to indicate how much data has been moved.
492 * @param vp The vnode to write to.
493 * @param uio Description of request, including file offset, amount of data to write, source address for data,
494 * and whether that destination is in kernel or user space.
495 * @param ioflag IO flags as defined in vnode.h, e.g. IO_SYNC, IO_NODELOCKED
496 * @param ctx Context against which to authenticate write request.
497 * @return 0 for success or a filesystem-specific error. VNOP_WRITE() can return success even if less data was
498 * written than originally requested; returning an error value should indicate that something actually went wrong.
499 */
500extern errno_t VNOP_WRITE(vnode_t vp, struct uio *uio, int ioflag, vfs_context_t ctx);
501
502struct vnop_ioctl_args {
503 struct vnodeop_desc *a_desc;
504 vnode_t a_vp;
505 u_long a_command;
506 caddr_t a_data;
507 int a_fflag;
508 vfs_context_t a_context;
509};
510
511/*!
512 * @function VNOP_IOCTL
513 * @abstract Call down to a filesystem or device driver to execute various control operations on or request data about a file.
514 * @discussion Ioctl controls are typically associated with devices, but they can in fact be passed
515 * down for any file; they are used to implement any of a wide range of controls and information requests.
516 * fcntl() calls VNOP_IOCTL for several commands, and will attempt a VNOP_IOCTL if it is passed an unknown command,
517 * though no copyin or copyout of arguments can occur in this case--the "arg" must be an integer value.
518 * Filesystems can define their own fcntls using this mechanism. How ioctl commands are structured
519 * is slightly complicated; see the manual page for ioctl(2).
520 * @param vp The vnode to execute the command on.
521 * @param command Identifier for action to take.
522 * @param data Pointer to data; this can be an integer constant (of 32 bits only) or an address to be read from or written to,
523 * depending on "command." If it is an address, it is valid and resides in the kernel; callers of VNOP_IOCTL() are
524 * responsible for copying to and from userland.
525 * @param ctx Context against which to authenticate ioctl request.
526 * @return 0 for success or a filesystem-specific error.
527 */
528extern errno_t VNOP_IOCTL(vnode_t vp, u_long command, caddr_t data, int fflag, vfs_context_t ctx);
529
530struct vnop_select_args {
531 struct vnodeop_desc *a_desc;
532 vnode_t a_vp;
533 int a_which;
534 int a_fflags;
535 void *a_wql;
536 vfs_context_t a_context;
537};
538
539/*!
540 * @function VNOP_SELECT
541 * @abstract Call down to a filesystem or device to check if a file is ready for I/O and request later notification if it is not currently ready.
542 * @discussion In general, regular are always "ready for I/O" and their select vnops simply return "1."
543 * Devices, though, may or may not be read; they keep track of who is selecting on them and send notifications
544 * when they become ready. xnu provides structures and routines for tracking threads waiting for I/O and waking up
545 * those threads: see selrecord(), selthreadclear(), seltrue(), selwait(), selwakeup(), and the selinfo structure (sys/select.h).
546 * @param vp The vnode to check for I/O readiness.
547 * @param which What kind of I/O is desired: FREAD, FWRITE.
548 * @param fflags Flags from fileglob as seen in fcntl.h, e.g. O_NONBLOCK, O_APPEND.
549 * @param wql Opaque object to pass to selrecord().
550 * @param ctx Context to authenticate for select request.
551 * @return Nonzero indicates that a file is ready for I/O. 0 indicates that the file is not ready for I/O;
552 * there is no way to return an error. 0 should be returned if the device (or file) is not ready for I/O
553 * and the driver (or filesystem) is going to track the request and provide subsequent wakeups.
554 * the device (or filesystem) will provide a wakeup.
555 */
556#ifdef XNU_KERNEL_PRIVATE
557extern errno_t VNOP_SELECT(vnode_t, int, int, void *, vfs_context_t);
558#endif /* XNU_KERNEL_PRIVATE */
559
560struct vnop_exchange_args {
561 struct vnodeop_desc *a_desc;
562 vnode_t a_fvp;
563 vnode_t a_tvp;
564 int a_options;
565 vfs_context_t a_context;
566};
567
568/*!
569 * @function VNOP_EXCHANGE
570 * @abstract Call down to a filesystem to atomically exchange the data of two files.
571 * @discussion VNOP_EXCHANGE() is currently only called by the exchangedata() system call. It will only
572 * be applied to files on the same volume.
573 * @param fvp First vnode.
574 * @param tvp Second vnode.
575 * @param options Unused.
576 * @param ctx Context to authenticate for exchangedata request.
577 * @return 0 for success, else an error code.
578 */
579#ifdef XNU_KERNEL_PRIVATE
580extern errno_t VNOP_EXCHANGE(vnode_t, vnode_t, int, vfs_context_t);
581#endif /* XNU_KERNEL_PRIVATE */
582
583struct vnop_revoke_args {
584 struct vnodeop_desc *a_desc;
585 vnode_t a_vp;
586 int a_flags;
587 vfs_context_t a_context;
588};
589
590/*!
591 * @function VNOP_REVOKE
592 * @abstract Call down to a filesystem to invalidate all open file descriptors for a vnode.
593 * @discussion This function is typically called as part of a TTY revoke, but can also be
594 * used on regular files. Most filesystems simply use nop_revoke(), which calls vn_revoke(),
595 * as their revoke vnop implementation.
596 * @param vp The vnode to revoke.
597 * @param flags Unused.
598 * @param ctx Context to authenticate for revoke request.
599 * @return 0 for success, else an error code.
600 */
601#ifdef XNU_KERNEL_PRIVATE
602extern errno_t VNOP_REVOKE(vnode_t, int, vfs_context_t);
603#endif /* XNU_KERNEL_PRIVATE */
604
605struct vnop_mmap_check_args {
606 struct vnodeop_desc *a_desc;
607 vnode_t a_vp;
608 int a_flags;
609 vfs_context_t a_context;
610};
611
612/*!
613 * @function VNOP_MMAP_CHECK
614 * @abstract Check with a filesystem if a file can be mmap-ed.
615 * @discussion VNOP_MMAP_CHECK is used to check with the file system if a
616 * file can be mmap-ed. It will be called before any call to VNOP_MMAP().
617 * @param vp The vnode being mmapped.
618 * @param flags Memory protection: PROT_READ, PROT_WRITE, PROT_EXEC.
619 * @param ctx Context to authenticate for mmap request.
620 * @return 0 for success; EPERM if the operation is not permitted; other
621 * errors (except ENOTSUP) may be returned at the discretion of the file
622 * system. ENOTSUP will never be returned by VNOP_MMAP_CHECK().
623 */
624#ifdef XNU_KERNEL_PRIVATE
625extern errno_t VNOP_MMAP_CHECK(vnode_t, int, vfs_context_t);
626#endif /* XNU_KERNEL_PRIVATE */
627
628
629struct vnop_mmap_args {
630 struct vnodeop_desc *a_desc;
631 vnode_t a_vp;
632 int a_fflags;
633 vfs_context_t a_context;
634};
635
636/*!
637 * @function VNOP_MMAP
638 * @abstract Notify a filesystem that a file is being mmap-ed.
639 * @discussion VNOP_MMAP is an advisory calldown to say that the system is mmap-ing a file.
640 * @param vp The vnode being mmapped.
641 * @param flags Memory protection: PROT_READ, PROT_WRITE, PROT_EXEC.
642 * @param ctx Context to authenticate for mmap request.
643 * @return 0 for success; all errors except EPERM are ignored.
644 */
645#ifdef XNU_KERNEL_PRIVATE
646extern errno_t VNOP_MMAP(vnode_t, int, vfs_context_t);
647#endif /* XNU_KERNEL_PRIVATE */
648
649struct vnop_mnomap_args {
650 struct vnodeop_desc *a_desc;
651 vnode_t a_vp;
652 vfs_context_t a_context;
653};
654
655/*!
656 * @function VNOP_MNOMAP
657 * @abstract Inform a filesystem that a file is no longer mapped.
658 * @discussion In general, no action is required of a filesystem for VNOP_MNOMAP.
659 * @param vp The vnode which is no longer mapped.
660 * @param ctx Context to authenticate for mnomap request.
661 * @return Return value is ignored.
662 */
663#ifdef XNU_KERNEL_PRIVATE
664extern errno_t VNOP_MNOMAP(vnode_t, vfs_context_t);
665#endif /* XNU_KERNEL_PRIVATE */
666
667struct vnop_fsync_args {
668 struct vnodeop_desc *a_desc;
669 vnode_t a_vp;
670 int a_waitfor;
671 vfs_context_t a_context;
672};
673
674/*!
675 * @function VNOP_FSYNC
676 * @abstract Call down to a filesystem to synchronize a file with on-disk state.
677 * @discussion VNOP_FSYNC is called whenever we need to make sure that a file's data has been
678 * pushed to backing store, for example when recycling; it is also the heart of the fsync() system call.
679 * @param vp The vnode whose data to flush to backing store.
680 * @param ctx Context to authenticate for fsync request.
681 * @return 0 for success, else an error code.
682 */
683extern errno_t VNOP_FSYNC(vnode_t vp, int waitfor, vfs_context_t ctx);
684
685struct vnop_remove_args {
686 struct vnodeop_desc *a_desc;
687 vnode_t a_dvp;
688 vnode_t a_vp;
689 struct componentname *a_cnp;
690 int a_flags;
691 vfs_context_t a_context;
692};
693
694/*!
695 * @function VNOP_REMOVE
696 * @abstract Call down to a filesystem to delete a file.
697 * @discussion VNOP_REMOVE is called to remove a file from a filesystem's namespace, for example by unlink().
698 * It can operate on regular files, named pipes, special files, and in some cases on directories.
699 * @param dvp Directory in which to delete a file.
700 * @param vp The file to delete.
701 * @param cnp Filename information.
702 * @param ctx Context to authenticate for fsync request.
703 * @return 0 for success, else an error code.
704 */
705#ifdef XNU_KERNEL_PRIVATE
706extern errno_t VNOP_REMOVE(vnode_t, vnode_t, struct componentname *, int, vfs_context_t);
707#endif /* XNU_KERNEL_PRIVATE */
708
709#ifdef KERNEL_PRIVATE
710struct vnop_compound_remove_args {
711 struct vnodeop_desc *a_desc;
712 vnode_t a_dvp; /* Directory in which to lookup and remove */
713 vnode_t *a_vpp; /* File to remove; may or may not point to NULL pointer */
714 struct componentname *a_cnp; /* Name of file to remove */
715 struct vnode_attr *a_vap; /* Destination for file attributes on successful delete */
716 uint32_t a_flags; /* Control flags (unused) */
717 vfs_context_t a_context; /* Authorization context */
718 int (*a_remove_authorizer)( /* Authorizer callback */
719 vnode_t dvp, /* Directory in which to delete */
720 vnode_t vp, /* File to delete */
721 struct componentname *cnp, /* As passed to VNOP */
722 vfs_context_t ctx, /* As passed to VNOP */
723 void *reserved); /* Always NULL */
724 void *a_reserved; /* Unused */
725};
726#endif /* KERNEL_PRIVATE */
727
728#ifdef BSD_KERNEL_PRIVATE
729extern errno_t VNOP_COMPOUND_REMOVE(vnode_t, vnode_t*, struct nameidata *, int32_t flags, struct vnode_attr *vap, vfs_context_t);
730#endif
731struct vnop_link_args {
732 struct vnodeop_desc *a_desc;
733 vnode_t a_vp;
734 vnode_t a_tdvp;
735 struct componentname *a_cnp;
736 vfs_context_t a_context;
737};
738
739/*!
740 * @function VNOP_LINK
741 * @abstract Call down to a filesystem to create a hardlink to a file.
742 * @discussion See "man 2 link".
743 * @param vp File to link to.
744 * @param dvp Directory in which to create the link.
745 * @param cnp Filename information for new link.
746 * @param ctx Context to authenticate for link request.
747 * @return 0 for success, else an error code.
748 */
749#ifdef XNU_KERNEL_PRIVATE
750extern errno_t VNOP_LINK(vnode_t, vnode_t, struct componentname *, vfs_context_t);
751#endif /* XNU_KERNEL_PRIVATE */
752
753struct vnop_rename_args {
754 struct vnodeop_desc *a_desc;
755 vnode_t a_fdvp;
756 vnode_t a_fvp;
757 struct componentname *a_fcnp;
758 vnode_t a_tdvp;
759 vnode_t a_tvp;
760 struct componentname *a_tcnp;
761 vfs_context_t a_context;
762};
763
764/*!
765 * @function VNOP_RENAME
766 * @abstract Call down to a filesystem to rename a file.
767 * @discussion VNOP_RENAME() will only be called with a source and target on the same volume.
768 * @param fdvp Directory in which source file resides.
769 * @param fvp File being renamed.
770 * @param fcnp Name information for source file.
771 * @param tdvp Directory file is being moved to.
772 * @param tvp Existing file with same name as target, should one exist.
773 * @param tcnp Name information for target path.
774 * @param ctx Context to authenticate for rename request.
775 * @return 0 for success, else an error code.
776 */
777#ifdef XNU_KERNEL_PRIVATE
778extern errno_t VNOP_RENAME(vnode_t, vnode_t, struct componentname *, vnode_t, vnode_t, struct componentname *, vfs_context_t);
779#endif /* XNU_KERNEL_PRIVATE */
780
781typedef unsigned int vfs_rename_flags_t;
782
783// Must match sys/stdio.h
784enum {
785 VFS_RENAME_SECLUDE = 0x00000001,
786 VFS_RENAME_SWAP = 0x00000002,
787 VFS_RENAME_EXCL = 0x00000004,
788
789 /*
790 * VFS_RENAME_DATALESS is kernel-only and is intentionally
791 * not included in VFS_RENAME_FLAGS_MASK.
792 */
793 VFS_RENAME_DATALESS = 0x00000008,
794 /* used by sys/stdio for RENAME_NOFOLLOW_ANY */
795 VFS_RENAME_RESERVED1 = 0x00000010,
796
797 VFS_RENAME_FLAGS_MASK = (VFS_RENAME_SECLUDE | VFS_RENAME_SWAP
798 | VFS_RENAME_EXCL),
799};
800
801struct vnop_renamex_args {
802 struct vnodeop_desc *a_desc;
803 vnode_t a_fdvp;
804 vnode_t a_fvp;
805 struct componentname *a_fcnp;
806 vnode_t a_tdvp;
807 vnode_t a_tvp;
808 struct componentname *a_tcnp;
809 struct vnode_attr *a_vap; // Reserved for future use
810 vfs_rename_flags_t a_flags;
811 vfs_context_t a_context;
812};
813
814/*!
815 * @function VNOP_RENAMEX
816 * @abstract Call down to a filesystem to rename a file.
817 * @discussion VNOP_RENAMEX() will only be called with a source and target on the same volume.
818 * @param fdvp Directory in which source file resides.
819 * @param fvp File being renamed.
820 * @param fcnp Name information for source file.
821 * @param tdvp Directory file is being moved to.
822 * @param tvp Existing file with same name as target, should one exist.
823 * @param tcnp Name information for target path.
824 * @param flags Control certain rename semantics.
825 * @param ctx Context to authenticate for rename request.
826 * @return 0 for success, else an error code.
827 */
828#ifdef XNU_KERNEL_PRIVATE
829extern errno_t VNOP_RENAMEX(vnode_t, vnode_t, struct componentname *, vnode_t, vnode_t, struct componentname *, vfs_rename_flags_t, vfs_context_t);
830#endif /* XNU_KERNEL_PRIVATE */
831
832#ifdef KERNEL_PRIVATE
833struct vnop_compound_rename_args {
834 struct vnodeop_desc *a_desc;
835
836 vnode_t a_fdvp; /* Directory from which to rename */
837 vnode_t *a_fvpp; /* Vnode to rename (can point to a NULL pointer) */
838 struct componentname *a_fcnp; /* Source name */
839 struct vnode_attr *a_fvap;
840
841 vnode_t a_tdvp; /* Directory to which to rename */
842 vnode_t *a_tvpp; /* Vnode to rename over (can point to a NULL pointer) */
843 struct componentname *a_tcnp; /* Destination name */
844 struct vnode_attr *a_tvap;
845
846 uint32_t a_flags; /* Control flags: currently unused */
847 vfs_context_t a_context; /* Authorization context */
848 int (*a_rename_authorizer)( /* Authorization callback */
849 vnode_t fdvp, /* As passed to VNOP */
850 vnode_t fvp, /* Vnode to rename */
851 struct componentname *fcnp, /* As passed to VNOP */
852 vnode_t tdvp, /* As passed to VNOP */
853 vnode_t tvp, /* Vnode to rename over (can be NULL) */
854 struct componentname *tcnp, /* As passed to VNOP */
855 vfs_context_t ctx, /* As passed to VNOP */
856 void *reserved); /* Always NULL */
857 void *a_reserved; /* Currently unused */
858};
859#endif /* KERNEL_PRIVATE */
860
861#ifdef XNU_KERNEL_PRIVATE
862errno_t
863VNOP_COMPOUND_RENAME(
864 struct vnode *fdvp, struct vnode **fvpp, struct componentname *fcnp, struct vnode_attr *fvap,
865 struct vnode *tdvp, struct vnode **tvpp, struct componentname *tcnp, struct vnode_attr *tvap,
866 uint32_t flags, vfs_context_t ctx);
867#endif /* XNU_KERNEL_PRIVATE */
868
869struct vnop_mkdir_args {
870 struct vnodeop_desc *a_desc;
871 vnode_t a_dvp;
872 vnode_t *a_vpp;
873 struct componentname *a_cnp;
874 struct vnode_attr *a_vap;
875 vfs_context_t a_context;
876};
877
878/*!
879 * @function VNOP_MKDIR
880 * @abstract Call down to a filesystem to create a directory.
881 * @discussion The newly created directory should be returned with an iocount which will be dropped by the caller.
882 * @param dvp Directory in which to create new directory.
883 * @param vpp Destination for pointer to new directory's vnode.
884 * @param cnp Name information for new directory.
885 * @param vap Attributes for new directory.
886 * @param ctx Context to authenticate for mkdir request.
887 * @return 0 for success, else an error code.
888 */
889#ifdef XNU_KERNEL_PRIVATE
890extern errno_t VNOP_MKDIR(vnode_t, vnode_t *, struct componentname *, struct vnode_attr *, vfs_context_t);
891#endif /* XNU_KERNEL_PRIVATE */
892
893
894#ifdef KERNEL_PRIVATE
895struct vnop_compound_mkdir_args {
896 struct vnodeop_desc *a_desc;
897 vnode_t a_dvp; /* Directory in which to create */
898 vnode_t *a_vpp; /* Destination for found or created vnode */
899 struct componentname *a_cnp; /* Name of directory to create */
900 struct vnode_attr *a_vap; /* Creation attributes */
901 uint32_t a_flags; /* Control flags (unused) */
902 vfs_context_t a_context; /* Authorization context */
903#if 0
904 int (*a_mkdir_authorizer)(vnode_t dvp, struct componentname *cnp, struct vnode_attr *vap, vfs_context_t ctx, void *reserved);
905#endif /* 0 */
906 void *a_reserved; /* Unused */
907};
908#endif /* KERNEL_PRIVATE */
909
910#ifdef XNU_KERNEL_PRIVATE
911extern errno_t VNOP_COMPOUND_MKDIR(vnode_t, vnode_t *, struct nameidata *, struct vnode_attr *, vfs_context_t);
912#endif /* XNU_KERNEL_PRIVATE */
913
914struct vnop_rmdir_args {
915 struct vnodeop_desc *a_desc;
916 vnode_t a_dvp;
917 vnode_t a_vp;
918 struct componentname *a_cnp;
919 vfs_context_t a_context;
920};
921
922/*!
923 * @function VNOP_RMDIR
924 * @abstract Call down to a filesystem to delete a directory.
925 * @param dvp Parent of directory to be removed.
926 * @param vp Directory to remove.
927 * @param cnp Name information for directory to be deleted.
928 * @param ctx Context to authenticate for rmdir request.
929 * @return 0 for success, else an error code.
930 */
931#ifdef XNU_KERNEL_PRIVATE
932extern errno_t VNOP_RMDIR(vnode_t, vnode_t, struct componentname *, vfs_context_t);
933#endif /* XNU_KERNEL_PRIVATE */
934
935#ifdef KERNEL_PRIVATE
936struct vnop_compound_rmdir_args {
937 struct vnodeop_desc *a_desc;
938 vnode_t a_dvp; /* Directory in which to look up and delete */
939 vnode_t *a_vpp; /* Destination for found vnode */
940 struct componentname *a_cnp; /* Name to delete */
941 struct vnode_attr *a_vap; /* Location in which to store attributes if delete succeeds (can be NULL) */
942 uint32_t a_flags; /* Control flags (currently unused) */
943 vfs_context_t a_context; /* Context for authorization */
944 int (*a_rmdir_authorizer)( /* Authorization callback */
945 vnode_t dvp, /* As passed to VNOP */
946 vnode_t vp, /* Directory to delete */
947 struct componentname *cnp, /* As passed to VNOP */
948 vfs_context_t ctx, /* As passed to VNOP */
949 void *reserved); /* Always NULL */
950 void *a_reserved; /* Unused */
951};
952#endif /* KERNEL_PRIVATE */
953
954#ifdef XNU_KERNEL_PRIVATE
955extern errno_t VNOP_COMPOUND_RMDIR(vnode_t, vnode_t*, struct nameidata *, struct vnode_attr *vap, vfs_context_t);
956#endif /* XNU_KERNEL_PRIVATE */
957
958
959struct vnop_symlink_args {
960 struct vnodeop_desc *a_desc;
961 vnode_t a_dvp;
962 vnode_t *a_vpp;
963 struct componentname *a_cnp;
964 struct vnode_attr *a_vap;
965 char *a_target;
966 vfs_context_t a_context;
967};
968
969/*!
970 * @function VNOP_SYMLINK
971 * @abstract Call down to a filesystem to create a symbolic link.
972 * @param If VNOP_SYMLINK() is successful, the new file should be returned with an iocount which will
973 * be dropped by the caller. VFS does not ensure that the target path will have a length shorter
974 * than the max symlink length for the filesystem.
975 * @param dvp Parent directory for new symlink file.
976 * @param vpp
977 * @param cnp Name information for new symlink.
978 * @param vap Attributes for symlink.
979 * @param target Path for symlink to store; for "ln -s /var/vardir linktovardir", "target" would be "/var/vardir"
980 * @param ctx Context to authenticate for symlink request.
981 * @return 0 for success, else an error code.
982 */
983#ifdef XNU_KERNEL_PRIVATE
984extern errno_t VNOP_SYMLINK(vnode_t, vnode_t *, struct componentname *, struct vnode_attr *, char *, vfs_context_t);
985#endif /* XNU_KERNEL_PRIVATE */
986
987/*
988 *
989 * When VNOP_READDIR is called from the NFS Server, the nfs_data
990 * argument is non-NULL.
991 *
992 * The value of nfs_eofflag should be set to TRUE if the end of
993 * the directory was reached while reading.
994 *
995 * The directory seek offset (cookies) are returned to the NFS client and
996 * may be used later to restart a directory read part way through
997 * the directory. There is one cookie returned for each directory
998 * entry returned and its size is determince from nfs_sizeofcookie.
999 * The value of the cookie should be the logical offset within the
1000 * directory where the on-disc version of the appropriate directory
1001 * entry starts. Memory for the cookies is allocated from M_TEMP
1002 * and it is freed by the caller of VNOP_READDIR.
1003 *
1004 */
1005
1006struct vnop_readdir_args {
1007 struct vnodeop_desc *a_desc;
1008 vnode_t a_vp;
1009 struct uio *a_uio;
1010 int a_flags;
1011 int *a_eofflag;
1012 int *a_numdirent;
1013 vfs_context_t a_context;
1014};
1015
1016/*!
1017 * @function VNOP_READDIR
1018 * @abstract Call down to a filesystem to enumerate directory entries.
1019 * @discussion VNOP_READDIR() packs a buffer with "struct dirent" directory entry representations as described
1020 * by the "getdirentries" manual page.
1021 * @param vp Directory to enumerate.
1022 * @param uio Destination information for resulting direntries.
1023 * @param flags VNODE_READDIR_EXTENDED, VNODE_READDIR_REQSEEKOFF, VNODE_READDIR_SEEKOFF32: Apple-internal flags.
1024 * @param eofflag Should be set to 1 if the end of the directory has been reached.
1025 * @param numdirent Should be set to number of entries written into buffer.
1026 * @param ctx Context to authenticate for readdir request.
1027 * @return 0 for success, else an error code.
1028 */
1029#ifdef XNU_KERNEL_PRIVATE
1030extern errno_t VNOP_READDIR(vnode_t, struct uio *, int, int *, int *, vfs_context_t);
1031#endif /* XNU_KERNEL_PRIVATE */
1032
1033struct vnop_readdirattr_args {
1034 struct vnodeop_desc *a_desc;
1035 vnode_t a_vp;
1036 struct attrlist *a_alist;
1037 struct uio *a_uio;
1038 uint32_t a_maxcount;
1039 uint32_t a_options;
1040 uint32_t *a_newstate;
1041 int *a_eofflag;
1042 uint32_t *a_actualcount;
1043 vfs_context_t a_context;
1044};
1045
1046/*!
1047 * @function VNOP_READDIRATTR
1048 * @abstract Call down to get file attributes for many files in a directory at once.
1049 * @discussion VNOP_READDIRATTR() packs a buffer with file attributes, as if the results of many "getattrlist" calls.
1050 * @param vp Directory in which to enumerate entries' attributes.
1051 * @param alist Which attributes are wanted for each directory entry.
1052 * @param uio Destination information for resulting attributes.
1053 * @param maxcount Maximum count of files to get attributes for.
1054 * @param options FSOPT_NOFOLLOW: do not follow symbolic links. FSOPT_NOINMEMUPDATE: do not use data which have been
1055 * updated since an inode was loaded into memory.
1056 * @param newstate The "newstate" should be set to a value which changes if the contents of a directory change
1057 * through an addition or deletion but stays the same otherwise.
1058 * @param eofflag Should be set to 1 if the end of the directory has been reached.
1059 * @param actualcount Should be set to number of files whose attributes were written into buffer.
1060 * @param ctx Context to authenticate for readdirattr request.
1061 * @return 0 for success, else an error code.
1062 */
1063#ifdef XNU_KERNEL_PRIVATE
1064extern errno_t VNOP_READDIRATTR(vnode_t, struct attrlist *, struct uio *, uint32_t, uint32_t, uint32_t *, int *, uint32_t *, vfs_context_t);
1065#endif /* XNU_KERNEL_PRIVATE */
1066
1067struct vnop_getattrlistbulk_args {
1068 struct vnodeop_desc *a_desc;
1069 vnode_t a_vp;
1070 struct attrlist *a_alist;
1071 struct vnode_attr *a_vap;
1072 struct uio *a_uio;
1073 void *a_private;
1074 uint64_t a_options;
1075 int32_t *a_eofflag;
1076 int32_t *a_actualcount;
1077 vfs_context_t a_context;
1078};
1079
1080/*!
1081 * @function VNOP_GETATTRLISTBULK
1082 * @abstract Call down to get file attributes for many files in a directory at once.
1083 * @discussion VNOP_GETATTRLISTBULK() packs a buffer with file attributes, as if the results of many "getattrlist" calls.
1084 * @param vp Directory in which to enumerate entries' attributes.
1085 * @param alist Which attributes are wanted for each directory entry.
1086 * @param uio Destination information for resulting attributes.
1087 * @param vap initialised vnode_attr structure pointer. This structure also has memory allocated (MAXPATHLEN bytes) and assigned to the va_name field for filesystems to use.
1088 * @param private reserved for future use.
1089 * @param options
1090 * @param eofflag Should be set to 1 if the end of the directory has been reached.
1091 * @param actualcount Should be set to number of files whose attributes were written into buffer.
1092 * @param ctx Context to authenticate for getattrlistbulk request.
1093 * @return 0 for success, else an error code.
1094 */
1095#ifdef XNU_KERNEL_PRIVATE
1096extern errno_t VNOP_GETATTRLISTBULK(vnode_t, struct attrlist *, struct vnode_attr *, uio_t, void *, uint64_t, int32_t *, int32_t *, vfs_context_t);
1097#endif /* XNU_KERNEL_PRIVATE */
1098
1099struct vnop_readlink_args {
1100 struct vnodeop_desc *a_desc;
1101 vnode_t a_vp;
1102 struct uio *a_uio;
1103 vfs_context_t a_context;
1104};
1105
1106/*!
1107 * @function VNOP_READLINK
1108 * @abstract Call down to a filesystem to get the pathname represented by a symbolic link.
1109 * @discussion VNOP_READLINK() gets the path stored in a symbolic link; it is called by namei() and the readlink() system call.
1110 * @param vp Symbolic link to read from.
1111 * @param uio Destination information for link path.
1112 * @param ctx Context to authenticate for readlink request.
1113 * @return 0 for success, else an error code.
1114 */
1115#ifdef XNU_KERNEL_PRIVATE
1116extern errno_t VNOP_READLINK(vnode_t, struct uio *, vfs_context_t);
1117#endif /* XNU_KERNEL_PRIVATE */
1118
1119struct vnop_inactive_args {
1120 struct vnodeop_desc *a_desc;
1121 vnode_t a_vp;
1122 vfs_context_t a_context;
1123};
1124
1125/*!
1126 * @function VNOP_INACTIVE
1127 * @abstract Notify a filesystem that the last usecount (persistent reference) on a vnode has been dropped.
1128 * @discussion VNOP_INACTVE() gives a filesystem a chance to aggressively release resources assocated with a vnode, perhaps
1129 * even to call vnode_recycle(), but no action is prescribed; it is acceptable for VNOP_INACTIVE to be a no-op and
1130 * to defer all reclamation until VNOP_RECLAIM().
1131 * VNOP_INACTVE() will not be called on a vnode if no persistent reference is ever taken; an
1132 * important example is a stat(), which takes an iocount, reads its data, and drops that iocount.
1133 * @param vp The vnode which is now inactive.
1134 * @param ctx Context to authenticate for inactive message.
1135 * @return 0 for success, else an error code, but return value is currently ignored.
1136 */
1137#ifdef XNU_KERNEL_PRIVATE
1138extern errno_t VNOP_INACTIVE(vnode_t, vfs_context_t);
1139#endif /* XNU_KERNEL_PRIVATE */
1140
1141struct vnop_reclaim_args {
1142 struct vnodeop_desc *a_desc;
1143 vnode_t a_vp;
1144 vfs_context_t a_context;
1145};
1146
1147/*!
1148 * @function VNOP_RECLAIM
1149 * @abstract Release filesystem-internal resources for a vnode.
1150 * @discussion VNOP_RECLAIM() is called as part of the process of recycling a vnode. During
1151 * a reclaim routine, a filesystem should remove a vnode from its hash and deallocate any resources
1152 * allocated to that vnode. VFS guarantees that when VNOP_RECLAIM() is called, there are no more
1153 * iocount references on a vnode (though there may still be usecount references--these are invalidated
1154 * by the reclaim) and that no more will be granted. This means in practice that there will be no
1155 * filesystem calls on the vnode being reclaimed until the reclaim has finished and the vnode has
1156 * been reused.
1157 * @param vp The vnode to reclaim.
1158 * @param ctx Context to authenticate for reclaim.
1159 * @return 0 for success, or an error code. A nonzero return value results in a panic.
1160 */
1161#ifdef XNU_KERNEL_PRIVATE
1162extern errno_t VNOP_RECLAIM(vnode_t, vfs_context_t);
1163#endif /* XNU_KERNEL_PRIVATE */
1164
1165struct vnop_pathconf_args {
1166 struct vnodeop_desc *a_desc;
1167 vnode_t a_vp;
1168 int a_name;
1169 int32_t *a_retval;
1170 vfs_context_t a_context;
1171};
1172
1173/*!
1174 * @function VNOP_PATHCONF
1175 * @abstract Query a filesystem for path properties.
1176 * @param vp The vnode whose filesystem to query.
1177 * @param name Which property to request: see unistd.h. For example: _PC_CASE_SENSITIVE (is
1178 * a filesystem case-sensitive?). Only one property can be requested at a time.
1179 * @param retval Destination for value of property.
1180 * @param ctx Context to authenticate for pathconf request.
1181 * @return 0 for success, or an error code.
1182 */
1183#ifdef XNU_KERNEL_PRIVATE
1184extern errno_t VNOP_PATHCONF(vnode_t, int, int32_t *, vfs_context_t);
1185#endif /* XNU_KERNEL_PRIVATE */
1186
1187struct vnop_advlock_args {
1188 struct vnodeop_desc *a_desc;
1189 vnode_t a_vp;
1190 caddr_t a_id;
1191 int a_op;
1192 struct flock *a_fl;
1193 int a_flags;
1194 vfs_context_t a_context;
1195 struct timespec *a_timeout;
1196};
1197
1198/*!
1199 * @function VNOP_ADVLOCK
1200 * @abstract Aquire or release and advisory lock on a vnode.
1201 * @discussion Advisory locking is somewhat complicated. VNOP_ADVLOCK is overloaded for
1202 * both flock() and POSIX advisory locking usage, though not all filesystems support both (or any). VFS
1203 * provides an advisory locking mechanism for filesystems which can take advantage of it; vfs_setlocklocal()
1204 * marks a filesystem as using VFS advisory locking support.
1205 * @param vp The vnode to lock or unlock.
1206 * @param id Identifier for lock holder: ignored by most filesystems.
1207 * @param op Which locking operation: F_SETLK: set locking information about a region.
1208 * F_GETLK: get locking information about the specified region. F_UNLCK: Unlock a region.
1209 * @param fl Description of file region to lock. l_whence is as with "lseek."
1210 * Includes a type: F_RDLCK (shared lock), F_UNLCK (unlock) , and F_WRLCK (exclusive lock).
1211 * @param flags F_FLOCK: use flock() semantics. F_POSIX: use POSIX semantics. F_WAIT: sleep if necessary.
1212 * F_PROV: Non-coelesced provisional lock (unused in xnu).
1213 * @param ctx Context to authenticate for advisory locking request.
1214 * @param timeout Timespec for timeout in case of F_SETLKWTIMEOUT.
1215 * @return 0 for success, or an error code.
1216 */
1217#ifdef XNU_KERNEL_PRIVATE
1218extern errno_t VNOP_ADVLOCK(vnode_t, caddr_t, int, struct flock *, int, vfs_context_t, struct timespec *);
1219#endif /* XNU_KERNEL_PRIVATE */
1220
1221struct vnop_allocate_args {
1222 struct vnodeop_desc *a_desc;
1223 vnode_t a_vp;
1224 off_t a_length;
1225 u_int32_t a_flags;
1226 off_t *a_bytesallocated;
1227 off_t a_offset;
1228 vfs_context_t a_context;
1229};
1230
1231/*!
1232 * @function VNOP_ALLOCATE
1233 * @abstract Pre-allocate space for a file.
1234 * @discussion VNOP_ALLOCATE() changes the amount of backing store set aside to
1235 * a file. It can be used to either shrink or grow a file. If the file shrinks,
1236 * its ubc size will be modified accordingly, but if it grows, then the ubc size is unchanged;
1237 * space is set aside without being actively used by the file. VNOP_ALLOCATE() is currently only
1238 * called as part of the F_PREALLOCATE fcntl.
1239 * @param vp The vnode for which to preallocate space.
1240 * @param length Desired preallocated file length.
1241 * @param flags
1242 * PREALLOCATE: preallocate allocation blocks.
1243 * ALLOCATECONTIG: allocate contigious space.
1244 * ALLOCATEALL: allocate all requested space or no space at all.
1245 * ALLOCATEPERSIST: do not deallocate allocated but unfilled blocks at close(2).
1246 * ALLOCATEFROMPEOF: allocate from the physical eof.
1247 * ALLOCATEFROMVOL: allocate from the volume offset.
1248 * @param bytesallocated Additional bytes set aside for file. Set to 0 if none are allocated
1249 * OR if the file is contracted.
1250 * @param offset Hint for where to find free blocks.
1251 * @param ctx Context to authenticate for allocation request.
1252 * @return 0 for success, or an error code.
1253 */
1254#ifdef XNU_KERNEL_PRIVATE
1255extern errno_t VNOP_ALLOCATE(vnode_t, off_t, u_int32_t, off_t *, off_t, vfs_context_t);
1256#endif /* XNU_KERNEL_PRIVATE */
1257
1258struct vnop_pagein_args {
1259 struct vnodeop_desc *a_desc;
1260 vnode_t a_vp;
1261 upl_t a_pl;
1262 upl_offset_t a_pl_offset;
1263 off_t a_f_offset;
1264 size_t a_size;
1265 int a_flags;
1266 vfs_context_t a_context;
1267};
1268
1269/*!
1270 * @function VNOP_PAGEIN
1271 * @abstract Pull file data into memory.
1272 * @discussion VNOP_PAGEIN() is called by when a process faults on data mapped from a file or
1273 * when madvise() demands pre-fetching. It is conceptually somewhat similar to VNOP_READ(). Filesystems
1274 * are typically expected to call cluster_pagein() to handle the labor of mapping and committing the UPL.
1275 * @param vp The vnode for which to page in data.
1276 * @param pl UPL describing pages needing to be paged in.
1277 * @param pl_offset Offset in UPL at which to start placing data.
1278 * @param f_offset Offset in file of data needing to be paged in.
1279 * @param size Amount of data to page in (in bytes).
1280 * @param flags UPL-style flags: UPL_IOSYNC, UPL_NOCOMMIT, UPL_NORDAHEAD, UPL_VNODE_PAGER, UPL_MSYNC.
1281 * Filesystems should generally leave it to the cluster layer to handle these flags. See the
1282 * memory_object_types.h header in the kernel framework if interested.
1283 * @param ctx Context to authenticate for pagein request.
1284 * @return 0 for success, or an error code.
1285 */
1286#ifdef XNU_KERNEL_PRIVATE
1287extern errno_t VNOP_PAGEIN(vnode_t, upl_t, upl_offset_t, off_t, size_t, int, vfs_context_t);
1288#endif /* XNU_KERNEL_PRIVATE */
1289
1290struct vnop_pageout_args {
1291 struct vnodeop_desc *a_desc;
1292 vnode_t a_vp;
1293 upl_t a_pl;
1294 upl_offset_t a_pl_offset;
1295 off_t a_f_offset;
1296 size_t a_size;
1297 int a_flags;
1298 vfs_context_t a_context;
1299};
1300
1301/*!
1302 * @function VNOP_PAGEOUT
1303 * @abstract Write data from a mapped file back to disk.
1304 * @discussion VNOP_PAGEOUT() is called when data from a mapped file needs to be flushed to disk, either
1305 * because of an msync() call or due to memory pressure. Filesystems are for the most part expected to
1306 * just call cluster_pageout(). However, if they opt into the VFC_VFSVNOP_PAGEOUTV2 flag, then
1307 * they will be responsible for creating their own UPLs.
1308 * @param vp The vnode for which to page out data.
1309 * @param pl UPL describing pages needed to be paged out. If UPL is NULL, then it means the filesystem
1310 * has opted into VFC_VFSVNOP_PAGEOUTV2 semantics, which means that it will create and operate on its own UPLs
1311 * as opposed to relying on the one passed down into the filesystem. This means that the filesystem must be
1312 * responsible for N cluster_pageout calls for N dirty ranges in the UPL.
1313 * @param pl_offset Offset in UPL from which to start paging out data. Under the new VFC_VFSVNOP_PAGEOUTV2
1314 * semantics, this is the offset in the range specified that must be paged out if the associated page is dirty.
1315 * @param f_offset Offset in file of data needing to be paged out. Under the new VFC_VFSVNOP_PAGEOUTV2
1316 * semantics, this represents the offset in the file where we should start looking for dirty pages.
1317 * @param size Amount of data to page out (in bytes). Under VFC_VFSVNOP_PAGEOUTV2, this represents
1318 * the size of the range to be considered. The fileystem is free to extend or shrink the specified range
1319 * to better fit its blocking model as long as the page at 'pl_offset' is included.
1320 * @param flags UPL-style flags: UPL_IOSYNC, UPL_NOCOMMIT, UPL_NORDAHEAD, UPL_VNODE_PAGER, UPL_MSYNC.
1321 * Filesystems should generally leave it to the cluster layer to handle these flags. See the
1322 * memory_object_types.h header in the kernel framework if interested.
1323 * @param ctx Context to authenticate for pageout request.
1324 * @return 0 for success, or an error code.
1325 */
1326#ifdef XNU_KERNEL_PRIVATE
1327extern errno_t VNOP_PAGEOUT(vnode_t, upl_t, upl_offset_t, off_t, size_t, int, vfs_context_t);
1328#endif /* XNU_KERNEL_PRIVATE */
1329
1330struct vnop_searchfs_args {
1331 struct vnodeop_desc *a_desc;
1332 vnode_t a_vp;
1333 void *a_searchparams1;
1334 void *a_searchparams2;
1335 struct attrlist *a_searchattrs;
1336 uint32_t a_maxmatches;
1337 struct timeval *a_timelimit;
1338 struct attrlist *a_returnattrs;
1339 uint32_t *a_nummatches;
1340 uint32_t a_scriptcode;
1341 uint32_t a_options;
1342 struct uio *a_uio;
1343 struct searchstate *a_searchstate;
1344 vfs_context_t a_context;
1345};
1346
1347/*
1348 * @function VNOP_SEARCHFS
1349 * @abstract Search a filesystem quickly for files or directories that match the passed-in search criteria.
1350 * @discussion VNOP_SEARCHFS is a getattrlist-based system call which is implemented almost entirely inside
1351 * supported filesystems. Callers provide a set of criteria to match against, and the filesystem is responsible
1352 * for finding all files or directories that match the criteria. Once these files or directories are found,
1353 * the user-requested attributes of these files is provided as output. The set of searchable attributes is a
1354 * subset of the getattrlist attributes. For example, ATTR_CMN_UUID is not a valid searchable attribute as of
1355 * 10.6. A common usage scenario could be to request all files whose mod dates is greater than time X, less than
1356 * time Y, and provide the inode ID and filename of the matching objects as output.
1357 * @param vp The vnode representing the mountpoint of the filesystem to be searched.
1358 * @param a_searchparams1 If one-argument search criteria is requested, the search criteria would go here. However,
1359 * some search criteria, like ATTR_CMN_MODTIME, can be bounded. The user could request files modified between time X
1360 * and time Y. In this case, the lower bound goes in a_searchparams1.
1361 * @param a_searchparams2 If two-argument search criteria is requested, the upper bound goes in here.
1362 * @param a_searchattrs Contains the getattrlist-style attribute bits which are requested by the current search.
1363 * @param a_maxmatches The maximum number of matches to return in a single system call.
1364 * @param a_timelimit The suggested maximum amount of time we can spend in the kernel to service this system call.
1365 * Filesystems should use this as a guide only, and set their own internal maximum time to avoid denial of service.
1366 * @param a_returnattrs The getattrlist-style attributes to return for items in the filesystem that match the search
1367 * criteria above.
1368 * @param a_scriptcode Currently ignored.
1369 * @param a_uio The uio in which to write out the search matches.
1370 * @param a_searchstate Sometimes searches cannot be completed in a single system call. In this case, we provide
1371 * an identifier back to the user which indicates where to resume a previously-started search. This is an opaque structure
1372 * used by the filesystem to identify where to resume said search.
1373 * @param a_context The context in which to perform the filesystem search.
1374 * @return 0 on success, EAGAIN for searches which could not be completed in 1 call, and other ERRNOS as needed.
1375 */
1376
1377#ifdef XNU_KERNEL_PRIVATE
1378extern errno_t VNOP_SEARCHFS(vnode_t, void *, void *, struct attrlist *, uint32_t, struct timeval *, struct attrlist *, uint32_t *, uint32_t, uint32_t, struct uio *, struct searchstate *, vfs_context_t);
1379#endif /* XNU_KERNEL_PRIVATE */
1380
1381struct vnop_copyfile_args {
1382 struct vnodeop_desc *a_desc;
1383 vnode_t a_fvp;
1384 vnode_t a_tdvp;
1385 vnode_t a_tvp;
1386 struct componentname *a_tcnp;
1387 int a_mode;
1388 int a_flags;
1389 vfs_context_t a_context;
1390};
1391
1392#ifdef XNU_KERNEL_PRIVATE
1393extern errno_t VNOP_COPYFILE(vnode_t, vnode_t, vnode_t, struct componentname *, int, int, vfs_context_t);
1394#endif /* XNU_KERNEL_PRIVATE */
1395
1396typedef enum dir_clone_authorizer_op {
1397 OP_AUTHORIZE = 0, /* request authorization of action */
1398 OP_VATTR_SETUP = 1, /* query for attributes that are required for OP_AUTHORIZE */
1399 OP_VATTR_CLEANUP = 2 /* request to cleanup any state or free any memory allocated in OP_AUTHORIZE */
1400} dir_clone_authorizer_op_t;
1401
1402struct vnop_clonefile_args {
1403 struct vnodeop_desc *a_desc;
1404 vnode_t a_fvp;
1405 vnode_t a_dvp;
1406 vnode_t *a_vpp;
1407 struct componentname *a_cnp;
1408 struct vnode_attr *a_vap;
1409 uint32_t a_flags;
1410 vfs_context_t a_context;
1411 int (*a_dir_clone_authorizer)( /* Authorization callback */
1412 struct vnode_attr *vap, /* attribute to be authorized */
1413 kauth_action_t action, /* action for which attribute is to be authorized */
1414 struct vnode_attr *dvap, /* target directory attributes */
1415 vnode_t sdvp, /* source directory vnode pointer (optional) */
1416 mount_t mp, /* mount point of filesystem */
1417 dir_clone_authorizer_op_t vattr_op, /* specific operation requested : setup, authorization or cleanup */
1418 uint32_t flags, /* needs to have the value passed to a_flags */
1419 vfs_context_t ctx, /* As passed to VNOP */
1420 void *reserved); /* Always NULL */
1421 void *a_reserved; /* Currently unused */
1422};
1423
1424/*!
1425 * @function VNOP_CLONEFILE
1426 * @abstract Call down to a filesystem to clone a filesystem object (regular file, directory or symbolic link.)
1427 * @discussion If file creation succeeds, "vpp" should be returned with an iocount to be dropped by the caller.
1428 * @param dvp Directory in which to clone object.
1429 * @param vpp Destination for vnode for newly cloned object.
1430 * @param cnp Description of name of object to clone.
1431 * @param vap File creation properties, as seen in vnode_getattr(). Manipulated with VATTR_ISACTIVE, VATTR_RETURN,
1432 * VATTR_SET_SUPPORTED, and so forth. All attributes not set here should either be copied
1433 * from the source object
1434 * or set to values which are used for creating new filesystem objects
1435 * @param ctx Context against which to authenticate file creation.
1436 * @return 0 for success or a filesystem-specific error.
1437 */
1438#ifdef XNU_KERNEL_PRIVATE
1439extern errno_t VNOP_CLONEFILE(vnode_t, vnode_t, vnode_t *, struct componentname *, struct vnode_attr *, uint32_t, vfs_context_t);
1440#endif /* XNU_KERNEL_PRIVATE */
1441
1442struct vnop_getxattr_args {
1443 struct vnodeop_desc *a_desc;
1444 vnode_t a_vp;
1445 const char * a_name;
1446 uio_t a_uio;
1447 size_t *a_size;
1448 int a_options;
1449 vfs_context_t a_context;
1450};
1451extern struct vnodeop_desc vnop_getxattr_desc;
1452
1453/*!
1454 * @function VNOP_GETXATTR
1455 * @abstract Get extended file attributes.
1456 * @param vp The vnode to get extended attributes for.
1457 * @param name Which property to extract.
1458 * @param uio Destination information for attribute value.
1459 * @param size Should be set to the amount of data written.
1460 * @param options XATTR_NOSECURITY: bypass security-checking.
1461 * @param ctx Context to authenticate for getxattr request.
1462 * @return 0 for success, or an error code.
1463 */
1464extern errno_t VNOP_GETXATTR(vnode_t vp, const char *name, uio_t uio, size_t *size, int options, vfs_context_t ctx);
1465
1466struct vnop_setxattr_args {
1467 struct vnodeop_desc *a_desc;
1468 vnode_t a_vp;
1469 const char * a_name;
1470 uio_t a_uio;
1471 int a_options;
1472 vfs_context_t a_context;
1473};
1474extern struct vnodeop_desc vnop_setxattr_desc;
1475
1476/*!
1477 * @function VNOP_SETXATTR
1478 * @abstract Set extended file attributes.
1479 * @param vp The vnode to set extended attributes for.
1480 * @param name Which property to extract.
1481 * @param uio Source information for attribute value.
1482 * @param options XATTR_NOSECURITY: bypass security-checking. XATTR_CREATE: set value, fail if exists.
1483 * XATTR_REPLACE: set value, fail if does not exist.
1484 * @param ctx Context to authenticate for setxattr request.
1485 * @return 0 for success, or an error code.
1486 */
1487extern errno_t VNOP_SETXATTR(vnode_t vp, const char *name, uio_t uio, int options, vfs_context_t ctx);
1488
1489struct vnop_removexattr_args {
1490 struct vnodeop_desc *a_desc;
1491 vnode_t a_vp;
1492 const char * a_name;
1493 int a_options;
1494 vfs_context_t a_context;
1495};
1496extern struct vnodeop_desc vnop_removexattr_desc;
1497
1498/*!
1499 * @function VNOP_REMOVEXATTR
1500 * @abstract Remove extended file attributes.
1501 * @param vp The vnode from which to remove extended attributes.
1502 * @param name Which attribute to delete.
1503 * @param options XATTR_NOSECURITY: bypass security-checking.
1504 * @param ctx Context to authenticate for attribute delete request.
1505 * @return 0 for success, or an error code.
1506 */
1507#ifdef XNU_KERNEL_PRIVATE
1508extern errno_t VNOP_REMOVEXATTR(vnode_t, const char *, int, vfs_context_t);
1509#endif /* XNU_KERNEL_PRIVATE */
1510
1511struct vnop_listxattr_args {
1512 struct vnodeop_desc *a_desc;
1513 vnode_t a_vp;
1514 uio_t a_uio;
1515 size_t *a_size;
1516 int a_options;
1517 vfs_context_t a_context;
1518};
1519extern struct vnodeop_desc vnop_listxattr_desc;
1520
1521/*!
1522 * @function VNOP_LISTXATTR
1523 * @abstract List extended attribute keys.
1524 * @discussion Should write a sequence of unseparated, null-terminated extended-attribute
1525 * names into the space described by the provided uio. These keys can then be passed to
1526 * getxattr() (and VNOP_GETXATTR()).
1527 * @param vp The vnode for which to get extended attribute keys.
1528 * @param uio Description of target memory for attribute keys.
1529 * @param size Should be set to amount of data written to buffer.
1530 * @param options XATTR_NOSECURITY: bypass security checking.
1531 * @param ctx Context to authenticate for attribute name request.
1532 */
1533#ifdef XNU_KERNEL_PRIVATE
1534extern errno_t VNOP_LISTXATTR(vnode_t, uio_t, size_t *, int, vfs_context_t);
1535#endif /* XNU_KERNEL_PRIVATE */
1536
1537struct vnop_blktooff_args {
1538 struct vnodeop_desc *a_desc;
1539 vnode_t a_vp;
1540 daddr64_t a_lblkno;
1541 off_t *a_offset;
1542};
1543
1544/*!
1545 * @function VNOP_BLKTOOFF
1546 * @abstract Call down to a filesystem to convert a logical block number to a file offset.
1547 * @discussion VNOP_BLKTOOFF() converts a logical block to a file offset in bytes. That offset
1548 * can be passed to VNOP_BLOCKMAP(), then, to get a physical block number--buf_strategy() does this.
1549 * @param vp The vnode for which to convert a logical block to an offset.
1550 * @param lblkno Logical block number to turn into offset.
1551 * @param offset Destination for file offset.
1552 * @return 0 for success, else an error code.
1553 */
1554#ifdef XNU_KERNEL_PRIVATE
1555extern errno_t VNOP_BLKTOOFF(vnode_t, daddr64_t, off_t *);
1556#endif /* XNU_KERNEL_PRIVATE */
1557
1558struct vnop_offtoblk_args {
1559 struct vnodeop_desc *a_desc;
1560 vnode_t a_vp;
1561 off_t a_offset;
1562 daddr64_t *a_lblkno;
1563};
1564
1565/*!
1566 * @function VNOP_OFFTOBLK
1567 * @abstract Call down to a filesystem to convert a file offset to a logical block number.
1568 * @param vp The vnode for which to convert an offset to a logical block number.
1569 * @param offset File offset to convert.
1570 * @param lblkno Destination for corresponding logical block number.
1571 * @return 0 for success, else an error code.
1572 */
1573#ifdef XNU_KERNEL_PRIVATE
1574extern errno_t VNOP_OFFTOBLK(vnode_t, off_t, daddr64_t *);
1575#endif /* XNU_KERNEL_PRIVATE */
1576
1577struct vnop_blockmap_args {
1578 struct vnodeop_desc *a_desc;
1579 vnode_t a_vp;
1580 off_t a_foffset;
1581 size_t a_size;
1582 daddr64_t *a_bpn;
1583 size_t *a_run;
1584 void *a_poff;
1585 int a_flags;
1586 vfs_context_t a_context;
1587};
1588
1589/*!
1590 * @function VNOP_BLOCKMAP
1591 * @abstract Call down to a filesystem to get information about the on-disk layout of a file region.
1592 * @discussion VNOP_BLOCKMAP() returns the information required to pass a request for a contiguous region
1593 * down to a device's strategy routine.
1594 * @param vp The vnode for which to get on-disk information.
1595 * @param foffset Offset (in bytes) at which region starts.
1596 * @param size Size of region.
1597 * @param bpn Destination for physical block number at which region begins on disk.
1598 * @param run Destination for number of bytes which can be found contiguously on-disk before
1599 * first discontinuity.
1600 * @param poff Currently unused.
1601 * @param flags VNODE_READ: request is for a read. VNODE_WRITE: request is for a write.
1602 * @param ctx Context to authenticate for blockmap request; currently often set to NULL.
1603 * @return 0 for success, else an error code.
1604 */
1605#ifdef XNU_KERNEL_PRIVATE
1606extern errno_t VNOP_BLOCKMAP(vnode_t, off_t, size_t, daddr64_t *, size_t *, void *,
1607 int, vfs_context_t);
1608#endif /* XNU_KERNEL_PRIVATE */
1609
1610struct vnop_strategy_args {
1611 struct vnodeop_desc *a_desc;
1612 struct buf *a_bp;
1613};
1614
1615/*!
1616 * @function VNOP_STRATEGY
1617 * @abstract Initiate I/O on a file (both read and write).
1618 * @discussion A filesystem strategy routine takes a buffer, performs whatever manipulations are necessary for passing
1619 * the I/O request down to the device layer, and calls the appropriate device's strategy routine. Most filesystems should
1620 * just call buf_strategy() with "bp" as the argument.
1621 * @param bp Complete specificiation of requested I/O: region of data involved, whether request is for read or write, and so on.
1622 * @return 0 for success, else an error code.
1623 */
1624extern errno_t VNOP_STRATEGY(struct buf *bp);
1625
1626struct vnop_bwrite_args {
1627 struct vnodeop_desc *a_desc;
1628 buf_t a_bp;
1629};
1630
1631/*!
1632 * @function VNOP_BWRITE
1633 * @abstract Write a buffer to backing store.
1634 * @discussion VNOP_BWRITE() is called by buf_bawrite() (asynchronous write) and potentially by buf_bdwrite() (delayed write)
1635 * but not by buf_bwrite(). A filesystem may choose to perform some kind of manipulation of the buffer in this routine; it
1636 * generally will end up calling VFS's default implementation, vn_bwrite() (which calls buf_bwrite() without further ado).
1637 * @param bp The buffer to write.
1638 * @return 0 for success, else an error code.
1639 */
1640extern errno_t VNOP_BWRITE(buf_t bp);
1641
1642struct vnop_kqfilt_add_args {
1643 struct vnodeop_desc *a_desc;
1644 struct vnode *a_vp;
1645 struct knote *a_kn;
1646 vfs_context_t a_context;
1647};
1648extern struct vnodeop_desc vnop_kqfilt_add_desc;
1649
1650#ifdef XNU_KERNEL_PRIVATE
1651extern errno_t VNOP_KQFILT_ADD(vnode_t, struct knote *, vfs_context_t);
1652#endif /* XNU_KERNEL_PRIVATE */
1653
1654struct vnop_kqfilt_remove_args {
1655 struct vnodeop_desc *a_desc;
1656 struct vnode *a_vp;
1657 uintptr_t a_ident;
1658 vfs_context_t a_context;
1659};
1660extern struct vnodeop_desc vnop_kqfilt_remove_desc;
1661
1662#ifdef XNU_KERNEL_PRIVATE
1663errno_t VNOP_KQFILT_REMOVE(vnode_t, uintptr_t, vfs_context_t);
1664#endif /* XNU_KERNEL_PRIVATE */
1665
1666
1667#ifdef KERNEL_PRIVATE
1668#define VNODE_MONITOR_BEGIN 0x01
1669#define VNODE_MONITOR_END 0x02
1670#define VNODE_MONITOR_UPDATE 0x04
1671struct vnop_monitor_args {
1672 struct vnodeop_desc *a_desc;
1673 vnode_t a_vp;
1674 uint32_t a_events;
1675 uint32_t a_flags;
1676 void *a_handle;
1677 vfs_context_t a_context;
1678};
1679extern struct vnodeop_desc vnop_monitor_desc;
1680#endif /* KERNEL_PRIVATE */
1681
1682#ifdef XNU_KERNEL_PRIVATE
1683/*!
1684 * @function VNOP_MONITOR
1685 * @abstract Indicate to a filesystem that the number of watchers of a file has changed.
1686 * @param vp The vnode whose watch state has changed.
1687 * @param events Unused. Filesystems can ignore this parameter.
1688 * @param flags Type of change to the watch state. VNODE_MONITOR_BEGIN is passed when the kernel
1689 * begins tracking a new watcher of a file. VNODE_MONITOR_END is passed when a watcher stops watching a file.
1690 * VNODE_MONITOR_UPDATE is currently unused. A filesystem is guaranteed that each VNODE_MONITOR_BEGIN
1691 * will be matched by a VNODE_MONITOR_END with the same "handle" argument.
1692 * @param handle Unique identifier for a given watcher. A VNODE_MONITOR_BEGIN for a given handle will be matched with a
1693 * VNODE_MONITOR_END for the same handle; a filesystem need not consider this parameter unless
1694 * it for some reason wants be able to match specific VNOP_MONITOR calls rather than just keeping
1695 * a count.
1696 * @param ctx The context which is starting to monitor a file or ending a watch on a file. A matching
1697 * pair of VNODE_MONITOR_BEGIN and VNODE_MONITOR_END need not have the same context.
1698 * @discussion VNOP_MONITOR() is intended to let networked filesystems know when they should bother
1699 * listening for changes to files which occur remotely, so that they can post notifications using
1700 * vnode_notify(). Local filesystems should not implement a monitor vnop.
1701 * It is called when there is a new watcher for a file or when a watcher for a file goes away.
1702 * Each BEGIN will be matched with an END with the same handle. Note that vnode_ismonitored() can
1703 * be used to see if there are currently watchers for a file.
1704 */
1705errno_t VNOP_MONITOR(vnode_t vp, uint32_t events, uint32_t flags, void *handle, vfs_context_t ctx);
1706#endif /* XNU_KERNEL_PRIVATE */
1707
1708struct label;
1709struct vnop_setlabel_args {
1710 struct vnodeop_desc *a_desc;
1711 struct vnode *a_vp;
1712 struct label *a_vl;
1713 vfs_context_t a_context;
1714};
1715extern struct vnodeop_desc vnop_setlabel_desc;
1716
1717/*!
1718 * @function VNOP_SETLABEL
1719 * @abstract Associate a MACF label with a file.
1720 * @param vp The vnode to label.
1721 * @param label The desired label.
1722 * @param ctx Context to authenticate for label change.
1723 * @return 0 for success, else an error code.
1724 */
1725#ifdef XNU_KERNEL_PRIVATE
1726errno_t VNOP_SETLABEL(vnode_t, struct label *, vfs_context_t);
1727#endif /* XNU_KERNEL_PRIVATE */
1728
1729#ifdef __APPLE_API_UNSTABLE
1730
1731#if NAMEDSTREAMS
1732
1733enum nsoperation { NS_OPEN, NS_CREATE, NS_DELETE };
1734
1735/* a_flags for vnop_getnamedstream_args: */
1736#define NS_GETRAWENCRYPTED 0x00000001
1737
1738struct vnop_getnamedstream_args {
1739 struct vnodeop_desc *a_desc;
1740 vnode_t a_vp;
1741 vnode_t *a_svpp;
1742 const char *a_name;
1743 enum nsoperation a_operation;
1744 int a_flags;
1745 vfs_context_t a_context;
1746};
1747
1748/*!
1749 * @function VNOP_GETNAMEDSTREAM
1750 * @abstract Get a named stream associated with a file.
1751 * @discussion If this call sucecss, svpp should be returned with an iocount which the caller
1752 * will drop. VFS provides a facility for simulating named streams when interacting with filesystems
1753 * which do not support them.
1754 * @param vp The vnode for which to get a named stream.
1755 * @param svpp Destination for pointer to named stream's vnode.
1756 * @param name The name of the named stream, e.g. "com.apple.ResourceFork".
1757 * @param operation Operation to perform. In HFS and AFP, this parameter is only considered as follows:
1758 * if the resource fork has not been opened and the operation is not NS_OPEN, fail with ENOATTR. Currently
1759 * only passed as NS_OPEN by VFS.
1760 * @param flags Flags used to control getnamedstream behavior. Currently only used for raw-encrypted-requests.
1761 * @param ctx Context to authenticate for getting named stream.
1762 * @return 0 for success, else an error code.
1763 */
1764#ifdef XNU_KERNEL_PRIVATE
1765extern errno_t VNOP_GETNAMEDSTREAM(vnode_t, vnode_t *, const char *, enum nsoperation, int flags, vfs_context_t);
1766#endif /* XNU_KERNEL_PRIVATE */
1767
1768struct vnop_makenamedstream_args {
1769 struct vnodeop_desc *a_desc;
1770 vnode_t *a_svpp;
1771 vnode_t a_vp;
1772 const char *a_name;
1773 int a_flags;
1774 vfs_context_t a_context;
1775};
1776
1777/*!
1778 * @function VNOP_MAKENAMEDSTREAM
1779 * @abstract Create a named stream associated with a file.
1780 * @discussion If this call succeeds, svpp should be returned with an iocount which the caller will drop.
1781 * VFS provides a facility for simulating named streams when interacting with filesystems
1782 * which do not support them.
1783 * @param vp The vnode for which to get a named stream.
1784 * @param svpp Destination for pointer to named stream's vnode.
1785 * @param name The name of the named stream, e.g. "com.apple.ResourceFork".
1786 * @param flags Currently unused.
1787 * @param ctx Context to authenticate creating named stream.
1788 * @return 0 for success, else an error code.
1789 */
1790#ifdef XNU_KERNEL_PRIVATE
1791extern errno_t VNOP_MAKENAMEDSTREAM(vnode_t, vnode_t *, const char *, int flags, vfs_context_t);
1792#endif /* XNU_KERNEL_PRIVATE */
1793
1794struct vnop_removenamedstream_args {
1795 struct vnodeop_desc *a_desc;
1796 vnode_t a_vp;
1797 vnode_t a_svp;
1798 const char *a_name;
1799 int a_flags;
1800 vfs_context_t a_context;
1801};
1802
1803/*!
1804 * @function VNOP_REMOVENAMEDSTREAM
1805 * @abstract Delete a named stream associated with a file.
1806 * @discussion VFS provides a facility for simulating named streams when interacting with filesystems
1807 * which do not support them.
1808 * @param vp The vnode to which the named stream belongs.
1809 * @param svp The named stream's vnode.
1810 * @param name The name of the named stream, e.g. "com.apple.ResourceFork".
1811 * @param flags Currently unused.
1812 * @param ctx Context to authenticate deleting named stream.
1813 * @return 0 for success, else an error code.
1814 */
1815#ifdef XNU_KERNEL_PRIVATE
1816extern errno_t VNOP_REMOVENAMEDSTREAM(vnode_t, vnode_t, const char *, int flags, vfs_context_t);
1817#endif /* XNU_KERNEL_PRIVATE */
1818
1819#endif // NAMEDSTREAMS
1820
1821__options_decl(vnode_verify_flags_t, uint32_t, {
1822 VNODE_VERIFY_DEFAULT = 0,
1823 VNODE_VERIFY_CONTEXT_ALLOC = 1,
1824 VNODE_VERIFY_WITH_CONTEXT = 2,
1825 VNODE_VERIFY_CONTEXT_FREE = 4,
1826});
1827
1828#define VNODE_VERIFY_DEFAULT VNODE_VERIFY_DEFAULT
1829#define VNODE_VERIFY_WITH_CONTEXT VNODE_VERIFY_WITH_CONTEXT
1830
1831struct vnop_verify_args {
1832 struct vnodeop_desc *a_desc;
1833 vnode_t a_vp;
1834 off_t a_foffset;
1835 uint8_t *a_buf;
1836 size_t a_bufsize;
1837 size_t *a_verifyblksize;
1838 void **a_verify_ctxp;
1839 vnode_verify_flags_t a_flags;
1840 vfs_context_t a_context;
1841};
1842
1843/*!
1844 * @function VNOP_VERIFY
1845 * @abstract Call down to a filesystem to verify file data for integrity.
1846 * @discussion VNOP_VERIFY() returns whether file data being read has been verified to be what was written.
1847 * This does not impose a specific mechanism for ensuring integrity beyond requiring that this be done in
1848 * multiples of a verify block size (analogous to a filesystem block size but it can be per file)
1849 * @param vp The vnode for which data is to be verified.
1850 * @param foffset Offset (in bytes) at which region to be verified starts.
1851 * @param buf buffer containing file data at foffset. If this is NULL, then only the verification block size is
1852 * being requested.
1853 * @param bufsize size of data buffer to be verified.
1854 * @param verifyblksize pointer to size of verification block size in use for this file. If the verification block size is 0,
1855 * no verification will be performed. The verification block size can be any value which is a power of two upto 128KiB.
1856 * @param verify_ctxp context for verification to allocated by the FS and used in verification.
1857 * @param flags modifier flags.
1858 * @param ctx Context to authenticate for verify request; currently often set to NULL.
1859 * @return 0 for success, else an error code.
1860 */
1861#ifdef XNU_KERNEL_PRIVATE
1862extern errno_t VNOP_VERIFY(vnode_t, off_t, uint8_t *, size_t, size_t *, void **, vnode_verify_flags_t, vfs_context_t);
1863#endif /* XNU_KERNEL_PRIVATE */
1864
1865#endif // defined(__APPLE_API_UNSTABLE)
1866
1867__END_DECLS
1868
1869#endif /* KERNEL */
1870
1871#pragma clang diagnostic pop /* #pragma clang diagnostic ignored "-Wdocumentation" */
1872#endif /* !_SYS_VNODE_IF_H_ */
1873