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/kernel.h>
46 #include <linux/types.h>
49 # include <linux/fs.h>
50 # include <linux/quota.h>
51 # include <linux/string.h> /* snprintf() */
52 # include <linux/version.h>
53 # include <uapi/linux/lustre/lustre_fiemap.h>
54 #else /* !__KERNEL__ */
57 # include <stdio.h> /* snprintf() */
60 # define NEED_QUOTA_DEFS
61 /* # include <sys/quota.h> - this causes complaints about caddr_t */
62 # include <sys/stat.h>
63 # include <linux/lustre/lustre_fiemap.h>
64 #endif /* __KERNEL__ */
66 /* Handle older distros */
67 #ifndef __ALIGN_KERNEL
68 # define __ALIGN_KERNEL(x, a) __ALIGN_KERNEL_MASK(x, (typeof(x))(a) - 1)
69 # define __ALIGN_KERNEL_MASK(x, mask) (((x) + (mask)) & ~(mask))
72 #if defined(__cplusplus)
77 * This is a temporary solution of adding quota type.
78 * Should be removed as soon as system header is updated.
81 #define LL_MAXQUOTAS 3
83 #define INITQFNAMES { \
84 "user", /* USRQUOTA */ \
85 "group", /* GRPQUOTA */ \
86 "project", /* PRJQUOTA */ \
100 * We need to always use 64bit version because the structure
101 * is shared across entire cluster where 32bit and 64bit machines
104 #if __BITS_PER_LONG != 64 || defined(__ARCH_WANT_STAT64)
105 typedef struct stat64 lstat_t;
106 #define lstat_f lstat64
107 #define fstat_f fstat64
108 #define fstatat_f fstatat64
110 typedef struct stat lstat_t;
111 #define lstat_f lstat
112 #define fstat_f fstat
113 #define fstatat_f fstatat
116 #define HAVE_LOV_USER_MDS_DATA
118 #define LUSTRE_EOF 0xffffffffffffffffULL
121 #define LL_SUPER_MAGIC 0x0BD00BD0
123 #define FSFILT_IOC_GETVERSION _IOR('f', 3, long)
125 /* FIEMAP flags supported by Lustre */
126 #define LUSTRE_FIEMAP_FLAGS_COMPAT (FIEMAP_FLAG_SYNC | FIEMAP_FLAG_DEVICE_ORDER)
128 enum obd_statfs_state {
129 OS_STATE_DEGRADED = 0x00000001, /**< RAID degraded/rebuilding */
130 OS_STATE_READONLY = 0x00000002, /**< filesystem is read-only */
131 OS_STATE_NOPRECREATE = 0x00000004, /**< no object precreation */
132 OS_STATE_ENOSPC = 0x00000020, /**< not enough free space */
133 OS_STATE_ENOINO = 0x00000040, /**< not enough inodes */
134 OS_STATE_SUM = 0x00000100, /**< aggregated for all tagrets */
137 /** filesystem statistics/attributes for target device */
139 __u64 os_type; /* EXT4_SUPER_MAGIC, UBERBLOCK_MAGIC */
140 __u64 os_blocks; /* total size in #os_bsize blocks */
141 __u64 os_bfree; /* number of unused blocks */
142 __u64 os_bavail; /* blocks available for allocation */
143 __u64 os_files; /* total number of objects */
144 __u64 os_ffree; /* # objects that could be created */
145 __u8 os_fsid[40]; /* identifier for filesystem */
146 __u32 os_bsize; /* block size in bytes for os_blocks */
147 __u32 os_namelen; /* maximum length of filename in bytes*/
148 __u64 os_maxbytes; /* maximum object size in bytes */
149 __u32 os_state; /**< obd_statfs_state OS_STATE_* flag */
150 __u32 os_fprecreated; /* objs available now to the caller */
151 /* used in QoS code to find preferred
153 __u32 os_granted; /* space granted for MDS */
154 __u32 os_spare3; /* Unused padding fields. Remember */
155 __u32 os_spare4; /* to fix lustre_swab_obd_statfs() */
166 * FID is a cluster-wide unique identifier of a file or an object (stripe).
167 * FIDs are never reused.
171 * FID sequence. Sequence is a unit of migration: all files (objects)
172 * with FIDs from a given sequence are stored on the same server.
173 * Lustre should support 2^64 objects, so even if each sequence
174 * has only a single object we can still enumerate 2^64 objects.
177 /* FID number within sequence. */
180 * FID version, used to distinguish different versions (in the sense
181 * of snapshots, etc.) of the same file system object. Not currently
187 static inline bool fid_is_zero(const struct lu_fid *fid)
189 return fid->f_seq == 0 && fid->f_oid == 0;
192 /* Currently, the filter_fid::ff_parent::f_ver is not the real parent
193 * MDT-object's FID::f_ver, instead it is the OST-object index in its
194 * parent MDT-object's layout EA. */
195 #define f_stripe_idx f_ver
198 __u32 ol_stripe_size;
199 __u32 ol_stripe_count;
203 } __attribute__((packed));
205 /* The filter_fid structure has changed several times over its lifetime.
206 * For a long time "trusted.fid" held the MDT inode parent FID/IGIF and
207 * stripe_index and the "self FID" (objid/seq) to be able to recover the
208 * OST objects in case of corruption. With the move to 2.4 and OSD-API for
209 * the OST, the "trusted.lma" xattr was added to the OST objects to store
210 * the "self FID" to be consistent with the MDT on-disk format, and the
211 * filter_fid only stored the MDT inode parent FID and stripe index.
213 * In 2.10, the addition of PFL composite layouts required more information
214 * to be stored into the filter_fid in order to be able to identify which
215 * component the OST object belonged. As well, the stripe size may vary
216 * between components, so it was no longer safe to assume the stripe size
217 * or stripe_count of a file. This is also more robust for plain layouts.
219 * For ldiskfs OSTs that were formatted with 256-byte inodes, there is not
220 * enough space to store both the filter_fid and LMA in the inode, so they
221 * are packed into struct lustre_ost_attrs on disk in trusted.lma to avoid
222 * an extra seek for every OST object access.
224 * In 2.11, FLR mirror layouts also need to store the layout version and
225 * range so that writes to old versions of the layout are not allowed.
226 * That ensures that mirrored objects are not modified by evicted clients,
227 * and ensures that the components are correctly marked stale on the MDT.
229 struct filter_fid_18_23 {
230 struct lu_fid ff_parent; /* stripe_idx in f_ver */
235 struct filter_fid_24_29 {
236 struct lu_fid ff_parent; /* stripe_idx in f_ver */
239 struct filter_fid_210 {
240 struct lu_fid ff_parent; /* stripe_idx in f_ver */
241 struct ost_layout ff_layout;
245 struct lu_fid ff_parent; /* stripe_idx in f_ver */
246 struct ost_layout ff_layout;
247 __u32 ff_layout_version;
248 __u32 ff_range; /* range of layout version that
249 * write are allowed */
250 } __attribute__((packed));
252 /* Userspace should treat lu_fid as opaque, and only use the following methods
253 * to print or parse them. Other functions (e.g. compare, swab) could be moved
254 * here from lustre_idl.h if needed. */
258 LMAC_HSM = 0x00000001,
259 /* LMAC_SOM = 0x00000002, obsolete since 2.8.0 */
260 LMAC_NOT_IN_OI = 0x00000004, /* the object does NOT need OI mapping */
261 LMAC_FID_ON_OST = 0x00000008, /* For OST-object, its OI mapping is
262 * under /O/<seq>/d<x>. */
263 LMAC_STRIPE_INFO = 0x00000010, /* stripe info in the LMA EA. */
264 LMAC_COMP_INFO = 0x00000020, /* Component info in the LMA EA. */
265 LMAC_IDX_BACKUP = 0x00000040, /* Has index backup. */
269 * Masks for all features that should be supported by a Lustre version to
270 * access a specific file.
271 * This information is stored in lustre_mdt_attrs::lma_incompat.
274 LMAI_RELEASED = 0x00000001, /* file is released */
275 LMAI_AGENT = 0x00000002, /* agent inode */
276 LMAI_REMOTE_PARENT = 0x00000004, /* the parent of the object
277 is on the remote MDT */
278 LMAI_STRIPED = 0x00000008, /* striped directory inode */
279 LMAI_ORPHAN = 0x00000010, /* inode is orphan */
280 LMA_INCOMPAT_SUPP = (LMAI_AGENT | LMAI_REMOTE_PARENT | \
281 LMAI_STRIPED | LMAI_ORPHAN)
286 * Following struct for object attributes, that will be kept inode's EA.
287 * Introduced in 2.0 release (please see b15993, for details)
288 * Added to all objects since Lustre 2.4 as contains self FID
290 struct lustre_mdt_attrs {
292 * Bitfield for supported data in this structure. From enum lma_compat.
293 * lma_self_fid and lma_flags are always available.
297 * Per-file incompat feature list. Lustre version should support all
298 * flags set in this field. The supported feature mask is available in
302 /** FID of this inode */
303 struct lu_fid lma_self_fid;
306 struct lustre_ost_attrs {
307 /* Use lustre_mdt_attrs directly for now, need a common header
308 * structure if want to change lustre_mdt_attrs in future. */
309 struct lustre_mdt_attrs loa_lma;
311 /* Below five elements are for OST-object's PFID EA, the
312 * lma_parent_fid::f_ver is composed of the stripe_count (high 16 bits)
313 * and the stripe_index (low 16 bits), the size should not exceed
314 * 5 * sizeof(__u64)) to be accessable by old Lustre. If the flag
315 * LMAC_STRIPE_INFO is set, then loa_parent_fid and loa_stripe_size
316 * are valid; if the flag LMAC_COMP_INFO is set, then the next three
317 * loa_comp_* elements are valid. */
318 struct lu_fid loa_parent_fid;
319 __u32 loa_stripe_size;
321 __u64 loa_comp_start;
326 * Prior to 2.4, the LMA structure also included SOM attributes which has since
327 * been moved to a dedicated xattr
328 * lma_flags was also removed because of lma_compat/incompat fields.
330 #define LMA_OLD_SIZE (sizeof(struct lustre_mdt_attrs) + 5 * sizeof(__u64))
332 enum lustre_som_flags {
333 /* Unknow or no SoM data, must get size from OSTs. */
334 SOM_FL_UNKNOWN = 0x0000,
335 /* Known strictly correct, FLR or DoM file (SoM guaranteed). */
336 SOM_FL_STRICT = 0x0001,
337 /* Known stale - was right at some point in the past, but it is
338 * known (or likely) to be incorrect now (e.g. opened for write). */
339 SOM_FL_STALE = 0x0002,
340 /* Approximate, may never have been strictly correct,
341 * need to sync SOM data to achieve eventual consistency. */
342 SOM_FL_LAZY = 0x0004,
345 struct lustre_som_attrs {
347 __u16 lsa_reserved[3];
353 * OST object IDentifier.
361 struct lu_fid oi_fid;
365 #define DOSTID "%#llx:%llu"
366 #define POSTID(oi) ((unsigned long long)ostid_seq(oi)), \
367 ((unsigned long long)ostid_id(oi))
369 struct ll_futimes_3 {
371 __u64 lfu_atime_nsec;
373 __u64 lfu_mtime_nsec;
375 __u64 lfu_ctime_nsec;
379 * Maximum number of mirrors currently implemented.
381 #define LUSTRE_MIRROR_COUNT_MAX 16
383 /* Lease types for use as arg and return of LL_IOC_{GET,SET}_LEASE ioctl. */
385 LL_LEASE_RDLCK = 0x01,
386 LL_LEASE_WRLCK = 0x02,
387 LL_LEASE_UNLCK = 0x04,
390 enum ll_lease_flags {
391 LL_LEASE_RESYNC = 0x1,
392 LL_LEASE_RESYNC_DONE = 0x2,
393 LL_LEASE_LAYOUT_MERGE = 0x4,
394 LL_LEASE_LAYOUT_SPLIT = 0x8,
397 #define IOC_IDS_MAX 4096
398 struct ll_ioc_lease {
405 struct ll_ioc_lease_id {
416 * The ioctl naming rules:
417 * LL_* - works on the currently opened filehandle instead of parent dir
418 * *_OBD_* - gets data for both OSC or MDC (LOV, LMV indirectly)
419 * *_MDC_* - gets/sets data related to MDC
420 * *_LOV_* - gets/sets data related to OSC/LOV
421 * *FILE* - called on parent dir and passes in a filename
422 * *STRIPE* - set/get lov_user_md
423 * *INFO - set/get lov_user_mds_data
425 /* lustre_ioctl.h 101-150 */
426 #define LL_IOC_GETFLAGS _IOR ('f', 151, long)
427 #define LL_IOC_SETFLAGS _IOW ('f', 152, long)
428 #define LL_IOC_CLRFLAGS _IOW ('f', 153, long)
429 #define LL_IOC_LOV_SETSTRIPE _IOW ('f', 154, long)
430 #define LL_IOC_LOV_SETSTRIPE_NEW _IOWR('f', 154, struct lov_user_md)
431 #define LL_IOC_LOV_GETSTRIPE _IOW ('f', 155, long)
432 #define LL_IOC_LOV_GETSTRIPE_NEW _IOR('f', 155, struct lov_user_md)
433 #define LL_IOC_LOV_SETEA _IOW ('f', 156, long)
434 /* LL_IOC_RECREATE_OBJ 157 obsolete */
435 /* LL_IOC_RECREATE_FID 157 obsolete */
436 #define LL_IOC_GROUP_LOCK _IOW ('f', 158, long)
437 #define LL_IOC_GROUP_UNLOCK _IOW ('f', 159, long)
438 /* LL_IOC_QUOTACHECK 160 OBD_IOC_QUOTACHECK */
439 /* LL_IOC_POLL_QUOTACHECK 161 OBD_IOC_POLL_QUOTACHECK */
440 /* LL_IOC_QUOTACTL 162 OBD_IOC_QUOTACTL */
441 #define IOC_OBD_STATFS _IOWR('f', 164, struct obd_statfs *)
442 /* IOC_LOV_GETINFO 165 obsolete */
443 #define LL_IOC_FLUSHCTX _IOW ('f', 166, long)
444 /* LL_IOC_RMTACL 167 obsolete */
445 #define LL_IOC_GETOBDCOUNT _IOR ('f', 168, long)
446 #define LL_IOC_LLOOP_ATTACH _IOWR('f', 169, long)
447 #define LL_IOC_LLOOP_DETACH _IOWR('f', 170, long)
448 #define LL_IOC_LLOOP_INFO _IOWR('f', 171, struct lu_fid)
449 #define LL_IOC_LLOOP_DETACH_BYDEV _IOWR('f', 172, long)
450 #define LL_IOC_PATH2FID _IOR ('f', 173, long)
451 #define LL_IOC_GET_CONNECT_FLAGS _IOWR('f', 174, __u64 *)
452 #define LL_IOC_GET_MDTIDX _IOR ('f', 175, int)
453 #define LL_IOC_FUTIMES_3 _IOWR('f', 176, struct ll_futimes_3)
454 #define LL_IOC_FLR_SET_MIRROR _IOW ('f', 177, long)
455 /* lustre_ioctl.h 177-210 */
456 #define LL_IOC_HSM_STATE_GET _IOR('f', 211, struct hsm_user_state)
457 #define LL_IOC_HSM_STATE_SET _IOW('f', 212, struct hsm_state_set)
458 #define LL_IOC_HSM_CT_START _IOW('f', 213, struct lustre_kernelcomm)
459 #define LL_IOC_HSM_COPY_START _IOW('f', 214, struct hsm_copy *)
460 #define LL_IOC_HSM_COPY_END _IOW('f', 215, struct hsm_copy *)
461 #define LL_IOC_HSM_PROGRESS _IOW('f', 216, struct hsm_user_request)
462 #define LL_IOC_HSM_REQUEST _IOW('f', 217, struct hsm_user_request)
463 #define LL_IOC_DATA_VERSION _IOR('f', 218, struct ioc_data_version)
464 #define LL_IOC_LOV_SWAP_LAYOUTS _IOW('f', 219, \
465 struct lustre_swap_layouts)
466 #define LL_IOC_HSM_ACTION _IOR('f', 220, \
467 struct hsm_current_action)
468 /* lustre_ioctl.h 221-232 */
469 #define LL_IOC_LMV_SETSTRIPE _IOWR('f', 240, struct lmv_user_md)
470 #define LL_IOC_LMV_GETSTRIPE _IOWR('f', 241, struct lmv_user_md)
471 #define LL_IOC_REMOVE_ENTRY _IOWR('f', 242, __u64)
472 #define LL_IOC_SET_LEASE _IOWR('f', 243, struct ll_ioc_lease)
473 #define LL_IOC_SET_LEASE_OLD _IOWR('f', 243, long)
474 #define LL_IOC_GET_LEASE _IO('f', 244)
475 #define LL_IOC_HSM_IMPORT _IOWR('f', 245, struct hsm_user_import)
476 #define LL_IOC_LMV_SET_DEFAULT_STRIPE _IOWR('f', 246, struct lmv_user_md)
477 #define LL_IOC_MIGRATE _IOR('f', 247, int)
478 #define LL_IOC_FID2MDTIDX _IOWR('f', 248, struct lu_fid)
479 #define LL_IOC_GETPARENT _IOWR('f', 249, struct getparent)
480 #define LL_IOC_LADVISE _IOR('f', 250, struct llapi_lu_ladvise)
481 #define LL_IOC_HEAT_GET _IOWR('f', 251, struct lu_heat)
482 #define LL_IOC_HEAT_SET _IOW('f', 252, long)
484 #ifndef FS_IOC_FSGETXATTR
486 * Structure for FS_IOC_FSGETXATTR and FS_IOC_FSSETXATTR.
489 __u32 fsx_xflags; /* xflags field value (get/set) */
490 __u32 fsx_extsize; /* extsize field value (get/set)*/
491 __u32 fsx_nextents; /* nextents field value (get) */
492 __u32 fsx_projid; /* project identifier (get/set) */
493 unsigned char fsx_pad[12];
495 #define FS_IOC_FSGETXATTR _IOR('X', 31, struct fsxattr)
496 #define FS_IOC_FSSETXATTR _IOW('X', 32, struct fsxattr)
498 #define LL_IOC_FSGETXATTR FS_IOC_FSGETXATTR
499 #define LL_IOC_FSSETXATTR FS_IOC_FSSETXATTR
500 #ifndef FS_XFLAG_PROJINHERIT
501 #define FS_XFLAG_PROJINHERIT 0x00000200
505 #define LL_STATFS_LMV 1
506 #define LL_STATFS_LOV 2
507 #define LL_STATFS_NODELAY 4
509 #define IOC_MDC_TYPE 'i'
510 #define IOC_MDC_LOOKUP _IOWR(IOC_MDC_TYPE, 20, struct obd_device *)
511 #define IOC_MDC_GETFILESTRIPE _IOWR(IOC_MDC_TYPE, 21, struct lov_user_md *)
512 #define IOC_MDC_GETFILEINFO _IOWR(IOC_MDC_TYPE, 22, struct lov_user_mds_data *)
513 #define LL_IOC_MDC_GETINFO _IOWR(IOC_MDC_TYPE, 23, struct lov_user_mds_data *)
515 #define MAX_OBD_NAME 128 /* If this changes, a NEW ioctl must be added */
517 /* Define O_LOV_DELAY_CREATE to be a mask that is not useful for regular
518 * files, but are unlikely to be used in practice and are not harmful if
519 * used incorrectly. O_NOCTTY and FASYNC are only meaningful for character
520 * devices and are safe for use on new files. See LU-4209. */
521 /* To be compatible with old statically linked binary we keep the check for
522 * the older 0100000000 flag. This is already removed upstream. LU-812. */
523 #define O_LOV_DELAY_CREATE_1_8 0100000000 /* FMODE_NONOTIFY masked in 2.6.36 */
525 #define FASYNC 00020000 /* fcntl, for BSD compatibility */
527 #define O_LOV_DELAY_CREATE_MASK (O_NOCTTY | FASYNC)
528 #define O_LOV_DELAY_CREATE (O_LOV_DELAY_CREATE_1_8 | \
529 O_LOV_DELAY_CREATE_MASK)
531 #define LL_FILE_IGNORE_LOCK 0x00000001
532 #define LL_FILE_GROUP_LOCKED 0x00000002
533 #define LL_FILE_READAHEA 0x00000004
534 #define LL_FILE_LOCKED_DIRECTIO 0x00000008 /* client-side locks with dio */
535 #define LL_FILE_LOCKLESS_IO 0x00000010 /* server-side locks with cio */
537 #define LOV_USER_MAGIC_V1 0x0BD10BD0
538 #define LOV_USER_MAGIC LOV_USER_MAGIC_V1
539 #define LOV_USER_MAGIC_JOIN_V1 0x0BD20BD0
540 #define LOV_USER_MAGIC_V3 0x0BD30BD0
541 /* 0x0BD40BD0 is occupied by LOV_MAGIC_MIGRATE */
542 #define LOV_USER_MAGIC_SPECIFIC 0x0BD50BD0 /* for specific OSTs */
543 #define LOV_USER_MAGIC_COMP_V1 0x0BD60BD0
544 #define LOV_USER_MAGIC_FOREIGN 0x0BD70BD0
546 #define LMV_USER_MAGIC 0x0CD30CD0 /* default lmv magic */
547 #define LMV_USER_MAGIC_V0 0x0CD20CD0 /* old default lmv magic*/
548 #define LMV_USER_MAGIC_SPECIFIC 0x0CD40CD0
550 #define LOV_PATTERN_NONE 0x000
551 #define LOV_PATTERN_RAID0 0x001
552 #define LOV_PATTERN_RAID1 0x002
553 #define LOV_PATTERN_MDT 0x100
554 #define LOV_PATTERN_CMOBD 0x200
556 #define LOV_PATTERN_F_MASK 0xffff0000
557 #define LOV_PATTERN_F_HOLE 0x40000000 /* there is hole in LOV EA */
558 #define LOV_PATTERN_F_RELEASED 0x80000000 /* HSM released file */
559 #define LOV_PATTERN_DEFAULT 0xffffffff
561 #define LOV_OFFSET_DEFAULT ((__u16)-1)
563 static inline bool lov_pattern_supported(__u32 pattern)
565 return (pattern & ~LOV_PATTERN_F_RELEASED) == LOV_PATTERN_RAID0 ||
566 (pattern & ~LOV_PATTERN_F_RELEASED) == LOV_PATTERN_MDT;
569 #define LOV_MAXPOOLNAME 15
570 #define LOV_POOLNAMEF "%.15s"
572 #define LOV_MIN_STRIPE_BITS 16 /* maximum PAGE_SIZE (ia64), power of 2 */
573 #define LOV_MIN_STRIPE_SIZE (1 << LOV_MIN_STRIPE_BITS)
574 #define LOV_MAX_STRIPE_COUNT_OLD 160
575 /* This calculation is crafted so that input of 4096 will result in 160
576 * which in turn is equal to old maximal stripe count.
577 * XXX: In fact this is too simpified for now, what it also need is to get
578 * ea_type argument to clearly know how much space each stripe consumes.
580 * The limit of 12 pages is somewhat arbitrary, but is a reasonably large
581 * allocation that is sufficient for the current generation of systems.
583 * (max buffer size - lov+rpc header) / sizeof(struct lov_ost_data_v1) */
584 #define LOV_MAX_STRIPE_COUNT 2000 /* ((12 * 4096 - 256) / 24) */
585 #define LOV_ALL_STRIPES 0xffff /* only valid for directories */
586 #define LOV_V1_INSANE_STRIPE_COUNT 65532 /* maximum stripe count bz13933 */
588 #define XATTR_LUSTRE_PREFIX "lustre."
589 #define XATTR_LUSTRE_LOV XATTR_LUSTRE_PREFIX"lov"
591 #define lov_user_ost_data lov_user_ost_data_v1
592 struct lov_user_ost_data_v1 { /* per-stripe data structure */
593 struct ost_id l_ost_oi; /* OST object ID */
594 __u32 l_ost_gen; /* generation of this OST index */
595 __u32 l_ost_idx; /* OST index in LOV */
596 } __attribute__((packed));
598 #define lov_user_md lov_user_md_v1
599 struct lov_user_md_v1 { /* LOV EA user data (host-endian) */
600 __u32 lmm_magic; /* magic number = LOV_USER_MAGIC_V1 */
601 __u32 lmm_pattern; /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */
602 struct ost_id lmm_oi; /* MDT parent inode id/seq (id/0 for 1.x) */
603 __u32 lmm_stripe_size; /* size of stripe in bytes */
604 __u16 lmm_stripe_count; /* num stripes in use for this object */
606 __u16 lmm_stripe_offset; /* starting stripe offset in
607 * lmm_objects, use when writing */
608 __u16 lmm_layout_gen; /* layout generation number
609 * used when reading */
611 struct lov_user_ost_data_v1 lmm_objects[0]; /* per-stripe data */
612 } __attribute__((packed, __may_alias__));
614 struct lov_user_md_v3 { /* LOV EA user data (host-endian) */
615 __u32 lmm_magic; /* magic number = LOV_USER_MAGIC_V3 */
616 __u32 lmm_pattern; /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */
617 struct ost_id lmm_oi; /* MDT parent inode id/seq (id/0 for 1.x) */
618 __u32 lmm_stripe_size; /* size of stripe in bytes */
619 __u16 lmm_stripe_count; /* num stripes in use for this object */
621 __u16 lmm_stripe_offset; /* starting stripe offset in
622 * lmm_objects, use when writing */
623 __u16 lmm_layout_gen; /* layout generation number
624 * used when reading */
626 char lmm_pool_name[LOV_MAXPOOLNAME + 1]; /* pool name */
627 struct lov_user_ost_data_v1 lmm_objects[0]; /* per-stripe data */
628 } __attribute__((packed));
630 struct lov_foreign_md {
631 __u32 lfm_magic; /* magic number = LOV_MAGIC_FOREIGN */
632 __u32 lfm_length; /* length of lfm_value */
633 __u32 lfm_type; /* type, see LOV_FOREIGN_TYPE_ */
634 __u32 lfm_flags; /* flags, type specific */
638 #define foreign_size(lfm) (((struct lov_foreign_md *)lfm)->lfm_length + \
639 offsetof(struct lov_foreign_md, lfm_value))
641 #define foreign_size_le(lfm) \
642 (le32_to_cpu(((struct lov_foreign_md *)lfm)->lfm_length) + \
643 offsetof(struct lov_foreign_md, lfm_value))
650 #define DEXT "[%#llx, %#llx)"
651 #define PEXT(ext) (ext)->e_start, (ext)->e_end
653 static inline bool lu_extent_is_overlapped(struct lu_extent *e1,
654 struct lu_extent *e2)
656 return e1->e_start < e2->e_end && e2->e_start < e1->e_end;
659 static inline bool lu_extent_is_whole(struct lu_extent *e)
661 return e->e_start == 0 && e->e_end == LUSTRE_EOF;
664 enum lov_comp_md_entry_flags {
665 LCME_FL_STALE = 0x00000001, /* FLR: stale data */
666 LCME_FL_PREF_RD = 0x00000002, /* FLR: preferred for reading */
667 LCME_FL_PREF_WR = 0x00000004, /* FLR: preferred for writing */
668 LCME_FL_PREF_RW = LCME_FL_PREF_RD | LCME_FL_PREF_WR,
669 LCME_FL_OFFLINE = 0x00000008, /* Not used */
670 LCME_FL_INIT = 0x00000010, /* instantiated */
671 LCME_FL_NOSYNC = 0x00000020, /* FLR: no sync for the mirror */
672 LCME_FL_NEG = 0x80000000 /* used to indicate a negative flag,
673 won't be stored on disk */
676 #define LCME_KNOWN_FLAGS (LCME_FL_NEG | LCME_FL_INIT | LCME_FL_STALE | \
677 LCME_FL_PREF_RW | LCME_FL_NOSYNC)
678 /* The flags can be set by users at mirror creation time. */
679 #define LCME_USER_FLAGS (LCME_FL_PREF_RW)
681 /* The flags are for mirrors */
682 #define LCME_MIRROR_FLAGS (LCME_FL_NOSYNC)
684 /* These flags have meaning when set in a default layout and will be inherited
685 * from the default/template layout set on a directory.
687 #define LCME_TEMPLATE_FLAGS (LCME_FL_PREF_RW | LCME_FL_NOSYNC)
689 /* the highest bit in obdo::o_layout_version is used to mark if the file is
691 #define LU_LAYOUT_RESYNC LCME_FL_NEG
693 /* lcme_id can be specified as certain flags, and the the first
694 * bit of lcme_id is used to indicate that the ID is representing
695 * certain LCME_FL_* but not a real ID. Which implies we can have
696 * at most 31 flags (see LCME_FL_XXX). */
699 LCME_ID_MAX = 0x7FFFFFFF,
700 LCME_ID_ALL = 0xFFFFFFFF,
701 LCME_ID_NOT_ID = LCME_FL_NEG
704 #define LCME_ID_MASK LCME_ID_MAX
706 struct lov_comp_md_entry_v1 {
707 __u32 lcme_id; /* unique id of component */
708 __u32 lcme_flags; /* LCME_FL_XXX */
709 struct lu_extent lcme_extent; /* file extent for component */
710 __u32 lcme_offset; /* offset of component blob,
711 start from lov_comp_md_v1 */
712 __u32 lcme_size; /* size of component blob */
713 __u32 lcme_layout_gen;
714 __u64 lcme_timestamp; /* snapshot time if applicable*/
715 __u32 lcme_padding_1;
716 } __attribute__((packed));
718 #define SEQ_ID_MAX 0x0000FFFF
719 #define SEQ_ID_MASK SEQ_ID_MAX
720 /* bit 30:16 of lcme_id is used to store mirror id */
721 #define MIRROR_ID_MASK 0x7FFF0000
722 #define MIRROR_ID_NEG 0x8000
723 #define MIRROR_ID_SHIFT 16
725 static inline __u32 pflr_id(__u16 mirror_id, __u16 seqid)
727 return ((mirror_id << MIRROR_ID_SHIFT) & MIRROR_ID_MASK) | seqid;
730 static inline __u16 mirror_id_of(__u32 id)
732 return (id & MIRROR_ID_MASK) >> MIRROR_ID_SHIFT;
736 * on-disk data for lcm_flags. Valid if lcm_magic is LOV_MAGIC_COMP_V1.
738 enum lov_comp_md_flags {
739 /* the least 2 bits are used by FLR to record file state */
742 LCM_FL_WRITE_PENDING = 2,
743 LCM_FL_SYNC_PENDING = 3,
744 LCM_FL_FLR_MASK = 0x3,
747 struct lov_comp_md_v1 {
748 __u32 lcm_magic; /* LOV_USER_MAGIC_COMP_V1 */
749 __u32 lcm_size; /* overall size including this struct */
750 __u32 lcm_layout_gen;
752 __u16 lcm_entry_count;
753 /* lcm_mirror_count stores the number of actual mirrors minus 1,
754 * so that non-flr files will have value 0 meaning 1 mirror. */
755 __u16 lcm_mirror_count;
756 __u16 lcm_padding1[3];
758 struct lov_comp_md_entry_v1 lcm_entries[0];
759 } __attribute__((packed));
761 static inline __u32 lov_user_md_size(__u16 stripes, __u32 lmm_magic)
763 if (stripes == (__u16)-1)
766 if (lmm_magic == LOV_USER_MAGIC_V1)
767 return sizeof(struct lov_user_md_v1) +
768 stripes * sizeof(struct lov_user_ost_data_v1);
769 return sizeof(struct lov_user_md_v3) +
770 stripes * sizeof(struct lov_user_ost_data_v1);
773 /* Compile with -D_LARGEFILE64_SOURCE or -D_GNU_SOURCE (or #define) to
774 * use this. It is unsafe to #define those values in this header as it
775 * is possible the application has already #included <sys/stat.h>. */
776 #ifdef HAVE_LOV_USER_MDS_DATA
777 #define lov_user_mds_data lov_user_mds_data_v1
778 struct lov_user_mds_data_v1 {
779 lstat_t lmd_st; /* MDS stat struct */
780 struct lov_user_md_v1 lmd_lmm; /* LOV EA V1 user data */
781 } __attribute__((packed));
784 struct lmv_user_mds_data {
785 struct lu_fid lum_fid;
791 LMV_HASH_TYPE_UNKNOWN = 0, /* 0 is reserved for testing purpose */
792 LMV_HASH_TYPE_ALL_CHARS = 1,
793 LMV_HASH_TYPE_FNV_1A_64 = 2,
797 #define LMV_HASH_NAME_ALL_CHARS "all_char"
798 #define LMV_HASH_NAME_FNV_1A_64 "fnv_1a_64"
800 extern char *mdt_hash_name[LMV_HASH_TYPE_MAX];
805 #define LOV_FOREIGN_TYPE_NONE 0
806 #define LOV_FOREIGN_TYPE_DAOS 0xda05
807 #define LOV_FOREIGN_TYPE_UNKNOWN UINT32_MAX
809 struct lustre_foreign_type {
811 const char *lft_name;
814 extern struct lustre_foreign_type lov_foreign_type[];
816 /* Got this according to how get LOV_MAX_STRIPE_COUNT, see above,
817 * (max buffer size - lmv+rpc header) / sizeof(struct lmv_user_mds_data) */
818 #define LMV_MAX_STRIPE_COUNT 2000 /* ((12 * 4096 - 256) / 24) */
819 #define lmv_user_md lmv_user_md_v1
820 struct lmv_user_md_v1 {
821 __u32 lum_magic; /* must be the first field */
822 __u32 lum_stripe_count; /* dirstripe count */
823 __u32 lum_stripe_offset; /* MDT idx for default dirstripe */
824 __u32 lum_hash_type; /* Dir stripe policy */
825 __u32 lum_type; /* LMV type: default or normal */
829 char lum_pool_name[LOV_MAXPOOLNAME + 1];
830 struct lmv_user_mds_data lum_objects[0];
831 } __attribute__((packed));
833 static inline int lmv_user_md_size(int stripes, int lmm_magic)
835 int size = sizeof(struct lmv_user_md);
837 if (lmm_magic == LMV_USER_MAGIC_SPECIFIC)
838 size += stripes * sizeof(struct lmv_user_mds_data);
843 struct ll_recreate_obj {
849 __u64 id; /* holds object id */
850 __u32 generation; /* holds object generation */
851 __u32 f_type; /* holds object type or stripe idx when passing it to
852 * OST for saving into EA. */
860 static inline bool obd_uuid_equals(const struct obd_uuid *u1,
861 const struct obd_uuid *u2)
863 return strcmp((char *)u1->uuid, (char *)u2->uuid) == 0;
866 static inline int obd_uuid_empty(struct obd_uuid *uuid)
868 return uuid->uuid[0] == '\0';
871 static inline void obd_str2uuid(struct obd_uuid *uuid, const char *tmp)
873 strncpy((char *)uuid->uuid, tmp, sizeof(*uuid));
874 uuid->uuid[sizeof(*uuid) - 1] = '\0';
877 /* For printf's only, make sure uuid is terminated */
878 static inline char *obd_uuid2str(const struct obd_uuid *uuid)
883 if (uuid->uuid[sizeof(*uuid) - 1] != '\0') {
884 /* Obviously not safe, but for printfs, no real harm done...
885 we're always null-terminated, even in a race. */
886 static char temp[sizeof(*uuid)];
887 memcpy(temp, uuid->uuid, sizeof(*uuid) - 1);
888 temp[sizeof(*uuid) - 1] = '\0';
891 return (char *)(uuid->uuid);
894 #define LUSTRE_MAXFSNAME 8
896 /* Extract fsname from uuid (or target name) of a target
897 e.g. (myfs-OST0007_UUID -> myfs)
898 see also deuuidify. */
899 static inline void obd_uuid2fsname(char *buf, char *uuid, int buflen)
903 strncpy(buf, uuid, buflen - 1);
904 buf[buflen - 1] = '\0';
905 p = strrchr(buf, '-');
910 /* printf display format for Lustre FIDs
911 * usage: printf("file FID is "DFID"\n", PFID(fid)); */
912 #define FID_NOBRACE_LEN 40
913 #define FID_LEN (FID_NOBRACE_LEN + 2)
914 #define DFID_NOBRACE "%#llx:0x%x:0x%x"
915 #define DFID "["DFID_NOBRACE"]"
916 #define PFID(fid) (unsigned long long)(fid)->f_seq, (fid)->f_oid, (fid)->f_ver
918 /* scanf input parse format for fids in DFID_NOBRACE format
919 * Need to strip '[' from DFID format first or use "["SFID"]" at caller.
920 * usage: sscanf(fidstr, SFID, RFID(&fid)); */
921 #define SFID "0x%llx:0x%x:0x%x"
922 #define RFID(fid) &((fid)->f_seq), &((fid)->f_oid), &((fid)->f_ver)
924 /********* Quotas **********/
926 #define LUSTRE_QUOTABLOCK_BITS 10
927 #define LUSTRE_QUOTABLOCK_SIZE (1 << LUSTRE_QUOTABLOCK_BITS)
929 static inline __u64 lustre_stoqb(size_t space)
931 return (space + LUSTRE_QUOTABLOCK_SIZE - 1) >> LUSTRE_QUOTABLOCK_BITS;
934 #define Q_QUOTACHECK 0x800100 /* deprecated as of 2.4 */
935 #define Q_INITQUOTA 0x800101 /* deprecated as of 2.4 */
936 #define Q_GETOINFO 0x800102 /* get obd quota info */
937 #define Q_GETOQUOTA 0x800103 /* get obd quotas */
938 #define Q_FINVALIDATE 0x800104 /* deprecated as of 2.4 */
940 /* these must be explicitly translated into linux Q_* in ll_dir_ioctl */
941 #define LUSTRE_Q_QUOTAON 0x800002 /* deprecated as of 2.4 */
942 #define LUSTRE_Q_QUOTAOFF 0x800003 /* deprecated as of 2.4 */
943 #define LUSTRE_Q_GETINFO 0x800005 /* get information about quota files */
944 #define LUSTRE_Q_SETINFO 0x800006 /* set information about quota files */
945 #define LUSTRE_Q_GETQUOTA 0x800007 /* get user quota structure */
946 #define LUSTRE_Q_SETQUOTA 0x800008 /* set user quota structure */
947 /* lustre-specific control commands */
948 #define LUSTRE_Q_INVALIDATE 0x80000b /* deprecated as of 2.4 */
949 #define LUSTRE_Q_FINVALIDATE 0x80000c /* deprecated as of 2.4 */
950 #define LUSTRE_Q_GETDEFAULT 0x80000d /* get default quota */
951 #define LUSTRE_Q_SETDEFAULT 0x80000e /* set default quota */
953 /* In the current Lustre implementation, the grace time is either the time
954 * or the timestamp to be used after some quota ID exceeds the soft limt,
955 * 48 bits should be enough, its high 16 bits can be used as quota flags.
957 #define LQUOTA_GRACE_BITS 48
958 #define LQUOTA_GRACE_MASK ((1ULL << LQUOTA_GRACE_BITS) - 1)
959 #define LQUOTA_GRACE_MAX LQUOTA_GRACE_MASK
960 #define LQUOTA_GRACE(t) (t & LQUOTA_GRACE_MASK)
961 #define LQUOTA_FLAG(t) (t >> LQUOTA_GRACE_BITS)
962 #define LQUOTA_GRACE_FLAG(t, f) ((__u64)t | (__u64)f << LQUOTA_GRACE_BITS)
964 /* different quota flags */
966 /* the default quota flag, the corresponding quota ID will use the default
967 * quota setting, the hardlimit and softlimit of its quota record in the global
968 * quota file will be set to 0, the low 48 bits of the grace will be set to 0
969 * and high 16 bits will contain this flag (see above comment).
971 #define LQUOTA_FLAG_DEFAULT 0x0001
973 #define ALLQUOTA 255 /* set all quota */
974 static inline char *qtype_name(int qtype)
987 #define IDENTITY_DOWNCALL_MAGIC 0x6d6dd629
988 #define SEPOL_DOWNCALL_MAGIC 0x8b8bb842
991 #define N_PERMS_MAX 64
993 struct perm_downcall_data {
999 struct identity_downcall_data {
1006 struct perm_downcall_data idd_perms[N_PERMS_MAX];
1007 __u32 idd_groups[0];
1010 struct sepol_downcall_data {
1012 time_t sdd_sepol_mtime;
1013 __u16 sdd_sepol_len;
1017 #ifdef NEED_QUOTA_DEFS
1019 #define QIF_BLIMITS 1
1021 #define QIF_ILIMITS 4
1022 #define QIF_INODES 8
1023 #define QIF_BTIME 16
1024 #define QIF_ITIME 32
1025 #define QIF_LIMITS (QIF_BLIMITS | QIF_ILIMITS)
1026 #define QIF_USAGE (QIF_SPACE | QIF_INODES)
1027 #define QIF_TIMES (QIF_BTIME | QIF_ITIME)
1028 #define QIF_ALL (QIF_LIMITS | QIF_USAGE | QIF_TIMES)
1031 #endif /* !__KERNEL__ */
1033 /* lustre volatile file support
1034 * file name header: ".^L^S^T^R:volatile"
1036 #define LUSTRE_VOLATILE_HDR ".\x0c\x13\x14\x12:VOLATILE"
1037 #define LUSTRE_VOLATILE_HDR_LEN 14
1039 enum lustre_quota_version {
1043 /* XXX: same as if_dqinfo struct in kernel */
1051 /* XXX: same as if_dqblk struct in kernel, plus one padding */
1053 __u64 dqb_bhardlimit;
1054 __u64 dqb_bsoftlimit;
1056 __u64 dqb_ihardlimit;
1057 __u64 dqb_isoftlimit;
1058 __u64 dqb_curinodes;
1072 struct if_quotactl {
1079 struct obd_dqinfo qc_dqinfo;
1080 struct obd_dqblk qc_dqblk;
1082 struct obd_uuid obd_uuid;
1085 /* swap layout flags */
1086 #define SWAP_LAYOUTS_CHECK_DV1 (1 << 0)
1087 #define SWAP_LAYOUTS_CHECK_DV2 (1 << 1)
1088 #define SWAP_LAYOUTS_KEEP_MTIME (1 << 2)
1089 #define SWAP_LAYOUTS_KEEP_ATIME (1 << 3)
1090 #define SWAP_LAYOUTS_CLOSE (1 << 4)
1092 /* Swap XATTR_NAME_HSM as well, only on the MDT so far */
1093 #define SWAP_LAYOUTS_MDS_HSM (1 << 31)
1094 struct lustre_swap_layouts {
1102 /** Bit-mask of valid attributes */
1103 /* The LA_* flags are written to disk as part of the ChangeLog records
1104 * so they are part of the on-disk and network protocol, and cannot be changed.
1105 * Only the first 12 bits are currently saved.
1108 LA_ATIME = 1 << 0, /* 0x00001 */
1109 LA_MTIME = 1 << 1, /* 0x00002 */
1110 LA_CTIME = 1 << 2, /* 0x00004 */
1111 LA_SIZE = 1 << 3, /* 0x00008 */
1112 LA_MODE = 1 << 4, /* 0x00010 */
1113 LA_UID = 1 << 5, /* 0x00020 */
1114 LA_GID = 1 << 6, /* 0x00040 */
1115 LA_BLOCKS = 1 << 7, /* 0x00080 */
1116 LA_TYPE = 1 << 8, /* 0x00100 */
1117 LA_FLAGS = 1 << 9, /* 0x00200 */
1118 LA_NLINK = 1 << 10, /* 0x00400 */
1119 LA_RDEV = 1 << 11, /* 0x00800 */
1120 LA_BLKSIZE = 1 << 12, /* 0x01000 */
1121 LA_KILL_SUID = 1 << 13, /* 0x02000 */
1122 LA_KILL_SGID = 1 << 14, /* 0x04000 */
1123 LA_PROJID = 1 << 15, /* 0x08000 */
1124 LA_LAYOUT_VERSION = 1 << 16, /* 0x10000 */
1125 LA_LSIZE = 1 << 17, /* 0x20000 */
1126 LA_LBLOCKS = 1 << 18, /* 0x40000 */
1128 * Attributes must be transmitted to OST objects
1130 LA_REMOTE_ATTR_SET = (LA_UID | LA_GID | LA_PROJID | LA_LAYOUT_VERSION)
1133 #define MDS_FMODE_READ 00000001
1134 #define MDS_FMODE_WRITE 00000002
1136 #define MDS_FMODE_CLOSED 00000000
1137 #define MDS_FMODE_EXEC 00000004
1138 /* MDS_FMODE_EPOCH 01000000 obsolete since 2.8.0 */
1139 /* MDS_FMODE_TRUNC 02000000 obsolete since 2.8.0 */
1140 /* MDS_FMODE_SOM 04000000 obsolete since 2.8.0 */
1142 #define MDS_OPEN_CREATED 00000010
1143 /* MDS_OPEN_CROSS 00000020 obsolete in 2.12, internal use only */
1145 #define MDS_OPEN_CREAT 00000100
1146 #define MDS_OPEN_EXCL 00000200
1147 #define MDS_OPEN_TRUNC 00001000
1148 #define MDS_OPEN_APPEND 00002000
1149 #define MDS_OPEN_SYNC 00010000
1150 #define MDS_OPEN_DIRECTORY 00200000
1152 #define MDS_OPEN_BY_FID 040000000 /* open_by_fid for known object */
1153 #define MDS_OPEN_DELAY_CREATE 0100000000 /* delay initial object create */
1154 #define MDS_OPEN_OWNEROVERRIDE 0200000000 /* NFSD rw-reopen ro file for owner */
1155 #define MDS_OPEN_JOIN_FILE 0400000000 /* open for join file.
1156 * We do not support JOIN FILE
1157 * anymore, reserve this flags
1158 * just for preventing such bit
1161 #define MDS_OPEN_LOCK 04000000000 /* This open requires open lock */
1162 #define MDS_OPEN_HAS_EA 010000000000 /* specify object create pattern */
1163 #define MDS_OPEN_HAS_OBJS 020000000000 /* Just set the EA the obj exist */
1164 #define MDS_OPEN_NORESTORE 0100000000000ULL /* Do not restore file at open */
1165 #define MDS_OPEN_NEWSTRIPE 0200000000000ULL /* New stripe needed (restripe or
1167 #define MDS_OPEN_VOLATILE 0400000000000ULL /* File is volatile = created
1169 #define MDS_OPEN_LEASE 01000000000000ULL /* Open the file and grant lease
1170 * delegation, succeed if it's not
1171 * being opened with conflict mode.
1173 #define MDS_OPEN_RELEASE 02000000000000ULL /* Open the file for HSM release */
1175 #define MDS_OPEN_RESYNC 04000000000000ULL /* FLR: file resync */
1177 /* lustre internal open flags, which should not be set from user space */
1178 #define MDS_OPEN_FL_INTERNAL (MDS_OPEN_HAS_EA | MDS_OPEN_HAS_OBJS | \
1179 MDS_OPEN_OWNEROVERRIDE | MDS_OPEN_LOCK | \
1180 MDS_OPEN_BY_FID | MDS_OPEN_LEASE | \
1181 MDS_OPEN_RELEASE | MDS_OPEN_RESYNC)
1184 /********* Changelogs **********/
1185 /** Changelog record types */
1186 enum changelog_rec_type {
1189 CL_CREATE = 1, /* namespace */
1190 CL_MKDIR = 2, /* namespace */
1191 CL_HARDLINK = 3, /* namespace */
1192 CL_SOFTLINK = 4, /* namespace */
1193 CL_MKNOD = 5, /* namespace */
1194 CL_UNLINK = 6, /* namespace */
1195 CL_RMDIR = 7, /* namespace */
1196 CL_RENAME = 8, /* namespace */
1197 CL_EXT = 9, /* namespace extended record (2nd half of rename) */
1198 CL_OPEN = 10, /* not currently used */
1199 CL_CLOSE = 11, /* may be written to log only with mtime change */
1200 CL_LAYOUT = 12, /* file layout/striping modified */
1204 CL_XATTR = CL_SETXATTR, /* Deprecated name */
1205 CL_HSM = 16, /* HSM specific events, see flags */
1206 CL_MTIME = 17, /* Precedence: setattr > mtime > ctime > atime */
1210 CL_FLRW = 21, /* FLR: file was firstly written */
1211 CL_RESYNC = 22, /* FLR: file was resync-ed */
1213 CL_DN_OPEN = 24, /* denied open */
1217 static inline const char *changelog_type2str(int type) {
1218 static const char *changelog_str[] = {
1219 "MARK", "CREAT", "MKDIR", "HLINK", "SLINK", "MKNOD", "UNLNK",
1220 "RMDIR", "RENME", "RNMTO", "OPEN", "CLOSE", "LYOUT", "TRUNC",
1221 "SATTR", "XATTR", "HSM", "MTIME", "CTIME", "ATIME", "MIGRT",
1222 "FLRW", "RESYNC","GXATR", "NOPEN",
1225 if (type >= 0 && type < CL_LAST)
1226 return changelog_str[type];
1230 /* 12 bits of per-record data can be stored in the bottom of the flags */
1231 #define CLF_FLAGSHIFT 12
1232 enum changelog_rec_flags {
1233 CLF_VERSION = 0x1000,
1234 CLF_RENAME = 0x2000,
1236 CLF_EXTRA_FLAGS = 0x8000,
1237 CLF_SUPPORTED = CLF_VERSION | CLF_RENAME | CLF_JOBID |
1239 CLF_FLAGMASK = (1U << CLF_FLAGSHIFT) - 1,
1240 CLF_VERMASK = ~CLF_FLAGMASK,
1244 /* Anything under the flagmask may be per-type (if desired) */
1245 /* Flags for unlink */
1246 #define CLF_UNLINK_LAST 0x0001 /* Unlink of last hardlink */
1247 #define CLF_UNLINK_HSM_EXISTS 0x0002 /* File has something in HSM */
1248 /* HSM cleaning needed */
1249 /* Flags for rename */
1250 #define CLF_RENAME_LAST 0x0001 /* rename unlink last hardlink
1252 #define CLF_RENAME_LAST_EXISTS 0x0002 /* rename unlink last hardlink of target
1253 * has an archive in backend */
1256 /* 12b used (from high weight to low weight):
1261 #define CLF_HSM_ERR_L 0 /* HSM return code, 7 bits */
1262 #define CLF_HSM_ERR_H 6
1263 #define CLF_HSM_EVENT_L 7 /* HSM event, 3 bits, see enum hsm_event */
1264 #define CLF_HSM_EVENT_H 9
1265 #define CLF_HSM_FLAG_L 10 /* HSM flags, 2 bits, 1 used, 1 spare */
1266 #define CLF_HSM_FLAG_H 11
1267 #define CLF_HSM_SPARE_L 12 /* 4 spare bits */
1268 #define CLF_HSM_SPARE_H 15
1269 #define CLF_HSM_LAST 15
1271 /* Remove bits higher than _h, then extract the value
1272 * between _h and _l by shifting lower weigth to bit 0. */
1273 #define CLF_GET_BITS(_b, _h, _l) (((_b << (CLF_HSM_LAST - _h)) & 0xFFFF) \
1274 >> (CLF_HSM_LAST - _h + _l))
1276 #define CLF_HSM_SUCCESS 0x00
1277 #define CLF_HSM_MAXERROR 0x7E
1278 #define CLF_HSM_ERROVERFLOW 0x7F
1280 #define CLF_HSM_DIRTY 1 /* file is dirty after HSM request end */
1282 /* 3 bits field => 8 values allowed */
1294 static inline enum hsm_event hsm_get_cl_event(__u16 flags)
1296 return (enum hsm_event)CLF_GET_BITS(flags, CLF_HSM_EVENT_H,
1300 static inline void hsm_set_cl_event(enum changelog_rec_flags *clf_flags,
1303 *clf_flags |= (he << CLF_HSM_EVENT_L);
1306 static inline __u16 hsm_get_cl_flags(enum changelog_rec_flags clf_flags)
1308 return CLF_GET_BITS(clf_flags, CLF_HSM_FLAG_H, CLF_HSM_FLAG_L);
1311 static inline void hsm_set_cl_flags(enum changelog_rec_flags *clf_flags,
1314 *clf_flags |= (bits << CLF_HSM_FLAG_L);
1317 static inline int hsm_get_cl_error(enum changelog_rec_flags clf_flags)
1319 return CLF_GET_BITS(clf_flags, CLF_HSM_ERR_H, CLF_HSM_ERR_L);
1322 static inline void hsm_set_cl_error(enum changelog_rec_flags *clf_flags,
1325 *clf_flags |= (error << CLF_HSM_ERR_L);
1328 enum changelog_rec_extra_flags {
1330 CLFE_UIDGID = 0x0001,
1333 CLFE_XATTR = 0x0008,
1334 CLFE_SUPPORTED = CLFE_UIDGID | CLFE_NID | CLFE_OPEN | CLFE_XATTR
1337 enum changelog_send_flag {
1338 /* Not yet implemented */
1339 CHANGELOG_FLAG_FOLLOW = 0x01,
1340 /* Blocking IO makes sense in case of slow user parsing of the records,
1341 * but it also prevents us from cleaning up if the records are not
1343 CHANGELOG_FLAG_BLOCK = 0x02,
1344 /* Pack jobid into the changelog records if available. */
1345 CHANGELOG_FLAG_JOBID = 0x04,
1346 /* Pack additional flag bits into the changelog record */
1347 CHANGELOG_FLAG_EXTRA_FLAGS = 0x08,
1350 enum changelog_send_extra_flag {
1351 /* Pack uid/gid into the changelog record */
1352 CHANGELOG_EXTRA_FLAG_UIDGID = 0x01,
1353 /* Pack nid into the changelog record */
1354 CHANGELOG_EXTRA_FLAG_NID = 0x02,
1355 /* Pack open mode into the changelog record */
1356 CHANGELOG_EXTRA_FLAG_OMODE = 0x04,
1357 /* Pack xattr name into the changelog record */
1358 CHANGELOG_EXTRA_FLAG_XATTR = 0x08,
1361 #define CR_MAXSIZE __ALIGN_KERNEL(2 * NAME_MAX + 2 + \
1362 changelog_rec_offset(CLF_SUPPORTED, \
1365 /* 31 usable bytes string + null terminator. */
1366 #define LUSTRE_JOBID_SIZE 32
1368 /* This is the minimal changelog record. It can contain extensions
1369 * such as rename fields or process jobid. Its exact content is described
1370 * by the cr_flags and cr_extra_flags.
1372 * Extensions are packed in the same order as their corresponding flags,
1373 * then in the same order as their corresponding extra flags.
1375 struct changelog_rec {
1377 __u16 cr_flags; /**< \a changelog_rec_flags */
1378 __u32 cr_type; /**< \a changelog_rec_type */
1379 __u64 cr_index; /**< changelog record number */
1380 __u64 cr_prev; /**< last index for this target fid */
1383 struct lu_fid cr_tfid; /**< target fid */
1384 __u32 cr_markerflags; /**< CL_MARK flags */
1386 struct lu_fid cr_pfid; /**< parent fid */
1389 /* Changelog extension for RENAME. */
1390 struct changelog_ext_rename {
1391 struct lu_fid cr_sfid; /**< source fid, or zero */
1392 struct lu_fid cr_spfid; /**< source parent fid, or zero */
1395 /* Changelog extension to include JOBID. */
1396 struct changelog_ext_jobid {
1397 char cr_jobid[LUSTRE_JOBID_SIZE]; /**< zero-terminated string. */
1400 /* Changelog extension to include additional flags. */
1401 struct changelog_ext_extra_flags {
1402 __u64 cr_extra_flags; /* Additional CLFE_* flags */
1405 /* Changelog extra extension to include UID/GID. */
1406 struct changelog_ext_uidgid {
1411 /* Changelog extra extension to include NID. */
1412 struct changelog_ext_nid {
1413 /* have __u64 instead of lnet_nid_t type for use by client api */
1415 /* for use when IPv6 support is added */
1420 /* Changelog extra extension to include low 32 bits of MDS_OPEN_* flags. */
1421 struct changelog_ext_openmode {
1425 /* Changelog extra extension to include xattr */
1426 struct changelog_ext_xattr {
1427 char cr_xattr[XATTR_NAME_MAX + 1]; /**< zero-terminated string. */
1430 static inline struct changelog_ext_extra_flags *changelog_rec_extra_flags(
1431 const struct changelog_rec *rec);
1433 static inline size_t changelog_rec_offset(enum changelog_rec_flags crf,
1434 enum changelog_rec_extra_flags cref)
1436 size_t size = sizeof(struct changelog_rec);
1438 if (crf & CLF_RENAME)
1439 size += sizeof(struct changelog_ext_rename);
1441 if (crf & CLF_JOBID)
1442 size += sizeof(struct changelog_ext_jobid);
1444 if (crf & CLF_EXTRA_FLAGS) {
1445 size += sizeof(struct changelog_ext_extra_flags);
1446 if (cref & CLFE_UIDGID)
1447 size += sizeof(struct changelog_ext_uidgid);
1448 if (cref & CLFE_NID)
1449 size += sizeof(struct changelog_ext_nid);
1450 if (cref & CLFE_OPEN)
1451 size += sizeof(struct changelog_ext_openmode);
1452 if (cref & CLFE_XATTR)
1453 size += sizeof(struct changelog_ext_xattr);
1459 static inline size_t changelog_rec_size(const struct changelog_rec *rec)
1461 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1463 if (rec->cr_flags & CLF_EXTRA_FLAGS)
1464 cref = changelog_rec_extra_flags(rec)->cr_extra_flags;
1466 return changelog_rec_offset(rec->cr_flags, cref);
1469 static inline size_t changelog_rec_varsize(const struct changelog_rec *rec)
1471 return changelog_rec_size(rec) - sizeof(*rec) + rec->cr_namelen;
1475 struct changelog_ext_rename *changelog_rec_rename(const struct changelog_rec *rec)
1477 enum changelog_rec_flags crf = rec->cr_flags & CLF_VERSION;
1479 return (struct changelog_ext_rename *)((char *)rec +
1480 changelog_rec_offset(crf,
1484 /* The jobid follows the rename extension, if present */
1486 struct changelog_ext_jobid *changelog_rec_jobid(const struct changelog_rec *rec)
1488 enum changelog_rec_flags crf = rec->cr_flags &
1489 (CLF_VERSION | CLF_RENAME);
1491 return (struct changelog_ext_jobid *)((char *)rec +
1492 changelog_rec_offset(crf,
1496 /* The additional flags follow the rename and jobid extensions, if present */
1498 struct changelog_ext_extra_flags *changelog_rec_extra_flags(
1499 const struct changelog_rec *rec)
1501 enum changelog_rec_flags crf = rec->cr_flags &
1502 (CLF_VERSION | CLF_RENAME | CLF_JOBID);
1504 return (struct changelog_ext_extra_flags *)((char *)rec +
1505 changelog_rec_offset(crf,
1509 /* The uid/gid is the first extra extension */
1511 struct changelog_ext_uidgid *changelog_rec_uidgid(
1512 const struct changelog_rec *rec)
1514 enum changelog_rec_flags crf = rec->cr_flags &
1515 (CLF_VERSION | CLF_RENAME | CLF_JOBID | CLF_EXTRA_FLAGS);
1517 return (struct changelog_ext_uidgid *)((char *)rec +
1518 changelog_rec_offset(crf,
1522 /* The nid is the second extra extension */
1524 struct changelog_ext_nid *changelog_rec_nid(const struct changelog_rec *rec)
1526 enum changelog_rec_flags crf = rec->cr_flags &
1527 (CLF_VERSION | CLF_RENAME | CLF_JOBID | CLF_EXTRA_FLAGS);
1528 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1530 if (rec->cr_flags & CLF_EXTRA_FLAGS)
1531 cref = changelog_rec_extra_flags(rec)->cr_extra_flags &
1534 return (struct changelog_ext_nid *)((char *)rec +
1535 changelog_rec_offset(crf, cref));
1538 /* The OPEN mode is the third extra extension */
1540 struct changelog_ext_openmode *changelog_rec_openmode(
1541 const struct changelog_rec *rec)
1543 enum changelog_rec_flags crf = rec->cr_flags &
1544 (CLF_VERSION | CLF_RENAME | CLF_JOBID | CLF_EXTRA_FLAGS);
1545 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1547 if (rec->cr_flags & CLF_EXTRA_FLAGS)
1548 cref = changelog_rec_extra_flags(rec)->cr_extra_flags &
1549 (CLFE_UIDGID | CLFE_NID);
1551 return (struct changelog_ext_openmode *)((char *)rec +
1552 changelog_rec_offset(crf, cref));
1555 /* The xattr name is the fourth extra extension */
1557 struct changelog_ext_xattr *changelog_rec_xattr(
1558 const struct changelog_rec *rec)
1560 enum changelog_rec_flags crf = rec->cr_flags &
1561 (CLF_VERSION | CLF_RENAME | CLF_JOBID | CLF_EXTRA_FLAGS);
1562 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1564 if (rec->cr_flags & CLF_EXTRA_FLAGS)
1565 cref = changelog_rec_extra_flags(rec)->cr_extra_flags &
1566 (CLFE_UIDGID | CLFE_NID | CLFE_OPEN);
1568 return (struct changelog_ext_xattr *)((char *)rec +
1569 changelog_rec_offset(crf, cref));
1572 /* The name follows the rename, jobid and extra flags extns, if present */
1573 static inline char *changelog_rec_name(const struct changelog_rec *rec)
1575 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1577 if (rec->cr_flags & CLF_EXTRA_FLAGS)
1578 cref = changelog_rec_extra_flags(rec)->cr_extra_flags;
1580 return (char *)rec + changelog_rec_offset(rec->cr_flags & CLF_SUPPORTED,
1581 cref & CLFE_SUPPORTED);
1584 static inline size_t changelog_rec_snamelen(const struct changelog_rec *rec)
1586 return rec->cr_namelen - strlen(changelog_rec_name(rec)) - 1;
1589 static inline char *changelog_rec_sname(const struct changelog_rec *rec)
1591 char *cr_name = changelog_rec_name(rec);
1593 return cr_name + strlen(cr_name) + 1;
1597 * Remap a record to the desired format as specified by the crf flags.
1598 * The record must be big enough to contain the final remapped version.
1599 * Superfluous extension fields are removed and missing ones are added
1600 * and zeroed. The flags of the record are updated accordingly.
1602 * The jobid and rename extensions can be added to a record, to match the
1603 * format an application expects, typically. In this case, the newly added
1604 * fields will be zeroed.
1605 * The Jobid field can be removed, to guarantee compatibility with older
1606 * clients that don't expect this field in the records they process.
1608 * The following assumptions are being made:
1609 * - CLF_RENAME will not be removed
1610 * - CLF_JOBID will not be added without CLF_RENAME being added too
1611 * - CLF_EXTRA_FLAGS will not be added without CLF_JOBID being added too
1613 * @param[in,out] rec The record to remap.
1614 * @param[in] crf_wanted Flags describing the desired extensions.
1615 * @param[in] cref_want Flags describing the desired extra extensions.
1617 static inline void changelog_remap_rec(struct changelog_rec *rec,
1618 enum changelog_rec_flags crf_wanted,
1619 enum changelog_rec_extra_flags cref_want)
1621 char *xattr_mov = NULL;
1622 char *omd_mov = NULL;
1623 char *nid_mov = NULL;
1624 char *uidgid_mov = NULL;
1628 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1630 crf_wanted &= CLF_SUPPORTED;
1631 cref_want &= CLFE_SUPPORTED;
1633 if ((rec->cr_flags & CLF_SUPPORTED) == crf_wanted) {
1634 if (!(rec->cr_flags & CLF_EXTRA_FLAGS) ||
1635 (rec->cr_flags & CLF_EXTRA_FLAGS &&
1636 (changelog_rec_extra_flags(rec)->cr_extra_flags &
1642 /* First move the variable-length name field */
1643 memmove((char *)rec + changelog_rec_offset(crf_wanted, cref_want),
1644 changelog_rec_name(rec), rec->cr_namelen);
1646 /* Locations of extensions in the remapped record */
1647 if (rec->cr_flags & CLF_EXTRA_FLAGS) {
1648 xattr_mov = (char *)rec +
1649 changelog_rec_offset(crf_wanted & CLF_SUPPORTED,
1650 cref_want & ~CLFE_XATTR);
1651 omd_mov = (char *)rec +
1652 changelog_rec_offset(crf_wanted & CLF_SUPPORTED,
1653 cref_want & ~(CLFE_OPEN |
1655 nid_mov = (char *)rec +
1656 changelog_rec_offset(crf_wanted & CLF_SUPPORTED,
1657 cref_want & ~(CLFE_NID |
1660 uidgid_mov = (char *)rec +
1661 changelog_rec_offset(crf_wanted & CLF_SUPPORTED,
1662 cref_want & ~(CLFE_UIDGID |
1666 cref = changelog_rec_extra_flags(rec)->cr_extra_flags;
1669 ef_mov = (char *)rec +
1670 changelog_rec_offset(crf_wanted & ~CLF_EXTRA_FLAGS,
1672 jid_mov = (char *)rec +
1673 changelog_rec_offset(crf_wanted &
1674 ~(CLF_EXTRA_FLAGS | CLF_JOBID),
1676 rnm_mov = (char *)rec +
1677 changelog_rec_offset(crf_wanted &
1683 /* Move the extension fields to the desired positions */
1684 if ((crf_wanted & CLF_EXTRA_FLAGS) &&
1685 (rec->cr_flags & CLF_EXTRA_FLAGS)) {
1686 if ((cref_want & CLFE_XATTR) && (cref & CLFE_XATTR))
1687 memmove(xattr_mov, changelog_rec_xattr(rec),
1688 sizeof(struct changelog_ext_xattr));
1690 if ((cref_want & CLFE_OPEN) && (cref & CLFE_OPEN))
1691 memmove(omd_mov, changelog_rec_openmode(rec),
1692 sizeof(struct changelog_ext_openmode));
1694 if ((cref_want & CLFE_NID) && (cref & CLFE_NID))
1695 memmove(nid_mov, changelog_rec_nid(rec),
1696 sizeof(struct changelog_ext_nid));
1698 if ((cref_want & CLFE_UIDGID) && (cref & CLFE_UIDGID))
1699 memmove(uidgid_mov, changelog_rec_uidgid(rec),
1700 sizeof(struct changelog_ext_uidgid));
1702 memmove(ef_mov, changelog_rec_extra_flags(rec),
1703 sizeof(struct changelog_ext_extra_flags));
1706 if ((crf_wanted & CLF_JOBID) && (rec->cr_flags & CLF_JOBID))
1707 memmove(jid_mov, changelog_rec_jobid(rec),
1708 sizeof(struct changelog_ext_jobid));
1710 if ((crf_wanted & CLF_RENAME) && (rec->cr_flags & CLF_RENAME))
1711 memmove(rnm_mov, changelog_rec_rename(rec),
1712 sizeof(struct changelog_ext_rename));
1714 /* Clear newly added fields */
1715 if (xattr_mov && (cref_want & CLFE_XATTR) &&
1716 !(cref & CLFE_XATTR))
1717 memset(xattr_mov, 0, sizeof(struct changelog_ext_xattr));
1719 if (omd_mov && (cref_want & CLFE_OPEN) &&
1720 !(cref & CLFE_OPEN))
1721 memset(omd_mov, 0, sizeof(struct changelog_ext_openmode));
1723 if (nid_mov && (cref_want & CLFE_NID) &&
1725 memset(nid_mov, 0, sizeof(struct changelog_ext_nid));
1727 if (uidgid_mov && (cref_want & CLFE_UIDGID) &&
1728 !(cref & CLFE_UIDGID))
1729 memset(uidgid_mov, 0, sizeof(struct changelog_ext_uidgid));
1731 if ((crf_wanted & CLF_EXTRA_FLAGS) &&
1732 !(rec->cr_flags & CLF_EXTRA_FLAGS))
1733 memset(ef_mov, 0, sizeof(struct changelog_ext_extra_flags));
1735 if ((crf_wanted & CLF_JOBID) && !(rec->cr_flags & CLF_JOBID))
1736 memset(jid_mov, 0, sizeof(struct changelog_ext_jobid));
1738 if ((crf_wanted & CLF_RENAME) && !(rec->cr_flags & CLF_RENAME))
1739 memset(rnm_mov, 0, sizeof(struct changelog_ext_rename));
1741 /* Update the record's flags accordingly */
1742 rec->cr_flags = (rec->cr_flags & CLF_FLAGMASK) | crf_wanted;
1743 if (rec->cr_flags & CLF_EXTRA_FLAGS)
1744 changelog_rec_extra_flags(rec)->cr_extra_flags =
1745 changelog_rec_extra_flags(rec)->cr_extra_flags |
1749 enum changelog_message_type {
1750 CL_RECORD = 10, /* message is a changelog_rec */
1751 CL_EOF = 11, /* at end of current changelog */
1754 /********* Misc **********/
1756 struct ioc_data_version {
1758 __u32 idv_layout_version; /* FLR: layout version for OST objects */
1759 __u32 idv_flags; /* enum ioc_data_version_flags */
1762 enum ioc_data_version_flags {
1763 LL_DV_RD_FLUSH = (1 << 0), /* Flush dirty pages from clients */
1764 LL_DV_WR_FLUSH = (1 << 1), /* Flush all caching pages from clients */
1768 #define offsetof(typ, memb) ((unsigned long)((char *)&(((typ *)0)->memb)))
1771 #define dot_lustre_name ".lustre"
1774 /********* HSM **********/
1776 /** HSM per-file state
1777 * See HSM_FLAGS below.
1780 HS_NONE = 0x00000000,
1781 HS_EXISTS = 0x00000001,
1782 HS_DIRTY = 0x00000002,
1783 HS_RELEASED = 0x00000004,
1784 HS_ARCHIVED = 0x00000008,
1785 HS_NORELEASE = 0x00000010,
1786 HS_NOARCHIVE = 0x00000020,
1787 HS_LOST = 0x00000040,
1790 /* HSM user-setable flags. */
1791 #define HSM_USER_MASK (HS_NORELEASE | HS_NOARCHIVE | HS_DIRTY)
1793 /* Other HSM flags. */
1794 #define HSM_STATUS_MASK (HS_EXISTS | HS_LOST | HS_RELEASED | HS_ARCHIVED)
1797 * All HSM-related possible flags that could be applied to a file.
1798 * This should be kept in sync with hsm_states.
1800 #define HSM_FLAGS_MASK (HSM_USER_MASK | HSM_STATUS_MASK)
1803 * HSM request progress state
1805 enum hsm_progress_states {
1812 static inline const char *hsm_progress_state2name(enum hsm_progress_states s)
1815 case HPS_WAITING: return "waiting";
1816 case HPS_RUNNING: return "running";
1817 case HPS_DONE: return "done";
1818 default: return "unknown";
1825 } __attribute__((packed));
1828 * Current HSM states of a Lustre file.
1830 * This structure purpose is to be sent to user-space mainly. It describes the
1831 * current HSM flags and in-progress action.
1833 struct hsm_user_state {
1834 /** Current HSM states, from enum hsm_states. */
1836 __u32 hus_archive_id;
1837 /** The current undergoing action, if there is one */
1838 __u32 hus_in_progress_state;
1839 __u32 hus_in_progress_action;
1840 struct hsm_extent hus_in_progress_location;
1841 char hus_extended_info[];
1844 struct hsm_state_set_ioc {
1845 struct lu_fid hssi_fid;
1847 __u64 hssi_clearmask;
1851 * This structure describes the current in-progress action for a file.
1852 * it is retuned to user space and send over the wire
1854 struct hsm_current_action {
1855 /** The current undergoing action, if there is one */
1856 /* state is one of hsm_progress_states */
1858 /* action is one of hsm_user_action */
1860 struct hsm_extent hca_location;
1863 /***** HSM user requests ******/
1864 /* User-generated (lfs/ioctl) request types */
1865 enum hsm_user_action {
1866 HUA_NONE = 1, /* no action (noop) */
1867 HUA_ARCHIVE = 10, /* copy to hsm */
1868 HUA_RESTORE = 11, /* prestage */
1869 HUA_RELEASE = 12, /* drop ost objects */
1870 HUA_REMOVE = 13, /* remove from archive */
1871 HUA_CANCEL = 14 /* cancel a request */
1874 static inline const char *hsm_user_action2name(enum hsm_user_action a)
1877 case HUA_NONE: return "NOOP";
1878 case HUA_ARCHIVE: return "ARCHIVE";
1879 case HUA_RESTORE: return "RESTORE";
1880 case HUA_RELEASE: return "RELEASE";
1881 case HUA_REMOVE: return "REMOVE";
1882 case HUA_CANCEL: return "CANCEL";
1883 default: return "UNKNOWN";
1888 * List of hr_flags (bit field)
1890 #define HSM_FORCE_ACTION 0x0001
1891 /* used by CT, cannot be set by user */
1892 #define HSM_GHOST_COPY 0x0002
1895 * Contains all the fixed part of struct hsm_user_request.
1898 struct hsm_request {
1899 __u32 hr_action; /* enum hsm_user_action */
1900 __u32 hr_archive_id; /* archive id, used only with HUA_ARCHIVE */
1901 __u64 hr_flags; /* request flags */
1902 __u32 hr_itemcount; /* item count in hur_user_item vector */
1906 struct hsm_user_item {
1907 struct lu_fid hui_fid;
1908 struct hsm_extent hui_extent;
1909 } __attribute__((packed));
1911 struct hsm_user_request {
1912 struct hsm_request hur_request;
1913 struct hsm_user_item hur_user_item[0];
1914 /* extra data blob at end of struct (after all
1915 * hur_user_items), only use helpers to access it
1917 } __attribute__((packed));
1919 /** Return pointer to data field in a hsm user request */
1920 static inline void *hur_data(struct hsm_user_request *hur)
1922 return &(hur->hur_user_item[hur->hur_request.hr_itemcount]);
1926 * Compute the current length of the provided hsm_user_request. This returns -1
1927 * instead of an errno because ssize_t is defined to be only [ -1, SSIZE_MAX ]
1929 * return -1 on bounds check error.
1931 static inline ssize_t hur_len(struct hsm_user_request *hur)
1935 /* can't overflow a __u64 since hr_itemcount is only __u32 */
1936 size = offsetof(struct hsm_user_request, hur_user_item[0]) +
1937 (__u64)hur->hur_request.hr_itemcount *
1938 sizeof(hur->hur_user_item[0]) + hur->hur_request.hr_data_len;
1940 if (size != (ssize_t)size)
1946 /****** HSM RPCs to copytool *****/
1947 /* Message types the copytool may receive */
1948 enum hsm_message_type {
1949 HMT_ACTION_LIST = 100, /* message is a hsm_action_list */
1952 /* Actions the copytool may be instructed to take for a given action_item */
1953 enum hsm_copytool_action {
1954 HSMA_NONE = 10, /* no action */
1955 HSMA_ARCHIVE = 20, /* arbitrary offset */
1961 static inline const char *hsm_copytool_action2name(enum hsm_copytool_action a)
1964 case HSMA_NONE: return "NOOP";
1965 case HSMA_ARCHIVE: return "ARCHIVE";
1966 case HSMA_RESTORE: return "RESTORE";
1967 case HSMA_REMOVE: return "REMOVE";
1968 case HSMA_CANCEL: return "CANCEL";
1969 default: return "UNKNOWN";
1973 /* Copytool item action description */
1974 struct hsm_action_item {
1975 __u32 hai_len; /* valid size of this struct */
1976 __u32 hai_action; /* hsm_copytool_action, but use known size */
1977 struct lu_fid hai_fid; /* Lustre FID to operate on */
1978 struct lu_fid hai_dfid; /* fid used for data access */
1979 struct hsm_extent hai_extent; /* byte range to operate on */
1980 __u64 hai_cookie; /* action cookie from coordinator */
1981 __u64 hai_gid; /* grouplock id */
1982 char hai_data[0]; /* variable length */
1983 } __attribute__((packed));
1986 * helper function which print in hexa the first bytes of
1989 * \param hai [IN] record to print
1990 * \param buffer [IN,OUT] buffer to write the hex string to
1991 * \param len [IN] max buffer length
1995 static inline char *hai_dump_data_field(const struct hsm_action_item *hai,
1996 char *buffer, size_t len)
2003 data_len = hai->hai_len - sizeof(*hai);
2004 for (i = 0; (i < data_len) && (len > 2); i++) {
2005 snprintf(ptr, 3, "%02X", (unsigned char)hai->hai_data[i]);
2015 /* Copytool action list */
2016 #define HAL_VERSION 1
2017 #define HAL_MAXSIZE LNET_MTU /* bytes, used in userspace only */
2018 struct hsm_action_list {
2020 __u32 hal_count; /* number of hai's to follow */
2021 __u64 hal_compound_id; /* returned by coordinator, ignored */
2023 __u32 hal_archive_id; /* which archive backend */
2025 char hal_fsname[0]; /* null-terminated */
2026 /* struct hsm_action_item[hal_count] follows, aligned on 8-byte
2027 boundaries. See hai_zero */
2028 } __attribute__((packed));
2030 /* Return pointer to first hai in action list */
2031 static inline struct hsm_action_item *hai_first(struct hsm_action_list *hal)
2033 size_t offset = __ALIGN_KERNEL(strlen(hal->hal_fsname) + 1, 8);
2035 return (struct hsm_action_item *)(hal->hal_fsname + offset);
2038 /* Return pointer to next hai */
2039 static inline struct hsm_action_item * hai_next(struct hsm_action_item *hai)
2041 size_t offset = __ALIGN_KERNEL(hai->hai_len, 8);
2043 return (struct hsm_action_item *)((char *)hai + offset);
2046 /* Return size of an hsm_action_list */
2047 static inline size_t hal_size(struct hsm_action_list *hal)
2051 struct hsm_action_item *hai;
2053 sz = sizeof(*hal) + __ALIGN_KERNEL(strlen(hal->hal_fsname) + 1, 8);
2054 hai = hai_first(hal);
2055 for (i = 0; i < hal->hal_count ; i++, hai = hai_next(hai))
2056 sz += __ALIGN_KERNEL(hai->hai_len, 8);
2062 * describe the attributes to be set on imported file
2064 struct hsm_user_import {
2073 __u32 hui_archive_id;
2076 /* Copytool progress reporting */
2077 #define HP_FLAG_COMPLETED 0x01
2078 #define HP_FLAG_RETRY 0x02
2080 struct hsm_progress {
2081 struct lu_fid hp_fid;
2083 struct hsm_extent hp_extent;
2085 __u16 hp_errval; /* positive val */
2090 __u64 hc_data_version;
2092 __u16 hc_errval; /* positive val */
2094 struct hsm_action_item hc_hai;
2098 enum llapi_json_types {
2099 LLAPI_JSON_INTEGER = 1,
2105 struct llapi_json_item {
2114 struct llapi_json_item *lji_next;
2117 struct llapi_json_item_list {
2118 int ljil_item_count;
2119 struct llapi_json_item *ljil_items;
2122 enum lu_ladvise_type {
2123 LU_LADVISE_INVALID = 0,
2124 LU_LADVISE_WILLREAD = 1,
2125 LU_LADVISE_DONTNEED = 2,
2126 LU_LADVISE_LOCKNOEXPAND = 3,
2127 LU_LADVISE_LOCKAHEAD = 4,
2131 #define LU_LADVISE_NAMES { \
2132 [LU_LADVISE_WILLREAD] = "willread", \
2133 [LU_LADVISE_DONTNEED] = "dontneed", \
2134 [LU_LADVISE_LOCKNOEXPAND] = "locknoexpand", \
2135 [LU_LADVISE_LOCKAHEAD] = "lockahead", \
2138 /* This is the userspace argument for ladvise. It is currently the same as
2139 * what goes on the wire (struct lu_ladvise), but is defined separately as we
2140 * may need info which is only used locally. */
2141 struct llapi_lu_ladvise {
2142 __u16 lla_advice; /* advice type */
2143 __u16 lla_value1; /* values for different advice types */
2145 __u64 lla_start; /* first byte of extent for advice */
2146 __u64 lla_end; /* last byte of extent for advice */
2152 LF_ASYNC = 0x00000001,
2153 LF_UNSET = 0x00000002,
2156 #define LADVISE_MAGIC 0x1ADF1CE0
2157 /* Masks of valid flags for each advice */
2158 #define LF_LOCKNOEXPAND_MASK LF_UNSET
2159 /* Flags valid for all advices not explicitly specified */
2160 #define LF_DEFAULT_MASK LF_ASYNC
2162 #define LF_MASK (LF_ASYNC | LF_UNSET)
2164 #define lla_lockahead_mode lla_value1
2165 #define lla_peradvice_flags lla_value2
2166 #define lla_lockahead_result lla_value3
2168 /* This is the userspace argument for ladvise, corresponds to ladvise_hdr which
2169 * is used on the wire. It is defined separately as we may need info which is
2170 * only used locally. */
2171 struct llapi_ladvise_hdr {
2172 __u32 lah_magic; /* LADVISE_MAGIC */
2173 __u32 lah_count; /* number of advices */
2174 __u64 lah_flags; /* from enum ladvise_flag */
2175 __u32 lah_value1; /* unused */
2176 __u32 lah_value2; /* unused */
2177 __u64 lah_value3; /* unused */
2178 struct llapi_lu_ladvise lah_advise[0]; /* advices in this header */
2181 #define LAH_COUNT_MAX (1024)
2185 SK_CRYPT_INVALID = -1,
2187 SK_CRYPT_AES256_CTR = 1,
2191 SK_HMAC_INVALID = -1,
2197 struct sk_crypt_type {
2198 const char *sct_name;
2202 struct sk_hmac_type {
2203 const char *sht_name;
2207 enum lock_mode_user {
2213 #define LOCK_MODE_NAMES { \
2214 [MODE_READ_USER] = "READ",\
2215 [MODE_WRITE_USER] = "WRITE"\
2218 enum lockahead_results {
2219 LLA_RESULT_SENT = 0,
2220 LLA_RESULT_DIFFERENT,
2224 enum lu_heat_flag_bit {
2225 LU_HEAT_FLAG_BIT_INVALID = 0,
2226 LU_HEAT_FLAG_BIT_OFF,
2227 LU_HEAT_FLAG_BIT_CLEAR,
2230 #define LU_HEAT_FLAG_CLEAR (1 << LU_HEAT_FLAG_BIT_CLEAR)
2231 #define LU_HEAT_FLAG_OFF (1 << LU_HEAT_FLAG_BIT_OFF)
2233 enum obd_heat_type {
2234 OBD_HEAT_READSAMPLE = 0,
2235 OBD_HEAT_WRITESAMPLE = 1,
2236 OBD_HEAT_READBYTE = 2,
2237 OBD_HEAT_WRITEBYTE = 3,
2241 #define LU_HEAT_NAMES { \
2242 [OBD_HEAT_READSAMPLE] = "readsample", \
2243 [OBD_HEAT_WRITESAMPLE] = "writesample", \
2244 [OBD_HEAT_READBYTE] = "readbyte", \
2245 [OBD_HEAT_WRITEBYTE] = "writebyte", \
2254 #if defined(__cplusplus)
2258 /** @} lustreuser */
2260 #endif /* _LUSTRE_USER_H */