4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.gnu.org/licenses/gpl-2.0.html
23 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Use is subject to license terms.
26 * Copyright (c) 2010, 2017, Intel Corporation.
29 * This file is part of Lustre, http://www.lustre.org/
30 * Lustre is a trademark of Sun Microsystems, Inc.
32 * lustre/include/lustre/lustre_user.h
34 * Lustre public user-space interface definitions.
37 #ifndef _LUSTRE_USER_H
38 #define _LUSTRE_USER_H
40 /** \defgroup lustreuser lustreuser
45 #include <linux/types.h>
48 # include <linux/fs.h>
49 # include <linux/quota.h>
50 # include <linux/string.h> /* snprintf() */
51 # include <linux/version.h>
52 # include <uapi/linux/lustre/lustre_fiemap.h>
53 #else /* !__KERNEL__ */
54 # define NEED_QUOTA_DEFS
57 # include <stdio.h> /* snprintf() */
59 # include <sys/quota.h>
60 # include <sys/stat.h>
61 # include <linux/lustre/lustre_fiemap.h>
62 #endif /* __KERNEL__ */
64 #if defined(__cplusplus)
69 * This is a temporary solution of adding quota type.
70 * Should be removed as soon as system header is updated.
73 #define LL_MAXQUOTAS 3
75 #define INITQFNAMES { \
76 "user", /* USRQUOTA */ \
77 "group", /* GRPQUOTA */ \
78 "project", /* PRJQUOTA */ \
83 #if defined(__x86_64__) || defined(__ia64__) || defined(__ppc64__) || \
84 defined(__craynv) || defined(__mips64__) || defined(__powerpc64__) || \
86 typedef struct stat lstat_t;
87 # define lstat_f lstat
88 # define fstat_f fstat
89 # define fstatat_f fstatat
90 # define HAVE_LOV_USER_MDS_DATA
91 #elif defined(__USE_LARGEFILE64) || defined(__KERNEL__)
92 typedef struct stat64 lstat_t;
93 # define lstat_f lstat64
94 # define fstat_f fstat64
95 # define fstatat_f fstatat64
96 # define HAVE_LOV_USER_MDS_DATA
99 #define LUSTRE_EOF 0xffffffffffffffffULL
102 #define LL_SUPER_MAGIC 0x0BD00BD0
104 #ifndef FSFILT_IOC_GETFLAGS
105 #define FSFILT_IOC_GETFLAGS _IOR('f', 1, long)
106 #define FSFILT_IOC_SETFLAGS _IOW('f', 2, long)
107 #define FSFILT_IOC_GETVERSION _IOR('f', 3, long)
108 #define FSFILT_IOC_SETVERSION _IOW('f', 4, long)
109 #define FSFILT_IOC_GETVERSION_OLD _IOR('v', 1, long)
110 #define FSFILT_IOC_SETVERSION_OLD _IOW('v', 2, long)
113 /* FIEMAP flags supported by Lustre */
114 #define LUSTRE_FIEMAP_FLAGS_COMPAT (FIEMAP_FLAG_SYNC | FIEMAP_FLAG_DEVICE_ORDER)
116 enum obd_statfs_state {
117 OS_STATE_DEGRADED = 0x00000001, /**< RAID degraded/rebuilding */
118 OS_STATE_READONLY = 0x00000002, /**< filesystem is read-only */
119 OS_STATE_ENOSPC = 0x00000020, /**< not enough free space */
120 OS_STATE_ENOINO = 0x00000040, /**< not enough inodes */
123 /** filesystem statistics/attributes for target device */
125 __u64 os_type; /* EXT4_SUPER_MAGIC, UBERBLOCK_MAGIC */
126 __u64 os_blocks; /* total size in #os_bsize blocks */
127 __u64 os_bfree; /* number of unused blocks */
128 __u64 os_bavail; /* blocks available for allocation */
129 __u64 os_files; /* total number of objects */
130 __u64 os_ffree; /* # objects that could be created */
131 __u8 os_fsid[40]; /* identifier for filesystem */
132 __u32 os_bsize; /* block size in bytes for os_blocks */
133 __u32 os_namelen; /* maximum length of filename in bytes*/
134 __u64 os_maxbytes; /* maximum object size in bytes */
135 __u32 os_state; /**< obd_statfs_state OS_STATE_* flag */
136 __u32 os_fprecreated; /* objs available now to the caller */
137 /* used in QoS code to find preferred
139 __u32 os_spare2; /* Unused padding fields. Remember */
140 __u32 os_spare3; /* to fix lustre_swab_obd_statfs() */
152 * FID is a cluster-wide unique identifier of a file or an object (stripe).
153 * FIDs are never reused.
157 * FID sequence. Sequence is a unit of migration: all files (objects)
158 * with FIDs from a given sequence are stored on the same server.
159 * Lustre should support 2^64 objects, so even if each sequence
160 * has only a single object we can still enumerate 2^64 objects.
163 /* FID number within sequence. */
166 * FID version, used to distinguish different versions (in the sense
167 * of snapshots, etc.) of the same file system object. Not currently
173 static inline bool fid_is_zero(const struct lu_fid *fid)
175 return fid->f_seq == 0 && fid->f_oid == 0;
178 /* Currently, the filter_fid::ff_parent::f_ver is not the real parent
179 * MDT-object's FID::f_ver, instead it is the OST-object index in its
180 * parent MDT-object's layout EA. */
181 #define f_stripe_idx f_ver
184 __u32 ol_stripe_size;
185 __u32 ol_stripe_count;
189 } __attribute__((packed));
191 /* keep this one for compatibility */
192 struct filter_fid_old {
193 struct lu_fid ff_parent;
199 struct lu_fid ff_parent;
200 struct ost_layout ff_layout;
201 __u32 ff_layout_version;
202 __u32 ff_range; /* range of layout version that
203 * write are allowed */
204 } __attribute__((packed));
206 /* Userspace should treat lu_fid as opaque, and only use the following methods
207 * to print or parse them. Other functions (e.g. compare, swab) could be moved
208 * here from lustre_idl.h if needed. */
212 LMAC_HSM = 0x00000001,
213 /* LMAC_SOM = 0x00000002, obsolete since 2.8.0 */
214 LMAC_NOT_IN_OI = 0x00000004, /* the object does NOT need OI mapping */
215 LMAC_FID_ON_OST = 0x00000008, /* For OST-object, its OI mapping is
216 * under /O/<seq>/d<x>. */
217 LMAC_STRIPE_INFO = 0x00000010, /* stripe info in the LMA EA. */
218 LMAC_COMP_INFO = 0x00000020, /* Component info in the LMA EA. */
219 LMAC_IDX_BACKUP = 0x00000040, /* Has index backup. */
223 * Masks for all features that should be supported by a Lustre version to
224 * access a specific file.
225 * This information is stored in lustre_mdt_attrs::lma_incompat.
228 LMAI_RELEASED = 0x00000001, /* file is released */
229 LMAI_AGENT = 0x00000002, /* agent inode */
230 LMAI_REMOTE_PARENT = 0x00000004, /* the parent of the object
231 is on the remote MDT */
232 LMAI_STRIPED = 0x00000008, /* striped directory inode */
233 LMAI_ORPHAN = 0x00000010, /* inode is orphan */
234 LMA_INCOMPAT_SUPP = (LMAI_AGENT | LMAI_REMOTE_PARENT | \
235 LMAI_STRIPED | LMAI_ORPHAN)
240 * Following struct for object attributes, that will be kept inode's EA.
241 * Introduced in 2.0 release (please see b15993, for details)
242 * Added to all objects since Lustre 2.4 as contains self FID
244 struct lustre_mdt_attrs {
246 * Bitfield for supported data in this structure. From enum lma_compat.
247 * lma_self_fid and lma_flags are always available.
251 * Per-file incompat feature list. Lustre version should support all
252 * flags set in this field. The supported feature mask is available in
256 /** FID of this inode */
257 struct lu_fid lma_self_fid;
260 struct lustre_ost_attrs {
261 /* Use lustre_mdt_attrs directly for now, need a common header
262 * structure if want to change lustre_mdt_attrs in future. */
263 struct lustre_mdt_attrs loa_lma;
265 /* Below five elements are for OST-object's PFID EA, the
266 * lma_parent_fid::f_ver is composed of the stripe_count (high 16 bits)
267 * and the stripe_index (low 16 bits), the size should not exceed
268 * 5 * sizeof(__u64)) to be accessable by old Lustre. If the flag
269 * LMAC_STRIPE_INFO is set, then loa_parent_fid and loa_stripe_size
270 * are valid; if the flag LMAC_COMP_INFO is set, then the next three
271 * loa_comp_* elements are valid. */
272 struct lu_fid loa_parent_fid;
273 __u32 loa_stripe_size;
275 __u64 loa_comp_start;
280 * Prior to 2.4, the LMA structure also included SOM attributes which has since
281 * been moved to a dedicated xattr
282 * lma_flags was also removed because of lma_compat/incompat fields.
284 #define LMA_OLD_SIZE (sizeof(struct lustre_mdt_attrs) + 5 * sizeof(__u64))
287 LSOM_FL_VALID = 1 << 0,
290 struct lustre_som_attrs {
292 __u16 lsa_reserved[3];
298 * OST object IDentifier.
306 struct lu_fid oi_fid;
310 #define DOSTID "%#llx:%llu"
311 #define POSTID(oi) ((unsigned long long)ostid_seq(oi)), \
312 ((unsigned long long)ostid_id(oi))
314 struct ll_futimes_3 {
316 __u64 lfu_atime_nsec;
318 __u64 lfu_mtime_nsec;
320 __u64 lfu_ctime_nsec;
324 * Maximum number of mirrors currently implemented.
326 #define LUSTRE_MIRROR_COUNT_MAX 16
328 /* Lease types for use as arg and return of LL_IOC_{GET,SET}_LEASE ioctl. */
330 LL_LEASE_RDLCK = 0x01,
331 LL_LEASE_WRLCK = 0x02,
332 LL_LEASE_UNLCK = 0x04,
335 enum ll_lease_flags {
336 LL_LEASE_RESYNC = 0x1,
337 LL_LEASE_RESYNC_DONE = 0x2,
338 LL_LEASE_LAYOUT_MERGE = 0x4,
339 LL_LEASE_LAYOUT_SPLIT = 0x8,
342 #define IOC_IDS_MAX 4096
343 struct ll_ioc_lease {
351 * The ioctl naming rules:
352 * LL_* - works on the currently opened filehandle instead of parent dir
353 * *_OBD_* - gets data for both OSC or MDC (LOV, LMV indirectly)
354 * *_MDC_* - gets/sets data related to MDC
355 * *_LOV_* - gets/sets data related to OSC/LOV
356 * *FILE* - called on parent dir and passes in a filename
357 * *STRIPE* - set/get lov_user_md
358 * *INFO - set/get lov_user_mds_data
360 /* lustre_ioctl.h 101-150 */
361 #define LL_IOC_GETFLAGS _IOR ('f', 151, long)
362 #define LL_IOC_SETFLAGS _IOW ('f', 152, long)
363 #define LL_IOC_CLRFLAGS _IOW ('f', 153, long)
364 #define LL_IOC_LOV_SETSTRIPE _IOW ('f', 154, long)
365 #define LL_IOC_LOV_SETSTRIPE_NEW _IOWR('f', 154, struct lov_user_md)
366 #define LL_IOC_LOV_GETSTRIPE _IOW ('f', 155, long)
367 #define LL_IOC_LOV_GETSTRIPE_NEW _IOR('f', 155, struct lov_user_md)
368 #define LL_IOC_LOV_SETEA _IOW ('f', 156, long)
369 /* LL_IOC_RECREATE_OBJ 157 obsolete */
370 /* LL_IOC_RECREATE_FID 157 obsolete */
371 #define LL_IOC_GROUP_LOCK _IOW ('f', 158, long)
372 #define LL_IOC_GROUP_UNLOCK _IOW ('f', 159, long)
373 /* LL_IOC_QUOTACHECK 160 OBD_IOC_QUOTACHECK */
374 /* LL_IOC_POLL_QUOTACHECK 161 OBD_IOC_POLL_QUOTACHECK */
375 /* LL_IOC_QUOTACTL 162 OBD_IOC_QUOTACTL */
376 #define IOC_OBD_STATFS _IOWR('f', 164, struct obd_statfs *)
377 /* IOC_LOV_GETINFO 165 obsolete */
378 #define LL_IOC_FLUSHCTX _IOW ('f', 166, long)
379 /* LL_IOC_RMTACL 167 obsolete */
380 #define LL_IOC_GETOBDCOUNT _IOR ('f', 168, long)
381 #define LL_IOC_LLOOP_ATTACH _IOWR('f', 169, long)
382 #define LL_IOC_LLOOP_DETACH _IOWR('f', 170, long)
383 #define LL_IOC_LLOOP_INFO _IOWR('f', 171, struct lu_fid)
384 #define LL_IOC_LLOOP_DETACH_BYDEV _IOWR('f', 172, long)
385 #define LL_IOC_PATH2FID _IOR ('f', 173, long)
386 #define LL_IOC_GET_CONNECT_FLAGS _IOWR('f', 174, __u64 *)
387 #define LL_IOC_GET_MDTIDX _IOR ('f', 175, int)
388 #define LL_IOC_FUTIMES_3 _IOWR('f', 176, struct ll_futimes_3)
389 #define LL_IOC_FLR_SET_MIRROR _IOW ('f', 177, long)
390 /* lustre_ioctl.h 177-210 */
391 #define LL_IOC_HSM_STATE_GET _IOR('f', 211, struct hsm_user_state)
392 #define LL_IOC_HSM_STATE_SET _IOW('f', 212, struct hsm_state_set)
393 #define LL_IOC_HSM_CT_START _IOW('f', 213, struct lustre_kernelcomm)
394 #define LL_IOC_HSM_COPY_START _IOW('f', 214, struct hsm_copy *)
395 #define LL_IOC_HSM_COPY_END _IOW('f', 215, struct hsm_copy *)
396 #define LL_IOC_HSM_PROGRESS _IOW('f', 216, struct hsm_user_request)
397 #define LL_IOC_HSM_REQUEST _IOW('f', 217, struct hsm_user_request)
398 #define LL_IOC_DATA_VERSION _IOR('f', 218, struct ioc_data_version)
399 #define LL_IOC_LOV_SWAP_LAYOUTS _IOW('f', 219, \
400 struct lustre_swap_layouts)
401 #define LL_IOC_HSM_ACTION _IOR('f', 220, \
402 struct hsm_current_action)
403 /* lustre_ioctl.h 221-232 */
404 #define LL_IOC_LMV_SETSTRIPE _IOWR('f', 240, struct lmv_user_md)
405 #define LL_IOC_LMV_GETSTRIPE _IOWR('f', 241, struct lmv_user_md)
406 #define LL_IOC_REMOVE_ENTRY _IOWR('f', 242, __u64)
407 #define LL_IOC_SET_LEASE _IOWR('f', 243, struct ll_ioc_lease)
408 #define LL_IOC_SET_LEASE_OLD _IOWR('f', 243, long)
409 #define LL_IOC_GET_LEASE _IO('f', 244)
410 #define LL_IOC_HSM_IMPORT _IOWR('f', 245, struct hsm_user_import)
411 #define LL_IOC_LMV_SET_DEFAULT_STRIPE _IOWR('f', 246, struct lmv_user_md)
412 #define LL_IOC_MIGRATE _IOR('f', 247, int)
413 #define LL_IOC_FID2MDTIDX _IOWR('f', 248, struct lu_fid)
414 #define LL_IOC_GETPARENT _IOWR('f', 249, struct getparent)
415 #define LL_IOC_LADVISE _IOR('f', 250, struct llapi_lu_ladvise)
417 #ifndef FS_IOC_FSGETXATTR
419 * Structure for FS_IOC_FSGETXATTR and FS_IOC_FSSETXATTR.
422 __u32 fsx_xflags; /* xflags field value (get/set) */
423 __u32 fsx_extsize; /* extsize field value (get/set)*/
424 __u32 fsx_nextents; /* nextents field value (get) */
425 __u32 fsx_projid; /* project identifier (get/set) */
426 unsigned char fsx_pad[12];
428 #define FS_IOC_FSGETXATTR _IOR('X', 31, struct fsxattr)
429 #define FS_IOC_FSSETXATTR _IOW('X', 32, struct fsxattr)
431 #define LL_IOC_FSGETXATTR FS_IOC_FSGETXATTR
432 #define LL_IOC_FSSETXATTR FS_IOC_FSSETXATTR
433 #define LL_PROJINHERIT_FL 0x20000000
436 #define LL_STATFS_LMV 1
437 #define LL_STATFS_LOV 2
438 #define LL_STATFS_NODELAY 4
440 #define IOC_MDC_TYPE 'i'
441 #define IOC_MDC_LOOKUP _IOWR(IOC_MDC_TYPE, 20, struct obd_device *)
442 #define IOC_MDC_GETFILESTRIPE _IOWR(IOC_MDC_TYPE, 21, struct lov_user_md *)
443 #define IOC_MDC_GETFILEINFO _IOWR(IOC_MDC_TYPE, 22, struct lov_user_mds_data *)
444 #define LL_IOC_MDC_GETINFO _IOWR(IOC_MDC_TYPE, 23, struct lov_user_mds_data *)
446 #define MAX_OBD_NAME 128 /* If this changes, a NEW ioctl must be added */
448 /* Define O_LOV_DELAY_CREATE to be a mask that is not useful for regular
449 * files, but are unlikely to be used in practice and are not harmful if
450 * used incorrectly. O_NOCTTY and FASYNC are only meaningful for character
451 * devices and are safe for use on new files. See LU-4209. */
452 /* To be compatible with old statically linked binary we keep the check for
453 * the older 0100000000 flag. This is already removed upstream. LU-812. */
454 #define O_LOV_DELAY_CREATE_1_8 0100000000 /* FMODE_NONOTIFY masked in 2.6.36 */
455 #define O_LOV_DELAY_CREATE_MASK (O_NOCTTY | FASYNC)
456 #define O_LOV_DELAY_CREATE (O_LOV_DELAY_CREATE_1_8 | \
457 O_LOV_DELAY_CREATE_MASK)
459 #define LL_FILE_IGNORE_LOCK 0x00000001
460 #define LL_FILE_GROUP_LOCKED 0x00000002
461 #define LL_FILE_READAHEA 0x00000004
462 #define LL_FILE_LOCKED_DIRECTIO 0x00000008 /* client-side locks with dio */
463 #define LL_FILE_LOCKLESS_IO 0x00000010 /* server-side locks with cio */
465 #define LOV_USER_MAGIC_V1 0x0BD10BD0
466 #define LOV_USER_MAGIC LOV_USER_MAGIC_V1
467 #define LOV_USER_MAGIC_JOIN_V1 0x0BD20BD0
468 #define LOV_USER_MAGIC_V3 0x0BD30BD0
469 /* 0x0BD40BD0 is occupied by LOV_MAGIC_MIGRATE */
470 #define LOV_USER_MAGIC_SPECIFIC 0x0BD50BD0 /* for specific OSTs */
471 #define LOV_USER_MAGIC_COMP_V1 0x0BD60BD0
473 #define LMV_USER_MAGIC 0x0CD30CD0 /* default lmv magic */
474 #define LMV_USER_MAGIC_V0 0x0CD20CD0 /* old default lmv magic*/
475 #define LMV_USER_MAGIC_SPECIFIC 0x0CD40CD0
477 #define LOV_PATTERN_NONE 0x000
478 #define LOV_PATTERN_RAID0 0x001
479 #define LOV_PATTERN_RAID1 0x002
480 #define LOV_PATTERN_MDT 0x100
481 #define LOV_PATTERN_CMOBD 0x200
483 #define LOV_PATTERN_F_MASK 0xffff0000
484 #define LOV_PATTERN_F_HOLE 0x40000000 /* there is hole in LOV EA */
485 #define LOV_PATTERN_F_RELEASED 0x80000000 /* HSM released file */
486 #define LOV_PATTERN_DEFAULT 0xffffffff
488 static inline bool lov_pattern_supported(__u32 pattern)
490 return pattern == LOV_PATTERN_RAID0 ||
491 pattern == LOV_PATTERN_MDT ||
492 pattern == (LOV_PATTERN_RAID0 | LOV_PATTERN_F_RELEASED);
495 #define LOV_MAXPOOLNAME 15
496 #define LOV_POOLNAMEF "%.15s"
498 #define LOV_MIN_STRIPE_BITS 16 /* maximum PAGE_SIZE (ia64), power of 2 */
499 #define LOV_MIN_STRIPE_SIZE (1 << LOV_MIN_STRIPE_BITS)
500 #define LOV_MAX_STRIPE_COUNT_OLD 160
501 /* This calculation is crafted so that input of 4096 will result in 160
502 * which in turn is equal to old maximal stripe count.
503 * XXX: In fact this is too simpified for now, what it also need is to get
504 * ea_type argument to clearly know how much space each stripe consumes.
506 * The limit of 12 pages is somewhat arbitrary, but is a reasonably large
507 * allocation that is sufficient for the current generation of systems.
509 * (max buffer size - lov+rpc header) / sizeof(struct lov_ost_data_v1) */
510 #define LOV_MAX_STRIPE_COUNT 2000 /* ((12 * 4096 - 256) / 24) */
511 #define LOV_ALL_STRIPES 0xffff /* only valid for directories */
512 #define LOV_V1_INSANE_STRIPE_COUNT 65532 /* maximum stripe count bz13933 */
514 #define XATTR_LUSTRE_PREFIX "lustre."
515 #define XATTR_LUSTRE_LOV XATTR_LUSTRE_PREFIX"lov"
517 #define lov_user_ost_data lov_user_ost_data_v1
518 struct lov_user_ost_data_v1 { /* per-stripe data structure */
519 struct ost_id l_ost_oi; /* OST object ID */
520 __u32 l_ost_gen; /* generation of this OST index */
521 __u32 l_ost_idx; /* OST index in LOV */
522 } __attribute__((packed));
524 #define lov_user_md lov_user_md_v1
525 struct lov_user_md_v1 { /* LOV EA user data (host-endian) */
526 __u32 lmm_magic; /* magic number = LOV_USER_MAGIC_V1 */
527 __u32 lmm_pattern; /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */
528 struct ost_id lmm_oi; /* MDT parent inode id/seq (id/0 for 1.x) */
529 __u32 lmm_stripe_size; /* size of stripe in bytes */
530 __u16 lmm_stripe_count; /* num stripes in use for this object */
532 __u16 lmm_stripe_offset; /* starting stripe offset in
533 * lmm_objects, use when writing */
534 __u16 lmm_layout_gen; /* layout generation number
535 * used when reading */
537 struct lov_user_ost_data_v1 lmm_objects[0]; /* per-stripe data */
538 } __attribute__((packed, __may_alias__));
540 struct lov_user_md_v3 { /* LOV EA user data (host-endian) */
541 __u32 lmm_magic; /* magic number = LOV_USER_MAGIC_V3 */
542 __u32 lmm_pattern; /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */
543 struct ost_id lmm_oi; /* MDT parent inode id/seq (id/0 for 1.x) */
544 __u32 lmm_stripe_size; /* size of stripe in bytes */
545 __u16 lmm_stripe_count; /* num stripes in use for this object */
547 __u16 lmm_stripe_offset; /* starting stripe offset in
548 * lmm_objects, use when writing */
549 __u16 lmm_layout_gen; /* layout generation number
550 * used when reading */
552 char lmm_pool_name[LOV_MAXPOOLNAME + 1]; /* pool name */
553 struct lov_user_ost_data_v1 lmm_objects[0]; /* per-stripe data */
554 } __attribute__((packed));
561 #define DEXT "[%#llx, %#llx)"
562 #define PEXT(ext) (ext)->e_start, (ext)->e_end
564 static inline bool lu_extent_is_overlapped(struct lu_extent *e1,
565 struct lu_extent *e2)
567 return e1->e_start < e2->e_end && e2->e_start < e1->e_end;
570 static inline bool lu_extent_is_whole(struct lu_extent *e)
572 return e->e_start == 0 && e->e_end == LUSTRE_EOF;
575 enum lov_comp_md_entry_flags {
576 LCME_FL_STALE = 0x00000001, /* FLR: stale data */
577 LCME_FL_PREF_RD = 0x00000002, /* FLR: preferred for reading */
578 LCME_FL_PREF_WR = 0x00000004, /* FLR: preferred for writing */
579 LCME_FL_PREF_RW = LCME_FL_PREF_RD | LCME_FL_PREF_WR,
580 LCME_FL_OFFLINE = 0x00000008, /* Not used */
581 LCME_FL_INIT = 0x00000010, /* instantiated */
582 LCME_FL_NEG = 0x80000000 /* used to indicate a negative flag,
583 won't be stored on disk */
586 #define LCME_KNOWN_FLAGS (LCME_FL_NEG | LCME_FL_INIT | LCME_FL_STALE | \
588 /* The flags can be set by users at mirror creation time. */
589 #define LCME_USER_FLAGS (LCME_FL_PREF_RW)
591 /* the highest bit in obdo::o_layout_version is used to mark if the file is
593 #define LU_LAYOUT_RESYNC LCME_FL_NEG
595 /* lcme_id can be specified as certain flags, and the the first
596 * bit of lcme_id is used to indicate that the ID is representing
597 * certain LCME_FL_* but not a real ID. Which implies we can have
598 * at most 31 flags (see LCME_FL_XXX). */
601 LCME_ID_MAX = 0x7FFFFFFF,
602 LCME_ID_ALL = 0xFFFFFFFF,
603 LCME_ID_NOT_ID = LCME_FL_NEG
606 #define LCME_ID_MASK LCME_ID_MAX
608 struct lov_comp_md_entry_v1 {
609 __u32 lcme_id; /* unique id of component */
610 __u32 lcme_flags; /* LCME_FL_XXX */
611 struct lu_extent lcme_extent; /* file extent for component */
612 __u32 lcme_offset; /* offset of component blob,
613 start from lov_comp_md_v1 */
614 __u32 lcme_size; /* size of component blob */
615 __u64 lcme_padding[2];
616 } __attribute__((packed));
618 #define SEQ_ID_MAX 0x0000FFFF
619 #define SEQ_ID_MASK SEQ_ID_MAX
620 /* bit 30:16 of lcme_id is used to store mirror id */
621 #define MIRROR_ID_MASK 0x7FFF0000
622 #define MIRROR_ID_SHIFT 16
624 static inline __u32 pflr_id(__u16 mirror_id, __u16 seqid)
626 return ((mirror_id << MIRROR_ID_SHIFT) & MIRROR_ID_MASK) | seqid;
629 static inline __u16 mirror_id_of(__u32 id)
631 return (id & MIRROR_ID_MASK) >> MIRROR_ID_SHIFT;
635 * on-disk data for lcm_flags. Valid if lcm_magic is LOV_MAGIC_COMP_V1.
637 enum lov_comp_md_flags {
638 /* the least 2 bits are used by FLR to record file state */
641 LCM_FL_WRITE_PENDING = 2,
642 LCM_FL_SYNC_PENDING = 3,
643 LCM_FL_FLR_MASK = 0x3,
646 struct lov_comp_md_v1 {
647 __u32 lcm_magic; /* LOV_USER_MAGIC_COMP_V1 */
648 __u32 lcm_size; /* overall size including this struct */
649 __u32 lcm_layout_gen;
651 __u16 lcm_entry_count;
652 /* lcm_mirror_count stores the number of actual mirrors minus 1,
653 * so that non-flr files will have value 0 meaning 1 mirror. */
654 __u16 lcm_mirror_count;
655 __u16 lcm_padding1[3];
657 struct lov_comp_md_entry_v1 lcm_entries[0];
658 } __attribute__((packed));
660 static inline __u32 lov_user_md_size(__u16 stripes, __u32 lmm_magic)
662 if (stripes == (__u16)-1)
665 if (lmm_magic == LOV_USER_MAGIC_V1)
666 return sizeof(struct lov_user_md_v1) +
667 stripes * sizeof(struct lov_user_ost_data_v1);
668 return sizeof(struct lov_user_md_v3) +
669 stripes * sizeof(struct lov_user_ost_data_v1);
672 /* Compile with -D_LARGEFILE64_SOURCE or -D_GNU_SOURCE (or #define) to
673 * use this. It is unsafe to #define those values in this header as it
674 * is possible the application has already #included <sys/stat.h>. */
675 #ifdef HAVE_LOV_USER_MDS_DATA
676 #define lov_user_mds_data lov_user_mds_data_v1
677 struct lov_user_mds_data_v1 {
678 lstat_t lmd_st; /* MDS stat struct */
679 struct lov_user_md_v1 lmd_lmm; /* LOV EA V1 user data */
680 } __attribute__((packed));
682 struct lov_user_mds_data_v3 {
683 lstat_t lmd_st; /* MDS stat struct */
684 struct lov_user_md_v3 lmd_lmm; /* LOV EA V3 user data */
685 } __attribute__((packed));
688 struct lmv_user_mds_data {
689 struct lu_fid lum_fid;
695 LMV_HASH_TYPE_UNKNOWN = 0, /* 0 is reserved for testing purpose */
696 LMV_HASH_TYPE_ALL_CHARS = 1,
697 LMV_HASH_TYPE_FNV_1A_64 = 2,
701 #define LMV_HASH_NAME_ALL_CHARS "all_char"
702 #define LMV_HASH_NAME_FNV_1A_64 "fnv_1a_64"
704 extern char *mdt_hash_name[LMV_HASH_TYPE_MAX];
706 /* Got this according to how get LOV_MAX_STRIPE_COUNT, see above,
707 * (max buffer size - lmv+rpc header) / sizeof(struct lmv_user_mds_data) */
708 #define LMV_MAX_STRIPE_COUNT 2000 /* ((12 * 4096 - 256) / 24) */
709 #define lmv_user_md lmv_user_md_v1
710 struct lmv_user_md_v1 {
711 __u32 lum_magic; /* must be the first field */
712 __u32 lum_stripe_count; /* dirstripe count */
713 __u32 lum_stripe_offset; /* MDT idx for default dirstripe */
714 __u32 lum_hash_type; /* Dir stripe policy */
715 __u32 lum_type; /* LMV type: default or normal */
719 char lum_pool_name[LOV_MAXPOOLNAME + 1];
720 struct lmv_user_mds_data lum_objects[0];
721 } __attribute__((packed));
723 static inline int lmv_user_md_size(int stripes, int lmm_magic)
725 return sizeof(struct lmv_user_md) +
726 stripes * sizeof(struct lmv_user_mds_data);
729 struct ll_recreate_obj {
735 __u64 id; /* holds object id */
736 __u32 generation; /* holds object generation */
737 __u32 f_type; /* holds object type or stripe idx when passing it to
738 * OST for saving into EA. */
746 static inline bool obd_uuid_equals(const struct obd_uuid *u1,
747 const struct obd_uuid *u2)
749 return strcmp((char *)u1->uuid, (char *)u2->uuid) == 0;
752 static inline int obd_uuid_empty(struct obd_uuid *uuid)
754 return uuid->uuid[0] == '\0';
757 static inline void obd_str2uuid(struct obd_uuid *uuid, const char *tmp)
759 strncpy((char *)uuid->uuid, tmp, sizeof(*uuid));
760 uuid->uuid[sizeof(*uuid) - 1] = '\0';
763 /* For printf's only, make sure uuid is terminated */
764 static inline char *obd_uuid2str(const struct obd_uuid *uuid)
769 if (uuid->uuid[sizeof(*uuid) - 1] != '\0') {
770 /* Obviously not safe, but for printfs, no real harm done...
771 we're always null-terminated, even in a race. */
772 static char temp[sizeof(*uuid)];
773 memcpy(temp, uuid->uuid, sizeof(*uuid) - 1);
774 temp[sizeof(*uuid) - 1] = '\0';
777 return (char *)(uuid->uuid);
780 #define LUSTRE_MAXFSNAME 8
782 /* Extract fsname from uuid (or target name) of a target
783 e.g. (myfs-OST0007_UUID -> myfs)
784 see also deuuidify. */
785 static inline void obd_uuid2fsname(char *buf, char *uuid, int buflen)
789 strncpy(buf, uuid, buflen - 1);
790 buf[buflen - 1] = '\0';
791 p = strrchr(buf, '-');
796 /* printf display format for Lustre FIDs
797 * usage: printf("file FID is "DFID"\n", PFID(fid)); */
798 #define FID_NOBRACE_LEN 40
799 #define FID_LEN (FID_NOBRACE_LEN + 2)
800 #define DFID_NOBRACE "%#llx:0x%x:0x%x"
801 #define DFID "["DFID_NOBRACE"]"
802 #define PFID(fid) (unsigned long long)(fid)->f_seq, (fid)->f_oid, (fid)->f_ver
804 /* scanf input parse format for fids in DFID_NOBRACE format
805 * Need to strip '[' from DFID format first or use "["SFID"]" at caller.
806 * usage: sscanf(fidstr, SFID, RFID(&fid)); */
807 #define SFID "0x%llx:0x%x:0x%x"
808 #define RFID(fid) &((fid)->f_seq), &((fid)->f_oid), &((fid)->f_ver)
810 /********* Quotas **********/
812 #define LUSTRE_QUOTABLOCK_BITS 10
813 #define LUSTRE_QUOTABLOCK_SIZE (1 << LUSTRE_QUOTABLOCK_BITS)
815 static inline __u64 lustre_stoqb(size_t space)
817 return (space + LUSTRE_QUOTABLOCK_SIZE - 1) >> LUSTRE_QUOTABLOCK_BITS;
820 #define Q_QUOTACHECK 0x800100 /* deprecated as of 2.4 */
821 #define Q_INITQUOTA 0x800101 /* deprecated as of 2.4 */
822 #define Q_GETOINFO 0x800102 /* get obd quota info */
823 #define Q_GETOQUOTA 0x800103 /* get obd quotas */
824 #define Q_FINVALIDATE 0x800104 /* deprecated as of 2.4 */
826 /* these must be explicitly translated into linux Q_* in ll_dir_ioctl */
827 #define LUSTRE_Q_QUOTAON 0x800002 /* deprecated as of 2.4 */
828 #define LUSTRE_Q_QUOTAOFF 0x800003 /* deprecated as of 2.4 */
829 #define LUSTRE_Q_GETINFO 0x800005 /* get information about quota files */
830 #define LUSTRE_Q_SETINFO 0x800006 /* set information about quota files */
831 #define LUSTRE_Q_GETQUOTA 0x800007 /* get user quota structure */
832 #define LUSTRE_Q_SETQUOTA 0x800008 /* set user quota structure */
833 /* lustre-specific control commands */
834 #define LUSTRE_Q_INVALIDATE 0x80000b /* deprecated as of 2.4 */
835 #define LUSTRE_Q_FINVALIDATE 0x80000c /* deprecated as of 2.4 */
837 #define ALLQUOTA 255 /* set all quota */
838 static inline char *qtype_name(int qtype)
851 #define IDENTITY_DOWNCALL_MAGIC 0x6d6dd629
854 #define N_PERMS_MAX 64
856 struct perm_downcall_data {
862 struct identity_downcall_data {
869 struct perm_downcall_data idd_perms[N_PERMS_MAX];
873 #ifdef NEED_QUOTA_DEFS
875 #define QIF_BLIMITS 1
877 #define QIF_ILIMITS 4
881 #define QIF_LIMITS (QIF_BLIMITS | QIF_ILIMITS)
882 #define QIF_USAGE (QIF_SPACE | QIF_INODES)
883 #define QIF_TIMES (QIF_BTIME | QIF_ITIME)
884 #define QIF_ALL (QIF_LIMITS | QIF_USAGE | QIF_TIMES)
887 #endif /* !__KERNEL__ */
889 /* lustre volatile file support
890 * file name header: ".^L^S^T^R:volatile"
892 #define LUSTRE_VOLATILE_HDR ".\x0c\x13\x14\x12:VOLATILE"
893 #define LUSTRE_VOLATILE_HDR_LEN 14
895 typedef enum lustre_quota_version {
897 } lustre_quota_version_t;
899 /* XXX: same as if_dqinfo struct in kernel */
907 /* XXX: same as if_dqblk struct in kernel, plus one padding */
909 __u64 dqb_bhardlimit;
910 __u64 dqb_bsoftlimit;
912 __u64 dqb_ihardlimit;
913 __u64 dqb_isoftlimit;
935 struct obd_dqinfo qc_dqinfo;
936 struct obd_dqblk qc_dqblk;
938 struct obd_uuid obd_uuid;
941 /* swap layout flags */
942 #define SWAP_LAYOUTS_CHECK_DV1 (1 << 0)
943 #define SWAP_LAYOUTS_CHECK_DV2 (1 << 1)
944 #define SWAP_LAYOUTS_KEEP_MTIME (1 << 2)
945 #define SWAP_LAYOUTS_KEEP_ATIME (1 << 3)
946 #define SWAP_LAYOUTS_CLOSE (1 << 4)
948 /* Swap XATTR_NAME_HSM as well, only on the MDT so far */
949 #define SWAP_LAYOUTS_MDS_HSM (1 << 31)
950 struct lustre_swap_layouts {
958 /** Bit-mask of valid attributes */
959 /* The LA_* flags are written to disk as part of the ChangeLog records
960 * so they are part of the on-disk and network protocol, and cannot be changed.
961 * Only the first 12 bits are currently saved.
976 LA_BLKSIZE = 1 << 12,
977 LA_KILL_SUID = 1 << 13,
978 LA_KILL_SGID = 1 << 14,
980 LA_LAYOUT_VERSION = 1 << 16,
982 * Attributes must be transmitted to OST objects
984 LA_REMOTE_ATTR_SET = (LA_UID | LA_GID | LA_PROJID | LA_LAYOUT_VERSION)
988 #define FMODE_READ 00000001
989 #define FMODE_WRITE 00000002
992 #define MDS_FMODE_CLOSED 00000000
993 #define MDS_FMODE_EXEC 00000004
994 /* MDS_FMODE_EPOCH 01000000 obsolete since 2.8.0 */
995 /* MDS_FMODE_TRUNC 02000000 obsolete since 2.8.0 */
996 /* MDS_FMODE_SOM 04000000 obsolete since 2.8.0 */
998 #define MDS_OPEN_CREATED 00000010
999 #define MDS_OPEN_CROSS 00000020
1001 #define MDS_OPEN_CREAT 00000100
1002 #define MDS_OPEN_EXCL 00000200
1003 #define MDS_OPEN_TRUNC 00001000
1004 #define MDS_OPEN_APPEND 00002000
1005 #define MDS_OPEN_SYNC 00010000
1006 #define MDS_OPEN_DIRECTORY 00200000
1008 #define MDS_OPEN_BY_FID 040000000 /* open_by_fid for known object */
1009 #define MDS_OPEN_DELAY_CREATE 0100000000 /* delay initial object create */
1010 #define MDS_OPEN_OWNEROVERRIDE 0200000000 /* NFSD rw-reopen ro file for owner */
1011 #define MDS_OPEN_JOIN_FILE 0400000000 /* open for join file.
1012 * We do not support JOIN FILE
1013 * anymore, reserve this flags
1014 * just for preventing such bit
1017 #define MDS_OPEN_LOCK 04000000000 /* This open requires open lock */
1018 #define MDS_OPEN_HAS_EA 010000000000 /* specify object create pattern */
1019 #define MDS_OPEN_HAS_OBJS 020000000000 /* Just set the EA the obj exist */
1020 #define MDS_OPEN_NORESTORE 0100000000000ULL /* Do not restore file at open */
1021 #define MDS_OPEN_NEWSTRIPE 0200000000000ULL /* New stripe needed (restripe or
1023 #define MDS_OPEN_VOLATILE 0400000000000ULL /* File is volatile = created
1025 #define MDS_OPEN_LEASE 01000000000000ULL /* Open the file and grant lease
1026 * delegation, succeed if it's not
1027 * being opened with conflict mode.
1029 #define MDS_OPEN_RELEASE 02000000000000ULL /* Open the file for HSM release */
1031 #define MDS_OPEN_RESYNC 04000000000000ULL /* FLR: file resync */
1033 /* lustre internal open flags, which should not be set from user space */
1034 #define MDS_OPEN_FL_INTERNAL (MDS_OPEN_HAS_EA | MDS_OPEN_HAS_OBJS | \
1035 MDS_OPEN_OWNEROVERRIDE | MDS_OPEN_LOCK | \
1036 MDS_OPEN_BY_FID | MDS_OPEN_LEASE | \
1037 MDS_OPEN_RELEASE | MDS_OPEN_RESYNC)
1040 /********* Changelogs **********/
1041 /** Changelog record types */
1042 enum changelog_rec_type {
1044 CL_CREATE = 1, /* namespace */
1045 CL_MKDIR = 2, /* namespace */
1046 CL_HARDLINK = 3, /* namespace */
1047 CL_SOFTLINK = 4, /* namespace */
1048 CL_MKNOD = 5, /* namespace */
1049 CL_UNLINK = 6, /* namespace */
1050 CL_RMDIR = 7, /* namespace */
1051 CL_RENAME = 8, /* namespace */
1052 CL_EXT = 9, /* namespace extended record (2nd half of rename) */
1053 CL_OPEN = 10, /* not currently used */
1054 CL_CLOSE = 11, /* may be written to log only with mtime change */
1055 CL_LAYOUT = 12, /* file layout/striping modified */
1059 CL_XATTR = CL_SETXATTR, /* Deprecated name */
1060 CL_HSM = 16, /* HSM specific events, see flags */
1061 CL_MTIME = 17, /* Precedence: setattr > mtime > ctime > atime */
1065 CL_FLRW = 21, /* FLR: file was firstly written */
1066 CL_RESYNC = 22, /* FLR: file was resync-ed */
1068 CL_DN_OPEN = 24, /* denied open */
1072 static inline const char *changelog_type2str(int type) {
1073 static const char *changelog_str[] = {
1074 "MARK", "CREAT", "MKDIR", "HLINK", "SLINK", "MKNOD", "UNLNK",
1075 "RMDIR", "RENME", "RNMTO", "OPEN", "CLOSE", "LYOUT", "TRUNC",
1076 "SATTR", "XATTR", "HSM", "MTIME", "CTIME", "ATIME", "MIGRT",
1077 "FLRW", "RESYNC","GXATR", "NOPEN",
1080 if (type >= 0 && type < CL_LAST)
1081 return changelog_str[type];
1085 /* per-record flags */
1086 #define CLF_FLAGSHIFT 12
1087 #define CLF_FLAGMASK ((1U << CLF_FLAGSHIFT) - 1)
1088 #define CLF_VERMASK (~CLF_FLAGMASK)
1089 enum changelog_rec_flags {
1090 CLF_VERSION = 0x1000,
1091 CLF_RENAME = 0x2000,
1093 CLF_EXTRA_FLAGS = 0x8000,
1094 CLF_SUPPORTED = CLF_VERSION | CLF_RENAME | CLF_JOBID | CLF_EXTRA_FLAGS
1098 /* Anything under the flagmask may be per-type (if desired) */
1099 /* Flags for unlink */
1100 #define CLF_UNLINK_LAST 0x0001 /* Unlink of last hardlink */
1101 #define CLF_UNLINK_HSM_EXISTS 0x0002 /* File has something in HSM */
1102 /* HSM cleaning needed */
1103 /* Flags for rename */
1104 #define CLF_RENAME_LAST 0x0001 /* rename unlink last hardlink
1106 #define CLF_RENAME_LAST_EXISTS 0x0002 /* rename unlink last hardlink of target
1107 * has an archive in backend */
1110 /* 12b used (from high weight to low weight):
1115 #define CLF_HSM_ERR_L 0 /* HSM return code, 7 bits */
1116 #define CLF_HSM_ERR_H 6
1117 #define CLF_HSM_EVENT_L 7 /* HSM event, 3 bits, see enum hsm_event */
1118 #define CLF_HSM_EVENT_H 9
1119 #define CLF_HSM_FLAG_L 10 /* HSM flags, 2 bits, 1 used, 1 spare */
1120 #define CLF_HSM_FLAG_H 11
1121 #define CLF_HSM_SPARE_L 12 /* 4 spare bits */
1122 #define CLF_HSM_SPARE_H 15
1123 #define CLF_HSM_LAST 15
1125 /* Remove bits higher than _h, then extract the value
1126 * between _h and _l by shifting lower weigth to bit 0. */
1127 #define CLF_GET_BITS(_b, _h, _l) (((_b << (CLF_HSM_LAST - _h)) & 0xFFFF) \
1128 >> (CLF_HSM_LAST - _h + _l))
1130 #define CLF_HSM_SUCCESS 0x00
1131 #define CLF_HSM_MAXERROR 0x7E
1132 #define CLF_HSM_ERROVERFLOW 0x7F
1134 #define CLF_HSM_DIRTY 1 /* file is dirty after HSM request end */
1136 /* 3 bits field => 8 values allowed */
1148 static inline enum hsm_event hsm_get_cl_event(__u16 flags)
1150 return (enum hsm_event)CLF_GET_BITS(flags, CLF_HSM_EVENT_H,
1154 static inline void hsm_set_cl_event(int *flags, enum hsm_event he)
1156 *flags |= (he << CLF_HSM_EVENT_L);
1159 static inline __u16 hsm_get_cl_flags(int flags)
1161 return CLF_GET_BITS(flags, CLF_HSM_FLAG_H, CLF_HSM_FLAG_L);
1164 static inline void hsm_set_cl_flags(int *flags, int bits)
1166 *flags |= (bits << CLF_HSM_FLAG_L);
1169 static inline int hsm_get_cl_error(int flags)
1171 return CLF_GET_BITS(flags, CLF_HSM_ERR_H, CLF_HSM_ERR_L);
1174 static inline void hsm_set_cl_error(int *flags, int error)
1176 *flags |= (error << CLF_HSM_ERR_L);
1179 enum changelog_rec_extra_flags {
1181 CLFE_UIDGID = 0x0001,
1184 CLFE_XATTR = 0x0008,
1185 CLFE_SUPPORTED = CLFE_UIDGID | CLFE_NID | CLFE_OPEN | CLFE_XATTR
1188 enum changelog_send_flag {
1189 /* Not yet implemented */
1190 CHANGELOG_FLAG_FOLLOW = 0x01,
1191 /* Blocking IO makes sense in case of slow user parsing of the records,
1192 * but it also prevents us from cleaning up if the records are not
1194 CHANGELOG_FLAG_BLOCK = 0x02,
1195 /* Pack jobid into the changelog records if available. */
1196 CHANGELOG_FLAG_JOBID = 0x04,
1197 /* Pack additional flag bits into the changelog record */
1198 CHANGELOG_FLAG_EXTRA_FLAGS = 0x08,
1201 enum changelog_send_extra_flag {
1202 /* Pack uid/gid into the changelog record */
1203 CHANGELOG_EXTRA_FLAG_UIDGID = 0x01,
1204 /* Pack nid into the changelog record */
1205 CHANGELOG_EXTRA_FLAG_NID = 0x02,
1206 /* Pack open mode into the changelog record */
1207 CHANGELOG_EXTRA_FLAG_OMODE = 0x04,
1208 /* Pack xattr name into the changelog record */
1209 CHANGELOG_EXTRA_FLAG_XATTR = 0x08,
1212 #define CR_MAXSIZE cfs_size_round(2 * NAME_MAX + 2 + \
1213 changelog_rec_offset(CLF_SUPPORTED, \
1216 /* 31 usable bytes string + null terminator. */
1217 #define LUSTRE_JOBID_SIZE 32
1219 /* This is the minimal changelog record. It can contain extensions
1220 * such as rename fields or process jobid. Its exact content is described
1221 * by the cr_flags and cr_extra_flags.
1223 * Extensions are packed in the same order as their corresponding flags,
1224 * then in the same order as their corresponding extra flags.
1226 struct changelog_rec {
1228 __u16 cr_flags; /**< \a changelog_rec_flags */
1229 __u32 cr_type; /**< \a changelog_rec_type */
1230 __u64 cr_index; /**< changelog record number */
1231 __u64 cr_prev; /**< last index for this target fid */
1234 struct lu_fid cr_tfid; /**< target fid */
1235 __u32 cr_markerflags; /**< CL_MARK flags */
1237 struct lu_fid cr_pfid; /**< parent fid */
1240 /* Changelog extension for RENAME. */
1241 struct changelog_ext_rename {
1242 struct lu_fid cr_sfid; /**< source fid, or zero */
1243 struct lu_fid cr_spfid; /**< source parent fid, or zero */
1246 /* Changelog extension to include JOBID. */
1247 struct changelog_ext_jobid {
1248 char cr_jobid[LUSTRE_JOBID_SIZE]; /**< zero-terminated string. */
1251 /* Changelog extension to include additional flags. */
1252 struct changelog_ext_extra_flags {
1253 __u64 cr_extra_flags; /* Additional CLFE_* flags */
1256 /* Changelog extra extension to include UID/GID. */
1257 struct changelog_ext_uidgid {
1262 /* Changelog extra extension to include NID. */
1263 struct changelog_ext_nid {
1264 /* have __u64 instead of lnet_nid_t type for use by client api */
1266 /* for use when IPv6 support is added */
1271 /* Changelog extra extension to include OPEN mode. */
1272 struct changelog_ext_openmode {
1276 /* Changelog extra extension to include xattr */
1277 struct changelog_ext_xattr {
1278 char cr_xattr[XATTR_NAME_MAX + 1]; /**< zero-terminated string. */
1281 static inline struct changelog_ext_extra_flags *changelog_rec_extra_flags(
1282 const struct changelog_rec *rec);
1284 static inline size_t changelog_rec_offset(enum changelog_rec_flags crf,
1285 enum changelog_rec_extra_flags cref)
1287 size_t size = sizeof(struct changelog_rec);
1289 if (crf & CLF_RENAME)
1290 size += sizeof(struct changelog_ext_rename);
1292 if (crf & CLF_JOBID)
1293 size += sizeof(struct changelog_ext_jobid);
1295 if (crf & CLF_EXTRA_FLAGS) {
1296 size += sizeof(struct changelog_ext_extra_flags);
1297 if (cref & CLFE_UIDGID)
1298 size += sizeof(struct changelog_ext_uidgid);
1299 if (cref & CLFE_NID)
1300 size += sizeof(struct changelog_ext_nid);
1301 if (cref & CLFE_OPEN)
1302 size += sizeof(struct changelog_ext_openmode);
1303 if (cref & CLFE_XATTR)
1304 size += sizeof(struct changelog_ext_xattr);
1310 static inline size_t changelog_rec_size(const struct changelog_rec *rec)
1312 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1314 if (rec->cr_flags & CLF_EXTRA_FLAGS)
1315 cref = changelog_rec_extra_flags(rec)->cr_extra_flags;
1317 return changelog_rec_offset(rec->cr_flags, cref);
1320 static inline size_t changelog_rec_varsize(const struct changelog_rec *rec)
1322 return changelog_rec_size(rec) - sizeof(*rec) + rec->cr_namelen;
1326 struct changelog_ext_rename *changelog_rec_rename(const struct changelog_rec *rec)
1328 enum changelog_rec_flags crf = rec->cr_flags & CLF_VERSION;
1330 return (struct changelog_ext_rename *)((char *)rec +
1331 changelog_rec_offset(crf,
1335 /* The jobid follows the rename extension, if present */
1337 struct changelog_ext_jobid *changelog_rec_jobid(const struct changelog_rec *rec)
1339 enum changelog_rec_flags crf = rec->cr_flags &
1340 (CLF_VERSION | CLF_RENAME);
1342 return (struct changelog_ext_jobid *)((char *)rec +
1343 changelog_rec_offset(crf,
1347 /* The additional flags follow the rename and jobid extensions, if present */
1349 struct changelog_ext_extra_flags *changelog_rec_extra_flags(
1350 const struct changelog_rec *rec)
1352 enum changelog_rec_flags crf = rec->cr_flags &
1353 (CLF_VERSION | CLF_RENAME | CLF_JOBID);
1355 return (struct changelog_ext_extra_flags *)((char *)rec +
1356 changelog_rec_offset(crf,
1360 /* The uid/gid is the first extra extension */
1362 struct changelog_ext_uidgid *changelog_rec_uidgid(
1363 const struct changelog_rec *rec)
1365 enum changelog_rec_flags crf = rec->cr_flags &
1366 (CLF_VERSION | CLF_RENAME | CLF_JOBID | CLF_EXTRA_FLAGS);
1368 return (struct changelog_ext_uidgid *)((char *)rec +
1369 changelog_rec_offset(crf,
1373 /* The nid is the second extra extension */
1375 struct changelog_ext_nid *changelog_rec_nid(const struct changelog_rec *rec)
1377 enum changelog_rec_flags crf = rec->cr_flags &
1378 (CLF_VERSION | CLF_RENAME | CLF_JOBID | CLF_EXTRA_FLAGS);
1379 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1381 if (rec->cr_flags & CLF_EXTRA_FLAGS)
1382 cref = changelog_rec_extra_flags(rec)->cr_extra_flags &
1385 return (struct changelog_ext_nid *)((char *)rec +
1386 changelog_rec_offset(crf, cref));
1389 /* The OPEN mode is the third extra extension */
1391 struct changelog_ext_openmode *changelog_rec_openmode(
1392 const struct changelog_rec *rec)
1394 enum changelog_rec_flags crf = rec->cr_flags &
1395 (CLF_VERSION | CLF_RENAME | CLF_JOBID | CLF_EXTRA_FLAGS);
1396 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1398 if (rec->cr_flags & CLF_EXTRA_FLAGS)
1399 cref = changelog_rec_extra_flags(rec)->cr_extra_flags &
1400 (CLFE_UIDGID | CLFE_NID);
1402 return (struct changelog_ext_openmode *)((char *)rec +
1403 changelog_rec_offset(crf, cref));
1406 /* The xattr name is the fourth extra extension */
1408 struct changelog_ext_xattr *changelog_rec_xattr(
1409 const struct changelog_rec *rec)
1411 enum changelog_rec_flags crf = rec->cr_flags &
1412 (CLF_VERSION | CLF_RENAME | CLF_JOBID | CLF_EXTRA_FLAGS);
1413 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1415 if (rec->cr_flags & CLF_EXTRA_FLAGS)
1416 cref = changelog_rec_extra_flags(rec)->cr_extra_flags &
1417 (CLFE_UIDGID | CLFE_NID | CLFE_OPEN);
1419 return (struct changelog_ext_xattr *)((char *)rec +
1420 changelog_rec_offset(crf, cref));
1423 /* The name follows the rename, jobid and extra flags extns, if present */
1424 static inline char *changelog_rec_name(const struct changelog_rec *rec)
1426 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1428 if (rec->cr_flags & CLF_EXTRA_FLAGS)
1429 cref = changelog_rec_extra_flags(rec)->cr_extra_flags;
1431 return (char *)rec + changelog_rec_offset(rec->cr_flags & CLF_SUPPORTED,
1432 cref & CLFE_SUPPORTED);
1435 static inline size_t changelog_rec_snamelen(const struct changelog_rec *rec)
1437 return rec->cr_namelen - strlen(changelog_rec_name(rec)) - 1;
1440 static inline char *changelog_rec_sname(const struct changelog_rec *rec)
1442 char *cr_name = changelog_rec_name(rec);
1444 return cr_name + strlen(cr_name) + 1;
1448 * Remap a record to the desired format as specified by the crf flags.
1449 * The record must be big enough to contain the final remapped version.
1450 * Superfluous extension fields are removed and missing ones are added
1451 * and zeroed. The flags of the record are updated accordingly.
1453 * The jobid and rename extensions can be added to a record, to match the
1454 * format an application expects, typically. In this case, the newly added
1455 * fields will be zeroed.
1456 * The Jobid field can be removed, to guarantee compatibility with older
1457 * clients that don't expect this field in the records they process.
1459 * The following assumptions are being made:
1460 * - CLF_RENAME will not be removed
1461 * - CLF_JOBID will not be added without CLF_RENAME being added too
1462 * - CLF_EXTRA_FLAGS will not be added without CLF_JOBID being added too
1464 * @param[in,out] rec The record to remap.
1465 * @param[in] crf_wanted Flags describing the desired extensions.
1466 * @param[in] cref_want Flags describing the desired extra extensions.
1468 static inline void changelog_remap_rec(struct changelog_rec *rec,
1469 enum changelog_rec_flags crf_wanted,
1470 enum changelog_rec_extra_flags cref_want)
1472 char *xattr_mov = NULL;
1473 char *omd_mov = NULL;
1474 char *nid_mov = NULL;
1475 char *uidgid_mov = NULL;
1479 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1481 crf_wanted &= CLF_SUPPORTED;
1482 cref_want &= CLFE_SUPPORTED;
1484 if ((rec->cr_flags & CLF_SUPPORTED) == crf_wanted) {
1485 if (!(rec->cr_flags & CLF_EXTRA_FLAGS) ||
1486 (rec->cr_flags & CLF_EXTRA_FLAGS &&
1487 (changelog_rec_extra_flags(rec)->cr_extra_flags &
1493 /* First move the variable-length name field */
1494 memmove((char *)rec + changelog_rec_offset(crf_wanted, cref_want),
1495 changelog_rec_name(rec), rec->cr_namelen);
1497 /* Locations of extensions in the remapped record */
1498 if (rec->cr_flags & CLF_EXTRA_FLAGS) {
1499 xattr_mov = (char *)rec +
1500 changelog_rec_offset(crf_wanted & CLF_SUPPORTED,
1501 cref_want & ~CLFE_XATTR);
1502 omd_mov = (char *)rec +
1503 changelog_rec_offset(crf_wanted & CLF_SUPPORTED,
1504 cref_want & ~(CLFE_OPEN |
1506 nid_mov = (char *)rec +
1507 changelog_rec_offset(crf_wanted & CLF_SUPPORTED,
1508 cref_want & ~(CLFE_NID |
1511 uidgid_mov = (char *)rec +
1512 changelog_rec_offset(crf_wanted & CLF_SUPPORTED,
1513 cref_want & ~(CLFE_UIDGID |
1517 cref = changelog_rec_extra_flags(rec)->cr_extra_flags;
1520 ef_mov = (char *)rec +
1521 changelog_rec_offset(crf_wanted & ~CLF_EXTRA_FLAGS,
1523 jid_mov = (char *)rec +
1524 changelog_rec_offset(crf_wanted &
1525 ~(CLF_EXTRA_FLAGS | CLF_JOBID),
1527 rnm_mov = (char *)rec +
1528 changelog_rec_offset(crf_wanted &
1534 /* Move the extension fields to the desired positions */
1535 if ((crf_wanted & CLF_EXTRA_FLAGS) &&
1536 (rec->cr_flags & CLF_EXTRA_FLAGS)) {
1537 if ((cref_want & CLFE_XATTR) && (cref & CLFE_XATTR))
1538 memmove(xattr_mov, changelog_rec_xattr(rec),
1539 sizeof(struct changelog_ext_xattr));
1541 if ((cref_want & CLFE_OPEN) && (cref & CLFE_OPEN))
1542 memmove(omd_mov, changelog_rec_openmode(rec),
1543 sizeof(struct changelog_ext_openmode));
1545 if ((cref_want & CLFE_NID) && (cref & CLFE_NID))
1546 memmove(nid_mov, changelog_rec_nid(rec),
1547 sizeof(struct changelog_ext_nid));
1549 if ((cref_want & CLFE_UIDGID) && (cref & CLFE_UIDGID))
1550 memmove(uidgid_mov, changelog_rec_uidgid(rec),
1551 sizeof(struct changelog_ext_uidgid));
1553 memmove(ef_mov, changelog_rec_extra_flags(rec),
1554 sizeof(struct changelog_ext_extra_flags));
1557 if ((crf_wanted & CLF_JOBID) && (rec->cr_flags & CLF_JOBID))
1558 memmove(jid_mov, changelog_rec_jobid(rec),
1559 sizeof(struct changelog_ext_jobid));
1561 if ((crf_wanted & CLF_RENAME) && (rec->cr_flags & CLF_RENAME))
1562 memmove(rnm_mov, changelog_rec_rename(rec),
1563 sizeof(struct changelog_ext_rename));
1565 /* Clear newly added fields */
1566 if (xattr_mov && (cref_want & CLFE_XATTR) &&
1567 !(cref & CLFE_XATTR))
1568 memset(xattr_mov, 0, sizeof(struct changelog_ext_xattr));
1570 if (omd_mov && (cref_want & CLFE_OPEN) &&
1571 !(cref & CLFE_OPEN))
1572 memset(omd_mov, 0, sizeof(struct changelog_ext_openmode));
1574 if (nid_mov && (cref_want & CLFE_NID) &&
1576 memset(nid_mov, 0, sizeof(struct changelog_ext_nid));
1578 if (uidgid_mov && (cref_want & CLFE_UIDGID) &&
1579 !(cref & CLFE_UIDGID))
1580 memset(uidgid_mov, 0, sizeof(struct changelog_ext_uidgid));
1582 if ((crf_wanted & CLF_EXTRA_FLAGS) &&
1583 !(rec->cr_flags & CLF_EXTRA_FLAGS))
1584 memset(ef_mov, 0, sizeof(struct changelog_ext_extra_flags));
1586 if ((crf_wanted & CLF_JOBID) && !(rec->cr_flags & CLF_JOBID))
1587 memset(jid_mov, 0, sizeof(struct changelog_ext_jobid));
1589 if ((crf_wanted & CLF_RENAME) && !(rec->cr_flags & CLF_RENAME))
1590 memset(rnm_mov, 0, sizeof(struct changelog_ext_rename));
1592 /* Update the record's flags accordingly */
1593 rec->cr_flags = (rec->cr_flags & CLF_FLAGMASK) | crf_wanted;
1594 if (rec->cr_flags & CLF_EXTRA_FLAGS)
1595 changelog_rec_extra_flags(rec)->cr_extra_flags =
1596 changelog_rec_extra_flags(rec)->cr_extra_flags |
1600 enum changelog_message_type {
1601 CL_RECORD = 10, /* message is a changelog_rec */
1602 CL_EOF = 11, /* at end of current changelog */
1605 /********* Misc **********/
1607 struct ioc_data_version {
1609 __u32 idv_layout_version; /* FLR: layout version for OST objects */
1610 __u32 idv_flags; /* enum ioc_data_version_flags */
1613 enum ioc_data_version_flags {
1614 LL_DV_RD_FLUSH = (1 << 0), /* Flush dirty pages from clients */
1615 LL_DV_WR_FLUSH = (1 << 1), /* Flush all caching pages from clients */
1619 #define offsetof(typ, memb) ((unsigned long)((char *)&(((typ *)0)->memb)))
1622 #define dot_lustre_name ".lustre"
1625 /********* HSM **********/
1627 /** HSM per-file state
1628 * See HSM_FLAGS below.
1631 HS_NONE = 0x00000000,
1632 HS_EXISTS = 0x00000001,
1633 HS_DIRTY = 0x00000002,
1634 HS_RELEASED = 0x00000004,
1635 HS_ARCHIVED = 0x00000008,
1636 HS_NORELEASE = 0x00000010,
1637 HS_NOARCHIVE = 0x00000020,
1638 HS_LOST = 0x00000040,
1641 /* HSM user-setable flags. */
1642 #define HSM_USER_MASK (HS_NORELEASE | HS_NOARCHIVE | HS_DIRTY)
1644 /* Other HSM flags. */
1645 #define HSM_STATUS_MASK (HS_EXISTS | HS_LOST | HS_RELEASED | HS_ARCHIVED)
1648 * All HSM-related possible flags that could be applied to a file.
1649 * This should be kept in sync with hsm_states.
1651 #define HSM_FLAGS_MASK (HSM_USER_MASK | HSM_STATUS_MASK)
1654 * HSMÂ request progress state
1656 enum hsm_progress_states {
1663 static inline const char *hsm_progress_state2name(enum hsm_progress_states s)
1666 case HPS_WAITING: return "waiting";
1667 case HPS_RUNNING: return "running";
1668 case HPS_DONE: return "done";
1669 default: return "unknown";
1676 } __attribute__((packed));
1679 * Current HSM states of a Lustre file.
1681 * This structure purpose is to be sent to user-space mainly. It describes the
1682 * current HSM flags and in-progress action.
1684 struct hsm_user_state {
1685 /** Current HSM states, from enum hsm_states. */
1687 __u32 hus_archive_id;
1688 /** The current undergoing action, if there is one */
1689 __u32 hus_in_progress_state;
1690 __u32 hus_in_progress_action;
1691 struct hsm_extent hus_in_progress_location;
1692 char hus_extended_info[];
1695 struct hsm_state_set_ioc {
1696 struct lu_fid hssi_fid;
1698 __u64 hssi_clearmask;
1702 * This structure describes the current in-progress action for a file.
1703 * it is retuned to user space and send over the wire
1705 struct hsm_current_action {
1706 /** The current undergoing action, if there is one */
1707 /* state is one of hsm_progress_states */
1709 /* action is one of hsm_user_action */
1711 struct hsm_extent hca_location;
1714 /***** HSM user requests ******/
1715 /* User-generated (lfs/ioctl) request types */
1716 enum hsm_user_action {
1717 HUA_NONE = 1, /* no action (noop) */
1718 HUA_ARCHIVE = 10, /* copy to hsm */
1719 HUA_RESTORE = 11, /* prestage */
1720 HUA_RELEASE = 12, /* drop ost objects */
1721 HUA_REMOVE = 13, /* remove from archive */
1722 HUA_CANCEL = 14 /* cancel a request */
1725 static inline const char *hsm_user_action2name(enum hsm_user_action a)
1728 case HUA_NONE: return "NOOP";
1729 case HUA_ARCHIVE: return "ARCHIVE";
1730 case HUA_RESTORE: return "RESTORE";
1731 case HUA_RELEASE: return "RELEASE";
1732 case HUA_REMOVE: return "REMOVE";
1733 case HUA_CANCEL: return "CANCEL";
1734 default: return "UNKNOWN";
1739 * List of hr_flags (bit field)
1741 #define HSM_FORCE_ACTION 0x0001
1742 /* used by CT, cannot be set by user */
1743 #define HSM_GHOST_COPY 0x0002
1746 * Contains all the fixed part of struct hsm_user_request.
1749 struct hsm_request {
1750 __u32 hr_action; /* enum hsm_user_action */
1751 __u32 hr_archive_id; /* archive id, used only with HUA_ARCHIVE */
1752 __u64 hr_flags; /* request flags */
1753 __u32 hr_itemcount; /* item count in hur_user_item vector */
1757 struct hsm_user_item {
1758 struct lu_fid hui_fid;
1759 struct hsm_extent hui_extent;
1760 } __attribute__((packed));
1762 struct hsm_user_request {
1763 struct hsm_request hur_request;
1764 struct hsm_user_item hur_user_item[0];
1765 /* extra data blob at end of struct (after all
1766 * hur_user_items), only use helpers to access it
1768 } __attribute__((packed));
1770 /** Return pointer to data field in a hsm user request */
1771 static inline void *hur_data(struct hsm_user_request *hur)
1773 return &(hur->hur_user_item[hur->hur_request.hr_itemcount]);
1777 * Compute the current length of the provided hsm_user_request. This returns -1
1778 * instead of an errno because ssize_t is defined to be only [ -1, SSIZE_MAX ]
1780 * return -1 on bounds check error.
1782 static inline ssize_t hur_len(struct hsm_user_request *hur)
1786 /* can't overflow a __u64 since hr_itemcount is only __u32 */
1787 size = offsetof(struct hsm_user_request, hur_user_item[0]) +
1788 (__u64)hur->hur_request.hr_itemcount *
1789 sizeof(hur->hur_user_item[0]) + hur->hur_request.hr_data_len;
1791 if (size != (ssize_t)size)
1797 /****** HSM RPCs to copytool *****/
1798 /* Message types the copytool may receive */
1799 enum hsm_message_type {
1800 HMT_ACTION_LIST = 100, /* message is a hsm_action_list */
1803 /* Actions the copytool may be instructed to take for a given action_item */
1804 enum hsm_copytool_action {
1805 HSMA_NONE = 10, /* no action */
1806 HSMA_ARCHIVE = 20, /* arbitrary offset */
1812 static inline const char *hsm_copytool_action2name(enum hsm_copytool_action a)
1815 case HSMA_NONE: return "NOOP";
1816 case HSMA_ARCHIVE: return "ARCHIVE";
1817 case HSMA_RESTORE: return "RESTORE";
1818 case HSMA_REMOVE: return "REMOVE";
1819 case HSMA_CANCEL: return "CANCEL";
1820 default: return "UNKNOWN";
1824 /* Copytool item action description */
1825 struct hsm_action_item {
1826 __u32 hai_len; /* valid size of this struct */
1827 __u32 hai_action; /* hsm_copytool_action, but use known size */
1828 struct lu_fid hai_fid; /* Lustre FID to operate on */
1829 struct lu_fid hai_dfid; /* fid used for data access */
1830 struct hsm_extent hai_extent; /* byte range to operate on */
1831 __u64 hai_cookie; /* action cookie from coordinator */
1832 __u64 hai_gid; /* grouplock id */
1833 char hai_data[0]; /* variable length */
1834 } __attribute__((packed));
1837 * helper function which print in hexa the first bytes of
1840 * \param hai [IN] record to print
1841 * \param buffer [IN,OUT] buffer to write the hex string to
1842 * \param len [IN] max buffer length
1846 static inline char *hai_dump_data_field(const struct hsm_action_item *hai,
1847 char *buffer, size_t len)
1854 data_len = hai->hai_len - sizeof(*hai);
1855 for (i = 0; (i < data_len) && (len > 2); i++) {
1856 snprintf(ptr, 3, "%02X", (unsigned char)hai->hai_data[i]);
1866 /* Copytool action list */
1867 #define HAL_VERSION 1
1868 #define HAL_MAXSIZE LNET_MTU /* bytes, used in userspace only */
1869 struct hsm_action_list {
1871 __u32 hal_count; /* number of hai's to follow */
1872 __u64 hal_compound_id; /* returned by coordinator */
1874 __u32 hal_archive_id; /* which archive backend */
1876 char hal_fsname[0]; /* null-terminated */
1877 /* struct hsm_action_item[hal_count] follows, aligned on 8-byte
1878 boundaries. See hai_zero */
1879 } __attribute__((packed));
1881 #ifndef HAVE_CFS_SIZE_ROUND
1882 static inline int cfs_size_round (int val)
1884 return (val + 7) & (~0x7);
1886 #define HAVE_CFS_SIZE_ROUND
1889 /* Return pointer to first hai in action list */
1890 static inline struct hsm_action_item *hai_first(struct hsm_action_list *hal)
1892 return (struct hsm_action_item *)(hal->hal_fsname +
1893 cfs_size_round(strlen(hal-> \
1897 /* Return pointer to next hai */
1898 static inline struct hsm_action_item * hai_next(struct hsm_action_item *hai)
1900 return (struct hsm_action_item *)((char *)hai +
1901 cfs_size_round(hai->hai_len));
1904 /* Return size of an hsm_action_list */
1905 static inline size_t hal_size(struct hsm_action_list *hal)
1909 struct hsm_action_item *hai;
1911 sz = sizeof(*hal) + cfs_size_round(strlen(hal->hal_fsname) + 1);
1912 hai = hai_first(hal);
1913 for (i = 0; i < hal->hal_count ; i++, hai = hai_next(hai))
1914 sz += cfs_size_round(hai->hai_len);
1920 * describe the attributes to be set on imported file
1922 struct hsm_user_import {
1931 __u32 hui_archive_id;
1934 /* Copytool progress reporting */
1935 #define HP_FLAG_COMPLETED 0x01
1936 #define HP_FLAG_RETRY 0x02
1938 struct hsm_progress {
1939 struct lu_fid hp_fid;
1941 struct hsm_extent hp_extent;
1943 __u16 hp_errval; /* positive val */
1948 __u64 hc_data_version;
1950 __u16 hc_errval; /* positive val */
1952 struct hsm_action_item hc_hai;
1956 enum llapi_json_types {
1957 LLAPI_JSON_INTEGER = 1,
1963 struct llapi_json_item {
1972 struct llapi_json_item *lji_next;
1975 struct llapi_json_item_list {
1976 int ljil_item_count;
1977 struct llapi_json_item *ljil_items;
1980 enum lu_ladvise_type {
1981 LU_LADVISE_INVALID = 0,
1982 LU_LADVISE_WILLREAD = 1,
1983 LU_LADVISE_DONTNEED = 2,
1984 LU_LADVISE_LOCKNOEXPAND = 3,
1985 LU_LADVISE_LOCKAHEAD = 4,
1989 #define LU_LADVISE_NAMES { \
1990 [LU_LADVISE_WILLREAD] = "willread", \
1991 [LU_LADVISE_DONTNEED] = "dontneed", \
1992 [LU_LADVISE_LOCKNOEXPAND] = "locknoexpand", \
1993 [LU_LADVISE_LOCKAHEAD] = "lockahead", \
1996 /* This is the userspace argument for ladvise. It is currently the same as
1997 * what goes on the wire (struct lu_ladvise), but is defined separately as we
1998 * may need info which is only used locally. */
1999 struct llapi_lu_ladvise {
2000 __u16 lla_advice; /* advice type */
2001 __u16 lla_value1; /* values for different advice types */
2003 __u64 lla_start; /* first byte of extent for advice */
2004 __u64 lla_end; /* last byte of extent for advice */
2010 LF_ASYNC = 0x00000001,
2011 LF_UNSET = 0x00000002,
2014 #define LADVISE_MAGIC 0x1ADF1CE0
2015 /* Masks of valid flags for each advice */
2016 #define LF_LOCKNOEXPAND_MASK LF_UNSET
2017 /* Flags valid for all advices not explicitly specified */
2018 #define LF_DEFAULT_MASK LF_ASYNC
2020 #define LF_MASK (LF_ASYNC | LF_UNSET)
2022 #define lla_lockahead_mode lla_value1
2023 #define lla_peradvice_flags lla_value2
2024 #define lla_lockahead_result lla_value3
2026 /* This is the userspace argument for ladvise, corresponds to ladvise_hdr which
2027 * is used on the wire. It is defined separately as we may need info which is
2028 * only used locally. */
2029 struct llapi_ladvise_hdr {
2030 __u32 lah_magic; /* LADVISE_MAGIC */
2031 __u32 lah_count; /* number of advices */
2032 __u64 lah_flags; /* from enum ladvise_flag */
2033 __u32 lah_value1; /* unused */
2034 __u32 lah_value2; /* unused */
2035 __u64 lah_value3; /* unused */
2036 struct llapi_lu_ladvise lah_advise[0]; /* advices in this header */
2039 #define LAH_COUNT_MAX (1024)
2043 SK_CRYPT_INVALID = -1,
2045 SK_CRYPT_AES256_CTR = 1,
2050 SK_HMAC_INVALID = -1,
2057 struct sk_crypt_type {
2062 struct sk_hmac_type {
2067 enum lock_mode_user {
2073 #define LOCK_MODE_NAMES { \
2074 [MODE_READ_USER] = "READ",\
2075 [MODE_WRITE_USER] = "WRITE"\
2078 enum lockahead_results {
2079 LLA_RESULT_SENT = 0,
2080 LLA_RESULT_DIFFERENT,
2084 #if defined(__cplusplus)
2088 /** @} lustreuser */
2090 #endif /* _LUSTRE_USER_H */