1/*-
2 * Copyright (c) 2010-2012 Semihalf
3 * Copyright (c) 2008, 2009 Reinoud Zandijk
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 *
26 * Original definitions written by Koji Sato <koji@osrg.net>
27 *                    and Ryusuke Konishi <ryusuke@osrg.net>
28 * From: NetBSD: nandfs_fs.h,v 1.1 2009/07/18 16:31:42 reinoud
29 *
30 * $FreeBSD$
31 */
32
33#ifndef _NANDFS_FS_H
34#define _NANDFS_FS_H
35
36#include <sys/uuid.h>
37
38#define	MNINDIR(fsdev)	((fsdev)->nd_blocksize / sizeof(nandfs_daddr_t))
39
40/*
41 * Inode structure. There are a few dedicated inode numbers that are
42 * defined here first.
43 */
44#define	NANDFS_WHT_INO		1	/* Whiteout ino			*/
45#define	NANDFS_ROOT_INO		2	/* Root file inode		*/
46#define	NANDFS_DAT_INO		3	/* DAT file			*/
47#define	NANDFS_CPFILE_INO	4	/* checkpoint file		*/
48#define	NANDFS_SUFILE_INO	5	/* segment usage file		*/
49#define	NANDFS_IFILE_INO	6	/* ifile			*/
50#define	NANDFS_GC_INO		7	/* Cleanerd node		*/
51#define	NANDFS_ATIME_INO	8	/* Atime file (reserved)	*/
52#define	NANDFS_XATTR_INO	9	/* Xattribute file (reserved)	*/
53#define	NANDFS_SKETCH_INO	10	/* Sketch file (obsolete)	*/
54#define	NANDFS_USER_INO		11	/* First user's file inode number */
55
56#define	NANDFS_SYS_NODE(ino) \
57	(((ino) >= NANDFS_DAT_INO) && ((ino) <= NANDFS_GC_INO))
58
59#define	NDADDR		12		/* Direct addresses in inode. */
60#define	NIADDR		3		/* Indirect addresses in inode. */
61
62typedef	int64_t		nandfs_daddr_t;
63typedef	int64_t		nandfs_lbn_t;
64
65struct nandfs_inode {
66	uint64_t	i_blocks;	/* 0: size in device blocks		*/
67	uint64_t	i_size;		/* 8: size in bytes			*/
68	uint64_t	i_ctime;	/* 16: creation time in seconds		*/
69	uint64_t	i_mtime;	/* 24: modification time in seconds part*/
70	uint32_t	i_ctime_nsec;	/* 32: creation time nanoseconds part	*/
71	uint32_t	i_mtime_nsec;	/* 36: modification time in nanoseconds	*/
72	uint32_t	i_uid;		/* 40: user id				*/
73	uint32_t	i_gid;		/* 44: group id				*/
74	uint16_t	i_mode;		/* 48: file mode			*/
75	uint16_t	i_links_count;	/* 50: number of references to the inode*/
76	uint32_t	i_flags;	/* 52: NANDFS_*_FL flags		*/
77	nandfs_daddr_t	i_special;	/* 56: special				*/
78	nandfs_daddr_t	i_db[NDADDR];	/* 64: Direct disk blocks.		*/
79	nandfs_daddr_t	i_ib[NIADDR];	/* 160: Indirect disk blocks.		*/
80	uint64_t	i_xattr;	/* 184: reserved for extended attributes*/
81	uint32_t	i_generation;	/* 192: file generation for NFS		*/
82	uint32_t	i_pad[15];	/* 196: make it 64 bits aligned		*/
83};
84
85#ifdef _KERNEL
86CTASSERT(sizeof(struct nandfs_inode) == 256);
87#endif
88
89/*
90 * Each checkpoint/snapshot has a super root.
91 *
92 * The super root holds the inodes of the three system files: `dat', `cp' and
93 * 'su' files. All other FS state is defined by those.
94 *
95 * It is CRC checksum'ed and time stamped.
96 */
97
98struct nandfs_super_root {
99	uint32_t	sr_sum;		/* check-sum				*/
100	uint16_t	sr_bytes;	/* byte count of this structure		*/
101	uint16_t	sr_flags;	/* reserved for flags			*/
102	uint64_t	sr_nongc_ctime;	/* timestamp, not for cleaner(?)	*/
103	struct nandfs_inode sr_dat;	/* DAT, virt->phys translation inode	*/
104	struct nandfs_inode sr_cpfile;	/* CP, checkpoints inode		*/
105	struct nandfs_inode sr_sufile;	/* SU, segment usage inode		*/
106};
107
108#define	NANDFS_SR_MDT_OFFSET(inode_size, i)			\
109	((uint32_t)&((struct nandfs_super_root *)0)->sr_dat +	\
110	(inode_size) * (i))
111
112#define	NANDFS_SR_DAT_OFFSET(inode_size)	NANDFS_SR_MDT_OFFSET(inode_size, 0)
113#define	NANDFS_SR_CPFILE_OFFSET(inode_size)	NANDFS_SR_MDT_OFFSET(inode_size, 1)
114#define	NANDFS_SR_SUFILE_OFFSET(inode_size)	NANDFS_SR_MDT_OFFSET(inode_size, 2)
115#define	NANDFS_SR_BYTES			(sizeof(struct nandfs_super_root))
116
117/*
118 * The superblock describes the basic structure and mount history. It also
119 * records some sizes of structures found on the disc for sanity checks.
120 *
121 * The superblock is stored at two places: NANDFS_SB_OFFSET_BYTES and
122 * NANDFS_SB2_OFFSET_BYTES.
123 */
124
125/* File system states stored on media in superblock's sbp->s_state */
126#define	NANDFS_VALID_FS		0x0001	/* cleanly unmounted and all is ok  */
127#define	NANDFS_ERROR_FS		0x0002	/* there were errors detected, fsck */
128#define	NANDFS_RESIZE_FS	0x0004	/* resize required, XXX unknown flag*/
129#define	NANDFS_MOUNT_STATE_BITS	"\20\1VALID_FS\2ERROR_FS\3RESIZE_FS"
130
131/*
132 * Brief description of control structures:
133 *
134 * NANDFS_NFSAREAS first blocks contain fsdata and some amount of super blocks.
135 * Simple round-robin policy is used in order to choose which block will
136 * contain new super block.
137 *
138 * Simple case with 2 blocks:
139 * 1: fsdata sblock1 [sblock3 [sblock5 ..]]
140 * 2: fsdata sblock2 [sblock4 [sblock6 ..]]
141 */
142struct nandfs_fsdata {
143	uint16_t	f_magic;
144	uint16_t	f_bytes;
145
146	uint32_t	f_sum;		/* checksum of fsdata		*/
147	uint32_t	f_rev_level;	/* major disk format revision	*/
148
149	uint64_t	f_ctime;	/* creation time (execution time
150					   of newfs)			*/
151	/* Block size represented as: blocksize = 1 << (f_log_block_size + 10)	*/
152	uint32_t	f_log_block_size;
153
154	uint16_t	f_inode_size;		/* size of an inode		*/
155	uint16_t	f_dat_entry_size;	/* size of a dat entry		*/
156	uint16_t	f_checkpoint_size;	/* size of a checkpoint		*/
157	uint16_t	f_segment_usage_size;	/* size of a segment usage	*/
158
159	uint16_t	f_sbbytes;		/* byte count of CRC calculation
160						   for super blocks. s_reserved
161						   is excluded!			*/
162
163	uint16_t	f_errors;		/* behaviour on detecting errors	*/
164
165	uint32_t	f_erasesize;
166	uint64_t	f_nsegments;		/* number of segm. in filesystem	*/
167	nandfs_daddr_t	f_first_data_block;	/* 1st seg disk block number		*/
168	uint32_t	f_blocks_per_segment;	/* number of blocks per segment		*/
169	uint32_t	f_r_segments_percentage;	/* reserved segments percentage		*/
170
171	struct uuid	f_uuid;			/* 128-bit uuid for volume		*/
172	char		f_volume_name[16];	/* volume name				*/
173	uint32_t	f_pad[104];
174} __packed;
175
176#ifdef _KERNEL
177CTASSERT(sizeof(struct nandfs_fsdata) == 512);
178#endif
179
180struct nandfs_super_block {
181	uint16_t	s_magic;		/* magic value for identification */
182
183	uint32_t	s_sum;			/* check sum of super block       */
184
185	uint64_t	s_last_cno;		/* last checkpoint number         */
186	uint64_t	s_last_pseg;		/* addr part. segm. written last  */
187	uint64_t	s_last_seq;		/* seq.number of seg written last */
188	uint64_t	s_free_blocks_count;	/* free blocks count              */
189
190	uint64_t	s_mtime;		/* mount time                     */
191	uint64_t	s_wtime;		/* write time                     */
192	uint16_t	s_state;		/* file system state              */
193
194	char		s_last_mounted[64];	/* directory where last mounted   */
195
196	uint32_t	s_c_interval;		/* commit interval of segment     */
197	uint32_t	s_c_block_max;		/* threshold of data amount for
198						   the segment construction */
199	uint32_t	s_reserved[32];		/* padding to end of the block    */
200} __packed;
201
202#ifdef _KERNEL
203CTASSERT(sizeof(struct nandfs_super_block) == 256);
204#endif
205
206#define	NANDFS_FSDATA_MAGIC	0xf8da
207#define	NANDFS_SUPER_MAGIC	0x8008
208
209#define	NANDFS_NFSAREAS		4
210#define	NANDFS_DATA_OFFSET_BYTES(esize)	(NANDFS_NFSAREAS * (esize))
211
212#define	NANDFS_SBLOCK_OFFSET_BYTES (sizeof(struct nandfs_fsdata))
213
214#define	NANDFS_DEF_BLOCKSIZE	4096
215#define	NANDFS_MIN_BLOCKSIZE	512
216
217#define	NANDFS_DEF_ERASESIZE	(2 << 16)
218
219#define	NANDFS_MIN_SEGSIZE	NANDFS_DEF_ERASESIZE
220
221#define	NANDFS_CURRENT_REV	9	/* current major revision */
222
223#define	NANDFS_FSDATA_CRC_BYTES offsetof(struct nandfs_fsdata, f_pad)
224/* Bytes count of super_block for CRC-calculation */
225#define	NANDFS_SB_BYTES  offsetof(struct nandfs_super_block, s_reserved)
226
227/* Maximal count of links to a file */
228#define	NANDFS_LINK_MAX		32000
229
230/*
231 * Structure of a directory entry.
232 *
233 * Note that they can't span blocks; the rec_len fills out.
234 */
235
236#define	NANDFS_NAME_LEN 255
237struct nandfs_dir_entry {
238	uint64_t	inode;			/* inode number */
239	uint16_t	rec_len;		/* directory entry length */
240	uint8_t		name_len;		/* name length */
241	uint8_t		file_type;
242	char		name[NANDFS_NAME_LEN];	/* file name */
243	char		pad;
244};
245
246/*
247 * NANDFS_DIR_PAD defines the directory entries boundaries
248 *
249 * NOTE: It must be a multiple of 8
250 */
251#define	NANDFS_DIR_PAD			8
252#define	NANDFS_DIR_ROUND		(NANDFS_DIR_PAD - 1)
253#define	NANDFS_DIR_NAME_OFFSET		(offsetof(struct nandfs_dir_entry, name))
254#define	NANDFS_DIR_REC_LEN(name_len)					\
255	(((name_len) + NANDFS_DIR_NAME_OFFSET + NANDFS_DIR_ROUND)	\
256	& ~NANDFS_DIR_ROUND)
257#define	NANDFS_DIR_NAME_LEN(name_len)	\
258	(NANDFS_DIR_REC_LEN(name_len) - NANDFS_DIR_NAME_OFFSET)
259
260/*
261 * NiLFS/NANDFS devides the disc into fixed length segments. Each segment is
262 * filled with one or more partial segments of variable lengths.
263 *
264 * Each partial segment has a segment summary header followed by updates of
265 * files and optionally a super root.
266 */
267
268/*
269 * Virtual to physical block translation information. For data blocks it maps
270 * logical block number bi_blkoff to virtual block nr bi_vblocknr. For non
271 * datablocks it is the virtual block number assigned to an indirect block
272 * and has no bi_blkoff. The physical block number is the next
273 * available data block in the partial segment after all the binfo's.
274 */
275struct nandfs_binfo_v {
276	uint64_t	bi_ino;		/* file's inode			     */
277	uint64_t	bi_vblocknr;	/* assigned virtual block number     */
278	uint64_t	bi_blkoff;	/* for file's logical block number   */
279};
280
281/*
282 * DAT allocation. For data blocks just the logical block number that maps on
283 * the next available data block in the partial segment after the binfo's.
284 */
285struct nandfs_binfo_dat {
286	uint64_t	bi_ino;
287	uint64_t	bi_blkoff;	/* DAT file's logical block number */
288	uint8_t		bi_level;	/* whether this is meta block */
289	uint8_t		bi_pad[7];
290};
291
292#ifdef _KERNEL
293CTASSERT(sizeof(struct nandfs_binfo_v) == sizeof(struct nandfs_binfo_dat));
294#endif
295
296/* Convenience union for both types of binfo's */
297union nandfs_binfo {
298	struct nandfs_binfo_v bi_v;
299	struct nandfs_binfo_dat bi_dat;
300};
301
302/* Indirect buffers path */
303struct nandfs_indir {
304	nandfs_daddr_t	in_lbn;
305	int		in_off;
306};
307
308/* The (partial) segment summary */
309struct nandfs_segment_summary {
310	uint32_t	ss_datasum;	/* CRC of complete data block        */
311	uint32_t	ss_sumsum;	/* CRC of segment summary only       */
312	uint32_t	ss_magic;	/* magic to identify segment summary */
313	uint16_t	ss_bytes;	/* size of segment summary structure */
314	uint16_t	ss_flags;	/* NANDFS_SS_* flags                  */
315	uint64_t	ss_seq;		/* sequence number of this segm. sum */
316	uint64_t	ss_create;	/* creation timestamp in seconds     */
317	uint64_t	ss_next;	/* blocknumber of next segment       */
318	uint32_t	ss_nblocks;	/* number of blocks used by summary  */
319	uint32_t	ss_nbinfos;	/* number of binfo structures	     */
320	uint32_t	ss_sumbytes;	/* total size of segment summary     */
321	uint32_t	ss_pad;
322	/* stream of binfo structures */
323};
324
325#define	NANDFS_SEGSUM_MAGIC	0x8e680011	/* segment summary magic number */
326
327/* Segment summary flags */
328#define	NANDFS_SS_LOGBGN	0x0001	/* begins a logical segment */
329#define	NANDFS_SS_LOGEND	0x0002	/* ends a logical segment */
330#define	NANDFS_SS_SR		0x0004	/* has super root */
331#define	NANDFS_SS_SYNDT		0x0008	/* includes data only updates */
332#define	NANDFS_SS_GC		0x0010	/* segment written for cleaner operation */
333#define	NANDFS_SS_FLAG_BITS	"\20\1LOGBGN\2LOGEND\3SR\4SYNDT\5GC"
334
335/* Segment summary constrains */
336#define	NANDFS_SEG_MIN_BLOCKS	16	/* minimum number of blocks in a
337					   full segment */
338#define	NANDFS_PSEG_MIN_BLOCKS	2	/* minimum number of blocks in a
339					   partial segment */
340#define	NANDFS_MIN_NRSVSEGS	8	/* minimum number of reserved
341					   segments */
342
343/*
344 * Structure of DAT/inode file.
345 *
346 * A DAT file is divided into groups. The maximum number of groups is the
347 * number of block group descriptors that fit into one block; this descriptor
348 * only gives the number of free entries in the associated group.
349 *
350 * Each group has a block sized bitmap indicating if an entry is taken or
351 * empty. Each bit stands for a DAT entry.
352 *
353 * The inode file has exactly the same format only the entries are inode
354 * entries.
355 */
356
357struct nandfs_block_group_desc {
358	uint32_t	bg_nfrees;	/* num. free entries in block group  */
359};
360
361/* DAT entry in a super root's DAT file */
362struct nandfs_dat_entry {
363	uint64_t	de_blocknr;	/* block number                      */
364	uint64_t	de_start;	/* valid from checkpoint             */
365	uint64_t	de_end;		/* valid till checkpoint             */
366	uint64_t	de_rsv;		/* reserved for future use           */
367};
368
369/*
370 * Structure of CP file.
371 *
372 * A snapshot is just a checkpoint only it's protected against removal by the
373 * cleaner. The snapshots are kept on a double linked list of checkpoints.
374 */
375struct nandfs_snapshot_list {
376	uint64_t	ssl_next;	/* checkpoint nr. forward */
377	uint64_t	ssl_prev;	/* checkpoint nr. back    */
378};
379
380/* Checkpoint entry structure */
381struct nandfs_checkpoint {
382	uint32_t	cp_flags;		/* NANDFS_CHECKPOINT_* flags          */
383	uint32_t	cp_checkpoints_count;	/* ZERO, not used anymore?           */
384	struct nandfs_snapshot_list cp_snapshot_list; /* list of snapshots   */
385	uint64_t	cp_cno;			/* checkpoint number                 */
386	uint64_t	cp_create;		/* creation timestamp                */
387	uint64_t	cp_nblk_inc;		/* number of blocks incremented      */
388	uint64_t	cp_blocks_count;	/* reserved (might be deleted)       */
389	struct nandfs_inode cp_ifile_inode;	/* inode file inode          */
390};
391
392/* Checkpoint flags */
393#define	NANDFS_CHECKPOINT_SNAPSHOT	1
394#define	NANDFS_CHECKPOINT_INVALID	2
395#define	NANDFS_CHECKPOINT_SKETCH	4
396#define	NANDFS_CHECKPOINT_MINOR		8
397#define	NANDFS_CHECKPOINT_BITS		"\20\1SNAPSHOT\2INVALID\3SKETCH\4MINOR"
398
399/* Header of the checkpoint file */
400struct nandfs_cpfile_header {
401	uint64_t	ch_ncheckpoints;	/* number of checkpoints             */
402	uint64_t	ch_nsnapshots;	/* number of snapshots               */
403	struct nandfs_snapshot_list ch_snapshot_list;	/* snapshot list     */
404};
405
406#define	NANDFS_CPFILE_FIRST_CHECKPOINT_OFFSET		\
407	((sizeof(struct nandfs_cpfile_header) +		\
408	sizeof(struct nandfs_checkpoint) - 1) /		\
409	sizeof(struct nandfs_checkpoint))
410
411
412#define NANDFS_NOSEGMENT        0xffffffff
413
414/*
415 * Structure of SU file.
416 *
417 * The segment usage file sums up how each of the segments are used. They are
418 * indexed by their segment number.
419 */
420
421/* Segment usage entry */
422struct nandfs_segment_usage {
423	uint64_t	su_lastmod;	/* last modified timestamp           */
424	uint32_t	su_nblocks;	/* number of blocks in segment       */
425	uint32_t	su_flags;	/* NANDFS_SEGMENT_USAGE_* flags       */
426};
427
428/* Segment usage flag */
429#define	NANDFS_SEGMENT_USAGE_ACTIVE	1
430#define	NANDFS_SEGMENT_USAGE_DIRTY	2
431#define	NANDFS_SEGMENT_USAGE_ERROR	4
432#define	NANDFS_SEGMENT_USAGE_GC		8
433#define	NANDFS_SEGMENT_USAGE_BITS	"\20\1ACTIVE\2DIRTY\3ERROR"
434
435/* Header of the segment usage file */
436struct nandfs_sufile_header {
437	uint64_t	sh_ncleansegs;	/* number of segments marked clean   */
438	uint64_t	sh_ndirtysegs;	/* number of segments marked dirty   */
439	uint64_t	sh_last_alloc;	/* last allocated segment number     */
440};
441
442#define	NANDFS_SUFILE_FIRST_SEGMENT_USAGE_OFFSET	\
443	((sizeof(struct nandfs_sufile_header) +		\
444	sizeof(struct nandfs_segment_usage) - 1) /	\
445	sizeof(struct nandfs_segment_usage))
446
447struct nandfs_seg_stat {
448	uint64_t	nss_nsegs;
449	uint64_t	nss_ncleansegs;
450	uint64_t	nss_ndirtysegs;
451	uint64_t	nss_ctime;
452	uint64_t	nss_nongc_ctime;
453	uint64_t	nss_prot_seq;
454};
455
456enum {
457	NANDFS_CHECKPOINT,
458	NANDFS_SNAPSHOT
459};
460
461#define	NANDFS_CPINFO_MAX		512
462
463struct nandfs_cpinfo {
464	uint32_t	nci_flags;
465	uint32_t	nci_pad;
466	uint64_t	nci_cno;
467	uint64_t	nci_create;
468	uint64_t	nci_nblk_inc;
469	uint64_t	nci_blocks_count;
470	uint64_t	nci_next;
471};
472
473#define	NANDFS_SEGMENTS_MAX	512
474
475struct nandfs_suinfo {
476	uint64_t	nsi_num;
477	uint64_t	nsi_lastmod;
478	uint32_t	nsi_blocks;
479	uint32_t	nsi_flags;
480};
481
482#define	NANDFS_VINFO_MAX	512
483
484struct nandfs_vinfo {
485	uint64_t	nvi_ino;
486	uint64_t	nvi_vblocknr;
487	uint64_t	nvi_start;
488	uint64_t	nvi_end;
489	uint64_t	nvi_blocknr;
490	int		nvi_alive;
491};
492
493struct nandfs_cpmode {
494	uint64_t	ncpm_cno;
495	uint32_t	ncpm_mode;
496	uint32_t	ncpm_pad;
497};
498
499struct nandfs_argv {
500	uint64_t	nv_base;
501	uint32_t	nv_nmembs;
502	uint16_t	nv_size;
503	uint16_t	nv_flags;
504	uint64_t	nv_index;
505};
506
507struct nandfs_cpstat {
508	uint64_t	ncp_cno;
509	uint64_t	ncp_ncps;
510	uint64_t	ncp_nss;
511};
512
513struct nandfs_period {
514	uint64_t	p_start;
515	uint64_t	p_end;
516};
517
518struct nandfs_vdesc {
519	uint64_t	vd_ino;
520	uint64_t	vd_cno;
521	uint64_t	vd_vblocknr;
522	struct nandfs_period	vd_period;
523	uint64_t	vd_blocknr;
524	uint64_t	vd_offset;
525	uint32_t	vd_flags;
526	uint32_t	vd_pad;
527};
528
529struct nandfs_bdesc {
530	uint64_t	bd_ino;
531	uint64_t	bd_oblocknr;
532	uint64_t	bd_blocknr;
533	uint64_t	bd_offset;
534	uint32_t	bd_level;
535	uint32_t	bd_alive;
536};
537
538#ifndef _KERNEL
539#ifndef	MNAMELEN
540#define	MNAMELEN	88
541#endif
542#endif
543
544struct nandfs_fsinfo {
545	struct nandfs_fsdata		fs_fsdata;
546	struct nandfs_super_block	fs_super;
547	char				fs_dev[MNAMELEN];
548};
549
550#define	NANDFS_MAX_MOUNTS	65535
551
552#define	NANDFS_IOCTL_GET_SUSTAT		_IOR('N', 100, struct nandfs_seg_stat)
553#define	NANDFS_IOCTL_CHANGE_CPMODE	_IOWR('N', 101, struct nandfs_cpmode)
554#define	NANDFS_IOCTL_GET_CPINFO		_IOWR('N', 102, struct nandfs_argv)
555#define	NANDFS_IOCTL_DELETE_CP		_IOWR('N', 103, uint64_t[2])
556#define	NANDFS_IOCTL_GET_CPSTAT		_IOR('N', 104, struct nandfs_cpstat)
557#define	NANDFS_IOCTL_GET_SUINFO		_IOWR('N', 105, struct nandfs_argv)
558#define	NANDFS_IOCTL_GET_VINFO		_IOWR('N', 106, struct nandfs_argv)
559#define	NANDFS_IOCTL_GET_BDESCS		_IOWR('N', 107, struct nandfs_argv)
560#define	NANDFS_IOCTL_GET_FSINFO		_IOR('N', 108, struct nandfs_fsinfo)
561#define	NANDFS_IOCTL_MAKE_SNAP		_IOWR('N', 109, uint64_t)
562#define	NANDFS_IOCTL_DELETE_SNAP	_IOWR('N', 110, uint64_t)
563#define	NANDFS_IOCTL_SYNC		_IOWR('N', 111, uint64_t)
564
565#endif /* _NANDFS_FS_H */
566