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/
31 * lustre/include/lustre/lustre_user.h
33 * Lustre public user-space interface definitions.
36 #ifndef _LUSTRE_USER_H
37 #define _LUSTRE_USER_H
39 /** \defgroup lustreuser lustreuser
45 #include <linux/limits.h>
46 #include <linux/kernel.h>
47 #include <linux/string.h>
48 #include <linux/quota.h>
49 #include <linux/types.h>
50 #include <linux/unistd.h>
51 #include <linux/lustre/lustre_fiemap.h>
52 #include <linux/lustre/lustre_ver.h>
55 # define __USE_ISOC99 1
57 # include <stdio.h> /* snprintf() */
58 # include <sys/stat.h>
59 # define FILEID_LUSTRE 0x97 /* for name_to_handle_at() (and llapi_fd2fid()) */
60 #endif /* !__KERNEL__ */
62 #if defined(__cplusplus)
66 #ifdef __STRICT_ANSI__
67 #define typeof __typeof__
71 * This is a temporary solution of adding quota type.
72 * Should be removed as soon as system header is updated.
75 #define LL_MAXQUOTAS 3
77 #define INITQFNAMES { \
78 "user", /* USRQUOTA */ \
79 "group", /* GRPQUOTA */ \
80 "project", /* PRJQUOTA */ \
94 * We need to always use 64bit version because the structure
95 * is shared across entire cluster where 32bit and 64bit machines
98 #if __BITS_PER_LONG != 64 || defined(__ARCH_WANT_STAT64)
99 typedef struct stat64 lstat_t;
100 #define lstat_f lstat64
101 #define fstat_f fstat64
102 #define fstatat_f fstatat64
104 typedef struct stat lstat_t;
105 #define lstat_f lstat
106 #define fstat_f fstat
107 #define fstatat_f fstatat
110 #ifndef STATX_BASIC_STATS
112 * Timestamp structure for the timestamps in struct statx.
114 * tv_sec holds the number of seconds before (negative) or after (positive)
115 * 00:00:00 1st January 1970 UTC.
117 * tv_nsec holds a number of nanoseconds (0..999,999,999) after the tv_sec time.
119 * __reserved is held in case we need a yet finer resolution.
121 struct statx_timestamp {
128 * Structures for the extended file attribute retrieval system call
131 * The caller passes a mask of what they're specifically interested in as a
132 * parameter to statx(). What statx() actually got will be indicated in
133 * st_mask upon return.
135 * For each bit in the mask argument:
137 * - if the datum is not supported:
139 * - the bit will be cleared, and
141 * - the datum will be set to an appropriate fabricated value if one is
142 * available (eg. CIFS can take a default uid and gid), otherwise
144 * - the field will be cleared;
146 * - otherwise, if explicitly requested:
148 * - the datum will be synchronised to the server if AT_STATX_FORCE_SYNC is
149 * set or if the datum is considered out of date, and
151 * - the field will be filled in and the bit will be set;
153 * - otherwise, if not requested, but available in approximate form without any
154 * effort, it will be filled in anyway, and the bit will be set upon return
155 * (it might not be up to date, however, and no attempt will be made to
156 * synchronise the internal state first);
158 * - otherwise the field and the bit will be cleared before returning.
160 * Items in STATX_BASIC_STATS may be marked unavailable on return, but they
161 * will have values installed for compatibility purposes so that stat() and
162 * co. can be emulated in userspace.
166 __u32 stx_mask; /* What results were written [uncond] */
167 __u32 stx_blksize; /* Preferred general I/O size [uncond] */
168 __u64 stx_attributes; /* Flags conveying information about the file [uncond] */
170 __u32 stx_nlink; /* Number of hard links */
171 __u32 stx_uid; /* User ID of owner */
172 __u32 stx_gid; /* Group ID of owner */
173 __u16 stx_mode; /* File mode */
176 __u64 stx_ino; /* Inode number */
177 __u64 stx_size; /* File size */
178 __u64 stx_blocks; /* Number of 512-byte blocks allocated */
179 __u64 stx_attributes_mask; /* Mask to show what's supported in stx_attributes */
181 struct statx_timestamp stx_atime; /* Last access time */
182 struct statx_timestamp stx_btime; /* File creation time */
183 struct statx_timestamp stx_ctime; /* Last attribute change time */
184 struct statx_timestamp stx_mtime; /* Last data modification time */
186 __u32 stx_rdev_major; /* Device ID of special file [if bdev/cdev] */
187 __u32 stx_rdev_minor;
188 __u32 stx_dev_major; /* ID of device containing file [uncond] */
191 __u64 __spare2[14]; /* Spare space for future expansion */
196 * Flags to be stx_mask
198 * Query request/result mask for statx() and struct statx::stx_mask.
200 * These bits should be set in the mask argument of statx() to request
201 * particular items when calling statx().
203 #define STATX_TYPE 0x00000001U /* Want/got stx_mode & S_IFMT */
204 #define STATX_MODE 0x00000002U /* Want/got stx_mode & ~S_IFMT */
205 #define STATX_NLINK 0x00000004U /* Want/got stx_nlink */
206 #define STATX_UID 0x00000008U /* Want/got stx_uid */
207 #define STATX_GID 0x00000010U /* Want/got stx_gid */
208 #define STATX_ATIME 0x00000020U /* Want/got stx_atime */
209 #define STATX_MTIME 0x00000040U /* Want/got stx_mtime */
210 #define STATX_CTIME 0x00000080U /* Want/got stx_ctime */
211 #define STATX_INO 0x00000100U /* Want/got stx_ino */
212 #define STATX_SIZE 0x00000200U /* Want/got stx_size */
213 #define STATX_BLOCKS 0x00000400U /* Want/got stx_blocks */
214 #define STATX_BASIC_STATS 0x000007ffU /* The stuff in the normal stat struct */
215 #define STATX_BTIME 0x00000800U /* Want/got stx_btime */
216 #define STATX_ALL 0x00000fffU /* All currently supported flags */
217 #define STATX__RESERVED 0x80000000U /* Reserved for future struct statx expansion */
220 * Attributes to be found in stx_attributes and masked in stx_attributes_mask.
222 * These give information about the features or the state of a file that might
223 * be of use to ordinary userspace programs such as GUIs or ls rather than
226 * Note that the flags marked [I] correspond to generic FS_IOC_FLAGS
227 * semantically. Where possible, the numerical value is picked to correspond
230 #define STATX_ATTR_COMPRESSED 0x00000004 /* [I] File is compressed by the fs */
231 #define STATX_ATTR_IMMUTABLE 0x00000010 /* [I] File is marked immutable */
232 #define STATX_ATTR_APPEND 0x00000020 /* [I] File is append-only */
233 #define STATX_ATTR_NODUMP 0x00000040 /* [I] File is not to be dumped */
234 #define STATX_ATTR_ENCRYPTED 0x00000800 /* [I] File requires key to decrypt in fs */
236 #define STATX_ATTR_AUTOMOUNT 0x00001000 /* Dir: Automount trigger */
238 #define AT_STATX_SYNC_TYPE 0x6000 /* Type of synchronisation required from statx() */
239 #define AT_STATX_SYNC_AS_STAT 0x0000 /* - Do whatever stat() does */
240 #define AT_STATX_FORCE_SYNC 0x2000 /* - Force the attributes to be sync'd with the server */
241 #define AT_STATX_DONT_SYNC 0x4000 /* - Don't sync attributes with the server */
243 #endif /* STATX_BASIC_STATS */
245 typedef struct statx lstatx_t;
247 #define LUSTRE_EOF 0xffffffffffffffffULL
250 #define LL_SUPER_MAGIC 0x0BD00BD0
252 #define FSFILT_IOC_GETVERSION _IOR('f', 3, long)
254 /* FIEMAP flags supported by Lustre */
255 #define LUSTRE_FIEMAP_FLAGS_COMPAT (FIEMAP_FLAG_SYNC | FIEMAP_FLAG_DEVICE_ORDER)
257 enum obd_statfs_state {
258 OS_STATFS_DEGRADED = 0x00000001, /**< RAID degraded/rebuilding */
259 OS_STATFS_READONLY = 0x00000002, /**< filesystem is read-only */
260 OS_STATFS_NOPRECREATE = 0x00000004, /**< no object precreation */
261 OS_STATFS_UNUSED1 = 0x00000008, /**< obsolete 1.6, was EROFS=30 */
262 OS_STATFS_UNUSED2 = 0x00000010, /**< obsolete 1.6, was EROFS=30 */
263 OS_STATFS_ENOSPC = 0x00000020, /**< not enough free space */
264 OS_STATFS_ENOINO = 0x00000040, /**< not enough inodes */
265 OS_STATFS_SUM = 0x00000100, /**< aggregated for all tagrets */
266 OS_STATFS_NONROT = 0x00000200, /**< non-rotational device */
269 /** filesystem statistics/attributes for target device */
271 __u64 os_type; /* EXT4_SUPER_MAGIC, UBERBLOCK_MAGIC */
272 __u64 os_blocks; /* total size in #os_bsize blocks */
273 __u64 os_bfree; /* number of unused blocks */
274 __u64 os_bavail; /* blocks available for allocation */
275 __u64 os_files; /* total number of objects */
276 __u64 os_ffree; /* # objects that could be created */
277 __u8 os_fsid[40]; /* identifier for filesystem */
278 __u32 os_bsize; /* block size in bytes for os_blocks */
279 __u32 os_namelen; /* maximum length of filename in bytes*/
280 __u64 os_maxbytes; /* maximum object size in bytes */
281 __u32 os_state; /**< obd_statfs_state OS_STATFS_* */
282 __u32 os_fprecreated; /* objs available now to the caller */
283 /* used in QoS code to find preferred
285 __u32 os_granted; /* space granted for MDS */
286 __u32 os_spare3; /* Unused padding fields. Remember */
287 __u32 os_spare4; /* to fix lustre_swab_obd_statfs() */
295 /** additional filesystem attributes for target device */
296 struct obd_statfs_info {
297 __u32 os_reserved_mb_low; /* reserved mb low */
298 __u32 os_reserved_mb_high; /* reserved mb high */
299 bool os_enable_pre; /* enable pre create logic */
305 * FID is a cluster-wide unique identifier of a file or an object (stripe).
306 * FIDs are never reused.
310 * FID sequence. Sequence is a unit of migration: all files (objects)
311 * with FIDs from a given sequence are stored on the same server.
312 * Lustre should support 2^64 objects, so even if each sequence
313 * has only a single object we can still enumerate 2^64 objects.
316 /* FID number within sequence. */
319 * FID version, used to distinguish different versions (in the sense
320 * of snapshots, etc.) of the same file system object. Not currently
324 } __attribute__((packed));
326 static inline bool fid_is_zero(const struct lu_fid *fid)
328 return fid->f_seq == 0 && fid->f_oid == 0;
331 /* The data name_to_handle_at() places in a struct file_handle (at f_handle) */
332 struct lustre_file_handle {
333 struct lu_fid lfh_child;
334 struct lu_fid lfh_parent;
337 /* Currently, the filter_fid::ff_parent::f_ver is not the real parent
338 * MDT-object's FID::f_ver, instead it is the OST-object index in its
339 * parent MDT-object's layout EA. */
340 #define f_stripe_idx f_ver
343 __u32 ol_stripe_size;
344 __u32 ol_stripe_count;
348 } __attribute__((packed));
350 /* The filter_fid structure has changed several times over its lifetime.
351 * For a long time "trusted.fid" held the MDT inode parent FID/IGIF and
352 * stripe_index and the "self FID" (objid/seq) to be able to recover the
353 * OST objects in case of corruption. With the move to 2.4 and OSD-API for
354 * the OST, the "trusted.lma" xattr was added to the OST objects to store
355 * the "self FID" to be consistent with the MDT on-disk format, and the
356 * filter_fid only stored the MDT inode parent FID and stripe index.
358 * In 2.10, the addition of PFL composite layouts required more information
359 * to be stored into the filter_fid in order to be able to identify which
360 * component the OST object belonged. As well, the stripe size may vary
361 * between components, so it was no longer safe to assume the stripe size
362 * or stripe_count of a file. This is also more robust for plain layouts.
364 * For ldiskfs OSTs that were formatted with 256-byte inodes, there is not
365 * enough space to store both the filter_fid and LMA in the inode, so they
366 * are packed into struct lustre_ost_attrs on disk in trusted.lma to avoid
367 * an extra seek for every OST object access.
369 * In 2.11, FLR mirror layouts also need to store the layout version and
370 * range so that writes to old versions of the layout are not allowed.
371 * That ensures that mirrored objects are not modified by evicted clients,
372 * and ensures that the components are correctly marked stale on the MDT.
374 struct filter_fid_18_23 {
375 struct lu_fid ff_parent; /* stripe_idx in f_ver */
380 struct filter_fid_24_29 {
381 struct lu_fid ff_parent; /* stripe_idx in f_ver */
384 struct filter_fid_210 {
385 struct lu_fid ff_parent; /* stripe_idx in f_ver */
386 struct ost_layout ff_layout;
390 struct lu_fid ff_parent; /* stripe_idx in f_ver */
391 struct ost_layout ff_layout;
392 __u32 ff_layout_version;
393 __u32 ff_range; /* range of layout version that
394 * write are allowed */
395 } __attribute__((packed));
397 /* Userspace should treat lu_fid as opaque, and only use the following methods
398 * to print or parse them. Other functions (e.g. compare, swab) could be moved
399 * here from lustre_idl.h if needed. */
403 LMAC_HSM = 0x00000001,
404 /* LMAC_SOM = 0x00000002, obsolete since 2.8.0 */
405 LMAC_NOT_IN_OI = 0x00000004, /* the object does NOT need OI mapping */
406 LMAC_FID_ON_OST = 0x00000008, /* For OST-object, its OI mapping is
407 * under /O/<seq>/d<x>. */
408 LMAC_STRIPE_INFO = 0x00000010, /* stripe info in the LMA EA. */
409 LMAC_COMP_INFO = 0x00000020, /* Component info in the LMA EA. */
410 LMAC_IDX_BACKUP = 0x00000040, /* Has index backup. */
414 * Masks for all features that should be supported by a Lustre version to
415 * access a specific file.
416 * This information is stored in lustre_mdt_attrs::lma_incompat.
419 LMAI_RELEASED = 0x00000001, /* file is released */
420 LMAI_AGENT = 0x00000002, /* agent inode */
421 LMAI_REMOTE_PARENT = 0x00000004, /* the parent of the object
422 is on the remote MDT */
423 LMAI_STRIPED = 0x00000008, /* striped directory inode */
424 LMAI_ORPHAN = 0x00000010, /* inode is orphan */
425 LMAI_ENCRYPT = 0x00000020, /* inode is encrypted */
426 LMA_INCOMPAT_SUPP = (LMAI_AGENT | LMAI_REMOTE_PARENT | \
427 LMAI_STRIPED | LMAI_ORPHAN | LMAI_ENCRYPT)
432 * Following struct for object attributes, that will be kept inode's EA.
433 * Introduced in 2.0 release (please see b15993, for details)
434 * Added to all objects since Lustre 2.4 as contains self FID
436 struct lustre_mdt_attrs {
438 * Bitfield for supported data in this structure. From enum lma_compat.
439 * lma_self_fid and lma_flags are always available.
443 * Per-file incompat feature list. Lustre version should support all
444 * flags set in this field. The supported feature mask is available in
448 /** FID of this inode */
449 struct lu_fid lma_self_fid;
452 struct lustre_ost_attrs {
453 /* Use lustre_mdt_attrs directly for now, need a common header
454 * structure if want to change lustre_mdt_attrs in future. */
455 struct lustre_mdt_attrs loa_lma;
457 /* Below five elements are for OST-object's PFID EA, the
458 * lma_parent_fid::f_ver is composed of the stripe_count (high 16 bits)
459 * and the stripe_index (low 16 bits), the size should not exceed
460 * 5 * sizeof(__u64)) to be accessable by old Lustre. If the flag
461 * LMAC_STRIPE_INFO is set, then loa_parent_fid and loa_stripe_size
462 * are valid; if the flag LMAC_COMP_INFO is set, then the next three
463 * loa_comp_* elements are valid. */
464 struct lu_fid loa_parent_fid;
465 __u32 loa_stripe_size;
467 __u64 loa_comp_start;
472 * Prior to 2.4, the LMA structure also included SOM attributes which has since
473 * been moved to a dedicated xattr
474 * lma_flags was also removed because of lma_compat/incompat fields.
476 #define LMA_OLD_SIZE (sizeof(struct lustre_mdt_attrs) + 5 * sizeof(__u64))
478 enum lustre_som_flags {
479 /* Unknow or no SoM data, must get size from OSTs. */
480 SOM_FL_UNKNOWN = 0x0000,
481 /* Known strictly correct, FLR or DoM file (SoM guaranteed). */
482 SOM_FL_STRICT = 0x0001,
483 /* Known stale - was right at some point in the past, but it is
484 * known (or likely) to be incorrect now (e.g. opened for write). */
485 SOM_FL_STALE = 0x0002,
486 /* Approximate, may never have been strictly correct,
487 * need to sync SOM data to achieve eventual consistency. */
488 SOM_FL_LAZY = 0x0004,
491 struct lustre_som_attrs {
493 __u16 lsa_reserved[3];
499 * OST object IDentifier.
507 struct lu_fid oi_fid;
509 } __attribute__((packed));
511 #define DOSTID "%#llx:%llu"
512 #define POSTID(oi) ((unsigned long long)ostid_seq(oi)), \
513 ((unsigned long long)ostid_id(oi))
515 struct ll_futimes_3 {
517 __u64 lfu_atime_nsec;
519 __u64 lfu_mtime_nsec;
521 __u64 lfu_ctime_nsec;
525 * Maximum number of mirrors currently implemented.
527 #define LUSTRE_MIRROR_COUNT_MAX 16
529 /* Lease types for use as arg and return of LL_IOC_{GET,SET}_LEASE ioctl. */
531 LL_LEASE_RDLCK = 0x01,
532 LL_LEASE_WRLCK = 0x02,
533 LL_LEASE_UNLCK = 0x04,
536 enum ll_lease_flags {
537 LL_LEASE_RESYNC = 0x1,
538 LL_LEASE_RESYNC_DONE = 0x2,
539 LL_LEASE_LAYOUT_MERGE = 0x4,
540 LL_LEASE_LAYOUT_SPLIT = 0x8,
541 LL_LEASE_PCC_ATTACH = 0x10,
544 #define IOC_IDS_MAX 4096
545 struct ll_ioc_lease {
552 struct ll_ioc_lease_id {
563 * The ioctl naming rules:
564 * LL_* - works on the currently opened filehandle instead of parent dir
565 * *_OBD_* - gets data for both OSC or MDC (LOV, LMV indirectly)
566 * *_MDC_* - gets/sets data related to MDC
567 * *_LOV_* - gets/sets data related to OSC/LOV
568 * *FILE* - called on parent dir and passes in a filename
569 * *STRIPE* - set/get lov_user_md
570 * *INFO - set/get lov_user_mds_data
572 /* lustre_ioctl.h 101-150 */
573 /* ioctl codes 128-143 are reserved for fsverity */
574 #define LL_IOC_GETFLAGS _IOR ('f', 151, long)
575 #define LL_IOC_SETFLAGS _IOW ('f', 152, long)
576 #define LL_IOC_CLRFLAGS _IOW ('f', 153, long)
577 #define LL_IOC_LOV_SETSTRIPE _IOW ('f', 154, long)
578 #define LL_IOC_LOV_SETSTRIPE_NEW _IOWR('f', 154, struct lov_user_md)
579 #define LL_IOC_LOV_GETSTRIPE _IOW ('f', 155, long)
580 #define LL_IOC_LOV_GETSTRIPE_NEW _IOR('f', 155, struct lov_user_md)
581 #define LL_IOC_LOV_SETEA _IOW ('f', 156, long)
582 /* LL_IOC_RECREATE_OBJ 157 obsolete */
583 /* LL_IOC_RECREATE_FID 157 obsolete */
584 #define LL_IOC_GROUP_LOCK _IOW ('f', 158, long)
585 #define LL_IOC_GROUP_UNLOCK _IOW ('f', 159, long)
586 /* LL_IOC_QUOTACHECK 160 OBD_IOC_QUOTACHECK */
587 /* LL_IOC_POLL_QUOTACHECK 161 OBD_IOC_POLL_QUOTACHECK */
588 /* LL_IOC_QUOTACTL 162 OBD_IOC_QUOTACTL */
589 #define IOC_OBD_STATFS _IOWR('f', 164, struct obd_statfs *)
590 /* IOC_LOV_GETINFO 165 obsolete */
591 #define LL_IOC_FLUSHCTX _IOW ('f', 166, long)
592 /* LL_IOC_RMTACL 167 obsolete */
593 #define LL_IOC_GETOBDCOUNT _IOR ('f', 168, long)
594 #define LL_IOC_LLOOP_ATTACH _IOWR('f', 169, long)
595 #define LL_IOC_LLOOP_DETACH _IOWR('f', 170, long)
596 #define LL_IOC_LLOOP_INFO _IOWR('f', 171, struct lu_fid)
597 #define LL_IOC_LLOOP_DETACH_BYDEV _IOWR('f', 172, long)
598 #define LL_IOC_PATH2FID _IOR ('f', 173, long)
599 #define LL_IOC_GET_CONNECT_FLAGS _IOWR('f', 174, __u64 *)
600 #define LL_IOC_GET_MDTIDX _IOR ('f', 175, int)
601 #define LL_IOC_FUTIMES_3 _IOWR('f', 176, struct ll_futimes_3)
602 #define LL_IOC_FLR_SET_MIRROR _IOW ('f', 177, long)
603 /* lustre_ioctl.h 177-210 */
604 #define LL_IOC_HSM_STATE_GET _IOR('f', 211, struct hsm_user_state)
605 #define LL_IOC_HSM_STATE_SET _IOW('f', 212, struct hsm_state_set)
606 #define LL_IOC_HSM_CT_START _IOW('f', 213, struct lustre_kernelcomm)
607 #define LL_IOC_HSM_COPY_START _IOW('f', 214, struct hsm_copy *)
608 #define LL_IOC_HSM_COPY_END _IOW('f', 215, struct hsm_copy *)
609 #define LL_IOC_HSM_PROGRESS _IOW('f', 216, struct hsm_user_request)
610 #define LL_IOC_HSM_REQUEST _IOW('f', 217, struct hsm_user_request)
611 #define LL_IOC_DATA_VERSION _IOR('f', 218, struct ioc_data_version)
612 #define LL_IOC_LOV_SWAP_LAYOUTS _IOW('f', 219, \
613 struct lustre_swap_layouts)
614 #define LL_IOC_HSM_ACTION _IOR('f', 220, \
615 struct hsm_current_action)
616 /* lustre_ioctl.h 221-232 */
617 #define LL_IOC_LMV_SETSTRIPE _IOWR('f', 240, struct lmv_user_md)
618 #define LL_IOC_LMV_GETSTRIPE _IOWR('f', 241, struct lmv_user_md)
619 #define LL_IOC_REMOVE_ENTRY _IOWR('f', 242, __u64)
620 #define LL_IOC_RMFID _IOR('f', 242, struct fid_array)
621 #define LL_IOC_UNLOCK_FOREIGN _IO('f', 242)
622 #define LL_IOC_SET_LEASE _IOWR('f', 243, struct ll_ioc_lease)
623 #define LL_IOC_SET_LEASE_OLD _IOWR('f', 243, long)
624 #define LL_IOC_GET_LEASE _IO('f', 244)
625 #define LL_IOC_HSM_IMPORT _IOWR('f', 245, struct hsm_user_import)
626 #define LL_IOC_LMV_SET_DEFAULT_STRIPE _IOWR('f', 246, struct lmv_user_md)
627 #define LL_IOC_MIGRATE _IOR('f', 247, int)
628 #define LL_IOC_FID2MDTIDX _IOWR('f', 248, struct lu_fid)
629 #define LL_IOC_GETPARENT _IOWR('f', 249, struct getparent)
630 #define LL_IOC_LADVISE _IOR('f', 250, struct llapi_lu_ladvise)
631 #define LL_IOC_HEAT_GET _IOWR('f', 251, struct lu_heat)
632 #define LL_IOC_HEAT_SET _IOW('f', 251, __u64)
633 #define LL_IOC_PCC_DETACH _IOW('f', 252, struct lu_pcc_detach)
634 #define LL_IOC_PCC_DETACH_BY_FID _IOW('f', 252, struct lu_pcc_detach_fid)
635 #define LL_IOC_PCC_STATE _IOR('f', 252, struct lu_pcc_state)
637 #ifndef FS_IOC_FSGETXATTR
639 * Structure for FS_IOC_FSGETXATTR and FS_IOC_FSSETXATTR.
642 __u32 fsx_xflags; /* xflags field value (get/set) */
643 __u32 fsx_extsize; /* extsize field value (get/set)*/
644 __u32 fsx_nextents; /* nextents field value (get) */
645 __u32 fsx_projid; /* project identifier (get/set) */
646 unsigned char fsx_pad[12];
648 #define FS_IOC_FSGETXATTR _IOR('X', 31, struct fsxattr)
649 #define FS_IOC_FSSETXATTR _IOW('X', 32, struct fsxattr)
651 #ifndef FS_XFLAG_PROJINHERIT
652 #define FS_XFLAG_PROJINHERIT 0x00000200
656 #define LL_STATFS_LMV 1
657 #define LL_STATFS_LOV 2
658 #define LL_STATFS_NODELAY 4
660 #define IOC_MDC_TYPE 'i'
661 #define IOC_MDC_LOOKUP _IOWR(IOC_MDC_TYPE, 20, struct obd_device *)
662 #define IOC_MDC_GETFILESTRIPE _IOWR(IOC_MDC_TYPE, 21, struct lov_user_md *)
663 #define IOC_MDC_GETFILEINFO_V1 _IOWR(IOC_MDC_TYPE, 22, struct lov_user_mds_data_v1 *)
664 #define IOC_MDC_GETFILEINFO_V2 _IOWR(IOC_MDC_TYPE, 22, struct lov_user_mds_data)
665 #define LL_IOC_MDC_GETINFO_V1 _IOWR(IOC_MDC_TYPE, 23, struct lov_user_mds_data_v1 *)
666 #define LL_IOC_MDC_GETINFO_V2 _IOWR(IOC_MDC_TYPE, 23, struct lov_user_mds_data)
667 #define IOC_MDC_GETFILEINFO IOC_MDC_GETFILEINFO_V1
668 #define LL_IOC_MDC_GETINFO LL_IOC_MDC_GETINFO_V1
670 #define MAX_OBD_NAME 128 /* If this changes, a NEW ioctl must be added */
672 /* Define O_LOV_DELAY_CREATE to be a mask that is not useful for regular
673 * files, but are unlikely to be used in practice and are not harmful if
674 * used incorrectly. O_NOCTTY and FASYNC are only meaningful for character
675 * devices and are safe for use on new files. See LU-4209. */
676 /* To be compatible with old statically linked binary we keep the check for
677 * the older 0100000000 flag. This is already removed upstream. LU-812. */
678 #define O_LOV_DELAY_CREATE_1_8 0100000000 /* FMODE_NONOTIFY masked in 2.6.36 */
680 #define FASYNC 00020000 /* fcntl, for BSD compatibility */
682 #define O_LOV_DELAY_CREATE_MASK (O_NOCTTY | FASYNC)
683 #define O_LOV_DELAY_CREATE (O_LOV_DELAY_CREATE_1_8 | \
684 O_LOV_DELAY_CREATE_MASK)
686 #define LL_FILE_IGNORE_LOCK 0x00000001
687 #define LL_FILE_GROUP_LOCKED 0x00000002
688 #define LL_FILE_READAHEA 0x00000004
689 #define LL_FILE_LOCKED_DIRECTIO 0x00000008 /* client-side locks with dio */
690 #define LL_FILE_FLOCK_WARNING 0x00000020 /* warned about disabled flock */
692 #define LOV_USER_MAGIC_V1 0x0BD10BD0
693 #define LOV_USER_MAGIC LOV_USER_MAGIC_V1
694 #define LOV_USER_MAGIC_JOIN_V1 0x0BD20BD0
695 #define LOV_USER_MAGIC_V3 0x0BD30BD0
696 /* 0x0BD40BD0 is occupied by LOV_MAGIC_MIGRATE */
697 #define LOV_USER_MAGIC_SPECIFIC 0x0BD50BD0 /* for specific OSTs */
698 #define LOV_USER_MAGIC_COMP_V1 0x0BD60BD0
699 #define LOV_USER_MAGIC_FOREIGN 0x0BD70BD0
700 #define LOV_USER_MAGIC_SEL 0x0BD80BD0
702 #define LMV_USER_MAGIC 0x0CD30CD0 /* default lmv magic */
703 #define LMV_USER_MAGIC_V0 0x0CD20CD0 /* old default lmv magic*/
704 #define LMV_USER_MAGIC_SPECIFIC 0x0CD40CD0
706 #define LOV_PATTERN_NONE 0x000
707 #define LOV_PATTERN_RAID0 0x001
708 #define LOV_PATTERN_RAID1 0x002
709 #define LOV_PATTERN_MDT 0x100
710 #define LOV_PATTERN_OVERSTRIPING 0x200
711 #define LOV_PATTERN_FOREIGN 0x400
713 #define LOV_PATTERN_F_MASK 0xffff0000
714 #define LOV_PATTERN_F_HOLE 0x40000000 /* there is hole in LOV EA */
715 #define LOV_PATTERN_F_RELEASED 0x80000000 /* HSM released file */
716 #define LOV_PATTERN_DEFAULT 0xffffffff
718 #define LOV_OFFSET_DEFAULT ((__u16)-1)
719 #define LMV_OFFSET_DEFAULT ((__u32)-1)
721 static inline bool lov_pattern_supported(__u32 pattern)
723 return (pattern & ~LOV_PATTERN_F_RELEASED) == LOV_PATTERN_RAID0 ||
724 (pattern & ~LOV_PATTERN_F_RELEASED) ==
725 (LOV_PATTERN_RAID0 | LOV_PATTERN_OVERSTRIPING) ||
726 (pattern & ~LOV_PATTERN_F_RELEASED) == LOV_PATTERN_MDT;
729 /* RELEASED and MDT patterns are not valid in many places, so rather than
730 * having many extra checks on lov_pattern_supported, we have this separate
731 * check for non-released, non-DOM components
733 static inline bool lov_pattern_supported_normal_comp(__u32 pattern)
735 return pattern == LOV_PATTERN_RAID0 ||
736 pattern == (LOV_PATTERN_RAID0 | LOV_PATTERN_OVERSTRIPING);
740 #define LOV_MAXPOOLNAME 15
741 #define LOV_POOLNAMEF "%.15s"
743 #define LOV_MIN_STRIPE_BITS 16 /* maximum PAGE_SIZE (ia64), power of 2 */
744 #define LOV_MIN_STRIPE_SIZE (1 << LOV_MIN_STRIPE_BITS)
745 #define LOV_MAX_STRIPE_COUNT_OLD 160
746 /* This calculation is crafted so that input of 4096 will result in 160
747 * which in turn is equal to old maximal stripe count.
748 * XXX: In fact this is too simpified for now, what it also need is to get
749 * ea_type argument to clearly know how much space each stripe consumes.
751 * The limit of 12 pages is somewhat arbitrary, but is a reasonably large
752 * allocation that is sufficient for the current generation of systems.
754 * (max buffer size - lov+rpc header) / sizeof(struct lov_ost_data_v1) */
755 #define LOV_MAX_STRIPE_COUNT 2000 /* ~((12 * 4096 - 256) / 24) */
756 #define LOV_ALL_STRIPES 0xffff /* only valid for directories */
757 #define LOV_V1_INSANE_STRIPE_COUNT 65532 /* maximum stripe count bz13933 */
759 #define XATTR_LUSTRE_PREFIX "lustre."
760 #define XATTR_LUSTRE_LOV XATTR_LUSTRE_PREFIX"lov"
762 /* Please update if XATTR_LUSTRE_LOV".set" groks more flags in the future */
763 #define allowed_lustre_lov(att) (strcmp((att), XATTR_LUSTRE_LOV".add") == 0 || \
764 strcmp((att), XATTR_LUSTRE_LOV".set") == 0 || \
765 strcmp((att), XATTR_LUSTRE_LOV".set.flags") == 0 || \
766 strcmp((att), XATTR_LUSTRE_LOV".del") == 0)
768 #define lov_user_ost_data lov_user_ost_data_v1
769 struct lov_user_ost_data_v1 { /* per-stripe data structure */
770 struct ost_id l_ost_oi; /* OST object ID */
771 __u32 l_ost_gen; /* generation of this OST index */
772 __u32 l_ost_idx; /* OST index in LOV */
773 } __attribute__((packed));
775 #define lov_user_md lov_user_md_v1
776 struct lov_user_md_v1 { /* LOV EA user data (host-endian) */
777 __u32 lmm_magic; /* magic number = LOV_USER_MAGIC_V1 */
778 __u32 lmm_pattern; /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */
779 struct ost_id lmm_oi; /* MDT parent inode id/seq (id/0 for 1.x) */
780 __u32 lmm_stripe_size; /* size of stripe in bytes */
781 __u16 lmm_stripe_count; /* num stripes in use for this object */
783 __u16 lmm_stripe_offset; /* starting stripe offset in
784 * lmm_objects, use when writing */
785 __u16 lmm_layout_gen; /* layout generation number
786 * used when reading */
788 struct lov_user_ost_data_v1 lmm_objects[0]; /* per-stripe data */
789 } __attribute__((packed, __may_alias__));
791 struct lov_user_md_v3 { /* LOV EA user data (host-endian) */
792 __u32 lmm_magic; /* magic number = LOV_USER_MAGIC_V3 */
793 __u32 lmm_pattern; /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */
794 struct ost_id lmm_oi; /* MDT parent inode id/seq (id/0 for 1.x) */
795 __u32 lmm_stripe_size; /* size of stripe in bytes */
796 __u16 lmm_stripe_count; /* num stripes in use for this object */
798 __u16 lmm_stripe_offset; /* starting stripe offset in
799 * lmm_objects, use when writing */
800 __u16 lmm_layout_gen; /* layout generation number
801 * used when reading */
803 char lmm_pool_name[LOV_MAXPOOLNAME + 1]; /* pool name */
804 struct lov_user_ost_data_v1 lmm_objects[0]; /* per-stripe data */
805 } __attribute__((packed, __may_alias__));
807 struct lov_foreign_md {
808 __u32 lfm_magic; /* magic number = LOV_MAGIC_FOREIGN */
809 __u32 lfm_length; /* length of lfm_value */
810 __u32 lfm_type; /* type, see LU_FOREIGN_TYPE_ */
811 __u32 lfm_flags; /* flags, type specific */
813 } __attribute__((packed));
815 #define foreign_size(lfm) (((struct lov_foreign_md *)lfm)->lfm_length + \
816 offsetof(struct lov_foreign_md, lfm_value))
818 #define foreign_size_le(lfm) \
819 (le32_to_cpu(((struct lov_foreign_md *)lfm)->lfm_length) + \
820 offsetof(struct lov_foreign_md, lfm_value))
823 * The stripe size fields are shared for the extension size storage, however
824 * the extension size is stored in KB, not bytes.
826 #define SEL_UNIT_SIZE 1024llu
831 } __attribute__((packed));
833 #define DEXT "[%#llx, %#llx)"
834 #define PEXT(ext) (unsigned long long)(ext)->e_start, (unsigned long long)(ext)->e_end
836 static inline bool lu_extent_is_overlapped(struct lu_extent *e1,
837 struct lu_extent *e2)
839 return e1->e_start < e2->e_end && e2->e_start < e1->e_end;
842 static inline bool lu_extent_is_whole(struct lu_extent *e)
844 return e->e_start == 0 && e->e_end == LUSTRE_EOF;
847 enum lov_comp_md_entry_flags {
848 LCME_FL_STALE = 0x00000001, /* FLR: stale data */
849 LCME_FL_PREF_RD = 0x00000002, /* FLR: preferred for reading */
850 LCME_FL_PREF_WR = 0x00000004, /* FLR: preferred for writing */
851 LCME_FL_PREF_RW = LCME_FL_PREF_RD | LCME_FL_PREF_WR,
852 LCME_FL_OFFLINE = 0x00000008, /* Not used */
853 LCME_FL_INIT = 0x00000010, /* instantiated */
854 LCME_FL_NOSYNC = 0x00000020, /* FLR: no sync for the mirror */
855 LCME_FL_EXTENSION = 0x00000040, /* extension comp, never init */
856 LCME_FL_NEG = 0x80000000 /* used to indicate a negative flag,
857 * won't be stored on disk
861 #define LCME_KNOWN_FLAGS (LCME_FL_NEG | LCME_FL_INIT | LCME_FL_STALE | \
862 LCME_FL_PREF_RW | LCME_FL_NOSYNC | \
865 /* The component flags can be set by users at creation/modification time. */
866 #define LCME_USER_COMP_FLAGS (LCME_FL_PREF_RW | LCME_FL_NOSYNC | \
869 /* The mirror flags can be set by users at creation time. */
870 #define LCME_USER_MIRROR_FLAGS (LCME_FL_PREF_RW)
872 /* The allowed flags obtained from the client at component creation time. */
873 #define LCME_CL_COMP_FLAGS (LCME_USER_MIRROR_FLAGS | LCME_FL_EXTENSION)
875 /* The mirror flags sent by client */
876 #define LCME_MIRROR_FLAGS (LCME_FL_NOSYNC)
878 /* These flags have meaning when set in a default layout and will be inherited
879 * from the default/template layout set on a directory.
881 #define LCME_TEMPLATE_FLAGS (LCME_FL_PREF_RW | LCME_FL_NOSYNC | \
884 /* the highest bit in obdo::o_layout_version is used to mark if the file is
886 #define LU_LAYOUT_RESYNC LCME_FL_NEG
888 /* lcme_id can be specified as certain flags, and the the first
889 * bit of lcme_id is used to indicate that the ID is representing
890 * certain LCME_FL_* but not a real ID. Which implies we can have
891 * at most 31 flags (see LCME_FL_XXX). */
894 LCME_ID_MAX = 0x7FFFFFFF,
895 LCME_ID_ALL = 0xFFFFFFFF,
896 LCME_ID_NOT_ID = LCME_FL_NEG
899 #define LCME_ID_MASK LCME_ID_MAX
901 struct lov_comp_md_entry_v1 {
902 __u32 lcme_id; /* unique id of component */
903 __u32 lcme_flags; /* LCME_FL_XXX */
904 struct lu_extent lcme_extent; /* file extent for component */
905 __u32 lcme_offset; /* offset of component blob,
906 start from lov_comp_md_v1 */
907 __u32 lcme_size; /* size of component blob */
908 __u32 lcme_layout_gen;
909 __u64 lcme_timestamp; /* snapshot time if applicable*/
910 __u32 lcme_padding_1;
911 } __attribute__((packed));
913 #define SEQ_ID_MAX 0x0000FFFF
914 #define SEQ_ID_MASK SEQ_ID_MAX
915 /* bit 30:16 of lcme_id is used to store mirror id */
916 #define MIRROR_ID_MASK 0x7FFF0000
917 #define MIRROR_ID_NEG 0x8000
918 #define MIRROR_ID_SHIFT 16
920 static inline __u32 pflr_id(__u16 mirror_id, __u16 seqid)
922 return ((mirror_id << MIRROR_ID_SHIFT) & MIRROR_ID_MASK) | seqid;
925 static inline __u16 mirror_id_of(__u32 id)
927 return (id & MIRROR_ID_MASK) >> MIRROR_ID_SHIFT;
931 * on-disk data for lcm_flags. Valid if lcm_magic is LOV_MAGIC_COMP_V1.
933 enum lov_comp_md_flags {
934 /* the least 2 bits are used by FLR to record file state */
937 LCM_FL_WRITE_PENDING = 2,
938 LCM_FL_SYNC_PENDING = 3,
939 LCM_FL_FLR_MASK = 0x3,
942 struct lov_comp_md_v1 {
943 __u32 lcm_magic; /* LOV_USER_MAGIC_COMP_V1 */
944 __u32 lcm_size; /* overall size including this struct */
945 __u32 lcm_layout_gen;
947 __u16 lcm_entry_count;
948 /* lcm_mirror_count stores the number of actual mirrors minus 1,
949 * so that non-flr files will have value 0 meaning 1 mirror. */
950 __u16 lcm_mirror_count;
951 __u16 lcm_padding1[3];
953 struct lov_comp_md_entry_v1 lcm_entries[0];
954 } __attribute__((packed));
956 static inline __u32 lov_user_md_size(__u16 stripes, __u32 lmm_magic)
958 if (stripes == (__u16)-1)
961 if (lmm_magic == LOV_USER_MAGIC_V1)
962 return sizeof(struct lov_user_md_v1) +
963 stripes * sizeof(struct lov_user_ost_data_v1);
964 return sizeof(struct lov_user_md_v3) +
965 stripes * sizeof(struct lov_user_ost_data_v1);
968 /* Compile with -D_LARGEFILE64_SOURCE or -D_GNU_SOURCE (or #define) to
969 * use this. It is unsafe to #define those values in this header as it
970 * is possible the application has already #included <sys/stat.h>. */
971 #define lov_user_mds_data lov_user_mds_data_v2
972 struct lov_user_mds_data_v1 {
973 lstat_t lmd_st; /* MDS stat struct */
974 struct lov_user_md_v1 lmd_lmm; /* LOV EA V1 user data */
975 } __attribute__((packed));
977 struct lov_user_mds_data_v2 {
978 struct lu_fid lmd_fid; /* Lustre FID */
979 lstatx_t lmd_stx; /* MDS statx struct */
980 __u64 lmd_flags; /* MDS stat flags */
981 __u32 lmd_lmmsize; /* LOV EA size */
982 __u32 lmd_padding; /* unused */
983 struct lov_user_md_v1 lmd_lmm; /* LOV EA user data */
984 } __attribute__((packed));
986 struct lmv_user_mds_data {
987 struct lu_fid lum_fid;
990 } __attribute__((packed, __may_alias__));
993 LMV_HASH_TYPE_UNKNOWN = 0, /* 0 is reserved for testing purpose */
994 LMV_HASH_TYPE_ALL_CHARS = 1,
995 LMV_HASH_TYPE_FNV_1A_64 = 2,
996 LMV_HASH_TYPE_CRUSH = 3,
1000 static __attribute__((unused)) const char *mdt_hash_name[] = {
1007 #define LMV_HASH_TYPE_DEFAULT LMV_HASH_TYPE_FNV_1A_64
1009 /* Right now only the lower part(0-16bits) of lmv_hash_type is being used,
1010 * and the higher part will be the flag to indicate the status of object,
1011 * for example the object is being migrated. And the hash function
1012 * might be interpreted differently with different flags. */
1013 #define LMV_HASH_TYPE_MASK 0x0000ffff
1015 static inline bool lmv_is_known_hash_type(__u32 type)
1017 return (type & LMV_HASH_TYPE_MASK) == LMV_HASH_TYPE_FNV_1A_64 ||
1018 (type & LMV_HASH_TYPE_MASK) == LMV_HASH_TYPE_ALL_CHARS ||
1019 (type & LMV_HASH_TYPE_MASK) == LMV_HASH_TYPE_CRUSH;
1022 #define LMV_HASH_FLAG_MERGE 0x04000000
1023 #define LMV_HASH_FLAG_SPLIT 0x08000000
1025 /* The striped directory has ever lost its master LMV EA, then LFSCK
1026 * re-generated it. This flag is used to indicate such case. It is an
1028 #define LMV_HASH_FLAG_LOST_LMV 0x10000000
1030 #define LMV_HASH_FLAG_BAD_TYPE 0x20000000
1031 #define LMV_HASH_FLAG_MIGRATION 0x80000000
1033 #define LMV_HASH_FLAG_LAYOUT_CHANGE \
1034 (LMV_HASH_FLAG_MIGRATION | LMV_HASH_FLAG_SPLIT | LMV_HASH_FLAG_MERGE)
1036 /* both SPLIT and MIGRATION are set for directory split */
1037 static inline bool lmv_hash_is_splitting(__u32 hash)
1039 return (hash & LMV_HASH_FLAG_LAYOUT_CHANGE) ==
1040 (LMV_HASH_FLAG_SPLIT | LMV_HASH_FLAG_MIGRATION);
1043 /* both MERGE and MIGRATION are set for directory merge */
1044 static inline bool lmv_hash_is_merging(__u32 hash)
1046 return (hash & LMV_HASH_FLAG_LAYOUT_CHANGE) ==
1047 (LMV_HASH_FLAG_MERGE | LMV_HASH_FLAG_MIGRATION);
1050 /* only MIGRATION is set for directory migration */
1051 static inline bool lmv_hash_is_migrating(__u32 hash)
1053 return (hash & LMV_HASH_FLAG_LAYOUT_CHANGE) == LMV_HASH_FLAG_MIGRATION;
1056 static inline bool lmv_hash_is_restriping(__u32 hash)
1058 return lmv_hash_is_splitting(hash) || lmv_hash_is_merging(hash);
1061 static inline bool lmv_hash_is_layout_changing(__u32 hash)
1063 return lmv_hash_is_splitting(hash) || lmv_hash_is_merging(hash) ||
1064 lmv_hash_is_migrating(hash);
1067 struct lustre_foreign_type {
1069 const char *lft_name;
1073 * LOV/LMV foreign types
1075 enum lustre_foreign_types {
1076 LU_FOREIGN_TYPE_NONE = 0,
1077 LU_FOREIGN_TYPE_SYMLINK = 0xda05,
1078 /* must be the max/last one */
1079 LU_FOREIGN_TYPE_UNKNOWN = 0xffffffff,
1082 extern struct lustre_foreign_type lu_foreign_types[];
1084 /* Got this according to how get LOV_MAX_STRIPE_COUNT, see above,
1085 * (max buffer size - lmv+rpc header) / sizeof(struct lmv_user_mds_data) */
1086 #define LMV_MAX_STRIPE_COUNT 2000 /* ((12 * 4096 - 256) / 24) */
1087 #define lmv_user_md lmv_user_md_v1
1088 struct lmv_user_md_v1 {
1089 __u32 lum_magic; /* must be the first field */
1090 __u32 lum_stripe_count; /* dirstripe count */
1091 __u32 lum_stripe_offset; /* MDT idx for default dirstripe */
1092 __u32 lum_hash_type; /* Dir stripe policy */
1093 __u32 lum_type; /* LMV type: default */
1094 __u8 lum_max_inherit; /* inherit depth of default LMV */
1095 __u8 lum_max_inherit_rr; /* inherit depth of default LMV to round-robin mkdir */
1099 char lum_pool_name[LOV_MAXPOOLNAME + 1];
1100 struct lmv_user_mds_data lum_objects[0];
1101 } __attribute__((packed));
1103 static inline __u32 lmv_foreign_to_md_stripes(__u32 size)
1105 if (size <= sizeof(struct lmv_user_md))
1108 size -= sizeof(struct lmv_user_md);
1109 return (size + sizeof(struct lmv_user_mds_data) - 1) /
1110 sizeof(struct lmv_user_mds_data);
1114 * NB, historically default layout didn't set type, but use XATTR name to differ
1115 * from normal layout, for backward compatibility, define LMV_TYPE_DEFAULT 0x0,
1116 * and still use the same method.
1119 LMV_TYPE_DEFAULT = 0x0000,
1122 /* lum_max_inherit will be decreased by 1 after each inheritance if it's not
1123 * LMV_INHERIT_UNLIMITED or > LMV_INHERIT_MAX.
1126 /* for historical reason, 0 means unlimited inheritance */
1127 LMV_INHERIT_UNLIMITED = 0,
1128 /* unlimited lum_max_inherit by default */
1129 LMV_INHERIT_DEFAULT = 0,
1130 /* not inherit any more */
1131 LMV_INHERIT_END = 1,
1132 /* max inherit depth */
1133 LMV_INHERIT_MAX = 250,
1134 /* [251, 254] are reserved */
1135 /* not set, or when inherit depth goes beyond end, */
1136 LMV_INHERIT_NONE = 255,
1140 /* not set, or when inherit_rr depth goes beyond end, */
1141 LMV_INHERIT_RR_NONE = 0,
1142 /* disable lum_max_inherit_rr by default */
1143 LMV_INHERIT_RR_DEFAULT = 0,
1144 /* not inherit any more */
1145 LMV_INHERIT_RR_END = 1,
1146 /* max inherit depth */
1147 LMV_INHERIT_RR_MAX = 250,
1148 /* [251, 254] are reserved */
1149 /* unlimited inheritance */
1150 LMV_INHERIT_RR_UNLIMITED = 255,
1153 static inline int lmv_user_md_size(int stripes, int lmm_magic)
1155 int size = sizeof(struct lmv_user_md);
1157 if (lmm_magic == LMV_USER_MAGIC_SPECIFIC)
1158 size += stripes * sizeof(struct lmv_user_mds_data);
1163 struct ll_recreate_obj {
1169 __u64 id; /* holds object id */
1170 __u32 generation; /* holds object generation */
1171 __u32 f_type; /* holds object type or stripe idx when passing it to
1172 * OST for saving into EA. */
1177 char uuid[UUID_MAX];
1180 static inline bool obd_uuid_equals(const struct obd_uuid *u1,
1181 const struct obd_uuid *u2)
1183 return strcmp((char *)u1->uuid, (char *)u2->uuid) == 0;
1186 static inline int obd_uuid_empty(struct obd_uuid *uuid)
1188 return uuid->uuid[0] == '\0';
1191 static inline void obd_str2uuid(struct obd_uuid *uuid, const char *tmp)
1193 strncpy((char *)uuid->uuid, tmp, sizeof(*uuid));
1194 uuid->uuid[sizeof(*uuid) - 1] = '\0';
1197 /* For printf's only, make sure uuid is terminated */
1198 static inline char *obd_uuid2str(const struct obd_uuid *uuid)
1203 if (uuid->uuid[sizeof(*uuid) - 1] != '\0') {
1204 /* Obviously not safe, but for printfs, no real harm done...
1205 we're always null-terminated, even in a race. */
1206 static char temp[sizeof(*uuid)];
1207 memcpy(temp, uuid->uuid, sizeof(*uuid) - 1);
1208 temp[sizeof(*uuid) - 1] = '\0';
1211 return (char *)(uuid->uuid);
1214 #define LUSTRE_MAXFSNAME 8
1215 #define LUSTRE_MAXINSTANCE 16
1217 /* Extract fsname from uuid (or target name) of a target
1218 e.g. (myfs-OST0007_UUID -> myfs)
1219 see also deuuidify. */
1220 static inline void obd_uuid2fsname(char *buf, char *uuid, int buflen)
1224 strncpy(buf, uuid, buflen - 1);
1225 buf[buflen - 1] = '\0';
1226 p = strrchr(buf, '-');
1231 /* printf display format for Lustre FIDs
1232 * usage: printf("file FID is "DFID"\n", PFID(fid)); */
1233 #define FID_NOBRACE_LEN 40
1234 #define FID_LEN (FID_NOBRACE_LEN + 2)
1235 #define DFID_NOBRACE "%#llx:0x%x:0x%x"
1236 #define DFID "[" DFID_NOBRACE "]"
1237 #define PFID(fid) (unsigned long long)(fid)->f_seq, (fid)->f_oid, (fid)->f_ver
1239 /* scanf input parse format for fids in DFID_NOBRACE format
1240 * Need to strip '[' from DFID format first or use "["SFID"]" at caller.
1241 * usage: sscanf(fidstr, SFID, RFID(&fid)); */
1242 #define SFID "0x%llx:0x%x:0x%x"
1243 #define RFID(fid) (unsigned long long *)&((fid)->f_seq), &((fid)->f_oid), &((fid)->f_ver)
1245 /********* Quotas **********/
1247 #define LUSTRE_QUOTABLOCK_BITS 10
1248 #define LUSTRE_QUOTABLOCK_SIZE (1 << LUSTRE_QUOTABLOCK_BITS)
1250 static inline __u64 lustre_stoqb(__kernel_size_t space)
1252 return (space + LUSTRE_QUOTABLOCK_SIZE - 1) >> LUSTRE_QUOTABLOCK_BITS;
1255 #define Q_QUOTACHECK 0x800100 /* deprecated as of 2.4 */
1256 #define Q_INITQUOTA 0x800101 /* deprecated as of 2.4 */
1257 #define Q_GETOINFO 0x800102 /* get obd quota info */
1258 #define Q_GETOQUOTA 0x800103 /* get obd quotas */
1259 #define Q_FINVALIDATE 0x800104 /* deprecated as of 2.4 */
1261 /* these must be explicitly translated into linux Q_* in ll_dir_ioctl */
1262 #define LUSTRE_Q_QUOTAON 0x800002 /* deprecated as of 2.4 */
1263 #define LUSTRE_Q_QUOTAOFF 0x800003 /* deprecated as of 2.4 */
1264 #define LUSTRE_Q_GETINFO 0x800005 /* get information about quota files */
1265 #define LUSTRE_Q_SETINFO 0x800006 /* set information about quota files */
1266 #define LUSTRE_Q_GETQUOTA 0x800007 /* get user quota structure */
1267 #define LUSTRE_Q_SETQUOTA 0x800008 /* set user quota structure */
1268 /* lustre-specific control commands */
1269 #define LUSTRE_Q_INVALIDATE 0x80000b /* deprecated as of 2.4 */
1270 #define LUSTRE_Q_FINVALIDATE 0x80000c /* deprecated as of 2.4 */
1271 #define LUSTRE_Q_GETDEFAULT 0x80000d /* get default quota */
1272 #define LUSTRE_Q_SETDEFAULT 0x80000e /* set default quota */
1273 #define LUSTRE_Q_GETQUOTAPOOL 0x80000f /* get user pool quota */
1274 #define LUSTRE_Q_SETQUOTAPOOL 0x800010 /* set user pool quota */
1275 #define LUSTRE_Q_GETINFOPOOL 0x800011 /* get pool quota info */
1276 #define LUSTRE_Q_SETINFOPOOL 0x800012 /* set pool quota info */
1277 #define LUSTRE_Q_GETDEFAULT_POOL 0x800013 /* get default pool quota*/
1278 #define LUSTRE_Q_SETDEFAULT_POOL 0x800014 /* set default pool quota */
1279 /* In the current Lustre implementation, the grace time is either the time
1280 * or the timestamp to be used after some quota ID exceeds the soft limt,
1281 * 48 bits should be enough, its high 16 bits can be used as quota flags.
1283 #define LQUOTA_GRACE_BITS 48
1284 #define LQUOTA_GRACE_MASK ((1ULL << LQUOTA_GRACE_BITS) - 1)
1285 #define LQUOTA_GRACE_MAX LQUOTA_GRACE_MASK
1286 #define LQUOTA_GRACE(t) (t & LQUOTA_GRACE_MASK)
1287 #define LQUOTA_FLAG(t) (t >> LQUOTA_GRACE_BITS)
1288 #define LQUOTA_GRACE_FLAG(t, f) ((__u64)t | (__u64)f << LQUOTA_GRACE_BITS)
1290 /* special grace time, only notify the user when its quota is over soft limit
1291 * but doesn't block new writes until the hard limit is reached. */
1292 #define NOTIFY_GRACE "notify"
1293 #define NOTIFY_GRACE_TIME LQUOTA_GRACE_MASK
1295 /* different quota flags */
1297 /* the default quota flag, the corresponding quota ID will use the default
1298 * quota setting, the hardlimit and softlimit of its quota record in the global
1299 * quota file will be set to 0, the low 48 bits of the grace will be set to 0
1300 * and high 16 bits will contain this flag (see above comment).
1302 #define LQUOTA_FLAG_DEFAULT 0x0001
1304 #define LUSTRE_Q_CMD_IS_POOL(cmd) \
1305 (cmd == LUSTRE_Q_GETQUOTAPOOL || \
1306 cmd == LUSTRE_Q_SETQUOTAPOOL || \
1307 cmd == LUSTRE_Q_SETINFOPOOL || \
1308 cmd == LUSTRE_Q_GETINFOPOOL || \
1309 cmd == LUSTRE_Q_SETDEFAULT_POOL || \
1310 cmd == LUSTRE_Q_GETDEFAULT_POOL)
1312 #define ALLQUOTA 255 /* set all quota */
1313 static inline const char *qtype_name(int qtype)
1326 #define IDENTITY_DOWNCALL_MAGIC 0x6d6dd629
1329 #define N_PERMS_MAX 64
1331 struct perm_downcall_data {
1337 struct identity_downcall_data {
1344 struct perm_downcall_data idd_perms[N_PERMS_MAX];
1345 __u32 idd_groups[0];
1348 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 16, 53, 0)
1349 /* old interface struct is deprecated in 2.14 */
1350 #define SEPOL_DOWNCALL_MAGIC_OLD 0x8b8bb842
1351 struct sepol_downcall_data_old {
1353 __s64 sdd_sepol_mtime;
1354 __u16 sdd_sepol_len;
1359 #define SEPOL_DOWNCALL_MAGIC 0x8b8bb843
1360 struct sepol_downcall_data {
1362 __u16 sdd_sepol_len;
1364 __s64 sdd_sepol_mtime;
1368 #ifdef NEED_QUOTA_DEFS
1370 #define QIF_BLIMITS 1
1372 #define QIF_ILIMITS 4
1373 #define QIF_INODES 8
1374 #define QIF_BTIME 16
1375 #define QIF_ITIME 32
1376 #define QIF_LIMITS (QIF_BLIMITS | QIF_ILIMITS)
1377 #define QIF_USAGE (QIF_SPACE | QIF_INODES)
1378 #define QIF_TIMES (QIF_BTIME | QIF_ITIME)
1379 #define QIF_ALL (QIF_LIMITS | QIF_USAGE | QIF_TIMES)
1382 #endif /* !__KERNEL__ */
1384 /* lustre volatile file support
1385 * file name header: ".^L^S^T^R:volatile"
1387 #define LUSTRE_VOLATILE_HDR ".\x0c\x13\x14\x12:VOLATILE"
1388 #define LUSTRE_VOLATILE_HDR_LEN 14
1390 enum lustre_quota_version {
1394 /* XXX: same as if_dqinfo struct in kernel */
1402 /* XXX: same as if_dqblk struct in kernel, plus one padding */
1404 __u64 dqb_bhardlimit; /* kbytes unit */
1405 __u64 dqb_bsoftlimit; /* kbytes unit */
1406 __u64 dqb_curspace; /* bytes unit */
1407 __u64 dqb_ihardlimit;
1408 __u64 dqb_isoftlimit;
1409 __u64 dqb_curinodes;
1423 struct if_quotactl {
1430 struct obd_dqinfo qc_dqinfo;
1431 struct obd_dqblk qc_dqblk;
1433 struct obd_uuid obd_uuid;
1434 char qc_poolname[0];
1437 /* swap layout flags */
1438 #define SWAP_LAYOUTS_CHECK_DV1 (1 << 0)
1439 #define SWAP_LAYOUTS_CHECK_DV2 (1 << 1)
1440 #define SWAP_LAYOUTS_KEEP_MTIME (1 << 2)
1441 #define SWAP_LAYOUTS_KEEP_ATIME (1 << 3)
1442 #define SWAP_LAYOUTS_CLOSE (1 << 4)
1444 /* Swap XATTR_NAME_HSM as well, only on the MDT so far */
1445 #define SWAP_LAYOUTS_MDS_HSM (1 << 31)
1446 struct lustre_swap_layouts {
1454 /** Bit-mask of valid attributes */
1455 /* The LA_* flags are written to disk as part of the ChangeLog records
1456 * so they are part of the on-disk and network protocol, and cannot be changed.
1457 * Only the first 12 bits are currently saved.
1460 LA_ATIME = 1 << 0, /* 0x00001 */
1461 LA_MTIME = 1 << 1, /* 0x00002 */
1462 LA_CTIME = 1 << 2, /* 0x00004 */
1463 LA_SIZE = 1 << 3, /* 0x00008 */
1464 LA_MODE = 1 << 4, /* 0x00010 */
1465 LA_UID = 1 << 5, /* 0x00020 */
1466 LA_GID = 1 << 6, /* 0x00040 */
1467 LA_BLOCKS = 1 << 7, /* 0x00080 */
1468 LA_TYPE = 1 << 8, /* 0x00100 */
1469 LA_FLAGS = 1 << 9, /* 0x00200 */
1470 LA_NLINK = 1 << 10, /* 0x00400 */
1471 LA_RDEV = 1 << 11, /* 0x00800 */
1472 LA_BLKSIZE = 1 << 12, /* 0x01000 */
1473 LA_KILL_SUID = 1 << 13, /* 0x02000 */
1474 LA_KILL_SGID = 1 << 14, /* 0x04000 */
1475 LA_PROJID = 1 << 15, /* 0x08000 */
1476 LA_LAYOUT_VERSION = 1 << 16, /* 0x10000 */
1477 LA_LSIZE = 1 << 17, /* 0x20000 */
1478 LA_LBLOCKS = 1 << 18, /* 0x40000 */
1479 LA_BTIME = 1 << 19, /* 0x80000 */
1481 * Attributes must be transmitted to OST objects
1483 LA_REMOTE_ATTR_SET = (LA_UID | LA_GID | LA_PROJID | LA_LAYOUT_VERSION)
1486 #define MDS_FMODE_READ 00000001
1487 #define MDS_FMODE_WRITE 00000002
1489 #define MDS_FMODE_CLOSED 00000000
1490 #define MDS_FMODE_EXEC 00000004
1491 /* MDS_FMODE_EPOCH 01000000 obsolete since 2.8.0 */
1492 /* MDS_FMODE_TRUNC 02000000 obsolete since 2.8.0 */
1493 /* MDS_FMODE_SOM 04000000 obsolete since 2.8.0 */
1495 #define MDS_OPEN_CREATED 00000010
1496 /* MDS_OPEN_CROSS 00000020 obsolete in 2.12, internal use only */
1498 #define MDS_OPEN_CREAT 00000100
1499 #define MDS_OPEN_EXCL 00000200
1500 #define MDS_OPEN_TRUNC 00001000
1501 #define MDS_OPEN_APPEND 00002000
1502 #define MDS_OPEN_SYNC 00010000
1503 #define MDS_OPEN_DIRECTORY 00200000
1505 #define MDS_OPEN_BY_FID 040000000 /* open_by_fid for known object */
1506 #define MDS_OPEN_DELAY_CREATE 0100000000 /* delay initial object create */
1507 #define MDS_OPEN_OWNEROVERRIDE 0200000000 /* NFSD rw-reopen ro file for owner */
1508 #define MDS_OPEN_JOIN_FILE 0400000000 /* open for join file.
1509 * We do not support JOIN FILE
1510 * anymore, reserve this flags
1511 * just for preventing such bit
1514 #define MDS_OPEN_LOCK 04000000000 /* This open requires open lock */
1515 #define MDS_OPEN_HAS_EA 010000000000 /* specify object create pattern */
1516 #define MDS_OPEN_HAS_OBJS 020000000000 /* Just set the EA the obj exist */
1517 #define MDS_OPEN_NORESTORE 0100000000000ULL /* Do not restore file at open */
1518 #define MDS_OPEN_NEWSTRIPE 0200000000000ULL /* New stripe needed (restripe or
1520 #define MDS_OPEN_VOLATILE 0400000000000ULL /* File is volatile = created
1522 #define MDS_OPEN_LEASE 01000000000000ULL /* Open the file and grant lease
1523 * delegation, succeed if it's not
1524 * being opened with conflict mode.
1526 #define MDS_OPEN_RELEASE 02000000000000ULL /* Open the file for HSM release */
1528 #define MDS_OPEN_RESYNC 04000000000000ULL /* FLR: file resync */
1529 #define MDS_OPEN_PCC 010000000000000ULL /* PCC: auto RW-PCC cache attach
1530 * for newly created file */
1532 /* lustre internal open flags, which should not be set from user space */
1533 #define MDS_OPEN_FL_INTERNAL (MDS_OPEN_HAS_EA | MDS_OPEN_HAS_OBJS | \
1534 MDS_OPEN_OWNEROVERRIDE | MDS_OPEN_LOCK | \
1535 MDS_OPEN_BY_FID | MDS_OPEN_LEASE | \
1536 MDS_OPEN_RELEASE | MDS_OPEN_RESYNC | \
1540 /********* Changelogs **********/
1541 /** Changelog record types */
1542 enum changelog_rec_type {
1545 CL_CREATE = 1, /* namespace */
1546 CL_MKDIR = 2, /* namespace */
1547 CL_HARDLINK = 3, /* namespace */
1548 CL_SOFTLINK = 4, /* namespace */
1549 CL_MKNOD = 5, /* namespace */
1550 CL_UNLINK = 6, /* namespace */
1551 CL_RMDIR = 7, /* namespace */
1552 CL_RENAME = 8, /* namespace */
1553 CL_EXT = 9, /* namespace extended record (2nd half of rename) */
1554 CL_OPEN = 10, /* not currently used */
1555 CL_CLOSE = 11, /* may be written to log only with mtime change */
1556 CL_LAYOUT = 12, /* file layout/striping modified */
1560 CL_XATTR = CL_SETXATTR, /* Deprecated name */
1561 CL_HSM = 16, /* HSM specific events, see flags */
1562 CL_MTIME = 17, /* Precedence: setattr > mtime > ctime > atime */
1566 CL_FLRW = 21, /* FLR: file was firstly written */
1567 CL_RESYNC = 22, /* FLR: file was resync-ed */
1569 CL_DN_OPEN = 24, /* denied open */
1573 static inline const char *changelog_type2str(int type) {
1574 static const char *const changelog_str[] = {
1575 "MARK", "CREAT", "MKDIR", "HLINK", "SLINK", "MKNOD", "UNLNK",
1576 "RMDIR", "RENME", "RNMTO", "OPEN", "CLOSE", "LYOUT", "TRUNC",
1577 "SATTR", "XATTR", "HSM", "MTIME", "CTIME", "ATIME", "MIGRT",
1578 "FLRW", "RESYNC","GXATR", "NOPEN",
1581 if (type >= 0 && type < CL_LAST)
1582 return changelog_str[type];
1586 /* 12 bits of per-record data can be stored in the bottom of the flags */
1587 #define CLF_FLAGSHIFT 12
1588 enum changelog_rec_flags {
1589 CLF_VERSION = 0x1000,
1590 CLF_RENAME = 0x2000,
1592 CLF_EXTRA_FLAGS = 0x8000,
1593 CLF_SUPPORTED = CLF_VERSION | CLF_RENAME | CLF_JOBID |
1595 CLF_FLAGMASK = (1U << CLF_FLAGSHIFT) - 1,
1596 CLF_VERMASK = ~CLF_FLAGMASK,
1600 /* Anything under the flagmask may be per-type (if desired) */
1601 /* Flags for unlink */
1602 #define CLF_UNLINK_LAST 0x0001 /* Unlink of last hardlink */
1603 #define CLF_UNLINK_HSM_EXISTS 0x0002 /* File has something in HSM */
1604 /* HSM cleaning needed */
1605 /* Flags for rename */
1606 #define CLF_RENAME_LAST 0x0001 /* rename unlink last hardlink
1608 #define CLF_RENAME_LAST_EXISTS 0x0002 /* rename unlink last hardlink of target
1609 * has an archive in backend */
1612 /* 12b used (from high weight to low weight):
1617 #define CLF_HSM_ERR_L 0 /* HSM return code, 7 bits */
1618 #define CLF_HSM_ERR_H 6
1619 #define CLF_HSM_EVENT_L 7 /* HSM event, 3 bits, see enum hsm_event */
1620 #define CLF_HSM_EVENT_H 9
1621 #define CLF_HSM_FLAG_L 10 /* HSM flags, 2 bits, 1 used, 1 spare */
1622 #define CLF_HSM_FLAG_H 11
1623 #define CLF_HSM_SPARE_L 12 /* 4 spare bits */
1624 #define CLF_HSM_SPARE_H 15
1625 #define CLF_HSM_LAST 15
1627 /* Remove bits higher than _h, then extract the value
1628 * between _h and _l by shifting lower weigth to bit 0. */
1629 #define CLF_GET_BITS(_b, _h, _l) (((_b << (CLF_HSM_LAST - _h)) & 0xFFFF) \
1630 >> (CLF_HSM_LAST - _h + _l))
1632 #define CLF_HSM_SUCCESS 0x00
1633 #define CLF_HSM_MAXERROR 0x7E
1634 #define CLF_HSM_ERROVERFLOW 0x7F
1636 #define CLF_HSM_DIRTY 1 /* file is dirty after HSM request end */
1638 /* 3 bits field => 8 values allowed */
1650 static inline enum hsm_event hsm_get_cl_event(__u16 flags)
1652 return (enum hsm_event)CLF_GET_BITS(flags, CLF_HSM_EVENT_H,
1656 static inline void hsm_set_cl_event(enum changelog_rec_flags *clf_flags,
1659 *clf_flags = (enum changelog_rec_flags)
1660 (*clf_flags | (he << CLF_HSM_EVENT_L));
1663 static inline __u16 hsm_get_cl_flags(enum changelog_rec_flags clf_flags)
1665 return CLF_GET_BITS(clf_flags, CLF_HSM_FLAG_H, CLF_HSM_FLAG_L);
1668 static inline void hsm_set_cl_flags(enum changelog_rec_flags *clf_flags,
1671 *clf_flags = (enum changelog_rec_flags)
1672 (*clf_flags | (bits << CLF_HSM_FLAG_L));
1675 static inline int hsm_get_cl_error(enum changelog_rec_flags clf_flags)
1677 return CLF_GET_BITS(clf_flags, CLF_HSM_ERR_H, CLF_HSM_ERR_L);
1680 static inline void hsm_set_cl_error(enum changelog_rec_flags *clf_flags,
1683 *clf_flags = (enum changelog_rec_flags)
1684 (*clf_flags | (error << CLF_HSM_ERR_L));
1687 enum changelog_rec_extra_flags {
1689 CLFE_UIDGID = 0x0001,
1692 CLFE_XATTR = 0x0008,
1693 CLFE_SUPPORTED = CLFE_UIDGID | CLFE_NID | CLFE_OPEN | CLFE_XATTR
1696 enum changelog_send_flag {
1697 /* Not yet implemented */
1698 CHANGELOG_FLAG_FOLLOW = 0x01,
1699 /* Blocking IO makes sense in case of slow user parsing of the records,
1700 * but it also prevents us from cleaning up if the records are not
1702 CHANGELOG_FLAG_BLOCK = 0x02,
1703 /* Pack jobid into the changelog records if available. */
1704 CHANGELOG_FLAG_JOBID = 0x04,
1705 /* Pack additional flag bits into the changelog record */
1706 CHANGELOG_FLAG_EXTRA_FLAGS = 0x08,
1709 enum changelog_send_extra_flag {
1710 /* Pack uid/gid into the changelog record */
1711 CHANGELOG_EXTRA_FLAG_UIDGID = 0x01,
1712 /* Pack nid into the changelog record */
1713 CHANGELOG_EXTRA_FLAG_NID = 0x02,
1714 /* Pack open mode into the changelog record */
1715 CHANGELOG_EXTRA_FLAG_OMODE = 0x04,
1716 /* Pack xattr name into the changelog record */
1717 CHANGELOG_EXTRA_FLAG_XATTR = 0x08,
1720 #define CR_MAXSIZE __ALIGN_KERNEL(2 * NAME_MAX + 2 + \
1721 changelog_rec_offset(CLF_SUPPORTED, \
1724 /* 31 usable bytes string + null terminator. */
1725 #define LUSTRE_JOBID_SIZE 32
1727 /* This is the minimal changelog record. It can contain extensions
1728 * such as rename fields or process jobid. Its exact content is described
1729 * by the cr_flags and cr_extra_flags.
1731 * Extensions are packed in the same order as their corresponding flags,
1732 * then in the same order as their corresponding extra flags.
1734 struct changelog_rec {
1736 __u16 cr_flags; /**< \a changelog_rec_flags */
1737 __u32 cr_type; /**< \a changelog_rec_type */
1738 __u64 cr_index; /**< changelog record number */
1739 __u64 cr_prev; /**< last index for this target fid */
1742 struct lu_fid cr_tfid; /**< target fid */
1743 __u32 cr_markerflags; /**< CL_MARK flags */
1745 struct lu_fid cr_pfid; /**< parent fid */
1746 } __attribute__ ((packed));
1748 /* Changelog extension for RENAME. */
1749 struct changelog_ext_rename {
1750 struct lu_fid cr_sfid; /**< source fid, or zero */
1751 struct lu_fid cr_spfid; /**< source parent fid, or zero */
1754 /* Changelog extension to include JOBID. */
1755 struct changelog_ext_jobid {
1756 char cr_jobid[LUSTRE_JOBID_SIZE]; /**< zero-terminated string. */
1759 /* Changelog extension to include additional flags. */
1760 struct changelog_ext_extra_flags {
1761 __u64 cr_extra_flags; /* Additional CLFE_* flags */
1764 /* Changelog extra extension to include UID/GID. */
1765 struct changelog_ext_uidgid {
1770 /* Changelog extra extension to include NID. */
1771 struct changelog_ext_nid {
1772 /* have __u64 instead of lnet_nid_t type for use by client api */
1774 /* for use when IPv6 support is added */
1779 /* Changelog extra extension to include low 32 bits of MDS_OPEN_* flags. */
1780 struct changelog_ext_openmode {
1784 /* Changelog extra extension to include xattr */
1785 struct changelog_ext_xattr {
1786 char cr_xattr[XATTR_NAME_MAX + 1]; /**< zero-terminated string. */
1789 static inline struct changelog_ext_extra_flags *changelog_rec_extra_flags(
1790 const struct changelog_rec *rec);
1792 static inline __kernel_size_t changelog_rec_offset(enum changelog_rec_flags crf,
1793 enum changelog_rec_extra_flags cref)
1795 __kernel_size_t size = sizeof(struct changelog_rec);
1797 if (crf & CLF_RENAME)
1798 size += sizeof(struct changelog_ext_rename);
1800 if (crf & CLF_JOBID)
1801 size += sizeof(struct changelog_ext_jobid);
1803 if (crf & CLF_EXTRA_FLAGS) {
1804 size += sizeof(struct changelog_ext_extra_flags);
1805 if (cref & CLFE_UIDGID)
1806 size += sizeof(struct changelog_ext_uidgid);
1807 if (cref & CLFE_NID)
1808 size += sizeof(struct changelog_ext_nid);
1809 if (cref & CLFE_OPEN)
1810 size += sizeof(struct changelog_ext_openmode);
1811 if (cref & CLFE_XATTR)
1812 size += sizeof(struct changelog_ext_xattr);
1818 static inline __kernel_size_t changelog_rec_size(const struct changelog_rec *rec)
1820 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1822 if (rec->cr_flags & CLF_EXTRA_FLAGS)
1823 cref = (enum changelog_rec_extra_flags)
1824 changelog_rec_extra_flags(rec)->cr_extra_flags;
1826 return changelog_rec_offset(
1827 (enum changelog_rec_flags)rec->cr_flags, cref);
1830 static inline __kernel_size_t changelog_rec_varsize(const struct changelog_rec *rec)
1832 return changelog_rec_size(rec) - sizeof(*rec) + rec->cr_namelen;
1836 struct changelog_ext_rename *changelog_rec_rename(const struct changelog_rec *rec)
1838 enum changelog_rec_flags crf = (enum changelog_rec_flags)
1839 (rec->cr_flags & CLF_VERSION);
1841 return (struct changelog_ext_rename *)((char *)rec +
1842 changelog_rec_offset(crf,
1846 /* The jobid follows the rename extension, if present */
1848 struct changelog_ext_jobid *changelog_rec_jobid(const struct changelog_rec *rec)
1850 enum changelog_rec_flags crf = (enum changelog_rec_flags)
1851 (rec->cr_flags & (CLF_VERSION | CLF_RENAME));
1853 return (struct changelog_ext_jobid *)((char *)rec +
1854 changelog_rec_offset(crf,
1858 /* The additional flags follow the rename and jobid extensions, if present */
1860 struct changelog_ext_extra_flags *changelog_rec_extra_flags(
1861 const struct changelog_rec *rec)
1863 enum changelog_rec_flags crf = (enum changelog_rec_flags)
1864 (rec->cr_flags & (CLF_VERSION | CLF_RENAME | CLF_JOBID));
1866 return (struct changelog_ext_extra_flags *)((char *)rec +
1867 changelog_rec_offset(crf,
1871 /* The uid/gid is the first extra extension */
1873 struct changelog_ext_uidgid *changelog_rec_uidgid(
1874 const struct changelog_rec *rec)
1876 enum changelog_rec_flags crf = (enum changelog_rec_flags)
1878 (CLF_VERSION | CLF_RENAME | CLF_JOBID | CLF_EXTRA_FLAGS));
1880 return (struct changelog_ext_uidgid *)((char *)rec +
1881 changelog_rec_offset(crf,
1885 /* The nid is the second extra extension */
1887 struct changelog_ext_nid *changelog_rec_nid(const struct changelog_rec *rec)
1889 enum changelog_rec_flags crf = (enum changelog_rec_flags)
1891 (CLF_VERSION | CLF_RENAME | CLF_JOBID | CLF_EXTRA_FLAGS));
1892 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1894 if (rec->cr_flags & CLF_EXTRA_FLAGS)
1895 cref = (enum changelog_rec_extra_flags)
1896 (changelog_rec_extra_flags(rec)->cr_extra_flags &
1899 return (struct changelog_ext_nid *)((char *)rec +
1900 changelog_rec_offset(crf, cref));
1903 /* The OPEN mode is the third extra extension */
1905 struct changelog_ext_openmode *changelog_rec_openmode(
1906 const struct changelog_rec *rec)
1908 enum changelog_rec_flags crf = (enum changelog_rec_flags)
1910 (CLF_VERSION | CLF_RENAME | CLF_JOBID | CLF_EXTRA_FLAGS));
1911 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1913 if (rec->cr_flags & CLF_EXTRA_FLAGS) {
1914 cref = (enum changelog_rec_extra_flags)
1915 (changelog_rec_extra_flags(rec)->cr_extra_flags &
1916 (CLFE_UIDGID | CLFE_NID));
1919 return (struct changelog_ext_openmode *)((char *)rec +
1920 changelog_rec_offset(crf, cref));
1923 /* The xattr name is the fourth extra extension */
1925 struct changelog_ext_xattr *changelog_rec_xattr(
1926 const struct changelog_rec *rec)
1928 enum changelog_rec_flags crf = (enum changelog_rec_flags)
1930 (CLF_VERSION | CLF_RENAME | CLF_JOBID | CLF_EXTRA_FLAGS));
1931 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1933 if (rec->cr_flags & CLF_EXTRA_FLAGS)
1934 cref = (enum changelog_rec_extra_flags)
1935 (changelog_rec_extra_flags(rec)->cr_extra_flags &
1936 (CLFE_UIDGID | CLFE_NID | CLFE_OPEN));
1938 return (struct changelog_ext_xattr *)((char *)rec +
1939 changelog_rec_offset(crf, cref));
1942 /* The name follows the rename, jobid and extra flags extns, if present */
1943 static inline char *changelog_rec_name(const struct changelog_rec *rec)
1945 enum changelog_rec_extra_flags cref = CLFE_INVALID;
1947 if (rec->cr_flags & CLF_EXTRA_FLAGS)
1948 cref = (enum changelog_rec_extra_flags)
1949 changelog_rec_extra_flags(rec)->cr_extra_flags;
1951 return (char *)rec + changelog_rec_offset(
1952 (enum changelog_rec_flags)(rec->cr_flags & CLF_SUPPORTED),
1953 (enum changelog_rec_extra_flags)(cref & CLFE_SUPPORTED));
1956 static inline __kernel_size_t changelog_rec_snamelen(const struct changelog_rec *rec)
1958 return rec->cr_namelen - strlen(changelog_rec_name(rec)) - 1;
1961 static inline char *changelog_rec_sname(const struct changelog_rec *rec)
1963 char *cr_name = changelog_rec_name(rec);
1965 return cr_name + strlen(cr_name) + 1;
1969 * Remap a record to the desired format as specified by the crf flags.
1970 * The record must be big enough to contain the final remapped version.
1971 * Superfluous extension fields are removed and missing ones are added
1972 * and zeroed. The flags of the record are updated accordingly.
1974 * The jobid and rename extensions can be added to a record, to match the
1975 * format an application expects, typically. In this case, the newly added
1976 * fields will be zeroed.
1977 * The Jobid field can be removed, to guarantee compatibility with older
1978 * clients that don't expect this field in the records they process.
1980 * The following assumptions are being made:
1981 * - CLF_RENAME will not be removed
1982 * - CLF_JOBID will not be added without CLF_RENAME being added too
1983 * - CLF_EXTRA_FLAGS will not be added without CLF_JOBID being added too
1985 * @param[in,out] rec The record to remap.
1986 * @param[in] crf_wanted Flags describing the desired extensions.
1987 * @param[in] cref_want Flags describing the desired extra extensions.
1989 static inline void changelog_remap_rec(struct changelog_rec *rec,
1990 enum changelog_rec_flags crf_wanted,
1991 enum changelog_rec_extra_flags cref_want)
1993 char *xattr_mov = NULL;
1994 char *omd_mov = NULL;
1995 char *nid_mov = NULL;
1996 char *uidgid_mov = NULL;
2000 enum changelog_rec_extra_flags cref = CLFE_INVALID;
2002 crf_wanted = (enum changelog_rec_flags)
2003 (crf_wanted & CLF_SUPPORTED);
2004 cref_want = (enum changelog_rec_extra_flags)
2005 (cref_want & CLFE_SUPPORTED);
2007 if ((rec->cr_flags & CLF_SUPPORTED) == crf_wanted) {
2008 if (!(rec->cr_flags & CLF_EXTRA_FLAGS) ||
2009 (rec->cr_flags & CLF_EXTRA_FLAGS &&
2010 (changelog_rec_extra_flags(rec)->cr_extra_flags &
2016 /* First move the variable-length name field */
2017 memmove((char *)rec + changelog_rec_offset(crf_wanted, cref_want),
2018 changelog_rec_name(rec), rec->cr_namelen);
2020 /* Locations of extensions in the remapped record */
2021 if (rec->cr_flags & CLF_EXTRA_FLAGS) {
2022 xattr_mov = (char *)rec +
2023 changelog_rec_offset(
2024 (enum changelog_rec_flags)
2025 (crf_wanted & CLF_SUPPORTED),
2026 (enum changelog_rec_extra_flags)
2027 (cref_want & ~CLFE_XATTR));
2028 omd_mov = (char *)rec +
2029 changelog_rec_offset(
2030 (enum changelog_rec_flags)
2031 (crf_wanted & CLF_SUPPORTED),
2032 (enum changelog_rec_extra_flags)
2033 (cref_want & ~(CLFE_OPEN | CLFE_XATTR)));
2034 nid_mov = (char *)rec +
2035 changelog_rec_offset(
2036 (enum changelog_rec_flags)
2037 (crf_wanted & CLF_SUPPORTED),
2038 (enum changelog_rec_extra_flags)
2040 ~(CLFE_NID | CLFE_OPEN | CLFE_XATTR)));
2041 uidgid_mov = (char *)rec +
2042 changelog_rec_offset(
2043 (enum changelog_rec_flags)
2044 (crf_wanted & CLF_SUPPORTED),
2045 (enum changelog_rec_extra_flags)
2046 (cref_want & ~(CLFE_UIDGID |
2050 cref = (enum changelog_rec_extra_flags)
2051 changelog_rec_extra_flags(rec)->cr_extra_flags;
2054 ef_mov = (char *)rec +
2055 changelog_rec_offset(
2056 (enum changelog_rec_flags)
2057 (crf_wanted & ~CLF_EXTRA_FLAGS), CLFE_INVALID);
2058 jid_mov = (char *)rec +
2059 changelog_rec_offset((enum changelog_rec_flags)(crf_wanted &
2060 ~(CLF_EXTRA_FLAGS | CLF_JOBID)),
2062 rnm_mov = (char *)rec +
2063 changelog_rec_offset((enum changelog_rec_flags)(crf_wanted &
2069 /* Move the extension fields to the desired positions */
2070 if ((crf_wanted & CLF_EXTRA_FLAGS) &&
2071 (rec->cr_flags & CLF_EXTRA_FLAGS)) {
2072 if ((cref_want & CLFE_XATTR) && (cref & CLFE_XATTR))
2073 memmove(xattr_mov, changelog_rec_xattr(rec),
2074 sizeof(struct changelog_ext_xattr));
2076 if ((cref_want & CLFE_OPEN) && (cref & CLFE_OPEN))
2077 memmove(omd_mov, changelog_rec_openmode(rec),
2078 sizeof(struct changelog_ext_openmode));
2080 if ((cref_want & CLFE_NID) && (cref & CLFE_NID))
2081 memmove(nid_mov, changelog_rec_nid(rec),
2082 sizeof(struct changelog_ext_nid));
2084 if ((cref_want & CLFE_UIDGID) && (cref & CLFE_UIDGID))
2085 memmove(uidgid_mov, changelog_rec_uidgid(rec),
2086 sizeof(struct changelog_ext_uidgid));
2088 memmove(ef_mov, changelog_rec_extra_flags(rec),
2089 sizeof(struct changelog_ext_extra_flags));
2092 if ((crf_wanted & CLF_JOBID) && (rec->cr_flags & CLF_JOBID))
2093 memmove(jid_mov, changelog_rec_jobid(rec),
2094 sizeof(struct changelog_ext_jobid));
2096 if ((crf_wanted & CLF_RENAME) && (rec->cr_flags & CLF_RENAME))
2097 memmove(rnm_mov, changelog_rec_rename(rec),
2098 sizeof(struct changelog_ext_rename));
2100 /* Clear newly added fields */
2101 if (xattr_mov && (cref_want & CLFE_XATTR) &&
2102 !(cref & CLFE_XATTR))
2103 memset(xattr_mov, 0, sizeof(struct changelog_ext_xattr));
2105 if (omd_mov && (cref_want & CLFE_OPEN) &&
2106 !(cref & CLFE_OPEN))
2107 memset(omd_mov, 0, sizeof(struct changelog_ext_openmode));
2109 if (nid_mov && (cref_want & CLFE_NID) &&
2111 memset(nid_mov, 0, sizeof(struct changelog_ext_nid));
2113 if (uidgid_mov && (cref_want & CLFE_UIDGID) &&
2114 !(cref & CLFE_UIDGID))
2115 memset(uidgid_mov, 0, sizeof(struct changelog_ext_uidgid));
2117 if ((crf_wanted & CLF_EXTRA_FLAGS) &&
2118 !(rec->cr_flags & CLF_EXTRA_FLAGS))
2119 memset(ef_mov, 0, sizeof(struct changelog_ext_extra_flags));
2121 if ((crf_wanted & CLF_JOBID) && !(rec->cr_flags & CLF_JOBID))
2122 memset(jid_mov, 0, sizeof(struct changelog_ext_jobid));
2124 if ((crf_wanted & CLF_RENAME) && !(rec->cr_flags & CLF_RENAME))
2125 memset(rnm_mov, 0, sizeof(struct changelog_ext_rename));
2127 /* Update the record's flags accordingly */
2128 rec->cr_flags = (rec->cr_flags & CLF_FLAGMASK) | crf_wanted;
2129 if (rec->cr_flags & CLF_EXTRA_FLAGS)
2130 changelog_rec_extra_flags(rec)->cr_extra_flags =
2131 changelog_rec_extra_flags(rec)->cr_extra_flags |
2135 enum changelog_message_type {
2136 CL_RECORD = 10, /* message is a changelog_rec */
2137 CL_EOF = 11, /* at end of current changelog */
2140 /********* Misc **********/
2142 struct ioc_data_version {
2144 __u32 idv_layout_version; /* FLR: layout version for OST objects */
2145 __u32 idv_flags; /* enum ioc_data_version_flags */
2148 enum ioc_data_version_flags {
2149 LL_DV_RD_FLUSH = (1 << 0), /* Flush dirty pages from clients */
2150 LL_DV_WR_FLUSH = (1 << 1), /* Flush all caching pages from clients */
2154 #define offsetof(typ, memb) ((unsigned long)((char *)&(((typ *)0)->memb)))
2157 #define dot_lustre_name ".lustre"
2160 /********* HSM **********/
2162 /** HSM per-file state
2163 * See HSM_FLAGS below.
2166 HS_NONE = 0x00000000,
2167 HS_EXISTS = 0x00000001,
2168 HS_DIRTY = 0x00000002,
2169 HS_RELEASED = 0x00000004,
2170 HS_ARCHIVED = 0x00000008,
2171 HS_NORELEASE = 0x00000010,
2172 HS_NOARCHIVE = 0x00000020,
2173 HS_LOST = 0x00000040,
2176 /* HSM user-setable flags. */
2177 #define HSM_USER_MASK (HS_NORELEASE | HS_NOARCHIVE | HS_DIRTY)
2179 /* Other HSM flags. */
2180 #define HSM_STATUS_MASK (HS_EXISTS | HS_LOST | HS_RELEASED | HS_ARCHIVED)
2183 * All HSM-related possible flags that could be applied to a file.
2184 * This should be kept in sync with hsm_states.
2186 #define HSM_FLAGS_MASK (HSM_USER_MASK | HSM_STATUS_MASK)
2189 * HSM request progress state
2191 enum hsm_progress_states {
2198 static inline const char *hsm_progress_state2name(enum hsm_progress_states s)
2201 case HPS_WAITING: return "waiting";
2202 case HPS_RUNNING: return "running";
2203 case HPS_DONE: return "done";
2204 default: return "unknown";
2211 } __attribute__((packed));
2214 * Current HSM states of a Lustre file.
2216 * This structure purpose is to be sent to user-space mainly. It describes the
2217 * current HSM flags and in-progress action.
2219 struct hsm_user_state {
2220 /** Current HSM states, from enum hsm_states. */
2222 __u32 hus_archive_id;
2223 /** The current undergoing action, if there is one */
2224 __u32 hus_in_progress_state;
2225 __u32 hus_in_progress_action;
2226 struct hsm_extent hus_in_progress_location;
2227 char hus_extended_info[];
2230 struct hsm_state_set_ioc {
2231 struct lu_fid hssi_fid;
2233 __u64 hssi_clearmask;
2237 * This structure describes the current in-progress action for a file.
2238 * it is retuned to user space and send over the wire
2240 struct hsm_current_action {
2241 /** The current undergoing action, if there is one */
2242 /* state is one of hsm_progress_states */
2244 /* action is one of hsm_user_action */
2246 struct hsm_extent hca_location;
2249 /***** HSM user requests ******/
2250 /* User-generated (lfs/ioctl) request types */
2251 enum hsm_user_action {
2252 HUA_NONE = 1, /* no action (noop) */
2253 HUA_ARCHIVE = 10, /* copy to hsm */
2254 HUA_RESTORE = 11, /* prestage */
2255 HUA_RELEASE = 12, /* drop ost objects */
2256 HUA_REMOVE = 13, /* remove from archive */
2257 HUA_CANCEL = 14 /* cancel a request */
2260 static inline const char *hsm_user_action2name(enum hsm_user_action a)
2263 case HUA_NONE: return "NOOP";
2264 case HUA_ARCHIVE: return "ARCHIVE";
2265 case HUA_RESTORE: return "RESTORE";
2266 case HUA_RELEASE: return "RELEASE";
2267 case HUA_REMOVE: return "REMOVE";
2268 case HUA_CANCEL: return "CANCEL";
2269 default: return "UNKNOWN";
2274 * List of hr_flags (bit field)
2276 #define HSM_FORCE_ACTION 0x0001
2277 /* used by CT, cannot be set by user */
2278 #define HSM_GHOST_COPY 0x0002
2281 * Contains all the fixed part of struct hsm_user_request.
2284 struct hsm_request {
2285 __u32 hr_action; /* enum hsm_user_action */
2286 __u32 hr_archive_id; /* archive id, used only with HUA_ARCHIVE */
2287 __u64 hr_flags; /* request flags */
2288 __u32 hr_itemcount; /* item count in hur_user_item vector */
2292 struct hsm_user_item {
2293 struct lu_fid hui_fid;
2294 struct hsm_extent hui_extent;
2295 } __attribute__((packed));
2297 struct hsm_user_request {
2298 struct hsm_request hur_request;
2299 struct hsm_user_item hur_user_item[0];
2300 /* extra data blob at end of struct (after all
2301 * hur_user_items), only use helpers to access it
2303 } __attribute__((packed));
2305 /** Return pointer to data field in a hsm user request */
2306 static inline void *hur_data(struct hsm_user_request *hur)
2308 return &(hur->hur_user_item[hur->hur_request.hr_itemcount]);
2312 * Compute the current length of the provided hsm_user_request. This returns -1
2313 * instead of an errno because __kernel_ssize_t is defined to be only
2316 * return -1 on bounds check error.
2318 static inline __kernel_size_t hur_len(struct hsm_user_request *hur)
2322 /* can't overflow a __u64 since hr_itemcount is only __u32 */
2323 size = offsetof(struct hsm_user_request, hur_user_item[0]) +
2324 (__u64)hur->hur_request.hr_itemcount *
2325 sizeof(hur->hur_user_item[0]) + hur->hur_request.hr_data_len;
2327 if ((__kernel_ssize_t)size < 0)
2333 /****** HSM RPCs to copytool *****/
2334 /* Message types the copytool may receive */
2335 enum hsm_message_type {
2336 HMT_ACTION_LIST = 100, /* message is a hsm_action_list */
2339 /* Actions the copytool may be instructed to take for a given action_item */
2340 enum hsm_copytool_action {
2341 HSMA_NONE = 10, /* no action */
2342 HSMA_ARCHIVE = 20, /* arbitrary offset */
2348 static inline const char *hsm_copytool_action2name(enum hsm_copytool_action a)
2351 case HSMA_NONE: return "NOOP";
2352 case HSMA_ARCHIVE: return "ARCHIVE";
2353 case HSMA_RESTORE: return "RESTORE";
2354 case HSMA_REMOVE: return "REMOVE";
2355 case HSMA_CANCEL: return "CANCEL";
2356 default: return "UNKNOWN";
2360 /* Copytool item action description */
2361 struct hsm_action_item {
2362 __u32 hai_len; /* valid size of this struct */
2363 __u32 hai_action; /* hsm_copytool_action, but use known size */
2364 struct lu_fid hai_fid; /* Lustre FID to operate on */
2365 struct lu_fid hai_dfid; /* fid used for data access */
2366 struct hsm_extent hai_extent; /* byte range to operate on */
2367 __u64 hai_cookie; /* action cookie from coordinator */
2368 __u64 hai_gid; /* grouplock id */
2369 char hai_data[0]; /* variable length */
2370 } __attribute__((packed));
2373 * helper function which print in hexa the first bytes of
2376 * \param hai [IN] record to print
2377 * \param buffer [IN,OUT] buffer to write the hex string to
2378 * \param len [IN] max buffer length
2382 static inline char *hai_dump_data_field(const struct hsm_action_item *hai,
2383 char *buffer, __kernel_size_t len)
2390 data_len = hai->hai_len - sizeof(*hai);
2391 for (i = 0; (i < data_len) && (len > 2); i++) {
2392 snprintf(ptr, 3, "%02X", (unsigned char)hai->hai_data[i]);
2402 /* Copytool action list */
2403 #define HAL_VERSION 1
2404 #define HAL_MAXSIZE LNET_MTU /* bytes, used in userspace only */
2405 struct hsm_action_list {
2407 __u32 hal_count; /* number of hai's to follow */
2408 __u64 hal_compound_id; /* returned by coordinator, ignored */
2410 __u32 hal_archive_id; /* which archive backend */
2412 char hal_fsname[0]; /* null-terminated */
2413 /* struct hsm_action_item[hal_count] follows, aligned on 8-byte
2414 boundaries. See hai_zero */
2415 } __attribute__((packed));
2417 /* Return pointer to first hai in action list */
2418 static inline struct hsm_action_item *hai_first(struct hsm_action_list *hal)
2420 __kernel_size_t offset = __ALIGN_KERNEL(strlen(hal->hal_fsname) + 1, 8);
2422 return (struct hsm_action_item *)(hal->hal_fsname + offset);
2425 /* Return pointer to next hai */
2426 static inline struct hsm_action_item * hai_next(struct hsm_action_item *hai)
2428 __kernel_size_t offset = __ALIGN_KERNEL(hai->hai_len, 8);
2430 return (struct hsm_action_item *)((char *)hai + offset);
2433 /* Return size of an hsm_action_list */
2434 static inline __kernel_size_t hal_size(struct hsm_action_list *hal)
2438 struct hsm_action_item *hai;
2440 sz = sizeof(*hal) + __ALIGN_KERNEL(strlen(hal->hal_fsname) + 1, 8);
2441 hai = hai_first(hal);
2442 for (i = 0; i < hal->hal_count ; i++, hai = hai_next(hai))
2443 sz += __ALIGN_KERNEL(hai->hai_len, 8);
2449 * describe the attributes to be set on imported file
2451 struct hsm_user_import {
2460 __u32 hui_archive_id;
2463 /* Copytool progress reporting */
2464 #define HP_FLAG_COMPLETED 0x01
2465 #define HP_FLAG_RETRY 0x02
2467 struct hsm_progress {
2468 struct lu_fid hp_fid;
2470 struct hsm_extent hp_extent;
2472 __u16 hp_errval; /* positive val */
2477 __u64 hc_data_version;
2479 __u16 hc_errval; /* positive val */
2481 struct hsm_action_item hc_hai;
2484 enum lu_ladvise_type {
2485 LU_LADVISE_INVALID = 0,
2486 LU_LADVISE_WILLREAD = 1,
2487 LU_LADVISE_DONTNEED = 2,
2488 LU_LADVISE_LOCKNOEXPAND = 3,
2489 LU_LADVISE_LOCKAHEAD = 4,
2493 #define LU_LADVISE_NAMES { \
2494 [LU_LADVISE_WILLREAD] = "willread", \
2495 [LU_LADVISE_DONTNEED] = "dontneed", \
2496 [LU_LADVISE_LOCKNOEXPAND] = "locknoexpand", \
2497 [LU_LADVISE_LOCKAHEAD] = "lockahead", \
2500 /* This is the userspace argument for ladvise. It is currently the same as
2501 * what goes on the wire (struct lu_ladvise), but is defined separately as we
2502 * may need info which is only used locally. */
2503 struct llapi_lu_ladvise {
2504 __u16 lla_advice; /* advice type */
2505 __u16 lla_value1; /* values for different advice types */
2507 __u64 lla_start; /* first byte of extent for advice */
2508 __u64 lla_end; /* last byte of extent for advice */
2514 LF_ASYNC = 0x00000001,
2515 LF_UNSET = 0x00000002,
2518 #define LADVISE_MAGIC 0x1ADF1CE0
2519 /* Masks of valid flags for each advice */
2520 #define LF_LOCKNOEXPAND_MASK LF_UNSET
2521 /* Flags valid for all advices not explicitly specified */
2522 #define LF_DEFAULT_MASK LF_ASYNC
2524 #define LF_MASK (LF_ASYNC | LF_UNSET)
2526 #define lla_lockahead_mode lla_value1
2527 #define lla_peradvice_flags lla_value2
2528 #define lla_lockahead_result lla_value3
2530 /* This is the userspace argument for ladvise, corresponds to ladvise_hdr which
2531 * is used on the wire. It is defined separately as we may need info which is
2532 * only used locally. */
2533 struct llapi_ladvise_hdr {
2534 __u32 lah_magic; /* LADVISE_MAGIC */
2535 __u32 lah_count; /* number of advices */
2536 __u64 lah_flags; /* from enum ladvise_flag */
2537 __u32 lah_value1; /* unused */
2538 __u32 lah_value2; /* unused */
2539 __u64 lah_value3; /* unused */
2540 struct llapi_lu_ladvise lah_advise[0]; /* advices in this header */
2543 #define LAH_COUNT_MAX (1024)
2547 SK_CRYPT_INVALID = -1,
2549 SK_CRYPT_AES256_CTR = 1,
2553 SK_HMAC_INVALID = -1,
2559 struct sk_crypt_type {
2560 const char *sct_name;
2564 struct sk_hmac_type {
2565 const char *sht_name;
2569 enum lock_mode_user {
2575 #define LOCK_MODE_NAMES { \
2576 [MODE_READ_USER] = "READ",\
2577 [MODE_WRITE_USER] = "WRITE"\
2580 enum lockahead_results {
2581 LLA_RESULT_SENT = 0,
2582 LLA_RESULT_DIFFERENT,
2586 enum lu_heat_flag_bit {
2587 LU_HEAT_FLAG_BIT_INVALID = 0,
2588 LU_HEAT_FLAG_BIT_OFF,
2589 LU_HEAT_FLAG_BIT_CLEAR,
2593 LU_HEAT_FLAG_OFF = 1ULL << LU_HEAT_FLAG_BIT_OFF,
2594 LU_HEAT_FLAG_CLEAR = 1ULL << LU_HEAT_FLAG_BIT_CLEAR,
2597 enum obd_heat_type {
2598 OBD_HEAT_READSAMPLE = 0,
2599 OBD_HEAT_WRITESAMPLE = 1,
2600 OBD_HEAT_READBYTE = 2,
2601 OBD_HEAT_WRITEBYTE = 3,
2605 #define LU_HEAT_NAMES { \
2606 [OBD_HEAT_READSAMPLE] = "readsample", \
2607 [OBD_HEAT_WRITESAMPLE] = "writesample", \
2608 [OBD_HEAT_READBYTE] = "readbyte", \
2609 [OBD_HEAT_WRITEBYTE] = "writebyte", \
2624 static inline const char *pcc_type2string(enum lu_pcc_type type)
2629 case LU_PCC_READWRITE:
2636 struct lu_pcc_attach {
2637 __u32 pcca_type; /* PCC type */
2638 __u32 pcca_id; /* archive ID for readwrite, group ID for readonly */
2641 enum lu_pcc_detach_opts {
2642 PCC_DETACH_OPT_NONE = 0, /* Detach only, keep the PCC copy */
2643 PCC_DETACH_OPT_UNCACHE, /* Remove the cached file after detach */
2646 struct lu_pcc_detach_fid {
2647 /* fid of the file to detach */
2648 struct lu_fid pccd_fid;
2652 struct lu_pcc_detach {
2656 enum lu_pcc_state_flags {
2657 PCC_STATE_FL_NONE = 0x0,
2658 /* The inode attr is cached locally */
2659 PCC_STATE_FL_ATTR_VALID = 0x01,
2660 /* The file is being attached into PCC */
2661 PCC_STATE_FL_ATTACHING = 0x02,
2664 struct lu_pcc_state {
2665 __u32 pccs_type; /* enum lu_pcc_type */
2666 __u32 pccs_open_count;
2667 __u32 pccs_flags; /* enum lu_pcc_state_flags */
2669 char pccs_path[PATH_MAX];
2674 /* make header's size equal lu_fid */
2677 struct lu_fid fa_fids[0];
2679 #define OBD_MAX_FIDS_IN_ARRAY 4096
2681 /* more types could be defined upon need for more complex
2682 * format to be used in foreign symlink LOV/LMV EAs, like
2683 * one to describe a delimiter string and occurence number
2684 * of delimited sub-string, ...
2686 enum ll_foreign_symlink_upcall_item_type {
2692 /* may need to be modified to allow for more format items to be defined, and
2693 * like for ll_foreign_symlink_upcall_item_type enum
2695 struct ll_foreign_symlink_upcall_item {
2705 /* internal storage of constant string */
2707 /* upcall stores constant string in a raw */
2714 #define POSLEN_ITEM_SZ (offsetof(struct ll_foreign_symlink_upcall_item, len) + \
2715 sizeof(((struct ll_foreign_symlink_upcall_item *)0)->len))
2716 #define STRING_ITEM_SZ(sz) ( \
2717 offsetof(struct ll_foreign_symlink_upcall_item, bytestring) + \
2718 (sz + sizeof(__u32) - 1) / sizeof(__u32) * sizeof(__u32))
2720 /* presently limited to not cause max stack frame size to be reached
2721 * because of temporary automatic array of
2722 * "struct ll_foreign_symlink_upcall_item" presently used in
2723 * foreign_symlink_upcall_info_store()
2725 #define MAX_NB_UPCALL_ITEMS 32
2727 #if defined(__cplusplus)
2731 /** @} lustreuser */
2733 #endif /* _LUSTRE_USER_H */
git://git.whamcloud.com / fs / lustre-release.git / blob