lustre/include/lustre/lustre_user.h

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   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.
   9  *
  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).
  15  *
  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
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2010, 2016, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  * Lustre is a trademark of Sun Microsystems, Inc.
  31  *
  32  * lustre/include/lustre/lustre_user.h
  33  *
  34  * Lustre public user-space interface definitions.
  35  */
  36
  37 #ifndef _LUSTRE_USER_H
  38 #define _LUSTRE_USER_H
  39
  40 /** \defgroup lustreuser lustreuser
  41  *
  42  * @{
  43  */
  44
  45 #include <linux/types.h>
  46
  47 #ifdef __KERNEL__
  48 # include <linux/fs.h>
  49 # include <linux/quota.h>
  50 # include <linux/string.h> /* snprintf() */
  51 # include <linux/version.h>
  52 #else /* !__KERNEL__ */
  53 # define NEED_QUOTA_DEFS
  54 # include <limits.h>
  55 # include <stdbool.h>
  56 # include <stdio.h> /* snprintf() */
  57 # include <string.h>
  58 # include <sys/quota.h>
  59 # include <sys/stat.h>
  60 #endif /* __KERNEL__ */
  61 #include <lustre/ll_fiemap.h>
  62
  63 #if defined(__x86_64__) || defined(__ia64__) || defined(__ppc64__) || \
  64     defined(__craynv) || defined(__mips64__) || defined(__powerpc64__) || \
  65     defined(__aarch64__)
  66 typedef struct stat     lstat_t;
  67 # define lstat_f        lstat
  68 # define fstat_f        fstat
  69 # define fstatat_f      fstatat
  70 # define HAVE_LOV_USER_MDS_DATA
  71 #elif defined(__USE_LARGEFILE64) || defined(__KERNEL__)
  72 typedef struct stat64   lstat_t;
  73 # define lstat_f        lstat64
  74 # define fstat_f        fstat64
  75 # define fstatat_f      fstatat64
  76 # define HAVE_LOV_USER_MDS_DATA
  77 #endif
  78
  79 #define LUSTRE_EOF 0xffffffffffffffffULL
  80
  81 /* for statfs() */
  82 #define LL_SUPER_MAGIC 0x0BD00BD0
  83
  84 #ifndef FSFILT_IOC_GETFLAGS
  85 #define FSFILT_IOC_GETFLAGS               _IOR('f', 1, long)
  86 #define FSFILT_IOC_SETFLAGS               _IOW('f', 2, long)
  87 #define FSFILT_IOC_GETVERSION             _IOR('f', 3, long)
  88 #define FSFILT_IOC_SETVERSION             _IOW('f', 4, long)
  89 #define FSFILT_IOC_GETVERSION_OLD         _IOR('v', 1, long)
  90 #define FSFILT_IOC_SETVERSION_OLD         _IOW('v', 2, long)
  91 #endif
  92
  93 /* FIEMAP flags supported by Lustre */
  94 #define LUSTRE_FIEMAP_FLAGS_COMPAT (FIEMAP_FLAG_SYNC | FIEMAP_FLAG_DEVICE_ORDER)
  95
  96 enum obd_statfs_state {
  97         OS_STATE_DEGRADED       = 0x00000001, /**< RAID degraded/rebuilding */
  98         OS_STATE_READONLY       = 0x00000002, /**< filesystem is read-only */
  99         OS_STATE_ENOSPC         = 0x00000020, /**< not enough free space */
 100         OS_STATE_ENOINO         = 0x00000040, /**< not enough inodes */
 101 };
 102
 103 struct obd_statfs {
 104         __u64           os_type;
 105         __u64           os_blocks;
 106         __u64           os_bfree;
 107         __u64           os_bavail;
 108         __u64           os_files;
 109         __u64           os_ffree;
 110         __u8            os_fsid[40];
 111         __u32           os_bsize;
 112         __u32           os_namelen;
 113         __u64           os_maxbytes;
 114         __u32           os_state;       /**< obd_statfs_state OS_STATE_* flag */
 115         __u32           os_fprecreated; /* objs available now to the caller */
 116                                         /* used in QoS code to find preferred
 117                                          * OSTs */
 118         __u32           os_spare2;
 119         __u32           os_spare3;
 120         __u32           os_spare4;
 121         __u32           os_spare5;
 122         __u32           os_spare6;
 123         __u32           os_spare7;
 124         __u32           os_spare8;
 125         __u32           os_spare9;
 126 };
 127
 128 /**
 129  * File IDentifier.
 130  *
 131  * FID is a cluster-wide unique identifier of a file or an object (stripe).
 132  * FIDs are never reused.
 133  **/
 134 struct lu_fid {
 135        /**
 136         * FID sequence. Sequence is a unit of migration: all files (objects)
 137         * with FIDs from a given sequence are stored on the same server.
 138         * Lustre should support 2^64 objects, so even if each sequence
 139         * has only a single object we can still enumerate 2^64 objects.
 140         **/
 141         __u64 f_seq;
 142         /* FID number within sequence. */
 143         __u32 f_oid;
 144         /**
 145          * FID version, used to distinguish different versions (in the sense
 146          * of snapshots, etc.) of the same file system object. Not currently
 147          * used.
 148          **/
 149         __u32 f_ver;
 150 };
 151
 152 static inline bool fid_is_zero(const struct lu_fid *fid)
 153 {
 154         return fid->f_seq == 0 && fid->f_oid == 0;
 155 }
 156
 157 /* Currently, the filter_fid::ff_parent::f_ver is not the real parent
 158  * MDT-object's FID::f_ver, instead it is the OST-object index in its
 159  * parent MDT-object's layout EA. */
 160 #define f_stripe_idx f_ver
 161
 162 struct ost_layout {
 163         __u32   ol_stripe_size;
 164         __u32   ol_stripe_count;
 165         __u64   ol_comp_start;
 166         __u64   ol_comp_end;
 167         __u32   ol_comp_id;
 168 } __attribute__((packed));
 169
 170 /* keep this one for compatibility */
 171 struct filter_fid_old {
 172         struct lu_fid   ff_parent;
 173         __u64           ff_objid;
 174         __u64           ff_seq;
 175 };
 176
 177 struct filter_fid {
 178         struct lu_fid           ff_parent;
 179         struct ost_layout       ff_layout;
 180 } __attribute__((packed));
 181
 182 /* Userspace should treat lu_fid as opaque, and only use the following methods
 183  * to print or parse them.  Other functions (e.g. compare, swab) could be moved
 184  * here from lustre_idl.h if needed. */
 185 typedef struct lu_fid lustre_fid;
 186
 187 enum lma_compat {
 188         LMAC_HSM         = 0x00000001,
 189 /*      LMAC_SOM         = 0x00000002, obsolete since 2.8.0 */
 190         LMAC_NOT_IN_OI   = 0x00000004, /* the object does NOT need OI mapping */
 191         LMAC_FID_ON_OST  = 0x00000008, /* For OST-object, its OI mapping is
 192                                        * under /O/<seq>/d<x>. */
 193         LMAC_STRIPE_INFO = 0x00000010, /* stripe info in the LMA EA. */
 194         LMAC_COMP_INFO   = 0x00000020, /* Component info in the LMA EA. */
 195 };
 196
 197 /**
 198  * Masks for all features that should be supported by a Lustre version to
 199  * access a specific file.
 200  * This information is stored in lustre_mdt_attrs::lma_incompat.
 201  */
 202 enum lma_incompat {
 203         LMAI_RELEASED           = 0x00000001, /* file is released */
 204         LMAI_AGENT              = 0x00000002, /* agent inode */
 205         LMAI_REMOTE_PARENT      = 0x00000004, /* the parent of the object
 206                                                  is on the remote MDT */
 207         LMAI_STRIPED            = 0x00000008, /* striped directory inode */
 208         LMAI_ORPHAN             = 0x00000010, /* inode is orphan */
 209         LMA_INCOMPAT_SUPP       = (LMAI_AGENT | LMAI_REMOTE_PARENT | \
 210                                    LMAI_STRIPED | LMAI_ORPHAN)
 211 };
 212
 213
 214 /**
 215  * Following struct for object attributes, that will be kept inode's EA.
 216  * Introduced in 2.0 release (please see b15993, for details)
 217  * Added to all objects since Lustre 2.4 as contains self FID
 218  */
 219 struct lustre_mdt_attrs {
 220         /**
 221          * Bitfield for supported data in this structure. From enum lma_compat.
 222          * lma_self_fid and lma_flags are always available.
 223          */
 224         __u32   lma_compat;
 225         /**
 226          * Per-file incompat feature list. Lustre version should support all
 227          * flags set in this field. The supported feature mask is available in
 228          * LMA_INCOMPAT_SUPP.
 229          */
 230         __u32   lma_incompat;
 231         /** FID of this inode */
 232         struct lu_fid  lma_self_fid;
 233 };
 234
 235 struct lustre_ost_attrs {
 236         /* Use lustre_mdt_attrs directly for now, need a common header
 237          * structure if want to change lustre_mdt_attrs in future. */
 238         struct lustre_mdt_attrs loa_lma;
 239
 240         /* Below five elements are for OST-object's PFID EA, the
 241          * lma_parent_fid::f_ver is composed of the stripe_count (high 16 bits)
 242          * and the stripe_index (low 16 bits), the size should not exceed
 243          * 5 * sizeof(__u64)) to be accessable by old Lustre. If the flag
 244          * LMAC_STRIPE_INFO is set, then loa_parent_fid and loa_stripe_size
 245          * are valid; if the flag LMAC_COMP_INFO is set, then the next three
 246          * loa_comp_* elements are valid. */
 247         struct lu_fid   loa_parent_fid;
 248         __u32           loa_stripe_size;
 249         __u32           loa_comp_id;
 250         __u64           loa_comp_start;
 251         __u64           loa_comp_end;
 252 };
 253
 254 /**
 255  * Prior to 2.4, the LMA structure also included SOM attributes which has since
 256  * been moved to a dedicated xattr
 257  * lma_flags was also removed because of lma_compat/incompat fields.
 258  */
 259 #define LMA_OLD_SIZE (sizeof(struct lustre_mdt_attrs) + 5 * sizeof(__u64))
 260
 261 /**
 262  * OST object IDentifier.
 263  */
 264 struct ost_id {
 265         union {
 266                 struct {
 267                         __u64   oi_id;
 268                         __u64   oi_seq;
 269                 } oi;
 270                 struct lu_fid oi_fid;
 271         };
 272 };
 273
 274 #define DOSTID "%#llx:%llu"
 275 #define POSTID(oi) ((unsigned long long)ostid_seq(oi)), \
 276                    ((unsigned long long)ostid_id(oi))
 277
 278 struct ll_futimes_3 {
 279         __u64 lfu_atime_sec;
 280         __u64 lfu_atime_nsec;
 281         __u64 lfu_mtime_sec;
 282         __u64 lfu_mtime_nsec;
 283         __u64 lfu_ctime_sec;
 284         __u64 lfu_ctime_nsec;
 285 };
 286
 287 /*
 288  * The ioctl naming rules:
 289  * LL_*     - works on the currently opened filehandle instead of parent dir
 290  * *_OBD_*  - gets data for both OSC or MDC (LOV, LMV indirectly)
 291  * *_MDC_*  - gets/sets data related to MDC
 292  * *_LOV_*  - gets/sets data related to OSC/LOV
 293  * *FILE*   - called on parent dir and passes in a filename
 294  * *STRIPE* - set/get lov_user_md
 295  * *INFO    - set/get lov_user_mds_data
 296  */
 297 /*      lustre_ioctl.h                  101-150 */
 298 #define LL_IOC_GETFLAGS                 _IOR ('f', 151, long)
 299 #define LL_IOC_SETFLAGS                 _IOW ('f', 152, long)
 300 #define LL_IOC_CLRFLAGS                 _IOW ('f', 153, long)
 301 #define LL_IOC_LOV_SETSTRIPE            _IOW ('f', 154, long)
 302 #define LL_IOC_LOV_GETSTRIPE            _IOW ('f', 155, long)
 303 #define LL_IOC_LOV_SETEA                _IOW ('f', 156, long)
 304 /*      LL_IOC_RECREATE_OBJ             157 obsolete */
 305 /*      LL_IOC_RECREATE_FID             157 obsolete */
 306 #define LL_IOC_GROUP_LOCK               _IOW ('f', 158, long)
 307 #define LL_IOC_GROUP_UNLOCK             _IOW ('f', 159, long)
 308 /*      LL_IOC_QUOTACHECK               160 OBD_IOC_QUOTACHECK */
 309 /*      LL_IOC_POLL_QUOTACHECK          161 OBD_IOC_POLL_QUOTACHECK */
 310 /*      LL_IOC_QUOTACTL                 162 OBD_IOC_QUOTACTL */
 311 #define IOC_OBD_STATFS                  _IOWR('f', 164, struct obd_statfs *)
 312 /*      IOC_LOV_GETINFO                 165 obsolete */
 313 #define LL_IOC_FLUSHCTX                 _IOW ('f', 166, long)
 314 /*      LL_IOC_RMTACL                   167 obsolete */
 315 #define LL_IOC_GETOBDCOUNT              _IOR ('f', 168, long)
 316 #define LL_IOC_LLOOP_ATTACH             _IOWR('f', 169, long)
 317 #define LL_IOC_LLOOP_DETACH             _IOWR('f', 170, long)
 318 #define LL_IOC_LLOOP_INFO               _IOWR('f', 171, struct lu_fid)
 319 #define LL_IOC_LLOOP_DETACH_BYDEV       _IOWR('f', 172, long)
 320 #define LL_IOC_PATH2FID                 _IOR ('f', 173, long)
 321 #define LL_IOC_GET_CONNECT_FLAGS        _IOWR('f', 174, __u64 *)
 322 #define LL_IOC_GET_MDTIDX               _IOR ('f', 175, int)
 323 #define LL_IOC_FUTIMES_3                _IOWR('f', 176, struct ll_futimes_3)
 324 /*      lustre_ioctl.h                  177-210 */
 325 #define LL_IOC_HSM_STATE_GET            _IOR('f', 211, struct hsm_user_state)
 326 #define LL_IOC_HSM_STATE_SET            _IOW('f', 212, struct hsm_state_set)
 327 #define LL_IOC_HSM_CT_START             _IOW('f', 213, struct lustre_kernelcomm)
 328 #define LL_IOC_HSM_COPY_START           _IOW('f', 214, struct hsm_copy *)
 329 #define LL_IOC_HSM_COPY_END             _IOW('f', 215, struct hsm_copy *)
 330 #define LL_IOC_HSM_PROGRESS             _IOW('f', 216, struct hsm_user_request)
 331 #define LL_IOC_HSM_REQUEST              _IOW('f', 217, struct hsm_user_request)
 332 #define LL_IOC_DATA_VERSION             _IOR('f', 218, struct ioc_data_version)
 333 #define LL_IOC_LOV_SWAP_LAYOUTS         _IOW('f', 219, \
 334                                                 struct lustre_swap_layouts)
 335 #define LL_IOC_HSM_ACTION               _IOR('f', 220, \
 336                                                 struct hsm_current_action)
 337 /*      lustre_ioctl.h                  221-232 */
 338 #define LL_IOC_LMV_SETSTRIPE            _IOWR('f', 240, struct lmv_user_md)
 339 #define LL_IOC_LMV_GETSTRIPE            _IOWR('f', 241, struct lmv_user_md)
 340 #define LL_IOC_REMOVE_ENTRY             _IOWR('f', 242, __u64)
 341 #define LL_IOC_SET_LEASE                _IOWR('f', 243, long)
 342 #define LL_IOC_GET_LEASE                _IO('f', 244)
 343 #define LL_IOC_HSM_IMPORT               _IOWR('f', 245, struct hsm_user_import)
 344 #define LL_IOC_LMV_SET_DEFAULT_STRIPE   _IOWR('f', 246, struct lmv_user_md)
 345 #define LL_IOC_MIGRATE                  _IOR('f', 247, int)
 346 #define LL_IOC_FID2MDTIDX               _IOWR('f', 248, struct lu_fid)
 347 #define LL_IOC_GETPARENT                _IOWR('f', 249, struct getparent)
 348 #define LL_IOC_LADVISE                  _IOR('f', 250, struct llapi_lu_ladvise)
 349
 350 /* Lease types for use as arg and return of LL_IOC_{GET,SET}_LEASE ioctl. */
 351 enum ll_lease_type {
 352         LL_LEASE_RDLCK  = 0x1,
 353         LL_LEASE_WRLCK  = 0x2,
 354         LL_LEASE_UNLCK  = 0x4,
 355 };
 356
 357 #define LL_STATFS_LMV           1
 358 #define LL_STATFS_LOV           2
 359 #define LL_STATFS_NODELAY       4
 360
 361 #define IOC_MDC_TYPE            'i'
 362 #define IOC_MDC_LOOKUP          _IOWR(IOC_MDC_TYPE, 20, struct obd_device *)
 363 #define IOC_MDC_GETFILESTRIPE   _IOWR(IOC_MDC_TYPE, 21, struct lov_user_md *)
 364 #define IOC_MDC_GETFILEINFO     _IOWR(IOC_MDC_TYPE, 22, struct lov_user_mds_data *)
 365 #define LL_IOC_MDC_GETINFO      _IOWR(IOC_MDC_TYPE, 23, struct lov_user_mds_data *)
 366
 367 #define MAX_OBD_NAME 128 /* If this changes, a NEW ioctl must be added */
 368
 369 /* Define O_LOV_DELAY_CREATE to be a mask that is not useful for regular
 370  * files, but are unlikely to be used in practice and are not harmful if
 371  * used incorrectly.  O_NOCTTY and FASYNC are only meaningful for character
 372  * devices and are safe for use on new files. See LU-4209. */
 373 /* To be compatible with old statically linked binary we keep the check for
 374  * the older 0100000000 flag.  This is already removed upstream.  LU-812. */
 375 #define O_LOV_DELAY_CREATE_1_8  0100000000 /* FMODE_NONOTIFY masked in 2.6.36 */
 376 #define O_LOV_DELAY_CREATE_MASK (O_NOCTTY | FASYNC)
 377 #define O_LOV_DELAY_CREATE              (O_LOV_DELAY_CREATE_1_8 | \
 378                                          O_LOV_DELAY_CREATE_MASK)
 379
 380 #define LL_FILE_IGNORE_LOCK     0x00000001
 381 #define LL_FILE_GROUP_LOCKED    0x00000002
 382 #define LL_FILE_READAHEA        0x00000004
 383 #define LL_FILE_LOCKED_DIRECTIO 0x00000008 /* client-side locks with dio */
 384 #define LL_FILE_LOCKLESS_IO     0x00000010 /* server-side locks with cio */
 385
 386 #define LOV_USER_MAGIC_V1       0x0BD10BD0
 387 #define LOV_USER_MAGIC          LOV_USER_MAGIC_V1
 388 #define LOV_USER_MAGIC_JOIN_V1  0x0BD20BD0
 389 #define LOV_USER_MAGIC_V3       0x0BD30BD0
 390 /* 0x0BD40BD0 is occupied by LOV_MAGIC_MIGRATE */
 391 #define LOV_USER_MAGIC_SPECIFIC 0x0BD50BD0      /* for specific OSTs */
 392 #define LOV_USER_MAGIC_COMP_V1  0x0BD60BD0
 393
 394 #define LMV_USER_MAGIC    0x0CD30CD0    /*default lmv magic*/
 395
 396 #define LOV_PATTERN_RAID0       0x001
 397 #define LOV_PATTERN_RAID1       0x002
 398 #define LOV_PATTERN_FIRST       0x100
 399 #define LOV_PATTERN_CMOBD       0x200
 400
 401 #define LOV_PATTERN_F_MASK      0xffff0000
 402 #define LOV_PATTERN_F_HOLE      0x40000000 /* there is hole in LOV EA */
 403 #define LOV_PATTERN_F_RELEASED  0x80000000 /* HSM released file */
 404
 405 static inline bool lov_pattern_supported(__u32 pattern)
 406 {
 407         return pattern == LOV_PATTERN_RAID0 ||
 408                pattern == (LOV_PATTERN_RAID0 | LOV_PATTERN_F_RELEASED);
 409 }
 410
 411 #define LOV_MAXPOOLNAME 15
 412 #define LOV_POOLNAMEF "%.15s"
 413
 414 #define LOV_MIN_STRIPE_BITS 16   /* maximum PAGE_SIZE (ia64), power of 2 */
 415 #define LOV_MIN_STRIPE_SIZE (1 << LOV_MIN_STRIPE_BITS)
 416 #define LOV_MAX_STRIPE_COUNT_OLD 160
 417 /* This calculation is crafted so that input of 4096 will result in 160
 418  * which in turn is equal to old maximal stripe count.
 419  * XXX: In fact this is too simpified for now, what it also need is to get
 420  * ea_type argument to clearly know how much space each stripe consumes.
 421  *
 422  * The limit of 12 pages is somewhat arbitrary, but is a reasonably large
 423  * allocation that is sufficient for the current generation of systems.
 424  *
 425  * (max buffer size - lov+rpc header) / sizeof(struct lov_ost_data_v1) */
 426 #define LOV_MAX_STRIPE_COUNT 2000  /* ((12 * 4096 - 256) / 24) */
 427 #define LOV_ALL_STRIPES       0xffff /* only valid for directories */
 428 #define LOV_V1_INSANE_STRIPE_COUNT 65532 /* maximum stripe count bz13933 */
 429
 430 #define XATTR_LUSTRE_PREFIX     "lustre."
 431 #define XATTR_LUSTRE_LOV        XATTR_LUSTRE_PREFIX"lov"
 432
 433 #define lov_user_ost_data lov_user_ost_data_v1
 434 struct lov_user_ost_data_v1 {     /* per-stripe data structure */
 435         struct ost_id l_ost_oi;   /* OST object ID */
 436         __u32 l_ost_gen;          /* generation of this OST index */
 437         __u32 l_ost_idx;          /* OST index in LOV */
 438 } __attribute__((packed));
 439
 440 #define lov_user_md lov_user_md_v1
 441 struct lov_user_md_v1 {           /* LOV EA user data (host-endian) */
 442         __u32 lmm_magic;          /* magic number = LOV_USER_MAGIC_V1 */
 443         __u32 lmm_pattern;        /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */
 444         struct ost_id lmm_oi;     /* MDT parent inode id/seq (id/0 for 1.x) */
 445         __u32 lmm_stripe_size;    /* size of stripe in bytes */
 446         __u16 lmm_stripe_count;   /* num stripes in use for this object */
 447         union {
 448                 __u16 lmm_stripe_offset;  /* starting stripe offset in
 449                                            * lmm_objects, use when writing */
 450                 __u16 lmm_layout_gen;     /* layout generation number
 451                                            * used when reading */
 452         };
 453         struct lov_user_ost_data_v1 lmm_objects[0]; /* per-stripe data */
 454 } __attribute__((packed,  __may_alias__));
 455
 456 struct lov_user_md_v3 {           /* LOV EA user data (host-endian) */
 457         __u32 lmm_magic;          /* magic number = LOV_USER_MAGIC_V3 */
 458         __u32 lmm_pattern;        /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */
 459         struct ost_id lmm_oi;     /* MDT parent inode id/seq (id/0 for 1.x) */
 460         __u32 lmm_stripe_size;    /* size of stripe in bytes */
 461         __u16 lmm_stripe_count;   /* num stripes in use for this object */
 462         union {
 463                 __u16 lmm_stripe_offset;  /* starting stripe offset in
 464                                            * lmm_objects, use when writing */
 465                 __u16 lmm_layout_gen;     /* layout generation number
 466                                            * used when reading */
 467         };
 468         char  lmm_pool_name[LOV_MAXPOOLNAME + 1]; /* pool name */
 469         struct lov_user_ost_data_v1 lmm_objects[0]; /* per-stripe data */
 470 } __attribute__((packed));
 471
 472 struct lu_extent {
 473         __u64   e_start;
 474         __u64   e_end;
 475 };
 476
 477 #define DEXT "[ %#llx , %#llx )"
 478 #define PEXT(ext) (ext)->e_start, (ext)->e_end
 479
 480 static inline bool lu_extent_is_overlapped(struct lu_extent *e1,
 481                                            struct lu_extent *e2)
 482 {
 483         return e1->e_start < e2->e_end && e2->e_start < e1->e_end;
 484 }
 485
 486 enum lov_comp_md_entry_flags {
 487         LCME_FL_PRIMARY = 0x00000001,   /* Not used */
 488         LCME_FL_STALE   = 0x00000002,   /* Not used */
 489         LCME_FL_OFFLINE = 0x00000004,   /* Not used */
 490         LCME_FL_PREFERRED = 0x00000008, /* Not used */
 491         LCME_FL_INIT    = 0x00000010,   /* instantiated */
 492 };
 493
 494 #define LCME_KNOWN_FLAGS        LCME_FL_INIT
 495
 496 /* lcme_id can be specified as certain flags, and the the first
 497  * bit of lcme_id is used to indicate that the ID is representing
 498  * certain LCME_FL_* but not a real ID. Which implies we can have
 499  * at most 31 flags (see LCME_FL_XXX). */
 500 enum lcme_id {
 501         LCME_ID_INVAL   = 0x0,
 502         LCME_ID_MAX     = 0x7FFFFFFF,
 503         LCME_ID_ALL     = 0xFFFFFFFF,
 504         LCME_ID_NONE    = 0x80000000
 505 };
 506
 507 #define LCME_ID_MASK    LCME_ID_MAX
 508
 509 struct lov_comp_md_entry_v1 {
 510         __u32                   lcme_id;        /* unique id of component */
 511         __u32                   lcme_flags;     /* LCME_FL_XXX */
 512         struct lu_extent        lcme_extent;    /* file extent for component */
 513         __u32                   lcme_offset;    /* offset of component blob,
 514                                                    start from lov_comp_md_v1 */
 515         __u32                   lcme_size;      /* size of component blob */
 516         __u64                   lcme_padding[2];
 517 } __attribute__((packed));
 518
 519 enum lov_comp_md_flags;
 520
 521 struct lov_comp_md_v1 {
 522         __u32   lcm_magic;      /* LOV_USER_MAGIC_COMP_V1 */
 523         __u32   lcm_size;       /* overall size including this struct */
 524         __u32   lcm_layout_gen;
 525         __u16   lcm_flags;
 526         __u16   lcm_entry_count;
 527         __u64   lcm_padding1;
 528         __u64   lcm_padding2;
 529         struct lov_comp_md_entry_v1 lcm_entries[0];
 530 } __attribute__((packed));
 531
 532 static inline __u32 lov_user_md_size(__u16 stripes, __u32 lmm_magic)
 533 {
 534         if (lmm_magic == LOV_USER_MAGIC_V1)
 535                 return sizeof(struct lov_user_md_v1) +
 536                               stripes * sizeof(struct lov_user_ost_data_v1);
 537         return sizeof(struct lov_user_md_v3) +
 538                                 stripes * sizeof(struct lov_user_ost_data_v1);
 539 }
 540
 541 /* Compile with -D_LARGEFILE64_SOURCE or -D_GNU_SOURCE (or #define) to
 542  * use this.  It is unsafe to #define those values in this header as it
 543  * is possible the application has already #included <sys/stat.h>. */
 544 #ifdef HAVE_LOV_USER_MDS_DATA
 545 #define lov_user_mds_data lov_user_mds_data_v1
 546 struct lov_user_mds_data_v1 {
 547         lstat_t lmd_st;                 /* MDS stat struct */
 548         struct lov_user_md_v1 lmd_lmm;  /* LOV EA V1 user data */
 549 } __attribute__((packed));
 550
 551 struct lov_user_mds_data_v3 {
 552         lstat_t lmd_st;                 /* MDS stat struct */
 553         struct lov_user_md_v3 lmd_lmm;  /* LOV EA V3 user data */
 554 } __attribute__((packed));
 555 #endif
 556
 557 struct lmv_user_mds_data {
 558         struct lu_fid   lum_fid;
 559         __u32           lum_padding;
 560         __u32           lum_mds;
 561 };
 562
 563 enum lmv_hash_type {
 564         LMV_HASH_TYPE_UNKNOWN   = 0,    /* 0 is reserved for testing purpose */
 565         LMV_HASH_TYPE_ALL_CHARS = 1,
 566         LMV_HASH_TYPE_FNV_1A_64 = 2,
 567         LMV_HASH_TYPE_MAX,
 568 };
 569
 570 #define LMV_HASH_NAME_ALL_CHARS "all_char"
 571 #define LMV_HASH_NAME_FNV_1A_64 "fnv_1a_64"
 572
 573 extern char *mdt_hash_name[LMV_HASH_TYPE_MAX];
 574
 575 /* Got this according to how get LOV_MAX_STRIPE_COUNT, see above,
 576  * (max buffer size - lmv+rpc header) / sizeof(struct lmv_user_mds_data) */
 577 #define LMV_MAX_STRIPE_COUNT 2000  /* ((12 * 4096 - 256) / 24) */
 578 #define lmv_user_md lmv_user_md_v1
 579 struct lmv_user_md_v1 {
 580         __u32   lum_magic;       /* must be the first field */
 581         __u32   lum_stripe_count;  /* dirstripe count */
 582         __u32   lum_stripe_offset; /* MDT idx for default dirstripe */
 583         __u32   lum_hash_type;     /* Dir stripe policy */
 584         __u32   lum_type;         /* LMV type: default or normal */
 585         __u32   lum_padding1;
 586         __u32   lum_padding2;
 587         __u32   lum_padding3;
 588         char    lum_pool_name[LOV_MAXPOOLNAME + 1];
 589         struct  lmv_user_mds_data  lum_objects[0];
 590 } __attribute__((packed));
 591
 592 static inline int lmv_user_md_size(int stripes, int lmm_magic)
 593 {
 594         return sizeof(struct lmv_user_md) +
 595                       stripes * sizeof(struct lmv_user_mds_data);
 596 }
 597
 598 struct ll_recreate_obj {
 599         __u64 lrc_id;
 600         __u32 lrc_ost_idx;
 601 };
 602
 603 struct ll_fid {
 604         __u64 id;         /* holds object id */
 605         __u32 generation; /* holds object generation */
 606         __u32 f_type;     /* holds object type or stripe idx when passing it to
 607                            * OST for saving into EA. */
 608 };
 609
 610 #define UUID_MAX        40
 611 struct obd_uuid {
 612         char uuid[UUID_MAX];
 613 };
 614
 615 static inline bool obd_uuid_equals(const struct obd_uuid *u1,
 616                                    const struct obd_uuid *u2)
 617 {
 618         return strcmp((char *)u1->uuid, (char *)u2->uuid) == 0;
 619 }
 620
 621 static inline int obd_uuid_empty(struct obd_uuid *uuid)
 622 {
 623         return uuid->uuid[0] == '\0';
 624 }
 625
 626 static inline void obd_str2uuid(struct obd_uuid *uuid, const char *tmp)
 627 {
 628         strncpy((char *)uuid->uuid, tmp, sizeof(*uuid));
 629         uuid->uuid[sizeof(*uuid) - 1] = '\0';
 630 }
 631
 632 /* For printf's only, make sure uuid is terminated */
 633 static inline char *obd_uuid2str(const struct obd_uuid *uuid)
 634 {
 635         if (uuid == NULL)
 636                 return NULL;
 637
 638         if (uuid->uuid[sizeof(*uuid) - 1] != '\0') {
 639                 /* Obviously not safe, but for printfs, no real harm done...
 640                    we're always null-terminated, even in a race. */
 641                 static char temp[sizeof(*uuid)];
 642                 memcpy(temp, uuid->uuid, sizeof(*uuid) - 1);
 643                 temp[sizeof(*uuid) - 1] = '\0';
 644                 return temp;
 645         }
 646         return (char *)(uuid->uuid);
 647 }
 648
 649 /* Extract fsname from uuid (or target name) of a target
 650    e.g. (myfs-OST0007_UUID -> myfs)
 651    see also deuuidify. */
 652 static inline void obd_uuid2fsname(char *buf, char *uuid, int buflen)
 653 {
 654         char *p;
 655
 656         strncpy(buf, uuid, buflen - 1);
 657         buf[buflen - 1] = '\0';
 658         p = strrchr(buf, '-');
 659         if (p != NULL)
 660                 *p = '\0';
 661 }
 662
 663 /* printf display format for Lustre FIDs
 664  * usage: printf("file FID is "DFID"\n", PFID(fid)); */
 665 #define FID_NOBRACE_LEN 40
 666 #define FID_LEN (FID_NOBRACE_LEN + 2)
 667 #define DFID_NOBRACE "%#llx:0x%x:0x%x"
 668 #define DFID "["DFID_NOBRACE"]"
 669 #define PFID(fid) (unsigned long long)(fid)->f_seq, (fid)->f_oid, (fid)->f_ver
 670
 671 /* scanf input parse format for fids in DFID_NOBRACE format
 672  * Need to strip '[' from DFID format first or use "["SFID"]" at caller.
 673  * usage: sscanf(fidstr, SFID, RFID(&fid)); */
 674 #define SFID "0x%llx:0x%x:0x%x"
 675 #define RFID(fid) &((fid)->f_seq), &((fid)->f_oid), &((fid)->f_ver)
 676
 677 /********* Quotas **********/
 678
 679 #define LUSTRE_QUOTABLOCK_BITS 10
 680 #define LUSTRE_QUOTABLOCK_SIZE (1 << LUSTRE_QUOTABLOCK_BITS)
 681
 682 static inline __u64 lustre_stoqb(size_t space)
 683 {
 684         return (space + LUSTRE_QUOTABLOCK_SIZE - 1) >> LUSTRE_QUOTABLOCK_BITS;
 685 }
 686
 687 #define Q_QUOTACHECK    0x800100 /* deprecated as of 2.4 */
 688 #define Q_INITQUOTA     0x800101 /* deprecated as of 2.4  */
 689 #define Q_GETOINFO      0x800102 /* get obd quota info */
 690 #define Q_GETOQUOTA     0x800103 /* get obd quotas */
 691 #define Q_FINVALIDATE   0x800104 /* deprecated as of 2.4 */
 692
 693 /* these must be explicitly translated into linux Q_* in ll_dir_ioctl */
 694 #define LUSTRE_Q_QUOTAON    0x800002     /* deprecated as of 2.4 */
 695 #define LUSTRE_Q_QUOTAOFF   0x800003     /* deprecated as of 2.4 */
 696 #define LUSTRE_Q_GETINFO    0x800005     /* get information about quota files */
 697 #define LUSTRE_Q_SETINFO    0x800006     /* set information about quota files */
 698 #define LUSTRE_Q_GETQUOTA   0x800007     /* get user quota structure */
 699 #define LUSTRE_Q_SETQUOTA   0x800008     /* set user quota structure */
 700 /* lustre-specific control commands */
 701 #define LUSTRE_Q_INVALIDATE  0x80000b     /* deprecated as of 2.4 */
 702 #define LUSTRE_Q_FINVALIDATE 0x80000c     /* deprecated as of 2.4 */
 703
 704 #define UGQUOTA 2       /* set both USRQUOTA and GRPQUOTA */
 705
 706 #define IDENTITY_DOWNCALL_MAGIC 0x6d6dd629
 707
 708 /* permission */
 709 #define N_PERMS_MAX      64
 710
 711 struct perm_downcall_data {
 712         __u64 pdd_nid;
 713         __u32 pdd_perm;
 714         __u32 pdd_padding;
 715 };
 716
 717 struct identity_downcall_data {
 718         __u32                            idd_magic;
 719         __u32                            idd_err;
 720         __u32                            idd_uid;
 721         __u32                            idd_gid;
 722         __u32                            idd_nperms;
 723         __u32                            idd_ngroups;
 724         struct perm_downcall_data idd_perms[N_PERMS_MAX];
 725         __u32                            idd_groups[0];
 726 };
 727
 728 #ifdef NEED_QUOTA_DEFS
 729 #ifndef QIF_BLIMITS
 730 #define QIF_BLIMITS     1
 731 #define QIF_SPACE       2
 732 #define QIF_ILIMITS     4
 733 #define QIF_INODES      8
 734 #define QIF_BTIME       16
 735 #define QIF_ITIME       32
 736 #define QIF_LIMITS      (QIF_BLIMITS | QIF_ILIMITS)
 737 #define QIF_USAGE       (QIF_SPACE | QIF_INODES)
 738 #define QIF_TIMES       (QIF_BTIME | QIF_ITIME)
 739 #define QIF_ALL         (QIF_LIMITS | QIF_USAGE | QIF_TIMES)
 740 #endif
 741
 742 #endif /* !__KERNEL__ */
 743
 744 /* lustre volatile file support
 745  * file name header: .^L^S^T^R:volatile"
 746  */
 747 #define LUSTRE_VOLATILE_HDR     ".\x0c\x13\x14\x12:VOLATILE"
 748 #define LUSTRE_VOLATILE_HDR_LEN 14
 749
 750 typedef enum lustre_quota_version {
 751         LUSTRE_QUOTA_V2 = 1
 752 } lustre_quota_version_t;
 753
 754 /* XXX: same as if_dqinfo struct in kernel */
 755 struct obd_dqinfo {
 756         __u64 dqi_bgrace;
 757         __u64 dqi_igrace;
 758         __u32 dqi_flags;
 759         __u32 dqi_valid;
 760 };
 761
 762 /* XXX: same as if_dqblk struct in kernel, plus one padding */
 763 struct obd_dqblk {
 764         __u64 dqb_bhardlimit;
 765         __u64 dqb_bsoftlimit;
 766         __u64 dqb_curspace;
 767         __u64 dqb_ihardlimit;
 768         __u64 dqb_isoftlimit;
 769         __u64 dqb_curinodes;
 770         __u64 dqb_btime;
 771         __u64 dqb_itime;
 772         __u32 dqb_valid;
 773         __u32 dqb_padding;
 774 };
 775
 776 enum {
 777         QC_GENERAL      = 0,
 778         QC_MDTIDX       = 1,
 779         QC_OSTIDX       = 2,
 780         QC_UUID         = 3
 781 };
 782
 783 struct if_quotactl {
 784         __u32                   qc_cmd;
 785         __u32                   qc_type;
 786         __u32                   qc_id;
 787         __u32                   qc_stat;
 788         __u32                   qc_valid;
 789         __u32                   qc_idx;
 790         struct obd_dqinfo       qc_dqinfo;
 791         struct obd_dqblk        qc_dqblk;
 792         char                    obd_type[16];
 793         struct obd_uuid         obd_uuid;
 794 };
 795
 796 /* swap layout flags */
 797 #define SWAP_LAYOUTS_CHECK_DV1          (1 << 0)
 798 #define SWAP_LAYOUTS_CHECK_DV2          (1 << 1)
 799 #define SWAP_LAYOUTS_KEEP_MTIME         (1 << 2)
 800 #define SWAP_LAYOUTS_KEEP_ATIME         (1 << 3)
 801 #define SWAP_LAYOUTS_CLOSE              (1 << 4)
 802
 803 /* Swap XATTR_NAME_HSM as well, only on the MDT so far */
 804 #define SWAP_LAYOUTS_MDS_HSM            (1 << 31)
 805 struct lustre_swap_layouts {
 806         __u64   sl_flags;
 807         __u32   sl_fd;
 808         __u32   sl_gid;
 809         __u64   sl_dv1;
 810         __u64   sl_dv2;
 811 };
 812
 813
 814 /********* Changelogs **********/
 815 /** Changelog record types */
 816 enum changelog_rec_type {
 817         CL_MARK     = 0,
 818         CL_CREATE   = 1,  /* namespace */
 819         CL_MKDIR    = 2,  /* namespace */
 820         CL_HARDLINK = 3,  /* namespace */
 821         CL_SOFTLINK = 4,  /* namespace */
 822         CL_MKNOD    = 5,  /* namespace */
 823         CL_UNLINK   = 6,  /* namespace */
 824         CL_RMDIR    = 7,  /* namespace */
 825         CL_RENAME   = 8,  /* namespace */
 826         CL_EXT      = 9,  /* namespace extended record (2nd half of rename) */
 827         CL_OPEN     = 10, /* not currently used */
 828         CL_CLOSE    = 11, /* may be written to log only with mtime change */
 829         CL_LAYOUT   = 12, /* file layout/striping modified */
 830         CL_TRUNC    = 13,
 831         CL_SETATTR  = 14,
 832         CL_XATTR    = 15,
 833         CL_HSM      = 16, /* HSM specific events, see flags */
 834         CL_MTIME    = 17, /* Precedence: setattr > mtime > ctime > atime */
 835         CL_CTIME    = 18,
 836         CL_ATIME    = 19,
 837         CL_MIGRATE  = 20,
 838         CL_LAST
 839 };
 840
 841 static inline const char *changelog_type2str(int type) {
 842         static const char *changelog_str[] = {
 843                 "MARK",  "CREAT", "MKDIR", "HLINK", "SLINK", "MKNOD", "UNLNK",
 844                 "RMDIR", "RENME", "RNMTO", "OPEN",  "CLOSE", "LYOUT", "TRUNC",
 845                 "SATTR", "XATTR", "HSM",   "MTIME", "CTIME", "ATIME", "MIGRT"
 846         };
 847
 848         if (type >= 0 && type < CL_LAST)
 849                 return changelog_str[type];
 850         return NULL;
 851 }
 852
 853 /* per-record flags */
 854 #define CLF_FLAGSHIFT   12
 855 #define CLF_FLAGMASK    ((1U << CLF_FLAGSHIFT) - 1)
 856 #define CLF_VERMASK     (~CLF_FLAGMASK)
 857 enum changelog_rec_flags {
 858         CLF_VERSION     = 0x1000,
 859         CLF_RENAME      = 0x2000,
 860         CLF_JOBID       = 0x4000,
 861         CLF_SUPPORTED   = CLF_VERSION | CLF_RENAME | CLF_JOBID
 862 };
 863
 864
 865 /* Anything under the flagmask may be per-type (if desired) */
 866 /* Flags for unlink */
 867 #define CLF_UNLINK_LAST       0x0001 /* Unlink of last hardlink */
 868 #define CLF_UNLINK_HSM_EXISTS 0x0002 /* File has something in HSM */
 869                                      /* HSM cleaning needed */
 870 /* Flags for rename */
 871 #define CLF_RENAME_LAST         0x0001 /* rename unlink last hardlink
 872                                         * of target */
 873 #define CLF_RENAME_LAST_EXISTS  0x0002 /* rename unlink last hardlink of target
 874                                         * has an archive in backend */
 875
 876 /* Flags for HSM */
 877 /* 12b used (from high weight to low weight):
 878  * 2b for flags
 879  * 3b for event
 880  * 7b for error code
 881  */
 882 #define CLF_HSM_ERR_L        0 /* HSM return code, 7 bits */
 883 #define CLF_HSM_ERR_H        6
 884 #define CLF_HSM_EVENT_L      7 /* HSM event, 3 bits, see enum hsm_event */
 885 #define CLF_HSM_EVENT_H      9
 886 #define CLF_HSM_FLAG_L      10 /* HSM flags, 2 bits, 1 used, 1 spare */
 887 #define CLF_HSM_FLAG_H      11
 888 #define CLF_HSM_SPARE_L     12 /* 4 spare bits */
 889 #define CLF_HSM_SPARE_H     15
 890 #define CLF_HSM_LAST        15
 891
 892 /* Remove bits higher than _h, then extract the value
 893  * between _h and _l by shifting lower weigth to bit 0. */
 894 #define CLF_GET_BITS(_b, _h, _l) (((_b << (CLF_HSM_LAST - _h)) & 0xFFFF) \
 895                                    >> (CLF_HSM_LAST - _h + _l))
 896
 897 #define CLF_HSM_SUCCESS      0x00
 898 #define CLF_HSM_MAXERROR     0x7E
 899 #define CLF_HSM_ERROVERFLOW  0x7F
 900
 901 #define CLF_HSM_DIRTY        1 /* file is dirty after HSM request end */
 902
 903 /* 3 bits field => 8 values allowed */
 904 enum hsm_event {
 905         HE_ARCHIVE      = 0,
 906         HE_RESTORE      = 1,
 907         HE_CANCEL       = 2,
 908         HE_RELEASE      = 3,
 909         HE_REMOVE       = 4,
 910         HE_STATE        = 5,
 911         HE_SPARE1       = 6,
 912         HE_SPARE2       = 7,
 913 };
 914
 915 static inline enum hsm_event hsm_get_cl_event(__u16 flags)
 916 {
 917         return (enum hsm_event)CLF_GET_BITS(flags, CLF_HSM_EVENT_H,
 918                                             CLF_HSM_EVENT_L);
 919 }
 920
 921 static inline void hsm_set_cl_event(int *flags, enum hsm_event he)
 922 {
 923         *flags |= (he << CLF_HSM_EVENT_L);
 924 }
 925
 926 static inline __u16 hsm_get_cl_flags(int flags)
 927 {
 928         return CLF_GET_BITS(flags, CLF_HSM_FLAG_H, CLF_HSM_FLAG_L);
 929 }
 930
 931 static inline void hsm_set_cl_flags(int *flags, int bits)
 932 {
 933         *flags |= (bits << CLF_HSM_FLAG_L);
 934 }
 935
 936 static inline int hsm_get_cl_error(int flags)
 937 {
 938         return CLF_GET_BITS(flags, CLF_HSM_ERR_H, CLF_HSM_ERR_L);
 939 }
 940
 941 static inline void hsm_set_cl_error(int *flags, int error)
 942 {
 943         *flags |= (error << CLF_HSM_ERR_L);
 944 }
 945
 946 enum changelog_send_flag {
 947         /* Not yet implemented */
 948         CHANGELOG_FLAG_FOLLOW   = 0x01,
 949         /* Blocking IO makes sense in case of slow user parsing of the records,
 950          * but it also prevents us from cleaning up if the records are not
 951          * consumed. */
 952         CHANGELOG_FLAG_BLOCK    = 0x02,
 953         /* Pack jobid into the changelog records if available. */
 954         CHANGELOG_FLAG_JOBID    = 0x04,
 955 };
 956
 957 #define CR_MAXSIZE cfs_size_round(2 * NAME_MAX + 2 + \
 958                                   changelog_rec_offset(CLF_SUPPORTED))
 959
 960 /* 31 usable bytes string + null terminator. */
 961 #define LUSTRE_JOBID_SIZE       32
 962
 963 /* This is the minimal changelog record. It can contain extensions
 964  * such as rename fields or process jobid. Its exact content is described
 965  * by the cr_flags.
 966  *
 967  * Extensions are packed in the same order as their corresponding flags.
 968  */
 969 struct changelog_rec {
 970         __u16                   cr_namelen;
 971         __u16                   cr_flags; /**< \a changelog_rec_flags */
 972         __u32                   cr_type;  /**< \a changelog_rec_type */
 973         __u64                   cr_index; /**< changelog record number */
 974         __u64                   cr_prev;  /**< last index for this target fid */
 975         __u64                   cr_time;
 976         union {
 977                 lustre_fid      cr_tfid;        /**< target fid */
 978                 __u32           cr_markerflags; /**< CL_MARK flags */
 979         };
 980         lustre_fid              cr_pfid;        /**< parent fid */
 981 };
 982
 983 /* Changelog extension for RENAME. */
 984 struct changelog_ext_rename {
 985         lustre_fid              cr_sfid;     /**< source fid, or zero */
 986         lustre_fid              cr_spfid;    /**< source parent fid, or zero */
 987 };
 988
 989 /* Changelog extension to include JOBID. */
 990 struct changelog_ext_jobid {
 991         char    cr_jobid[LUSTRE_JOBID_SIZE];    /**< zero-terminated string. */
 992 };
 993
 994
 995 static inline size_t changelog_rec_offset(enum changelog_rec_flags crf)
 996 {
 997         size_t size = sizeof(struct changelog_rec);
 998
 999         if (crf & CLF_RENAME)
1000                 size += sizeof(struct changelog_ext_rename);
1001
1002         if (crf & CLF_JOBID)
1003                 size += sizeof(struct changelog_ext_jobid);
1004
1005         return size;
1006 }
1007
1008 static inline size_t changelog_rec_size(const struct changelog_rec *rec)
1009 {
1010         return changelog_rec_offset(rec->cr_flags);
1011 }
1012
1013 static inline size_t changelog_rec_varsize(const struct changelog_rec *rec)
1014 {
1015         return changelog_rec_size(rec) - sizeof(*rec) + rec->cr_namelen;
1016 }
1017
1018 static inline
1019 struct changelog_ext_rename *changelog_rec_rename(const struct changelog_rec *rec)
1020 {
1021         enum changelog_rec_flags crf = rec->cr_flags & CLF_VERSION;
1022
1023         return (struct changelog_ext_rename *)((char *)rec +
1024                                                changelog_rec_offset(crf));
1025 }
1026
1027 /* The jobid follows the rename extension, if present */
1028 static inline
1029 struct changelog_ext_jobid *changelog_rec_jobid(const struct changelog_rec *rec)
1030 {
1031         enum changelog_rec_flags crf = rec->cr_flags &
1032                                         (CLF_VERSION | CLF_RENAME);
1033
1034         return (struct changelog_ext_jobid *)((char *)rec +
1035                                               changelog_rec_offset(crf));
1036 }
1037
1038 /* The name follows the rename and jobid extensions, if present */
1039 static inline char *changelog_rec_name(const struct changelog_rec *rec)
1040 {
1041         return (char *)rec + changelog_rec_offset(rec->cr_flags &
1042                                                   CLF_SUPPORTED);
1043 }
1044
1045 static inline size_t changelog_rec_snamelen(const struct changelog_rec *rec)
1046 {
1047         return rec->cr_namelen - strlen(changelog_rec_name(rec)) - 1;
1048 }
1049
1050 static inline char *changelog_rec_sname(const struct changelog_rec *rec)
1051 {
1052         char *cr_name = changelog_rec_name(rec);
1053
1054         return cr_name + strlen(cr_name) + 1;
1055 }
1056
1057 /**
1058  * Remap a record to the desired format as specified by the crf flags.
1059  * The record must be big enough to contain the final remapped version.
1060  * Superfluous extension fields are removed and missing ones are added
1061  * and zeroed. The flags of the record are updated accordingly.
1062  *
1063  * The jobid and rename extensions can be added to a record, to match the
1064  * format an application expects, typically. In this case, the newly added
1065  * fields will be zeroed.
1066  * The Jobid field can be removed, to guarantee compatibility with older
1067  * clients that don't expect this field in the records they process.
1068  *
1069  * The following assumptions are being made:
1070  *   - CLF_RENAME will not be removed
1071  *   - CLF_JOBID will not be added without CLF_RENAME being added too
1072  *
1073  * @param[in,out]  rec         The record to remap.
1074  * @param[in]      crf_wanted  Flags describing the desired extensions.
1075  */
1076 static inline void changelog_remap_rec(struct changelog_rec *rec,
1077                                        enum changelog_rec_flags crf_wanted)
1078 {
1079         char *jid_mov;
1080         char *rnm_mov;
1081
1082         crf_wanted &= CLF_SUPPORTED;
1083
1084         if ((rec->cr_flags & CLF_SUPPORTED) == crf_wanted)
1085                 return;
1086
1087         /* First move the variable-length name field */
1088         memmove((char *)rec + changelog_rec_offset(crf_wanted),
1089                 changelog_rec_name(rec), rec->cr_namelen);
1090
1091         /* Locations of jobid and rename extensions in the remapped record */
1092         jid_mov = (char *)rec +
1093                   changelog_rec_offset(crf_wanted & ~CLF_JOBID);
1094         rnm_mov = (char *)rec +
1095                   changelog_rec_offset(crf_wanted & ~(CLF_JOBID | CLF_RENAME));
1096
1097         /* Move the extension fields to the desired positions */
1098         if ((crf_wanted & CLF_JOBID) && (rec->cr_flags & CLF_JOBID))
1099                 memmove(jid_mov, changelog_rec_jobid(rec),
1100                         sizeof(struct changelog_ext_jobid));
1101
1102         if ((crf_wanted & CLF_RENAME) && (rec->cr_flags & CLF_RENAME))
1103                 memmove(rnm_mov, changelog_rec_rename(rec),
1104                         sizeof(struct changelog_ext_rename));
1105
1106         /* Clear newly added fields */
1107         if ((crf_wanted & CLF_JOBID) && !(rec->cr_flags & CLF_JOBID))
1108                 memset(jid_mov, 0, sizeof(struct changelog_ext_jobid));
1109
1110         if ((crf_wanted & CLF_RENAME) && !(rec->cr_flags & CLF_RENAME))
1111                 memset(rnm_mov, 0, sizeof(struct changelog_ext_rename));
1112
1113         /* Update the record's flags accordingly */
1114         rec->cr_flags = (rec->cr_flags & CLF_FLAGMASK) | crf_wanted;
1115 }
1116
1117 struct ioc_changelog {
1118         __u64 icc_recno;
1119         __u32 icc_mdtindex;
1120         __u32 icc_id;
1121         __u32 icc_flags;
1122 };
1123
1124 enum changelog_message_type {
1125         CL_RECORD = 10, /* message is a changelog_rec */
1126         CL_EOF    = 11, /* at end of current changelog */
1127 };
1128
1129 /********* Misc **********/
1130
1131 struct ioc_data_version {
1132         __u64 idv_version;
1133         __u64 idv_flags;     /* See LL_DV_xxx */
1134 };
1135 #define LL_DV_RD_FLUSH (1 << 0) /* Flush dirty pages from clients */
1136 #define LL_DV_WR_FLUSH (1 << 1) /* Flush all caching pages from clients */
1137
1138 #ifndef offsetof
1139 #define offsetof(typ, memb)     ((unsigned long)((char *)&(((typ *)0)->memb)))
1140 #endif
1141
1142 #define dot_lustre_name ".lustre"
1143
1144
1145 /********* HSM **********/
1146
1147 /** HSM per-file state
1148  * See HSM_FLAGS below.
1149  */
1150 enum hsm_states {
1151         HS_NONE         = 0x00000000,
1152         HS_EXISTS       = 0x00000001,
1153         HS_DIRTY        = 0x00000002,
1154         HS_RELEASED     = 0x00000004,
1155         HS_ARCHIVED     = 0x00000008,
1156         HS_NORELEASE    = 0x00000010,
1157         HS_NOARCHIVE    = 0x00000020,
1158         HS_LOST         = 0x00000040,
1159 };
1160
1161 /* HSM user-setable flags. */
1162 #define HSM_USER_MASK   (HS_NORELEASE | HS_NOARCHIVE | HS_DIRTY)
1163
1164 /* Other HSM flags. */
1165 #define HSM_STATUS_MASK (HS_EXISTS | HS_LOST | HS_RELEASED | HS_ARCHIVED)
1166
1167 /*
1168  * All HSM-related possible flags that could be applied to a file.
1169  * This should be kept in sync with hsm_states.
1170  */
1171 #define HSM_FLAGS_MASK  (HSM_USER_MASK | HSM_STATUS_MASK)
1172
1173 /**
1174  * HSM request progress state
1175  */
1176 enum hsm_progress_states {
1177         HPS_WAITING     = 1,
1178         HPS_RUNNING     = 2,
1179         HPS_DONE        = 3,
1180 };
1181 #define HPS_NONE        0
1182
1183 static inline const char *hsm_progress_state2name(enum hsm_progress_states s)
1184 {
1185         switch  (s) {
1186         case HPS_WAITING:       return "waiting";
1187         case HPS_RUNNING:       return "running";
1188         case HPS_DONE:          return "done";
1189         default:                return "unknown";
1190         }
1191 }
1192
1193 struct hsm_extent {
1194         __u64 offset;
1195         __u64 length;
1196 } __attribute__((packed));
1197
1198 /**
1199  * Current HSM states of a Lustre file.
1200  *
1201  * This structure purpose is to be sent to user-space mainly. It describes the
1202  * current HSM flags and in-progress action.
1203  */
1204 struct hsm_user_state {
1205         /** Current HSM states, from enum hsm_states. */
1206         __u32                   hus_states;
1207         __u32                   hus_archive_id;
1208         /**  The current undergoing action, if there is one */
1209         __u32                   hus_in_progress_state;
1210         __u32                   hus_in_progress_action;
1211         struct hsm_extent       hus_in_progress_location;
1212         char                    hus_extended_info[];
1213 };
1214
1215 struct hsm_state_set_ioc {
1216         struct lu_fid   hssi_fid;
1217         __u64           hssi_setmask;
1218         __u64           hssi_clearmask;
1219 };
1220
1221 /*
1222  * This structure describes the current in-progress action for a file.
1223  * it is retuned to user space and send over the wire
1224  */
1225 struct hsm_current_action {
1226         /**  The current undergoing action, if there is one */
1227         /* state is one of hsm_progress_states */
1228         __u32                   hca_state;
1229         /* action is one of hsm_user_action */
1230         __u32                   hca_action;
1231         struct hsm_extent       hca_location;
1232 };
1233
1234 /***** HSM user requests ******/
1235 /* User-generated (lfs/ioctl) request types */
1236 enum hsm_user_action {
1237         HUA_NONE    =  1, /* no action (noop) */
1238         HUA_ARCHIVE = 10, /* copy to hsm */
1239         HUA_RESTORE = 11, /* prestage */
1240         HUA_RELEASE = 12, /* drop ost objects */
1241         HUA_REMOVE  = 13, /* remove from archive */
1242         HUA_CANCEL  = 14  /* cancel a request */
1243 };
1244
1245 static inline const char *hsm_user_action2name(enum hsm_user_action  a)
1246 {
1247         switch  (a) {
1248         case HUA_NONE:    return "NOOP";
1249         case HUA_ARCHIVE: return "ARCHIVE";
1250         case HUA_RESTORE: return "RESTORE";
1251         case HUA_RELEASE: return "RELEASE";
1252         case HUA_REMOVE:  return "REMOVE";
1253         case HUA_CANCEL:  return "CANCEL";
1254         default:          return "UNKNOWN";
1255         }
1256 }
1257
1258 /*
1259  * List of hr_flags (bit field)
1260  */
1261 #define HSM_FORCE_ACTION 0x0001
1262 /* used by CT, cannot be set by user */
1263 #define HSM_GHOST_COPY   0x0002
1264
1265 /**
1266  * Contains all the fixed part of struct hsm_user_request.
1267  *
1268  */
1269 struct hsm_request {
1270         __u32 hr_action;        /* enum hsm_user_action */
1271         __u32 hr_archive_id;    /* archive id, used only with HUA_ARCHIVE */
1272         __u64 hr_flags;         /* request flags */
1273         __u32 hr_itemcount;     /* item count in hur_user_item vector */
1274         __u32 hr_data_len;
1275 };
1276
1277 struct hsm_user_item {
1278        lustre_fid        hui_fid;
1279        struct hsm_extent hui_extent;
1280 } __attribute__((packed));
1281
1282 struct hsm_user_request {
1283         struct hsm_request      hur_request;
1284         struct hsm_user_item    hur_user_item[0];
1285         /* extra data blob at end of struct (after all
1286          * hur_user_items), only use helpers to access it
1287          */
1288 } __attribute__((packed));
1289
1290 /** Return pointer to data field in a hsm user request */
1291 static inline void *hur_data(struct hsm_user_request *hur)
1292 {
1293         return &(hur->hur_user_item[hur->hur_request.hr_itemcount]);
1294 }
1295
1296 /**
1297  * Compute the current length of the provided hsm_user_request.  This returns -1
1298  * instead of an errno because ssize_t is defined to be only [ -1, SSIZE_MAX ]
1299  *
1300  * return -1 on bounds check error.
1301  */
1302 static inline ssize_t hur_len(struct hsm_user_request *hur)
1303 {
1304         __u64   size;
1305
1306         /* can't overflow a __u64 since hr_itemcount is only __u32 */
1307         size = offsetof(struct hsm_user_request, hur_user_item[0]) +
1308                 (__u64)hur->hur_request.hr_itemcount *
1309                 sizeof(hur->hur_user_item[0]) + hur->hur_request.hr_data_len;
1310
1311         if (size != (ssize_t)size)
1312                 return -1;
1313
1314         return size;
1315 }
1316
1317 /****** HSM RPCs to copytool *****/
1318 /* Message types the copytool may receive */
1319 enum hsm_message_type {
1320         HMT_ACTION_LIST = 100, /* message is a hsm_action_list */
1321 };
1322
1323 /* Actions the copytool may be instructed to take for a given action_item */
1324 enum hsm_copytool_action {
1325         HSMA_NONE    = 10, /* no action */
1326         HSMA_ARCHIVE = 20, /* arbitrary offset */
1327         HSMA_RESTORE = 21,
1328         HSMA_REMOVE  = 22,
1329         HSMA_CANCEL  = 23
1330 };
1331
1332 static inline const char *hsm_copytool_action2name(enum hsm_copytool_action  a)
1333 {
1334         switch  (a) {
1335         case HSMA_NONE:    return "NOOP";
1336         case HSMA_ARCHIVE: return "ARCHIVE";
1337         case HSMA_RESTORE: return "RESTORE";
1338         case HSMA_REMOVE:  return "REMOVE";
1339         case HSMA_CANCEL:  return "CANCEL";
1340         default:           return "UNKNOWN";
1341         }
1342 }
1343
1344 /* Copytool item action description */
1345 struct hsm_action_item {
1346         __u32      hai_len;     /* valid size of this struct */
1347         __u32      hai_action;  /* hsm_copytool_action, but use known size */
1348         lustre_fid hai_fid;     /* Lustre FID to operate on */
1349         lustre_fid hai_dfid;    /* fid used for data access */
1350         struct hsm_extent hai_extent;  /* byte range to operate on */
1351         __u64      hai_cookie;  /* action cookie from coordinator */
1352         __u64      hai_gid;     /* grouplock id */
1353         char       hai_data[0]; /* variable length */
1354 } __attribute__((packed));
1355
1356 /**
1357  * helper function which print in hexa the first bytes of
1358  * hai opaque field
1359  *
1360  * \param hai [IN]        record to print
1361  * \param buffer [IN,OUT] buffer to write the hex string to
1362  * \param len [IN]        max buffer length
1363  *
1364  * \retval buffer
1365  */
1366 static inline char *hai_dump_data_field(const struct hsm_action_item *hai,
1367                                         char *buffer, size_t len)
1368 {
1369         int i;
1370         int data_len;
1371         char *ptr;
1372
1373         ptr = buffer;
1374         data_len = hai->hai_len - sizeof(*hai);
1375         for (i = 0; (i < data_len) && (len > 2); i++) {
1376                 snprintf(ptr, 3, "%02X", (unsigned char)hai->hai_data[i]);
1377                 ptr += 2;
1378                 len -= 2;
1379         }
1380
1381         *ptr = '\0';
1382
1383         return buffer;
1384 }
1385
1386 /* Copytool action list */
1387 #define HAL_VERSION 1
1388 #define HAL_MAXSIZE LNET_MTU /* bytes, used in userspace only */
1389 struct hsm_action_list {
1390         __u32 hal_version;
1391         __u32 hal_count;       /* number of hai's to follow */
1392         __u64 hal_compound_id; /* returned by coordinator */
1393         __u64 hal_flags;
1394         __u32 hal_archive_id; /* which archive backend */
1395         __u32 padding1;
1396         char  hal_fsname[0];   /* null-terminated */
1397         /* struct hsm_action_item[hal_count] follows, aligned on 8-byte
1398            boundaries. See hai_zero */
1399 } __attribute__((packed));
1400
1401 #ifndef HAVE_CFS_SIZE_ROUND
1402 static inline int cfs_size_round (int val)
1403 {
1404         return (val + 7) & (~0x7);
1405 }
1406 #define HAVE_CFS_SIZE_ROUND
1407 #endif
1408
1409 /* Return pointer to first hai in action list */
1410 static inline struct hsm_action_item *hai_first(struct hsm_action_list *hal)
1411 {
1412         return (struct hsm_action_item *)(hal->hal_fsname +
1413                                           cfs_size_round(strlen(hal-> \
1414                                                                 hal_fsname)
1415                                                          + 1));
1416 }
1417 /* Return pointer to next hai */
1418 static inline struct hsm_action_item * hai_next(struct hsm_action_item *hai)
1419 {
1420         return (struct hsm_action_item *)((char *)hai +
1421                                           cfs_size_round(hai->hai_len));
1422 }
1423
1424 /* Return size of an hsm_action_list */
1425 static inline size_t hal_size(struct hsm_action_list *hal)
1426 {
1427         __u32 i;
1428         size_t sz;
1429         struct hsm_action_item *hai;
1430
1431         sz = sizeof(*hal) + cfs_size_round(strlen(hal->hal_fsname) + 1);
1432         hai = hai_first(hal);
1433         for (i = 0; i < hal->hal_count ; i++, hai = hai_next(hai))
1434                 sz += cfs_size_round(hai->hai_len);
1435
1436         return sz;
1437 }
1438
1439 /* HSM file import
1440  * describe the attributes to be set on imported file
1441  */
1442 struct hsm_user_import {
1443         __u64           hui_size;
1444         __u64           hui_atime;
1445         __u64           hui_mtime;
1446         __u32           hui_atime_ns;
1447         __u32           hui_mtime_ns;
1448         __u32           hui_uid;
1449         __u32           hui_gid;
1450         __u32           hui_mode;
1451         __u32           hui_archive_id;
1452 };
1453
1454 /* Copytool progress reporting */
1455 #define HP_FLAG_COMPLETED 0x01
1456 #define HP_FLAG_RETRY     0x02
1457
1458 struct hsm_progress {
1459         lustre_fid              hp_fid;
1460         __u64                   hp_cookie;
1461         struct hsm_extent       hp_extent;
1462         __u16                   hp_flags;
1463         __u16                   hp_errval; /* positive val */
1464         __u32                   padding;
1465 };
1466
1467 struct hsm_copy {
1468         __u64                   hc_data_version;
1469         __u16                   hc_flags;
1470         __u16                   hc_errval; /* positive val */
1471         __u32                   padding;
1472         struct hsm_action_item  hc_hai;
1473 };
1474
1475 /* JSON objects */
1476 enum llapi_json_types {
1477         LLAPI_JSON_INTEGER = 1,
1478         LLAPI_JSON_BIGNUM,
1479         LLAPI_JSON_REAL,
1480         LLAPI_JSON_STRING
1481 };
1482
1483 struct llapi_json_item {
1484         char                    *lji_key;
1485         __u32                   lji_type;
1486         union {
1487                 int     lji_integer;
1488                 __u64   lji_u64;
1489                 double  lji_real;
1490                 char    *lji_string;
1491         };
1492         struct llapi_json_item  *lji_next;
1493 };
1494
1495 struct llapi_json_item_list {
1496         int                     ljil_item_count;
1497         struct llapi_json_item  *ljil_items;
1498 };
1499
1500 enum lu_ladvise_type {
1501         LU_LADVISE_INVALID      = 0,
1502         LU_LADVISE_WILLREAD     = 1,
1503         LU_LADVISE_DONTNEED     = 2,
1504 };
1505
1506 #define LU_LADVISE_NAMES {                                              \
1507         [LU_LADVISE_WILLREAD]   = "willread",                           \
1508         [LU_LADVISE_DONTNEED]   = "dontneed",                           \
1509 }
1510
1511 /* This is the userspace argument for ladvise.  It is currently the same as
1512  * what goes on the wire (struct lu_ladvise), but is defined separately as we
1513  * may need info which is only used locally. */
1514 struct llapi_lu_ladvise {
1515         __u16 lla_advice;       /* advice type */
1516         __u16 lla_value1;       /* values for different advice types */
1517         __u32 lla_value2;
1518         __u64 lla_start;        /* first byte of extent for advice */
1519         __u64 lla_end;          /* last byte of extent for advice */
1520         __u32 lla_value3;
1521         __u32 lla_value4;
1522 };
1523
1524 enum ladvise_flag {
1525         LF_ASYNC        = 0x00000001,
1526 };
1527
1528 #define LADVISE_MAGIC 0x1ADF1CE0
1529 #define LF_MASK LF_ASYNC
1530
1531 /* This is the userspace argument for ladvise, corresponds to ladvise_hdr which
1532  * is used on the wire.  It is defined separately as we may need info which is
1533  * only used locally. */
1534 struct llapi_ladvise_hdr {
1535         __u32                   lah_magic;      /* LADVISE_MAGIC */
1536         __u32                   lah_count;      /* number of advices */
1537         __u64                   lah_flags;      /* from enum ladvise_flag */
1538         __u32                   lah_value1;     /* unused */
1539         __u32                   lah_value2;     /* unused */
1540         __u64                   lah_value3;     /* unused */
1541         struct llapi_lu_ladvise lah_advise[0];  /* advices in this header */
1542 };
1543
1544 #define LAH_COUNT_MAX   (1024)
1545
1546 /* Shared key */
1547 enum sk_crypt_alg {
1548         SK_CRYPT_INVALID        = -1,
1549         SK_CRYPT_EMPTY          = 0,
1550         SK_CRYPT_AES256_CTR     = 1,
1551         SK_CRYPT_MAX            = 2,
1552 };
1553
1554 struct sk_crypt_type {
1555         char            *cht_name;
1556         unsigned int     cht_key;
1557         unsigned int     cht_bytes;
1558 };
1559
1560 /** @} lustreuser */
1561 #endif /* _LUSTRE_USER_H */