The C and C++ Include Header Files

/usr/include/linux/fuse.h


$ cat -n /usr/include/linux/fuse.h

     1	/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */
     2	/*
     3	    This file defines the kernel interface of FUSE
     4	    Copyright (C) 2001-2008  Miklos Szeredi <miklos@szeredi.hu>
     5	
     6	    This program can be distributed under the terms of the GNU GPL.
     7	    See the file COPYING.
     8	
     9	    This -- and only this -- header file may also be distributed under
    10	    the terms of the BSD Licence as follows:
    11	
    12	    Copyright (C) 2001-2007 Miklos Szeredi. All rights reserved.
    13	
    14	    Redistribution and use in source and binary forms, with or without
    15	    modification, are permitted provided that the following conditions
    16	    are met:
    17	    1. Redistributions of source code must retain the above copyright
    18	       notice, this list of conditions and the following disclaimer.
    19	    2. Redistributions in binary form must reproduce the above copyright
    20	       notice, this list of conditions and the following disclaimer in the
    21	       documentation and/or other materials provided with the distribution.
    22	
    23	    THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
    24	    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    25	    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    26	    ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
    27	    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    28	    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
    29	    OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    30	    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    31	    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    32	    OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    33	    SUCH DAMAGE.
    34	*/
    35	
    36	/*
    37	 * This file defines the kernel interface of FUSE
    38	 *
    39	 * Protocol changelog:
    40	 *
    41	 * 7.1:
    42	 *  - add the following messages:
    43	 *      FUSE_SETATTR, FUSE_SYMLINK, FUSE_MKNOD, FUSE_MKDIR, FUSE_UNLINK,
    44	 *      FUSE_RMDIR, FUSE_RENAME, FUSE_LINK, FUSE_OPEN, FUSE_READ, FUSE_WRITE,
    45	 *      FUSE_RELEASE, FUSE_FSYNC, FUSE_FLUSH, FUSE_SETXATTR, FUSE_GETXATTR,
    46	 *      FUSE_LISTXATTR, FUSE_REMOVEXATTR, FUSE_OPENDIR, FUSE_READDIR,
    47	 *      FUSE_RELEASEDIR
    48	 *  - add padding to messages to accommodate 32-bit servers on 64-bit kernels
    49	 *
    50	 * 7.2:
    51	 *  - add FOPEN_DIRECT_IO and FOPEN_KEEP_CACHE flags
    52	 *  - add FUSE_FSYNCDIR message
    53	 *
    54	 * 7.3:
    55	 *  - add FUSE_ACCESS message
    56	 *  - add FUSE_CREATE message
    57	 *  - add filehandle to fuse_setattr_in
    58	 *
    59	 * 7.4:
    60	 *  - add frsize to fuse_kstatfs
    61	 *  - clean up request size limit checking
    62	 *
    63	 * 7.5:
    64	 *  - add flags and max_write to fuse_init_out
    65	 *
    66	 * 7.6:
    67	 *  - add max_readahead to fuse_init_in and fuse_init_out
    68	 *
    69	 * 7.7:
    70	 *  - add FUSE_INTERRUPT message
    71	 *  - add POSIX file lock support
    72	 *
    73	 * 7.8:
    74	 *  - add lock_owner and flags fields to fuse_release_in
    75	 *  - add FUSE_BMAP message
    76	 *  - add FUSE_DESTROY message
    77	 *
    78	 * 7.9:
    79	 *  - new fuse_getattr_in input argument of GETATTR
    80	 *  - add lk_flags in fuse_lk_in
    81	 *  - add lock_owner field to fuse_setattr_in, fuse_read_in and fuse_write_in
    82	 *  - add blksize field to fuse_attr
    83	 *  - add file flags field to fuse_read_in and fuse_write_in
    84	 *  - Add ATIME_NOW and MTIME_NOW flags to fuse_setattr_in
    85	 *
    86	 * 7.10
    87	 *  - add nonseekable open flag
    88	 *
    89	 * 7.11
    90	 *  - add IOCTL message
    91	 *  - add unsolicited notification support
    92	 *  - add POLL message and NOTIFY_POLL notification
    93	 *
    94	 * 7.12
    95	 *  - add umask flag to input argument of create, mknod and mkdir
    96	 *  - add notification messages for invalidation of inodes and
    97	 *    directory entries
    98	 *
    99	 * 7.13
   100	 *  - make max number of background requests and congestion threshold
   101	 *    tunables
   102	 *
   103	 * 7.14
   104	 *  - add splice support to fuse device
   105	 *
   106	 * 7.15
   107	 *  - add store notify
   108	 *  - add retrieve notify
   109	 *
   110	 * 7.16
   111	 *  - add BATCH_FORGET request
   112	 *  - FUSE_IOCTL_UNRESTRICTED shall now return with array of 'struct
   113	 *    fuse_ioctl_iovec' instead of ambiguous 'struct iovec'
   114	 *  - add FUSE_IOCTL_32BIT flag
   115	 *
   116	 * 7.17
   117	 *  - add FUSE_FLOCK_LOCKS and FUSE_RELEASE_FLOCK_UNLOCK
   118	 *
   119	 * 7.18
   120	 *  - add FUSE_IOCTL_DIR flag
   121	 *  - add FUSE_NOTIFY_DELETE
   122	 *
   123	 * 7.19
   124	 *  - add FUSE_FALLOCATE
   125	 *
   126	 * 7.20
   127	 *  - add FUSE_AUTO_INVAL_DATA
   128	 *
   129	 * 7.21
   130	 *  - add FUSE_READDIRPLUS
   131	 *  - send the requested events in POLL request
   132	 *
   133	 * 7.22
   134	 *  - add FUSE_ASYNC_DIO
   135	 *
   136	 * 7.23
   137	 *  - add FUSE_WRITEBACK_CACHE
   138	 *  - add time_gran to fuse_init_out
   139	 *  - add reserved space to fuse_init_out
   140	 *  - add FATTR_CTIME
   141	 *  - add ctime and ctimensec to fuse_setattr_in
   142	 *  - add FUSE_RENAME2 request
   143	 *  - add FUSE_NO_OPEN_SUPPORT flag
   144	 *
   145	 *  7.24
   146	 *  - add FUSE_LSEEK for SEEK_HOLE and SEEK_DATA support
   147	 *
   148	 *  7.25
   149	 *  - add FUSE_PARALLEL_DIROPS
   150	 *
   151	 *  7.26
   152	 *  - add FUSE_HANDLE_KILLPRIV
   153	 *  - add FUSE_POSIX_ACL
   154	 *
   155	 *  7.27
   156	 *  - add FUSE_ABORT_ERROR
   157	 *
   158	 *  7.28
   159	 *  - add FUSE_COPY_FILE_RANGE
   160	 *  - add FOPEN_CACHE_DIR
   161	 *  - add FUSE_MAX_PAGES, add max_pages to init_out
   162	 *  - add FUSE_CACHE_SYMLINKS
   163	 *
   164	 *  7.29
   165	 *  - add FUSE_NO_OPENDIR_SUPPORT flag
   166	 *
   167	 *  7.30
   168	 *  - add FUSE_EXPLICIT_INVAL_DATA
   169	 *  - add FUSE_IOCTL_COMPAT_X32
   170	 *
   171	 *  7.31
   172	 *  - add FUSE_WRITE_KILL_PRIV flag
   173	 *  - add FUSE_SETUPMAPPING and FUSE_REMOVEMAPPING
   174	 *  - add map_alignment to fuse_init_out, add FUSE_MAP_ALIGNMENT flag
   175	 *
   176	 *  7.32
   177	 *  - add flags to fuse_attr, add FUSE_ATTR_SUBMOUNT, add FUSE_SUBMOUNTS
   178	 *
   179	 *  7.33
   180	 *  - add FUSE_HANDLE_KILLPRIV_V2, FUSE_WRITE_KILL_SUIDGID, FATTR_KILL_SUIDGID
   181	 *  - add FUSE_OPEN_KILL_SUIDGID
   182	 *  - extend fuse_setxattr_in, add FUSE_SETXATTR_EXT
   183	 *  - add FUSE_SETXATTR_ACL_KILL_SGID
   184	 *
   185	 *  7.34
   186	 *  - add FUSE_SYNCFS
   187	 *
   188	 *  7.35
   189	 *  - add FOPEN_NOFLUSH
   190	 *
   191	 *  7.36
   192	 *  - extend fuse_init_in with reserved fields, add FUSE_INIT_EXT init flag
   193	 *  - add flags2 to fuse_init_in and fuse_init_out
   194	 *  - add FUSE_SECURITY_CTX init flag
   195	 *  - add security context to create, mkdir, symlink, and mknod requests
   196	 *  - add FUSE_HAS_INODE_DAX, FUSE_ATTR_DAX
   197	 *
   198	 *  7.37
   199	 *  - add FUSE_TMPFILE
   200	 *
   201	 *  7.38
   202	 *  - add FUSE_EXPIRE_ONLY flag to fuse_notify_inval_entry
   203	 *  - add FOPEN_PARALLEL_DIRECT_WRITES
   204	 *  - add total_extlen to fuse_in_header
   205	 *  - add FUSE_MAX_NR_SECCTX
   206	 *  - add extension header
   207	 *  - add FUSE_EXT_GROUPS
   208	 *  - add FUSE_CREATE_SUPP_GROUP
   209	 *  - add FUSE_HAS_EXPIRE_ONLY
   210	 *
   211	 *  7.39
   212	 *  - add FUSE_DIRECT_IO_ALLOW_MMAP
   213	 *  - add FUSE_STATX and related structures
   214	 */
   215	
   216	#ifndef _LINUX_FUSE_H
   217	#define _LINUX_FUSE_H
   218	
   219	#include <stdint.h>
   220	
   221	/*
   222	 * Version negotiation:
   223	 *
   224	 * Both the kernel and userspace send the version they support in the
   225	 * INIT request and reply respectively.
   226	 *
   227	 * If the major versions match then both shall use the smallest
   228	 * of the two minor versions for communication.
   229	 *
   230	 * If the kernel supports a larger major version, then userspace shall
   231	 * reply with the major version it supports, ignore the rest of the
   232	 * INIT message and expect a new INIT message from the kernel with a
   233	 * matching major version.
   234	 *
   235	 * If the library supports a larger major version, then it shall fall
   236	 * back to the major protocol version sent by the kernel for
   237	 * communication and reply with that major version (and an arbitrary
   238	 * supported minor version).
   239	 */
   240	
   241	/** Version number of this interface */
   242	#define FUSE_KERNEL_VERSION 7
   243	
   244	/** Minor version number of this interface */
   245	#define FUSE_KERNEL_MINOR_VERSION 39
   246	
   247	/** The node ID of the root inode */
   248	#define FUSE_ROOT_ID 1
   249	
   250	/* Make sure all structures are padded to 64bit boundary, so 32bit
   251	   userspace works under 64bit kernels */
   252	
   253	struct fuse_attr {
   254		uint64_t	ino;
   255		uint64_t	size;
   256		uint64_t	blocks;
   257		uint64_t	atime;
   258		uint64_t	mtime;
   259		uint64_t	ctime;
   260		uint32_t	atimensec;
   261		uint32_t	mtimensec;
   262		uint32_t	ctimensec;
   263		uint32_t	mode;
   264		uint32_t	nlink;
   265		uint32_t	uid;
   266		uint32_t	gid;
   267		uint32_t	rdev;
   268		uint32_t	blksize;
   269		uint32_t	flags;
   270	};
   271	
   272	/*
   273	 * The following structures are bit-for-bit compatible with the statx(2) ABI in
   274	 * Linux.
   275	 */
   276	struct fuse_sx_time {
   277		int64_t		tv_sec;
   278		uint32_t	tv_nsec;
   279		int32_t		__reserved;
   280	};
   281	
   282	struct fuse_statx {
   283		uint32_t	mask;
   284		uint32_t	blksize;
   285		uint64_t	attributes;
   286		uint32_t	nlink;
   287		uint32_t	uid;
   288		uint32_t	gid;
   289		uint16_t	mode;
   290		uint16_t	__spare0[1];
   291		uint64_t	ino;
   292		uint64_t	size;
   293		uint64_t	blocks;
   294		uint64_t	attributes_mask;
   295		struct fuse_sx_time	atime;
   296		struct fuse_sx_time	btime;
   297		struct fuse_sx_time	ctime;
   298		struct fuse_sx_time	mtime;
   299		uint32_t	rdev_major;
   300		uint32_t	rdev_minor;
   301		uint32_t	dev_major;
   302		uint32_t	dev_minor;
   303		uint64_t	__spare2[14];
   304	};
   305	
   306	struct fuse_kstatfs {
   307		uint64_t	blocks;
   308		uint64_t	bfree;
   309		uint64_t	bavail;
   310		uint64_t	files;
   311		uint64_t	ffree;
   312		uint32_t	bsize;
   313		uint32_t	namelen;
   314		uint32_t	frsize;
   315		uint32_t	padding;
   316		uint32_t	spare[6];
   317	};
   318	
   319	struct fuse_file_lock {
   320		uint64_t	start;
   321		uint64_t	end;
   322		uint32_t	type;
   323		uint32_t	pid; /* tgid */
   324	};
   325	
   326	/**
   327	 * Bitmasks for fuse_setattr_in.valid
   328	 */
   329	#define FATTR_MODE	(1 << 0)
   330	#define FATTR_UID	(1 << 1)
   331	#define FATTR_GID	(1 << 2)
   332	#define FATTR_SIZE	(1 << 3)
   333	#define FATTR_ATIME	(1 << 4)
   334	#define FATTR_MTIME	(1 << 5)
   335	#define FATTR_FH	(1 << 6)
   336	#define FATTR_ATIME_NOW	(1 << 7)
   337	#define FATTR_MTIME_NOW	(1 << 8)
   338	#define FATTR_LOCKOWNER	(1 << 9)
   339	#define FATTR_CTIME	(1 << 10)
   340	#define FATTR_KILL_SUIDGID	(1 << 11)
   341	
   342	/**
   343	 * Flags returned by the OPEN request
   344	 *
   345	 * FOPEN_DIRECT_IO: bypass page cache for this open file
   346	 * FOPEN_KEEP_CACHE: don't invalidate the data cache on open
   347	 * FOPEN_NONSEEKABLE: the file is not seekable
   348	 * FOPEN_CACHE_DIR: allow caching this directory
   349	 * FOPEN_STREAM: the file is stream-like (no file position at all)
   350	 * FOPEN_NOFLUSH: don't flush data cache on close (unless FUSE_WRITEBACK_CACHE)
   351	 * FOPEN_PARALLEL_DIRECT_WRITES: Allow concurrent direct writes on the same inode
   352	 */
   353	#define FOPEN_DIRECT_IO		(1 << 0)
   354	#define FOPEN_KEEP_CACHE	(1 << 1)
   355	#define FOPEN_NONSEEKABLE	(1 << 2)
   356	#define FOPEN_CACHE_DIR		(1 << 3)
   357	#define FOPEN_STREAM		(1 << 4)
   358	#define FOPEN_NOFLUSH		(1 << 5)
   359	#define FOPEN_PARALLEL_DIRECT_WRITES	(1 << 6)
   360	
   361	/**
   362	 * INIT request/reply flags
   363	 *
   364	 * FUSE_ASYNC_READ: asynchronous read requests
   365	 * FUSE_POSIX_LOCKS: remote locking for POSIX file locks
   366	 * FUSE_FILE_OPS: kernel sends file handle for fstat, etc... (not yet supported)
   367	 * FUSE_ATOMIC_O_TRUNC: handles the O_TRUNC open flag in the filesystem
   368	 * FUSE_EXPORT_SUPPORT: filesystem handles lookups of "." and ".."
   369	 * FUSE_BIG_WRITES: filesystem can handle write size larger than 4kB
   370	 * FUSE_DONT_MASK: don't apply umask to file mode on create operations
   371	 * FUSE_SPLICE_WRITE: kernel supports splice write on the device
   372	 * FUSE_SPLICE_MOVE: kernel supports splice move on the device
   373	 * FUSE_SPLICE_READ: kernel supports splice read on the device
   374	 * FUSE_FLOCK_LOCKS: remote locking for BSD style file locks
   375	 * FUSE_HAS_IOCTL_DIR: kernel supports ioctl on directories
   376	 * FUSE_AUTO_INVAL_DATA: automatically invalidate cached pages
   377	 * FUSE_DO_READDIRPLUS: do READDIRPLUS (READDIR+LOOKUP in one)
   378	 * FUSE_READDIRPLUS_AUTO: adaptive readdirplus
   379	 * FUSE_ASYNC_DIO: asynchronous direct I/O submission
   380	 * FUSE_WRITEBACK_CACHE: use writeback cache for buffered writes
   381	 * FUSE_NO_OPEN_SUPPORT: kernel supports zero-message opens
   382	 * FUSE_PARALLEL_DIROPS: allow parallel lookups and readdir
   383	 * FUSE_HANDLE_KILLPRIV: fs handles killing suid/sgid/cap on write/chown/trunc
   384	 * FUSE_POSIX_ACL: filesystem supports posix acls
   385	 * FUSE_ABORT_ERROR: reading the device after abort returns ECONNABORTED
   386	 * FUSE_MAX_PAGES: init_out.max_pages contains the max number of req pages
   387	 * FUSE_CACHE_SYMLINKS: cache READLINK responses
   388	 * FUSE_NO_OPENDIR_SUPPORT: kernel supports zero-message opendir
   389	 * FUSE_EXPLICIT_INVAL_DATA: only invalidate cached pages on explicit request
   390	 * FUSE_MAP_ALIGNMENT: init_out.map_alignment contains log2(byte alignment) for
   391	 *		       foffset and moffset fields in struct
   392	 *		       fuse_setupmapping_out and fuse_removemapping_one.
   393	 * FUSE_SUBMOUNTS: kernel supports auto-mounting directory submounts
   394	 * FUSE_HANDLE_KILLPRIV_V2: fs kills suid/sgid/cap on write/chown/trunc.
   395	 *			Upon write/truncate suid/sgid is only killed if caller
   396	 *			does not have CAP_FSETID. Additionally upon
   397	 *			write/truncate sgid is killed only if file has group
   398	 *			execute permission. (Same as Linux VFS behavior).
   399	 * FUSE_SETXATTR_EXT:	Server supports extended struct fuse_setxattr_in
   400	 * FUSE_INIT_EXT: extended fuse_init_in request
   401	 * FUSE_INIT_RESERVED: reserved, do not use
   402	 * FUSE_SECURITY_CTX:	add security context to create, mkdir, symlink, and
   403	 *			mknod
   404	 * FUSE_HAS_INODE_DAX:  use per inode DAX
   405	 * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir,
   406	 *			symlink and mknod (single group that matches parent)
   407	 * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation
   408	 * FUSE_DIRECT_IO_ALLOW_MMAP: allow shared mmap in FOPEN_DIRECT_IO mode.
   409	 */
   410	#define FUSE_ASYNC_READ		(1 << 0)
   411	#define FUSE_POSIX_LOCKS	(1 << 1)
   412	#define FUSE_FILE_OPS		(1 << 2)
   413	#define FUSE_ATOMIC_O_TRUNC	(1 << 3)
   414	#define FUSE_EXPORT_SUPPORT	(1 << 4)
   415	#define FUSE_BIG_WRITES		(1 << 5)
   416	#define FUSE_DONT_MASK		(1 << 6)
   417	#define FUSE_SPLICE_WRITE	(1 << 7)
   418	#define FUSE_SPLICE_MOVE	(1 << 8)
   419	#define FUSE_SPLICE_READ	(1 << 9)
   420	#define FUSE_FLOCK_LOCKS	(1 << 10)
   421	#define FUSE_HAS_IOCTL_DIR	(1 << 11)
   422	#define FUSE_AUTO_INVAL_DATA	(1 << 12)
   423	#define FUSE_DO_READDIRPLUS	(1 << 13)
   424	#define FUSE_READDIRPLUS_AUTO	(1 << 14)
   425	#define FUSE_ASYNC_DIO		(1 << 15)
   426	#define FUSE_WRITEBACK_CACHE	(1 << 16)
   427	#define FUSE_NO_OPEN_SUPPORT	(1 << 17)
   428	#define FUSE_PARALLEL_DIROPS    (1 << 18)
   429	#define FUSE_HANDLE_KILLPRIV	(1 << 19)
   430	#define FUSE_POSIX_ACL		(1 << 20)
   431	#define FUSE_ABORT_ERROR	(1 << 21)
   432	#define FUSE_MAX_PAGES		(1 << 22)
   433	#define FUSE_CACHE_SYMLINKS	(1 << 23)
   434	#define FUSE_NO_OPENDIR_SUPPORT (1 << 24)
   435	#define FUSE_EXPLICIT_INVAL_DATA (1 << 25)
   436	#define FUSE_MAP_ALIGNMENT	(1 << 26)
   437	#define FUSE_SUBMOUNTS		(1 << 27)
   438	#define FUSE_HANDLE_KILLPRIV_V2	(1 << 28)
   439	#define FUSE_SETXATTR_EXT	(1 << 29)
   440	#define FUSE_INIT_EXT		(1 << 30)
   441	#define FUSE_INIT_RESERVED	(1 << 31)
   442	/* bits 32..63 get shifted down 32 bits into the flags2 field */
   443	#define FUSE_SECURITY_CTX	(1ULL << 32)
   444	#define FUSE_HAS_INODE_DAX	(1ULL << 33)
   445	#define FUSE_CREATE_SUPP_GROUP	(1ULL << 34)
   446	#define FUSE_HAS_EXPIRE_ONLY	(1ULL << 35)
   447	#define FUSE_DIRECT_IO_ALLOW_MMAP (1ULL << 36)
   448	
   449	/* Obsolete alias for FUSE_DIRECT_IO_ALLOW_MMAP */
   450	#define FUSE_DIRECT_IO_RELAX	FUSE_DIRECT_IO_ALLOW_MMAP
   451	
   452	/**
   453	 * CUSE INIT request/reply flags
   454	 *
   455	 * CUSE_UNRESTRICTED_IOCTL:  use unrestricted ioctl
   456	 */
   457	#define CUSE_UNRESTRICTED_IOCTL	(1 << 0)
   458	
   459	/**
   460	 * Release flags
   461	 */
   462	#define FUSE_RELEASE_FLUSH	(1 << 0)
   463	#define FUSE_RELEASE_FLOCK_UNLOCK	(1 << 1)
   464	
   465	/**
   466	 * Getattr flags
   467	 */
   468	#define FUSE_GETATTR_FH		(1 << 0)
   469	
   470	/**
   471	 * Lock flags
   472	 */
   473	#define FUSE_LK_FLOCK		(1 << 0)
   474	
   475	/**
   476	 * WRITE flags
   477	 *
   478	 * FUSE_WRITE_CACHE: delayed write from page cache, file handle is guessed
   479	 * FUSE_WRITE_LOCKOWNER: lock_owner field is valid
   480	 * FUSE_WRITE_KILL_SUIDGID: kill suid and sgid bits
   481	 */
   482	#define FUSE_WRITE_CACHE	(1 << 0)
   483	#define FUSE_WRITE_LOCKOWNER	(1 << 1)
   484	#define FUSE_WRITE_KILL_SUIDGID (1 << 2)
   485	
   486	/* Obsolete alias; this flag implies killing suid/sgid only. */
   487	#define FUSE_WRITE_KILL_PRIV	FUSE_WRITE_KILL_SUIDGID
   488	
   489	/**
   490	 * Read flags
   491	 */
   492	#define FUSE_READ_LOCKOWNER	(1 << 1)
   493	
   494	/**
   495	 * Ioctl flags
   496	 *
   497	 * FUSE_IOCTL_COMPAT: 32bit compat ioctl on 64bit machine
   498	 * FUSE_IOCTL_UNRESTRICTED: not restricted to well-formed ioctls, retry allowed
   499	 * FUSE_IOCTL_RETRY: retry with new iovecs
   500	 * FUSE_IOCTL_32BIT: 32bit ioctl
   501	 * FUSE_IOCTL_DIR: is a directory
   502	 * FUSE_IOCTL_COMPAT_X32: x32 compat ioctl on 64bit machine (64bit time_t)
   503	 *
   504	 * FUSE_IOCTL_MAX_IOV: maximum of in_iovecs + out_iovecs
   505	 */
   506	#define FUSE_IOCTL_COMPAT	(1 << 0)
   507	#define FUSE_IOCTL_UNRESTRICTED	(1 << 1)
   508	#define FUSE_IOCTL_RETRY	(1 << 2)
   509	#define FUSE_IOCTL_32BIT	(1 << 3)
   510	#define FUSE_IOCTL_DIR		(1 << 4)
   511	#define FUSE_IOCTL_COMPAT_X32	(1 << 5)
   512	
   513	#define FUSE_IOCTL_MAX_IOV	256
   514	
   515	/**
   516	 * Poll flags
   517	 *
   518	 * FUSE_POLL_SCHEDULE_NOTIFY: request poll notify
   519	 */
   520	#define FUSE_POLL_SCHEDULE_NOTIFY (1 << 0)
   521	
   522	/**
   523	 * Fsync flags
   524	 *
   525	 * FUSE_FSYNC_FDATASYNC: Sync data only, not metadata
   526	 */
   527	#define FUSE_FSYNC_FDATASYNC	(1 << 0)
   528	
   529	/**
   530	 * fuse_attr flags
   531	 *
   532	 * FUSE_ATTR_SUBMOUNT: Object is a submount root
   533	 * FUSE_ATTR_DAX: Enable DAX for this file in per inode DAX mode
   534	 */
   535	#define FUSE_ATTR_SUBMOUNT      (1 << 0)
   536	#define FUSE_ATTR_DAX		(1 << 1)
   537	
   538	/**
   539	 * Open flags
   540	 * FUSE_OPEN_KILL_SUIDGID: Kill suid and sgid if executable
   541	 */
   542	#define FUSE_OPEN_KILL_SUIDGID	(1 << 0)
   543	
   544	/**
   545	 * setxattr flags
   546	 * FUSE_SETXATTR_ACL_KILL_SGID: Clear SGID when system.posix_acl_access is set
   547	 */
   548	#define FUSE_SETXATTR_ACL_KILL_SGID	(1 << 0)
   549	
   550	/**
   551	 * notify_inval_entry flags
   552	 * FUSE_EXPIRE_ONLY
   553	 */
   554	#define FUSE_EXPIRE_ONLY		(1 << 0)
   555	
   556	/**
   557	 * extension type
   558	 * FUSE_MAX_NR_SECCTX: maximum value of &fuse_secctx_header.nr_secctx
   559	 * FUSE_EXT_GROUPS: &fuse_supp_groups extension
   560	 */
   561	enum fuse_ext_type {
   562		/* Types 0..31 are reserved for fuse_secctx_header */
   563		FUSE_MAX_NR_SECCTX	= 31,
   564		FUSE_EXT_GROUPS		= 32,
   565	};
   566	
   567	enum fuse_opcode {
   568		FUSE_LOOKUP		= 1,
   569		FUSE_FORGET		= 2,  /* no reply */
   570		FUSE_GETATTR		= 3,
   571		FUSE_SETATTR		= 4,
   572		FUSE_READLINK		= 5,
   573		FUSE_SYMLINK		= 6,
   574		FUSE_MKNOD		= 8,
   575		FUSE_MKDIR		= 9,
   576		FUSE_UNLINK		= 10,
   577		FUSE_RMDIR		= 11,
   578		FUSE_RENAME		= 12,
   579		FUSE_LINK		= 13,
   580		FUSE_OPEN		= 14,
   581		FUSE_READ		= 15,
   582		FUSE_WRITE		= 16,
   583		FUSE_STATFS		= 17,
   584		FUSE_RELEASE		= 18,
   585		FUSE_FSYNC		= 20,
   586		FUSE_SETXATTR		= 21,
   587		FUSE_GETXATTR		= 22,
   588		FUSE_LISTXATTR		= 23,
   589		FUSE_REMOVEXATTR	= 24,
   590		FUSE_FLUSH		= 25,
   591		FUSE_INIT		= 26,
   592		FUSE_OPENDIR		= 27,
   593		FUSE_READDIR		= 28,
   594		FUSE_RELEASEDIR		= 29,
   595		FUSE_FSYNCDIR		= 30,
   596		FUSE_GETLK		= 31,
   597		FUSE_SETLK		= 32,
   598		FUSE_SETLKW		= 33,
   599		FUSE_ACCESS		= 34,
   600		FUSE_CREATE		= 35,
   601		FUSE_INTERRUPT		= 36,
   602		FUSE_BMAP		= 37,
   603		FUSE_DESTROY		= 38,
   604		FUSE_IOCTL		= 39,
   605		FUSE_POLL		= 40,
   606		FUSE_NOTIFY_REPLY	= 41,
   607		FUSE_BATCH_FORGET	= 42,
   608		FUSE_FALLOCATE		= 43,
   609		FUSE_READDIRPLUS	= 44,
   610		FUSE_RENAME2		= 45,
   611		FUSE_LSEEK		= 46,
   612		FUSE_COPY_FILE_RANGE	= 47,
   613		FUSE_SETUPMAPPING	= 48,
   614		FUSE_REMOVEMAPPING	= 49,
   615		FUSE_SYNCFS		= 50,
   616		FUSE_TMPFILE		= 51,
   617		FUSE_STATX		= 52,
   618	
   619		/* CUSE specific operations */
   620		CUSE_INIT		= 4096,
   621	
   622		/* Reserved opcodes: helpful to detect structure endian-ness */
   623		CUSE_INIT_BSWAP_RESERVED	= 1048576,	/* CUSE_INIT << 8 */
   624		FUSE_INIT_BSWAP_RESERVED	= 436207616,	/* FUSE_INIT << 24 */
   625	};
   626	
   627	enum fuse_notify_code {
   628		FUSE_NOTIFY_POLL   = 1,
   629		FUSE_NOTIFY_INVAL_INODE = 2,
   630		FUSE_NOTIFY_INVAL_ENTRY = 3,
   631		FUSE_NOTIFY_STORE = 4,
   632		FUSE_NOTIFY_RETRIEVE = 5,
   633		FUSE_NOTIFY_DELETE = 6,
   634		FUSE_NOTIFY_CODE_MAX,
   635	};
   636	
   637	/* The read buffer is required to be at least 8k, but may be much larger */
   638	#define FUSE_MIN_READ_BUFFER 8192
   639	
   640	#define FUSE_COMPAT_ENTRY_OUT_SIZE 120
   641	
   642	struct fuse_entry_out {
   643		uint64_t	nodeid;		/* Inode ID */
   644		uint64_t	generation;	/* Inode generation: nodeid:gen must
   645						   be unique for the fs's lifetime */
   646		uint64_t	entry_valid;	/* Cache timeout for the name */
   647		uint64_t	attr_valid;	/* Cache timeout for the attributes */
   648		uint32_t	entry_valid_nsec;
   649		uint32_t	attr_valid_nsec;
   650		struct fuse_attr attr;
   651	};
   652	
   653	struct fuse_forget_in {
   654		uint64_t	nlookup;
   655	};
   656	
   657	struct fuse_forget_one {
   658		uint64_t	nodeid;
   659		uint64_t	nlookup;
   660	};
   661	
   662	struct fuse_batch_forget_in {
   663		uint32_t	count;
   664		uint32_t	dummy;
   665	};
   666	
   667	struct fuse_getattr_in {
   668		uint32_t	getattr_flags;
   669		uint32_t	dummy;
   670		uint64_t	fh;
   671	};
   672	
   673	#define FUSE_COMPAT_ATTR_OUT_SIZE 96
   674	
   675	struct fuse_attr_out {
   676		uint64_t	attr_valid;	/* Cache timeout for the attributes */
   677		uint32_t	attr_valid_nsec;
   678		uint32_t	dummy;
   679		struct fuse_attr attr;
   680	};
   681	
   682	struct fuse_statx_in {
   683		uint32_t	getattr_flags;
   684		uint32_t	reserved;
   685		uint64_t	fh;
   686		uint32_t	sx_flags;
   687		uint32_t	sx_mask;
   688	};
   689	
   690	struct fuse_statx_out {
   691		uint64_t	attr_valid;	/* Cache timeout for the attributes */
   692		uint32_t	attr_valid_nsec;
   693		uint32_t	flags;
   694		uint64_t	spare[2];
   695		struct fuse_statx stat;
   696	};
   697	
   698	#define FUSE_COMPAT_MKNOD_IN_SIZE 8
   699	
   700	struct fuse_mknod_in {
   701		uint32_t	mode;
   702		uint32_t	rdev;
   703		uint32_t	umask;
   704		uint32_t	padding;
   705	};
   706	
   707	struct fuse_mkdir_in {
   708		uint32_t	mode;
   709		uint32_t	umask;
   710	};
   711	
   712	struct fuse_rename_in {
   713		uint64_t	newdir;
   714	};
   715	
   716	struct fuse_rename2_in {
   717		uint64_t	newdir;
   718		uint32_t	flags;
   719		uint32_t	padding;
   720	};
   721	
   722	struct fuse_link_in {
   723		uint64_t	oldnodeid;
   724	};
   725	
   726	struct fuse_setattr_in {
   727		uint32_t	valid;
   728		uint32_t	padding;
   729		uint64_t	fh;
   730		uint64_t	size;
   731		uint64_t	lock_owner;
   732		uint64_t	atime;
   733		uint64_t	mtime;
   734		uint64_t	ctime;
   735		uint32_t	atimensec;
   736		uint32_t	mtimensec;
   737		uint32_t	ctimensec;
   738		uint32_t	mode;
   739		uint32_t	unused4;
   740		uint32_t	uid;
   741		uint32_t	gid;
   742		uint32_t	unused5;
   743	};
   744	
   745	struct fuse_open_in {
   746		uint32_t	flags;
   747		uint32_t	open_flags;	/* FUSE_OPEN_... */
   748	};
   749	
   750	struct fuse_create_in {
   751		uint32_t	flags;
   752		uint32_t	mode;
   753		uint32_t	umask;
   754		uint32_t	open_flags;	/* FUSE_OPEN_... */
   755	};
   756	
   757	struct fuse_open_out {
   758		uint64_t	fh;
   759		uint32_t	open_flags;
   760		uint32_t	padding;
   761	};
   762	
   763	struct fuse_release_in {
   764		uint64_t	fh;
   765		uint32_t	flags;
   766		uint32_t	release_flags;
   767		uint64_t	lock_owner;
   768	};
   769	
   770	struct fuse_flush_in {
   771		uint64_t	fh;
   772		uint32_t	unused;
   773		uint32_t	padding;
   774		uint64_t	lock_owner;
   775	};
   776	
   777	struct fuse_read_in {
   778		uint64_t	fh;
   779		uint64_t	offset;
   780		uint32_t	size;
   781		uint32_t	read_flags;
   782		uint64_t	lock_owner;
   783		uint32_t	flags;
   784		uint32_t	padding;
   785	};
   786	
   787	#define FUSE_COMPAT_WRITE_IN_SIZE 24
   788	
   789	struct fuse_write_in {
   790		uint64_t	fh;
   791		uint64_t	offset;
   792		uint32_t	size;
   793		uint32_t	write_flags;
   794		uint64_t	lock_owner;
   795		uint32_t	flags;
   796		uint32_t	padding;
   797	};
   798	
   799	struct fuse_write_out {
   800		uint32_t	size;
   801		uint32_t	padding;
   802	};
   803	
   804	#define FUSE_COMPAT_STATFS_SIZE 48
   805	
   806	struct fuse_statfs_out {
   807		struct fuse_kstatfs st;
   808	};
   809	
   810	struct fuse_fsync_in {
   811		uint64_t	fh;
   812		uint32_t	fsync_flags;
   813		uint32_t	padding;
   814	};
   815	
   816	#define FUSE_COMPAT_SETXATTR_IN_SIZE 8
   817	
   818	struct fuse_setxattr_in {
   819		uint32_t	size;
   820		uint32_t	flags;
   821		uint32_t	setxattr_flags;
   822		uint32_t	padding;
   823	};
   824	
   825	struct fuse_getxattr_in {
   826		uint32_t	size;
   827		uint32_t	padding;
   828	};
   829	
   830	struct fuse_getxattr_out {
   831		uint32_t	size;
   832		uint32_t	padding;
   833	};
   834	
   835	struct fuse_lk_in {
   836		uint64_t	fh;
   837		uint64_t	owner;
   838		struct fuse_file_lock lk;
   839		uint32_t	lk_flags;
   840		uint32_t	padding;
   841	};
   842	
   843	struct fuse_lk_out {
   844		struct fuse_file_lock lk;
   845	};
   846	
   847	struct fuse_access_in {
   848		uint32_t	mask;
   849		uint32_t	padding;
   850	};
   851	
   852	struct fuse_init_in {
   853		uint32_t	major;
   854		uint32_t	minor;
   855		uint32_t	max_readahead;
   856		uint32_t	flags;
   857		uint32_t	flags2;
   858		uint32_t	unused[11];
   859	};
   860	
   861	#define FUSE_COMPAT_INIT_OUT_SIZE 8
   862	#define FUSE_COMPAT_22_INIT_OUT_SIZE 24
   863	
   864	struct fuse_init_out {
   865		uint32_t	major;
   866		uint32_t	minor;
   867		uint32_t	max_readahead;
   868		uint32_t	flags;
   869		uint16_t	max_background;
   870		uint16_t	congestion_threshold;
   871		uint32_t	max_write;
   872		uint32_t	time_gran;
   873		uint16_t	max_pages;
   874		uint16_t	map_alignment;
   875		uint32_t	flags2;
   876		uint32_t	unused[7];
   877	};
   878	
   879	#define CUSE_INIT_INFO_MAX 4096
   880	
   881	struct cuse_init_in {
   882		uint32_t	major;
   883		uint32_t	minor;
   884		uint32_t	unused;
   885		uint32_t	flags;
   886	};
   887	
   888	struct cuse_init_out {
   889		uint32_t	major;
   890		uint32_t	minor;
   891		uint32_t	unused;
   892		uint32_t	flags;
   893		uint32_t	max_read;
   894		uint32_t	max_write;
   895		uint32_t	dev_major;		/* chardev major */
   896		uint32_t	dev_minor;		/* chardev minor */
   897		uint32_t	spare[10];
   898	};
   899	
   900	struct fuse_interrupt_in {
   901		uint64_t	unique;
   902	};
   903	
   904	struct fuse_bmap_in {
   905		uint64_t	block;
   906		uint32_t	blocksize;
   907		uint32_t	padding;
   908	};
   909	
   910	struct fuse_bmap_out {
   911		uint64_t	block;
   912	};
   913	
   914	struct fuse_ioctl_in {
   915		uint64_t	fh;
   916		uint32_t	flags;
   917		uint32_t	cmd;
   918		uint64_t	arg;
   919		uint32_t	in_size;
   920		uint32_t	out_size;
   921	};
   922	
   923	struct fuse_ioctl_iovec {
   924		uint64_t	base;
   925		uint64_t	len;
   926	};
   927	
   928	struct fuse_ioctl_out {
   929		int32_t		result;
   930		uint32_t	flags;
   931		uint32_t	in_iovs;
   932		uint32_t	out_iovs;
   933	};
   934	
   935	struct fuse_poll_in {
   936		uint64_t	fh;
   937		uint64_t	kh;
   938		uint32_t	flags;
   939		uint32_t	events;
   940	};
   941	
   942	struct fuse_poll_out {
   943		uint32_t	revents;
   944		uint32_t	padding;
   945	};
   946	
   947	struct fuse_notify_poll_wakeup_out {
   948		uint64_t	kh;
   949	};
   950	
   951	struct fuse_fallocate_in {
   952		uint64_t	fh;
   953		uint64_t	offset;
   954		uint64_t	length;
   955		uint32_t	mode;
   956		uint32_t	padding;
   957	};
   958	
   959	struct fuse_in_header {
   960		uint32_t	len;
   961		uint32_t	opcode;
   962		uint64_t	unique;
   963		uint64_t	nodeid;
   964		uint32_t	uid;
   965		uint32_t	gid;
   966		uint32_t	pid;
   967		uint16_t	total_extlen; /* length of extensions in 8byte units */
   968		uint16_t	padding;
   969	};
   970	
   971	struct fuse_out_header {
   972		uint32_t	len;
   973		int32_t		error;
   974		uint64_t	unique;
   975	};
   976	
   977	struct fuse_dirent {
   978		uint64_t	ino;
   979		uint64_t	off;
   980		uint32_t	namelen;
   981		uint32_t	type;
   982		char name[];
   983	};
   984	
   985	/* Align variable length records to 64bit boundary */
   986	#define FUSE_REC_ALIGN(x) \
   987		(((x) + sizeof(uint64_t) - 1) & ~(sizeof(uint64_t) - 1))
   988	
   989	#define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)
   990	#define FUSE_DIRENT_ALIGN(x) FUSE_REC_ALIGN(x)
   991	#define FUSE_DIRENT_SIZE(d) \
   992		FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)
   993	
   994	struct fuse_direntplus {
   995		struct fuse_entry_out entry_out;
   996		struct fuse_dirent dirent;
   997	};
   998	
   999	#define FUSE_NAME_OFFSET_DIRENTPLUS \
  1000		offsetof(struct fuse_direntplus, dirent.name)
  1001	#define FUSE_DIRENTPLUS_SIZE(d) \
  1002		FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET_DIRENTPLUS + (d)->dirent.namelen)
  1003	
  1004	struct fuse_notify_inval_inode_out {
  1005		uint64_t	ino;
  1006		int64_t		off;
  1007		int64_t		len;
  1008	};
  1009	
  1010	struct fuse_notify_inval_entry_out {
  1011		uint64_t	parent;
  1012		uint32_t	namelen;
  1013		uint32_t	flags;
  1014	};
  1015	
  1016	struct fuse_notify_delete_out {
  1017		uint64_t	parent;
  1018		uint64_t	child;
  1019		uint32_t	namelen;
  1020		uint32_t	padding;
  1021	};
  1022	
  1023	struct fuse_notify_store_out {
  1024		uint64_t	nodeid;
  1025		uint64_t	offset;
  1026		uint32_t	size;
  1027		uint32_t	padding;
  1028	};
  1029	
  1030	struct fuse_notify_retrieve_out {
  1031		uint64_t	notify_unique;
  1032		uint64_t	nodeid;
  1033		uint64_t	offset;
  1034		uint32_t	size;
  1035		uint32_t	padding;
  1036	};
  1037	
  1038	/* Matches the size of fuse_write_in */
  1039	struct fuse_notify_retrieve_in {
  1040		uint64_t	dummy1;
  1041		uint64_t	offset;
  1042		uint32_t	size;
  1043		uint32_t	dummy2;
  1044		uint64_t	dummy3;
  1045		uint64_t	dummy4;
  1046	};
  1047	
  1048	/* Device ioctls: */
  1049	#define FUSE_DEV_IOC_MAGIC		229
  1050	#define FUSE_DEV_IOC_CLONE		_IOR(FUSE_DEV_IOC_MAGIC, 0, uint32_t)
  1051	
  1052	struct fuse_lseek_in {
  1053		uint64_t	fh;
  1054		uint64_t	offset;
  1055		uint32_t	whence;
  1056		uint32_t	padding;
  1057	};
  1058	
  1059	struct fuse_lseek_out {
  1060		uint64_t	offset;
  1061	};
  1062	
  1063	struct fuse_copy_file_range_in {
  1064		uint64_t	fh_in;
  1065		uint64_t	off_in;
  1066		uint64_t	nodeid_out;
  1067		uint64_t	fh_out;
  1068		uint64_t	off_out;
  1069		uint64_t	len;
  1070		uint64_t	flags;
  1071	};
  1072	
  1073	#define FUSE_SETUPMAPPING_FLAG_WRITE (1ull << 0)
  1074	#define FUSE_SETUPMAPPING_FLAG_READ (1ull << 1)
  1075	struct fuse_setupmapping_in {
  1076		/* An already open handle */
  1077		uint64_t	fh;
  1078		/* Offset into the file to start the mapping */
  1079		uint64_t	foffset;
  1080		/* Length of mapping required */
  1081		uint64_t	len;
  1082		/* Flags, FUSE_SETUPMAPPING_FLAG_* */
  1083		uint64_t	flags;
  1084		/* Offset in Memory Window */
  1085		uint64_t	moffset;
  1086	};
  1087	
  1088	struct fuse_removemapping_in {
  1089		/* number of fuse_removemapping_one follows */
  1090		uint32_t        count;
  1091	};
  1092	
  1093	struct fuse_removemapping_one {
  1094		/* Offset into the dax window start the unmapping */
  1095		uint64_t        moffset;
  1096		/* Length of mapping required */
  1097		uint64_t	len;
  1098	};
  1099	
  1100	#define FUSE_REMOVEMAPPING_MAX_ENTRY   \
  1101			(PAGE_SIZE / sizeof(struct fuse_removemapping_one))
  1102	
  1103	struct fuse_syncfs_in {
  1104		uint64_t	padding;
  1105	};
  1106	
  1107	/*
  1108	 * For each security context, send fuse_secctx with size of security context
  1109	 * fuse_secctx will be followed by security context name and this in turn
  1110	 * will be followed by actual context label.
  1111	 * fuse_secctx, name, context
  1112	 */
  1113	struct fuse_secctx {
  1114		uint32_t	size;
  1115		uint32_t	padding;
  1116	};
  1117	
  1118	/*
  1119	 * Contains the information about how many fuse_secctx structures are being
  1120	 * sent and what's the total size of all security contexts (including
  1121	 * size of fuse_secctx_header).
  1122	 *
  1123	 */
  1124	struct fuse_secctx_header {
  1125		uint32_t	size;
  1126		uint32_t	nr_secctx;
  1127	};
  1128	
  1129	/**
  1130	 * struct fuse_ext_header - extension header
  1131	 * @size: total size of this extension including this header
  1132	 * @type: type of extension
  1133	 *
  1134	 * This is made compatible with fuse_secctx_header by using type values >
  1135	 * FUSE_MAX_NR_SECCTX
  1136	 */
  1137	struct fuse_ext_header {
  1138		uint32_t	size;
  1139		uint32_t	type;
  1140	};
  1141	
  1142	/**
  1143	 * struct fuse_supp_groups - Supplementary group extension
  1144	 * @nr_groups: number of supplementary groups
  1145	 * @groups: flexible array of group IDs
  1146	 */
  1147	struct fuse_supp_groups {
  1148		uint32_t	nr_groups;
  1149		uint32_t	groups[];
  1150	};
  1151	
  1152	#endif /* _LINUX_FUSE_H */