drivers/staging/lustre/include/uapi/linux/lustre/lustre_idl.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) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2011, 2015, 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 wire protocol definitions.
  33  */
  34
  35 /** \defgroup lustreidl lustreidl
  36  *
  37  * Lustre wire protocol definitions.
  38  *
  39  * ALL structs passing over the wire should be declared here.  Structs
  40  * that are used in interfaces with userspace should go in lustre_user.h.
  41  *
  42  * All structs being declared here should be built from simple fixed-size
  43  * types (__u8, __u16, __u32, __u64) or be built from other types or
  44  * structs also declared in this file.  Similarly, all flags and magic
  45  * values in those structs should also be declared here.  This ensures
  46  * that the Lustre wire protocol is not influenced by external dependencies.
  47  *
  48  * The only other acceptable items in this file are VERY SIMPLE accessor
  49  * functions to avoid callers grubbing inside the structures. Nothing that
  50  * depends on external functions or definitions should be in here.
  51  *
  52  * Structs must be properly aligned to put 64-bit values on an 8-byte
  53  * boundary.  Any structs being added here must also be added to
  54  * utils/wirecheck.c and "make newwiretest" run to regenerate the
  55  * utils/wiretest.c sources.  This allows us to verify that wire structs
  56  * have the proper alignment/size on all architectures.
  57  *
  58  * DO NOT CHANGE any of the structs, flags, values declared here and used
  59  * in released Lustre versions.  Some structs may have padding fields that
  60  * can be used.  Some structs might allow addition at the end (verify this
  61  * in the code to ensure that new/old clients that see this larger struct
  62  * do not fail, otherwise you need to implement protocol compatibility).
  63  *
  64  * @{
  65  */
  66
  67 #ifndef _LUSTRE_IDL_H_
  68 #define _LUSTRE_IDL_H_
  69
  70 #include <asm/byteorder.h>
  71 #include <linux/types.h>
  72
  73 #include <uapi/linux/lnet/lnet-types.h>
  74 /* Defn's shared with user-space. */
  75 #include <uapi/linux/lustre/lustre_user.h>
  76 #include <uapi/linux/lustre/lustre_ver.h>
  77
  78 /*
  79  *  GENERAL STUFF
  80  */
  81 /* FOO_REQUEST_PORTAL is for incoming requests on the FOO
  82  * FOO_REPLY_PORTAL   is for incoming replies on the FOO
  83  * FOO_BULK_PORTAL    is for incoming bulk on the FOO
  84  */
  85
  86 /* Lustre service names are following the format
  87  * service name + MDT + seq name
  88  */
  89 #define LUSTRE_MDT_MAXNAMELEN   80
  90
  91 #define CONNMGR_REQUEST_PORTAL    1
  92 #define CONNMGR_REPLY_PORTAL        2
  93 /*#define OSC_REQUEST_PORTAL        3 */
  94 #define OSC_REPLY_PORTAL                4
  95 /*#define OSC_BULK_PORTAL              5 */
  96 #define OST_IO_PORTAL              6
  97 #define OST_CREATE_PORTAL              7
  98 #define OST_BULK_PORTAL          8
  99 /*#define MDC_REQUEST_PORTAL        9 */
 100 #define MDC_REPLY_PORTAL               10
 101 /*#define MDC_BULK_PORTAL             11 */
 102 #define MDS_REQUEST_PORTAL           12
 103 /*#define MDS_REPLY_PORTAL           13 */
 104 #define MDS_BULK_PORTAL         14
 105 #define LDLM_CB_REQUEST_PORTAL   15
 106 #define LDLM_CB_REPLY_PORTAL       16
 107 #define LDLM_CANCEL_REQUEST_PORTAL     17
 108 #define LDLM_CANCEL_REPLY_PORTAL       18
 109 /*#define PTLBD_REQUEST_PORTAL     19 */
 110 /*#define PTLBD_REPLY_PORTAL         20 */
 111 /*#define PTLBD_BULK_PORTAL           21 */
 112 #define MDS_SETATTR_PORTAL           22
 113 #define MDS_READPAGE_PORTAL         23
 114 #define OUT_PORTAL                  24
 115
 116 #define MGC_REPLY_PORTAL               25
 117 #define MGS_REQUEST_PORTAL           26
 118 #define MGS_REPLY_PORTAL               27
 119 #define OST_REQUEST_PORTAL           28
 120 #define FLD_REQUEST_PORTAL           29
 121 #define SEQ_METADATA_PORTAL         30
 122 #define SEQ_DATA_PORTAL         31
 123 #define SEQ_CONTROLLER_PORTAL     32
 124 #define MGS_BULK_PORTAL         33
 125
 126 /* Portal 63 is reserved for the Cray Inc DVS - nic@cray.com, roe@cray.com,
 127  *                                              n8851@cray.com
 128  */
 129
 130 /* packet types */
 131 #define PTL_RPC_MSG_REQUEST 4711
 132 #define PTL_RPC_MSG_ERR     4712
 133 #define PTL_RPC_MSG_REPLY   4713
 134
 135 /* DON'T use swabbed values of MAGIC as magic! */
 136 #define LUSTRE_MSG_MAGIC_V2 0x0BD00BD3
 137 #define LUSTRE_MSG_MAGIC_V2_SWABBED 0xD30BD00B
 138
 139 #define LUSTRE_MSG_MAGIC LUSTRE_MSG_MAGIC_V2
 140
 141 #define PTLRPC_MSG_VERSION  0x00000003
 142 #define LUSTRE_VERSION_MASK 0xffff0000
 143 #define LUSTRE_OBD_VERSION  0x00010000
 144 #define LUSTRE_MDS_VERSION  0x00020000
 145 #define LUSTRE_OST_VERSION  0x00030000
 146 #define LUSTRE_DLM_VERSION  0x00040000
 147 #define LUSTRE_LOG_VERSION  0x00050000
 148 #define LUSTRE_MGS_VERSION  0x00060000
 149
 150 /**
 151  * Describes a range of sequence, lsr_start is included but lsr_end is
 152  * not in the range.
 153  * Same structure is used in fld module where lsr_index field holds mdt id
 154  * of the home mdt.
 155  */
 156 struct lu_seq_range {
 157         __u64 lsr_start;
 158         __u64 lsr_end;
 159         __u32 lsr_index;
 160         __u32 lsr_flags;
 161 };
 162
 163 struct lu_seq_range_array {
 164         __u32 lsra_count;
 165         __u32 lsra_padding;
 166         struct lu_seq_range lsra_lsr[0];
 167 };
 168
 169 #define LU_SEQ_RANGE_MDT        0x0
 170 #define LU_SEQ_RANGE_OST        0x1
 171 #define LU_SEQ_RANGE_ANY        0x3
 172
 173 #define LU_SEQ_RANGE_MASK       0x3
 174
 175 /** \defgroup lu_fid lu_fid
 176  * @{
 177  */
 178
 179 /**
 180  * Flags for lustre_mdt_attrs::lma_compat and lustre_mdt_attrs::lma_incompat.
 181  * Deprecated since HSM and SOM attributes are now stored in separate on-disk
 182  * xattr.
 183  */
 184 enum lma_compat {
 185         LMAC_HSM        = 0x00000001,
 186 /*      LMAC_SOM        = 0x00000002, obsolete since 2.8.0 */
 187         LMAC_NOT_IN_OI  = 0x00000004, /* the object does NOT need OI mapping */
 188         LMAC_FID_ON_OST = 0x00000008, /* For OST-object, its OI mapping is
 189                                        * under /O/<seq>/d<x>.
 190                                        */
 191 };
 192
 193 /**
 194  * Masks for all features that should be supported by a Lustre version to
 195  * access a specific file.
 196  * This information is stored in lustre_mdt_attrs::lma_incompat.
 197  */
 198 enum lma_incompat {
 199         LMAI_RELEASED           = 0x00000001, /* file is released */
 200         LMAI_AGENT              = 0x00000002, /* agent inode */
 201         LMAI_REMOTE_PARENT      = 0x00000004, /* the parent of the object
 202                                                * is on the remote MDT
 203                                                */
 204 };
 205
 206 #define LMA_INCOMPAT_SUPP       (LMAI_AGENT | LMAI_REMOTE_PARENT)
 207
 208 /**
 209  * fid constants
 210  */
 211 enum {
 212         /** LASTID file has zero OID */
 213         LUSTRE_FID_LASTID_OID = 0UL,
 214         /** initial fid id value */
 215         LUSTRE_FID_INIT_OID  = 1UL
 216 };
 217
 218 /* copytool uses a 32b bitmask field to encode archive-Ids during register
 219  * with MDT thru kuc.
 220  * archive num = 0 => all
 221  * archive num from 1 to 32
 222  */
 223 #define LL_HSM_MAX_ARCHIVE (sizeof(__u32) * 8)
 224
 225 /**
 226  * Note that reserved SEQ numbers below 12 will conflict with ldiskfs
 227  * inodes in the IGIF namespace, so these reserved SEQ numbers can be
 228  * used for other purposes and not risk collisions with existing inodes.
 229  *
 230  * Different FID Format
 231  * http://wiki.old.lustre.org/index.php/Architecture_-_Interoperability_fids_zfs
 232  */
 233 enum fid_seq {
 234         FID_SEQ_OST_MDT0        = 0,
 235         FID_SEQ_LLOG            = 1, /* unnamed llogs */
 236         FID_SEQ_ECHO            = 2,
 237         FID_SEQ_OST_MDT1        = 3,
 238         FID_SEQ_OST_MAX         = 9, /* Max MDT count before OST_on_FID */
 239         FID_SEQ_LLOG_NAME       = 10, /* named llogs */
 240         FID_SEQ_RSVD            = 11,
 241         FID_SEQ_IGIF            = 12,
 242         FID_SEQ_IGIF_MAX        = 0x0ffffffffULL,
 243         FID_SEQ_IDIF            = 0x100000000ULL,
 244         FID_SEQ_IDIF_MAX        = 0x1ffffffffULL,
 245         /* Normal FID sequence starts from this value, i.e. 1<<33 */
 246         FID_SEQ_START           = 0x200000000ULL,
 247         /* sequence for local pre-defined FIDs listed in local_oid */
 248         FID_SEQ_LOCAL_FILE      = 0x200000001ULL,
 249         FID_SEQ_DOT_LUSTRE      = 0x200000002ULL,
 250         /* sequence is used for local named objects FIDs generated
 251          * by local_object_storage library
 252          */
 253         FID_SEQ_LOCAL_NAME      = 0x200000003ULL,
 254         /* Because current FLD will only cache the fid sequence, instead
 255          * of oid on the client side, if the FID needs to be exposed to
 256          * clients sides, it needs to make sure all of fids under one
 257          * sequence will be located in one MDT.
 258          */
 259         FID_SEQ_SPECIAL         = 0x200000004ULL,
 260         FID_SEQ_QUOTA           = 0x200000005ULL,
 261         FID_SEQ_QUOTA_GLB       = 0x200000006ULL,
 262         FID_SEQ_ROOT            = 0x200000007ULL,  /* Located on MDT0 */
 263         FID_SEQ_NORMAL          = 0x200000400ULL,
 264         FID_SEQ_LOV_DEFAULT     = 0xffffffffffffffffULL
 265 };
 266
 267 #define OBIF_OID_MAX_BITS          32
 268 #define OBIF_MAX_OID            (1ULL << OBIF_OID_MAX_BITS)
 269 #define OBIF_OID_MASK          ((1ULL << OBIF_OID_MAX_BITS) - 1)
 270 #define IDIF_OID_MAX_BITS          48
 271 #define IDIF_MAX_OID            (1ULL << IDIF_OID_MAX_BITS)
 272 #define IDIF_OID_MASK          ((1ULL << IDIF_OID_MAX_BITS) - 1)
 273
 274 /** OID for FID_SEQ_SPECIAL */
 275 enum special_oid {
 276         /* Big Filesystem Lock to serialize rename operations */
 277         FID_OID_SPECIAL_BFL     = 1UL,
 278 };
 279
 280 /** OID for FID_SEQ_DOT_LUSTRE */
 281 enum dot_lustre_oid {
 282         FID_OID_DOT_LUSTRE  = 1UL,
 283         FID_OID_DOT_LUSTRE_OBF = 2UL,
 284 };
 285
 286 /** OID for FID_SEQ_ROOT */
 287 enum root_oid {
 288         FID_OID_ROOT            = 1UL,
 289         FID_OID_ECHO_ROOT       = 2UL,
 290 };
 291
 292 /** @} lu_fid */
 293
 294 /** \defgroup lu_dir lu_dir
 295  * @{
 296  */
 297
 298 /**
 299  * Enumeration of possible directory entry attributes.
 300  *
 301  * Attributes follow directory entry header in the order they appear in this
 302  * enumeration.
 303  */
 304 enum lu_dirent_attrs {
 305         LUDA_FID                = 0x0001,
 306         LUDA_TYPE               = 0x0002,
 307         LUDA_64BITHASH          = 0x0004,
 308 };
 309
 310 /**
 311  * Layout of readdir pages, as transmitted on wire.
 312  */
 313 struct lu_dirent {
 314         /** valid if LUDA_FID is set. */
 315         struct lu_fid lde_fid;
 316         /** a unique entry identifier: a hash or an offset. */
 317         __u64    lde_hash;
 318         /** total record length, including all attributes. */
 319         __u16    lde_reclen;
 320         /** name length */
 321         __u16    lde_namelen;
 322         /** optional variable size attributes following this entry.
 323          *  taken from enum lu_dirent_attrs.
 324          */
 325         __u32    lde_attrs;
 326         /** name is followed by the attributes indicated in ->ldp_attrs, in
 327          *  their natural order. After the last attribute, padding bytes are
 328          *  added to make ->lde_reclen a multiple of 8.
 329          */
 330         char      lde_name[0];
 331 };
 332
 333 /*
 334  * Definitions of optional directory entry attributes formats.
 335  *
 336  * Individual attributes do not have their length encoded in a generic way. It
 337  * is assumed that consumer of an attribute knows its format. This means that
 338  * it is impossible to skip over an unknown attribute, except by skipping over all
 339  * remaining attributes (by using ->lde_reclen), which is not too
 340  * constraining, because new server versions will append new attributes at
 341  * the end of an entry.
 342  */
 343
 344 /**
 345  * Fid directory attribute: a fid of an object referenced by the entry. This
 346  * will be almost always requested by the client and supplied by the server.
 347  *
 348  * Aligned to 8 bytes.
 349  */
 350 /* To have compatibility with 1.8, lets have fid in lu_dirent struct. */
 351
 352 /**
 353  * File type.
 354  *
 355  * Aligned to 2 bytes.
 356  */
 357 struct luda_type {
 358         __u16 lt_type;
 359 };
 360
 361 #ifndef IFSHIFT
 362 #define IFSHIFT                 12
 363 #endif
 364
 365 #ifndef IFTODT
 366 #define IFTODT(type)            (((type) & S_IFMT) >> IFSHIFT)
 367 #endif
 368 #ifndef DTTOIF
 369 #define DTTOIF(dirtype)         ((dirtype) << IFSHIFT)
 370 #endif
 371
 372 struct lu_dirpage {
 373         __le64      ldp_hash_start;
 374         __le64      ldp_hash_end;
 375         __le32      ldp_flags;
 376         __le32      ldp_pad0;
 377         struct lu_dirent ldp_entries[0];
 378 };
 379
 380 enum lu_dirpage_flags {
 381         /**
 382          * dirpage contains no entry.
 383          */
 384         LDF_EMPTY   = 1 << 0,
 385         /**
 386          * last entry's lde_hash equals ldp_hash_end.
 387          */
 388         LDF_COLLIDE = 1 << 1
 389 };
 390
 391 static inline struct lu_dirent *lu_dirent_start(struct lu_dirpage *dp)
 392 {
 393         if (__le32_to_cpu(dp->ldp_flags) & LDF_EMPTY)
 394                 return NULL;
 395         else
 396                 return dp->ldp_entries;
 397 }
 398
 399 static inline struct lu_dirent *lu_dirent_next(struct lu_dirent *ent)
 400 {
 401         struct lu_dirent *next;
 402
 403         if (__le16_to_cpu(ent->lde_reclen) != 0)
 404                 next = ((void *)ent) + __le16_to_cpu(ent->lde_reclen);
 405         else
 406                 next = NULL;
 407
 408         return next;
 409 }
 410
 411 static inline size_t lu_dirent_calc_size(size_t namelen, __u16 attr)
 412 {
 413         size_t size;
 414
 415         if (attr & LUDA_TYPE) {
 416                 const size_t align = sizeof(struct luda_type) - 1;
 417
 418                 size = (sizeof(struct lu_dirent) + namelen + align) & ~align;
 419                 size += sizeof(struct luda_type);
 420         } else {
 421                 size = sizeof(struct lu_dirent) + namelen;
 422         }
 423
 424         return (size + 7) & ~7;
 425 }
 426
 427 #define MDS_DIR_END_OFF 0xfffffffffffffffeULL
 428
 429 /**
 430  * MDS_READPAGE page size
 431  *
 432  * This is the directory page size packed in MDS_READPAGE RPC.
 433  * It's different than PAGE_SIZE because the client needs to
 434  * access the struct lu_dirpage header packed at the beginning of
 435  * the "page" and without this there isn't any way to know find the
 436  * lu_dirpage header is if client and server PAGE_SIZE differ.
 437  */
 438 #define LU_PAGE_SHIFT 12
 439 #define LU_PAGE_SIZE  (1UL << LU_PAGE_SHIFT)
 440 #define LU_PAGE_MASK  (~(LU_PAGE_SIZE - 1))
 441
 442 #define LU_PAGE_COUNT (1 << (PAGE_SHIFT - LU_PAGE_SHIFT))
 443
 444 /** @} lu_dir */
 445
 446 struct lustre_handle {
 447         __u64 cookie;
 448 };
 449
 450 #define DEAD_HANDLE_MAGIC 0xdeadbeefcafebabeULL
 451
 452 static inline bool lustre_handle_is_used(const struct lustre_handle *lh)
 453 {
 454         return lh->cookie != 0ull;
 455 }
 456
 457 static inline bool lustre_handle_equal(const struct lustre_handle *lh1,
 458                                        const struct lustre_handle *lh2)
 459 {
 460         return lh1->cookie == lh2->cookie;
 461 }
 462
 463 static inline void lustre_handle_copy(struct lustre_handle *tgt,
 464                                       const struct lustre_handle *src)
 465 {
 466         tgt->cookie = src->cookie;
 467 }
 468
 469 /* flags for lm_flags */
 470 #define MSGHDR_AT_SUPPORT              0x1
 471 #define MSGHDR_CKSUM_INCOMPAT18  0x2
 472
 473 #define lustre_msg lustre_msg_v2
 474 /* we depend on this structure to be 8-byte aligned */
 475 /* this type is only endian-adjusted in lustre_unpack_msg() */
 476 struct lustre_msg_v2 {
 477         __u32 lm_bufcount;
 478         __u32 lm_secflvr;
 479         __u32 lm_magic;
 480         __u32 lm_repsize;
 481         __u32 lm_cksum;
 482         __u32 lm_flags;
 483         __u32 lm_padding_2;
 484         __u32 lm_padding_3;
 485         __u32 lm_buflens[0];
 486 };
 487
 488 /* without gss, ptlrpc_body is put at the first buffer. */
 489 #define PTLRPC_NUM_VERSIONS     4
 490
 491 struct ptlrpc_body_v3 {
 492         struct lustre_handle pb_handle;
 493         __u32 pb_type;
 494         __u32 pb_version;
 495         __u32 pb_opc;
 496         __u32 pb_status;
 497         __u64 pb_last_xid; /* highest replied XID without lower unreplied XID */
 498         __u16 pb_tag;      /* virtual slot idx for multiple modifying RPCs */
 499         __u16 pb_padding0;
 500         __u32 pb_padding1;
 501         __u64 pb_last_committed;
 502         __u64 pb_transno;
 503         __u32 pb_flags;
 504         __u32 pb_op_flags;
 505         __u32 pb_conn_cnt;
 506         __u32 pb_timeout;  /* for req, the deadline, for rep, the service est */
 507         __u32 pb_service_time; /* for rep, actual service time */
 508         __u32 pb_limit;
 509         __u64 pb_slv;
 510         /* VBR: pre-versions */
 511         __u64 pb_pre_versions[PTLRPC_NUM_VERSIONS];
 512         __u64 pb_mbits; /**< match bits for bulk request */
 513         /* padding for future needs */
 514         __u64 pb_padding64_0;
 515         __u64 pb_padding64_1;
 516         __u64 pb_padding64_2;
 517         char  pb_jobid[LUSTRE_JOBID_SIZE];
 518 };
 519
 520 #define ptlrpc_body     ptlrpc_body_v3
 521
 522 struct ptlrpc_body_v2 {
 523         struct lustre_handle pb_handle;
 524         __u32 pb_type;
 525         __u32 pb_version;
 526         __u32 pb_opc;
 527         __u32 pb_status;
 528         __u64 pb_last_xid; /* highest replied XID without lower unreplied XID */
 529         __u16 pb_tag;      /* virtual slot idx for multiple modifying RPCs */
 530         __u16 pb_padding0;
 531         __u32 pb_padding1;
 532         __u64 pb_last_committed;
 533         __u64 pb_transno;
 534         __u32 pb_flags;
 535         __u32 pb_op_flags;
 536         __u32 pb_conn_cnt;
 537         __u32 pb_timeout;  /* for req, the deadline, for rep, the service est */
 538         __u32 pb_service_time; /* for rep, actual service time, also used for
 539                                 * net_latency of req
 540                                 */
 541         __u32 pb_limit;
 542         __u64 pb_slv;
 543         /* VBR: pre-versions */
 544         __u64 pb_pre_versions[PTLRPC_NUM_VERSIONS];
 545         __u64 pb_mbits; /**< unused in V2 */
 546         /* padding for future needs */
 547         __u64 pb_padding64_0;
 548         __u64 pb_padding64_1;
 549         __u64 pb_padding64_2;
 550 };
 551
 552 /* message body offset for lustre_msg_v2 */
 553 /* ptlrpc body offset in all request/reply messages */
 554 #define MSG_PTLRPC_BODY_OFF          0
 555
 556 /* normal request/reply message record offset */
 557 #define REQ_REC_OFF                  1
 558 #define REPLY_REC_OFF              1
 559
 560 /* ldlm request message body offset */
 561 #define DLM_LOCKREQ_OFF          1 /* lockreq offset */
 562 #define DLM_REQ_REC_OFF          2 /* normal dlm request record offset */
 563
 564 /* ldlm intent lock message body offset */
 565 #define DLM_INTENT_IT_OFF              2 /* intent lock it offset */
 566 #define DLM_INTENT_REC_OFF            3 /* intent lock record offset */
 567
 568 /* ldlm reply message body offset */
 569 #define DLM_LOCKREPLY_OFF              1 /* lockrep offset */
 570 #define DLM_REPLY_REC_OFF              2 /* reply record offset */
 571
 572 /** only use in req->rq_{req,rep}_swab_mask */
 573 #define MSG_PTLRPC_HEADER_OFF      31
 574
 575 /* Flags that are operation-specific go in the top 16 bits. */
 576 #define MSG_OP_FLAG_MASK   0xffff0000
 577 #define MSG_OP_FLAG_SHIFT  16
 578
 579 /* Flags that apply to all requests are in the bottom 16 bits */
 580 #define MSG_GEN_FLAG_MASK     0x0000ffff
 581 #define MSG_LAST_REPLAY    0x0001
 582 #define MSG_RESENT              0x0002
 583 #define MSG_REPLAY              0x0004
 584 /* #define MSG_AT_SUPPORT        0x0008
 585  * This was used in early prototypes of adaptive timeouts, and while there
 586  * shouldn't be any users of that code there also isn't a need for using this
 587  * bits. Defer usage until at least 1.10 to avoid potential conflict.
 588  */
 589 #define MSG_DELAY_REPLAY          0x0010
 590 #define MSG_VERSION_REPLAY      0x0020
 591 #define MSG_REQ_REPLAY_DONE       0x0040
 592 #define MSG_LOCK_REPLAY_DONE      0x0080
 593
 594 /*
 595  * Flags for all connect opcodes (MDS_CONNECT, OST_CONNECT)
 596  */
 597
 598 #define MSG_CONNECT_RECOVERING  0x00000001
 599 #define MSG_CONNECT_RECONNECT   0x00000002
 600 #define MSG_CONNECT_REPLAYABLE  0x00000004
 601 /*#define MSG_CONNECT_PEER      0x8 */
 602 #define MSG_CONNECT_LIBCLIENT   0x00000010
 603 #define MSG_CONNECT_INITIAL     0x00000020
 604 #define MSG_CONNECT_ASYNC       0x00000040
 605 #define MSG_CONNECT_NEXT_VER    0x00000080 /* use next version of lustre_msg */
 606 #define MSG_CONNECT_TRANSNO     0x00000100 /* report transno */
 607
 608 /* Connect flags */
 609 #define OBD_CONNECT_RDONLY                0x1ULL /*client has read-only access*/
 610 #define OBD_CONNECT_INDEX                 0x2ULL /*connect specific LOV idx */
 611 #define OBD_CONNECT_MDS                   0x4ULL /*connect from MDT to OST */
 612 #define OBD_CONNECT_GRANT                 0x8ULL /*OSC gets grant at connect */
 613 #define OBD_CONNECT_SRVLOCK              0x10ULL /*server takes locks for cli */
 614 #define OBD_CONNECT_VERSION              0x20ULL /*Lustre versions in ocd */
 615 #define OBD_CONNECT_REQPORTAL            0x40ULL /*Separate non-IO req portal */
 616 #define OBD_CONNECT_ACL                  0x80ULL /*access control lists */
 617 #define OBD_CONNECT_XATTR               0x100ULL /*client use extended attr */
 618 #define OBD_CONNECT_CROW                0x200ULL /*MDS+OST create obj on write*/
 619 #define OBD_CONNECT_TRUNCLOCK           0x400ULL /*locks on server for punch */
 620 #define OBD_CONNECT_TRANSNO             0x800ULL /*replay sends init transno */
 621 #define OBD_CONNECT_IBITS              0x1000ULL /*support for inodebits locks*/
 622 #define OBD_CONNECT_JOIN               0x2000ULL /*files can be concatenated.
 623                                                   *We do not support JOIN FILE
 624                                                   *anymore, reserve this flags
 625                                                   *just for preventing such bit
 626                                                   *to be reused.
 627                                                   */
 628 #define OBD_CONNECT_ATTRFID            0x4000ULL /*Server can GetAttr By Fid*/
 629 #define OBD_CONNECT_NODEVOH            0x8000ULL /*No open hndl on specl nodes*/
 630 #define OBD_CONNECT_RMT_CLIENT        0x10000ULL /* Remote client, never used
 631                                                   * in production. Removed in
 632                                                   * 2.9. Keep this flag to
 633                                                   * avoid reuse.
 634                                                   */
 635 #define OBD_CONNECT_RMT_CLIENT_FORCE  0x20000ULL /* Remote client by force,
 636                                                   * never used in production.
 637                                                   * Removed in 2.9. Keep this
 638                                                   * flag to avoid reuse
 639                                                   */
 640 #define OBD_CONNECT_BRW_SIZE          0x40000ULL /*Max bytes per rpc */
 641 #define OBD_CONNECT_QUOTA64           0x80000ULL /*Not used since 2.4 */
 642 #define OBD_CONNECT_MDS_CAPA         0x100000ULL /*MDS capability */
 643 #define OBD_CONNECT_OSS_CAPA         0x200000ULL /*OSS capability */
 644 #define OBD_CONNECT_CANCELSET        0x400000ULL /*Early batched cancels. */
 645 #define OBD_CONNECT_SOM              0x800000ULL /*Size on MDS */
 646 #define OBD_CONNECT_AT              0x1000000ULL /*client uses AT */
 647 #define OBD_CONNECT_LRU_RESIZE      0x2000000ULL /*LRU resize feature. */
 648 #define OBD_CONNECT_MDS_MDS         0x4000000ULL /*MDS-MDS connection */
 649 #define OBD_CONNECT_REAL            0x8000000ULL /* obsolete since 2.8 */
 650 #define OBD_CONNECT_CHANGE_QS      0x10000000ULL /*Not used since 2.4 */
 651 #define OBD_CONNECT_CKSUM          0x20000000ULL /*support several cksum algos*/
 652 #define OBD_CONNECT_FID            0x40000000ULL /*FID is supported by server */
 653 #define OBD_CONNECT_VBR            0x80000000ULL /*version based recovery */
 654 #define OBD_CONNECT_LOV_V3        0x100000000ULL /*client supports LOV v3 EA */
 655 #define OBD_CONNECT_GRANT_SHRINK  0x200000000ULL /* support grant shrink */
 656 #define OBD_CONNECT_SKIP_ORPHAN   0x400000000ULL /* don't reuse orphan objids */
 657 #define OBD_CONNECT_MAX_EASIZE    0x800000000ULL /* preserved for large EA */
 658 #define OBD_CONNECT_FULL20       0x1000000000ULL /* it is 2.0 client */
 659 #define OBD_CONNECT_LAYOUTLOCK   0x2000000000ULL /* client uses layout lock */
 660 #define OBD_CONNECT_64BITHASH    0x4000000000ULL /* client supports 64-bits
 661                                                   * directory hash
 662                                                   */
 663 #define OBD_CONNECT_MAXBYTES     0x8000000000ULL /* max stripe size */
 664 #define OBD_CONNECT_IMP_RECOV   0x10000000000ULL /* imp recovery support */
 665 #define OBD_CONNECT_JOBSTATS    0x20000000000ULL /* jobid in ptlrpc_body */
 666 #define OBD_CONNECT_UMASK       0x40000000000ULL /* create uses client umask */
 667 #define OBD_CONNECT_EINPROGRESS 0x80000000000ULL /* client handles -EINPROGRESS
 668                                                   * RPC error properly
 669                                                   */
 670 #define OBD_CONNECT_GRANT_PARAM 0x100000000000ULL/* extra grant params used for
 671                                                   * finer space reservation
 672                                                   */
 673 #define OBD_CONNECT_FLOCK_OWNER 0x200000000000ULL /* for the fixed 1.8
 674                                                    * policy and 2.x server
 675                                                    */
 676 #define OBD_CONNECT_LVB_TYPE    0x400000000000ULL /* variable type of LVB */
 677 #define OBD_CONNECT_NANOSEC_TIME 0x800000000000ULL /* nanosecond timestamps */
 678 #define OBD_CONNECT_LIGHTWEIGHT 0x1000000000000ULL/* lightweight connection */
 679 #define OBD_CONNECT_SHORTIO     0x2000000000000ULL/* short io */
 680 #define OBD_CONNECT_PINGLESS    0x4000000000000ULL/* pings not required */
 681 #define OBD_CONNECT_FLOCK_DEAD  0x8000000000000ULL/* flock deadlock detection */
 682 #define OBD_CONNECT_DISP_STRIPE 0x10000000000000ULL/*create stripe disposition*/
 683 #define OBD_CONNECT_OPEN_BY_FID 0x20000000000000ULL     /* open by fid won't pack
 684                                                          * name in request
 685                                                          */
 686 #define OBD_CONNECT_LFSCK       0x40000000000000ULL/* support online LFSCK */
 687 #define OBD_CONNECT_UNLINK_CLOSE 0x100000000000000ULL/* close file in unlink */
 688 #define OBD_CONNECT_MULTIMODRPCS 0x200000000000000ULL /* support multiple modify
 689                                                        *  RPCs in parallel
 690                                                        */
 691 #define OBD_CONNECT_DIR_STRIPE   0x400000000000000ULL/* striped DNE dir */
 692 #define OBD_CONNECT_SUBTREE      0x800000000000000ULL /* fileset mount */
 693 #define OBD_CONNECT_LOCK_AHEAD   0x1000000000000000ULL /* lock ahead */
 694 /** bulk matchbits is sent within ptlrpc_body */
 695 #define OBD_CONNECT_BULK_MBITS   0x2000000000000000ULL
 696 #define OBD_CONNECT_OBDOPACK     0x4000000000000000ULL /* compact OUT obdo */
 697 #define OBD_CONNECT_FLAGS2       0x8000000000000000ULL /* second flags word */
 698
 699 /* XXX README XXX:
 700  * Please DO NOT add flag values here before first ensuring that this same
 701  * flag value is not in use on some other branch.  Please clear any such
 702  * changes with senior engineers before starting to use a new flag.  Then,
 703  * submit a small patch against EVERY branch that ONLY adds the new flag,
 704  * updates obd_connect_names[] for lprocfs_rd_connect_flags(), adds the
 705  * flag to check_obd_connect_data(), and updates wiretests accordingly, so it
 706  * can be approved and landed easily to reserve the flag for future use.
 707  */
 708
 709 /* The MNE_SWAB flag is overloading the MDS_MDS bit only for the MGS
 710  * connection.  It is a temporary bug fix for Imperative Recovery interop
 711  * between 2.2 and 2.3 x86/ppc nodes, and can be removed when interop for
 712  * 2.2 clients/servers is no longer needed.  LU-1252/LU-1644.
 713  */
 714 #define OBD_CONNECT_MNE_SWAB             OBD_CONNECT_MDS_MDS
 715
 716 #define OCD_HAS_FLAG(ocd, flg)  \
 717         (!!((ocd)->ocd_connect_flags & OBD_CONNECT_##flg))
 718
 719 /* Features required for this version of the client to work with server */
 720 #define CLIENT_CONNECT_MDT_REQD (OBD_CONNECT_IBITS | OBD_CONNECT_FID | \
 721                                  OBD_CONNECT_FULL20)
 722
 723 /* This structure is used for both request and reply.
 724  *
 725  * If we eventually have separate connect data for different types, which we
 726  * almost certainly will, then perhaps we stick a union in here.
 727  */
 728 struct obd_connect_data {
 729         __u64 ocd_connect_flags; /* OBD_CONNECT_* per above */
 730         __u32 ocd_version;       /* lustre release version number */
 731         __u32 ocd_grant;         /* initial cache grant amount (bytes) */
 732         __u32 ocd_index;         /* LOV index to connect to */
 733         __u32 ocd_brw_size;      /* Maximum BRW size in bytes */
 734         __u64 ocd_ibits_known;   /* inode bits this client understands */
 735         __u8  ocd_blocksize;     /* log2 of the backend filesystem blocksize */
 736         __u8  ocd_inodespace;    /* log2 of the per-inode space consumption */
 737         __u16 ocd_grant_extent;  /* per-extent grant overhead, in 1K blocks */
 738         __u32 ocd_unused;        /* also fix lustre_swab_connect */
 739         __u64 ocd_transno;       /* first transno from client to be replayed */
 740         __u32 ocd_group;         /* MDS group on OST */
 741         __u32 ocd_cksum_types;   /* supported checksum algorithms */
 742         __u32 ocd_max_easize;    /* How big LOV EA can be on MDS */
 743         __u32 ocd_instance;      /* instance # of this target */
 744         __u64 ocd_maxbytes;      /* Maximum stripe size in bytes */
 745         /* Fields after ocd_maxbytes are only accessible by the receiver
 746          * if the corresponding flag in ocd_connect_flags is set. Accessing
 747          * any field after ocd_maxbytes on the receiver without a valid flag
 748          * may result in out-of-bound memory access and kernel oops.
 749          */
 750         __u16 ocd_maxmodrpcs;   /* Maximum modify RPCs in parallel */
 751         __u16 padding0;         /* added 2.1.0. also fix lustre_swab_connect */
 752         __u32 padding1;         /* added 2.1.0. also fix lustre_swab_connect */
 753         __u64 ocd_connect_flags2;
 754         __u64 padding3;   /* added 2.1.0. also fix lustre_swab_connect */
 755         __u64 padding4;   /* added 2.1.0. also fix lustre_swab_connect */
 756         __u64 padding5;   /* added 2.1.0. also fix lustre_swab_connect */
 757         __u64 padding6;   /* added 2.1.0. also fix lustre_swab_connect */
 758         __u64 padding7;   /* added 2.1.0. also fix lustre_swab_connect */
 759         __u64 padding8;   /* added 2.1.0. also fix lustre_swab_connect */
 760         __u64 padding9;   /* added 2.1.0. also fix lustre_swab_connect */
 761         __u64 paddingA;   /* added 2.1.0. also fix lustre_swab_connect */
 762         __u64 paddingB;   /* added 2.1.0. also fix lustre_swab_connect */
 763         __u64 paddingC;   /* added 2.1.0. also fix lustre_swab_connect */
 764         __u64 paddingD;   /* added 2.1.0. also fix lustre_swab_connect */
 765         __u64 paddingE;   /* added 2.1.0. also fix lustre_swab_connect */
 766         __u64 paddingF;   /* added 2.1.0. also fix lustre_swab_connect */
 767 };
 768
 769 /* XXX README XXX:
 770  * Please DO NOT use any fields here before first ensuring that this same
 771  * field is not in use on some other branch.  Please clear any such changes
 772  * with senior engineers before starting to use a new field.  Then, submit
 773  * a small patch against EVERY branch that ONLY adds the new field along with
 774  * the matching OBD_CONNECT flag, so that can be approved and landed easily to
 775  * reserve the flag for future use.
 776  */
 777
 778 /*
 779  * Supported checksum algorithms. Up to 32 checksum types are supported.
 780  * (32-bit mask stored in obd_connect_data::ocd_cksum_types)
 781  * Please update DECLARE_CKSUM_NAME/OBD_CKSUM_ALL in obd.h when adding a new
 782  * algorithm and also the OBD_FL_CKSUM* flags.
 783  */
 784 enum cksum_type {
 785         OBD_CKSUM_CRC32  = 0x00000001,
 786         OBD_CKSUM_ADLER  = 0x00000002,
 787         OBD_CKSUM_CRC32C = 0x00000004,
 788 };
 789
 790 /*
 791  *   OST requests: OBDO & OBD request records
 792  */
 793
 794 /* opcodes */
 795 enum ost_cmd {
 796         OST_REPLY      =  0,       /* reply ? */
 797         OST_GETATTR    =  1,
 798         OST_SETATTR    =  2,
 799         OST_READ       =  3,
 800         OST_WRITE      =  4,
 801         OST_CREATE     =  5,
 802         OST_DESTROY    =  6,
 803         OST_GET_INFO   =  7,
 804         OST_CONNECT    =  8,
 805         OST_DISCONNECT =  9,
 806         OST_PUNCH      = 10,
 807         OST_OPEN       = 11,
 808         OST_CLOSE      = 12,
 809         OST_STATFS     = 13,
 810         OST_SYNC       = 16,
 811         OST_SET_INFO   = 17,
 812         OST_QUOTACHECK = 18, /* not used since 2.4 */
 813         OST_QUOTACTL   = 19,
 814         OST_QUOTA_ADJUST_QUNIT = 20, /* not used since 2.4 */
 815         OST_LAST_OPC
 816 };
 817 #define OST_FIRST_OPC  OST_REPLY
 818
 819 enum obdo_flags {
 820         OBD_FL_INLINEDATA   = 0x00000001,
 821         OBD_FL_OBDMDEXISTS  = 0x00000002,
 822         OBD_FL_DELORPHAN    = 0x00000004, /* if set in o_flags delete orphans */
 823         OBD_FL_NORPC        = 0x00000008, /* set in o_flags do in OSC not OST */
 824         OBD_FL_IDONLY       = 0x00000010, /* set in o_flags only adjust obj id*/
 825         OBD_FL_RECREATE_OBJS = 0x00000020, /* recreate missing obj */
 826         OBD_FL_DEBUG_CHECK  = 0x00000040, /* echo client/server debug check */
 827         OBD_FL_NO_USRQUOTA  = 0x00000100, /* the object's owner is over quota */
 828         OBD_FL_NO_GRPQUOTA  = 0x00000200, /* the object's group is over quota */
 829         OBD_FL_CREATE_CROW  = 0x00000400, /* object should be create on write */
 830         OBD_FL_SRVLOCK      = 0x00000800, /* delegate DLM locking to server */
 831         OBD_FL_CKSUM_CRC32  = 0x00001000, /* CRC32 checksum type */
 832         OBD_FL_CKSUM_ADLER  = 0x00002000, /* ADLER checksum type */
 833         OBD_FL_CKSUM_CRC32C = 0x00004000, /* CRC32C checksum type */
 834         OBD_FL_CKSUM_RSVD2  = 0x00008000, /* for future cksum types */
 835         OBD_FL_CKSUM_RSVD3  = 0x00010000, /* for future cksum types */
 836         OBD_FL_SHRINK_GRANT = 0x00020000, /* object shrink the grant */
 837         OBD_FL_MMAP         = 0x00040000, /* object is mmapped on the client.
 838                                            * XXX: obsoleted - reserved for old
 839                                            * clients prior than 2.2
 840                                            */
 841         OBD_FL_RECOV_RESEND = 0x00080000, /* recoverable resent */
 842         OBD_FL_NOSPC_BLK    = 0x00100000, /* no more block space on OST */
 843         OBD_FL_FLUSH        = 0x00200000, /* flush pages on the OST */
 844         OBD_FL_SHORT_IO     = 0x00400000, /* short io request */
 845
 846         /* Note that while these checksum values are currently separate bits,
 847          * in 2.x we can actually allow all values from 1-31 if we wanted.
 848          */
 849         OBD_FL_CKSUM_ALL    = OBD_FL_CKSUM_CRC32 | OBD_FL_CKSUM_ADLER |
 850                               OBD_FL_CKSUM_CRC32C,
 851
 852         /* mask for local-only flag, which won't be sent over network */
 853         OBD_FL_LOCAL_MASK   = 0xF0000000,
 854 };
 855
 856 /*
 857  * All LOV EA magics should have the same postfix, if some new version
 858  * Lustre instroduces new LOV EA magic, then when down-grade to an old
 859  * Lustre, even though the old version system does not recognizes such
 860  * new magic, it still can distinguish the corrupted cases by checking
 861  * the magic's postfix.
 862  */
 863 #define LOV_MAGIC_MAGIC 0x0BD0
 864 #define LOV_MAGIC_MASK  0xFFFF
 865
 866 #define LOV_MAGIC_V1            (0x0BD10000 | LOV_MAGIC_MAGIC)
 867 #define LOV_MAGIC_JOIN_V1       (0x0BD20000 | LOV_MAGIC_MAGIC)
 868 #define LOV_MAGIC_V3            (0x0BD30000 | LOV_MAGIC_MAGIC)
 869 #define LOV_MAGIC_MIGRATE       (0x0BD40000 | LOV_MAGIC_MAGIC)
 870 /* reserved for specifying OSTs */
 871 #define LOV_MAGIC_SPECIFIC      (0x0BD50000 | LOV_MAGIC_MAGIC)
 872 #define LOV_MAGIC               LOV_MAGIC_V1
 873
 874 /*
 875  * magic for fully defined striping
 876  * the idea is that we should have different magics for striping "hints"
 877  * (struct lov_user_md_v[13]) and defined ready-to-use striping (struct
 878  * lov_mds_md_v[13]). at the moment the magics are used in wire protocol,
 879  * we can't just change it w/o long way preparation, but we still need a
 880  * mechanism to allow LOD to differentiate hint versus ready striping.
 881  * so, at the moment we do a trick: MDT knows what to expect from request
 882  * depending on the case (replay uses ready striping, non-replay req uses
 883  * hints), so MDT replaces magic with appropriate one and now LOD can
 884  * easily understand what's inside -bzzz
 885  */
 886 #define LOV_MAGIC_V1_DEF  0x0CD10BD0
 887 #define LOV_MAGIC_V3_DEF  0x0CD30BD0
 888
 889 #define lov_pattern(pattern)            (pattern & ~LOV_PATTERN_F_MASK)
 890 #define lov_pattern_flags(pattern)      (pattern & LOV_PATTERN_F_MASK)
 891
 892 #define lov_ost_data lov_ost_data_v1
 893 struct lov_ost_data_v1 {          /* per-stripe data structure (little-endian)*/
 894         struct ost_id l_ost_oi;   /* OST object ID */
 895         __u32 l_ost_gen;          /* generation of this l_ost_idx */
 896         __u32 l_ost_idx;          /* OST index in LOV (lov_tgt_desc->tgts) */
 897 };
 898
 899 #define lov_mds_md lov_mds_md_v1
 900 struct lov_mds_md_v1 {      /* LOV EA mds/wire data (little-endian) */
 901         __u32 lmm_magic;          /* magic number = LOV_MAGIC_V1 */
 902         __u32 lmm_pattern;      /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */
 903         struct ost_id   lmm_oi;   /* LOV object ID */
 904         __u32 lmm_stripe_size;    /* size of stripe in bytes */
 905         /* lmm_stripe_count used to be __u32 */
 906         __u16 lmm_stripe_count;   /* num stripes in use for this object */
 907         __u16 lmm_layout_gen;     /* layout generation number */
 908         struct lov_ost_data_v1 lmm_objects[0]; /* per-stripe data */
 909 };
 910
 911 #define MAX_MD_SIZE                                                     \
 912         (sizeof(struct lov_mds_md) + 4 * sizeof(struct lov_ost_data))
 913 #define MIN_MD_SIZE                                                     \
 914         (sizeof(struct lov_mds_md) + 1 * sizeof(struct lov_ost_data))
 915
 916 #define XATTR_NAME_ACL_ACCESS   "system.posix_acl_access"
 917 #define XATTR_NAME_ACL_DEFAULT  "system.posix_acl_default"
 918 #define XATTR_USER_PREFIX       "user."
 919 #define XATTR_TRUSTED_PREFIX    "trusted."
 920 #define XATTR_SECURITY_PREFIX   "security."
 921 #define XATTR_LUSTRE_PREFIX     "lustre."
 922
 923 #define XATTR_NAME_LOV    "trusted.lov"
 924 #define XATTR_NAME_LMA    "trusted.lma"
 925 #define XATTR_NAME_LMV    "trusted.lmv"
 926 #define XATTR_NAME_DEFAULT_LMV  "trusted.dmv"
 927 #define XATTR_NAME_LINK  "trusted.link"
 928 #define XATTR_NAME_FID    "trusted.fid"
 929 #define XATTR_NAME_VERSION      "trusted.version"
 930 #define XATTR_NAME_SOM          "trusted.som"
 931 #define XATTR_NAME_HSM          "trusted.hsm"
 932 #define XATTR_NAME_LFSCK_NAMESPACE "trusted.lfsck_namespace"
 933
 934 struct lov_mds_md_v3 {      /* LOV EA mds/wire data (little-endian) */
 935         __u32 lmm_magic;          /* magic number = LOV_MAGIC_V3 */
 936         __u32 lmm_pattern;      /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */
 937         struct ost_id   lmm_oi;   /* LOV object ID */
 938         __u32 lmm_stripe_size;    /* size of stripe in bytes */
 939         /* lmm_stripe_count used to be __u32 */
 940         __u16 lmm_stripe_count;   /* num stripes in use for this object */
 941         __u16 lmm_layout_gen;     /* layout generation number */
 942         char  lmm_pool_name[LOV_MAXPOOLNAME + 1]; /* must be 32bit aligned */
 943         struct lov_ost_data_v1 lmm_objects[0]; /* per-stripe data */
 944 };
 945
 946 static inline __u32 lov_mds_md_size(__u16 stripes, __u32 lmm_magic)
 947 {
 948         if (lmm_magic == LOV_MAGIC_V3)
 949                 return sizeof(struct lov_mds_md_v3) +
 950                                 stripes * sizeof(struct lov_ost_data_v1);
 951         else
 952                 return sizeof(struct lov_mds_md_v1) +
 953                                 stripes * sizeof(struct lov_ost_data_v1);
 954 }
 955
 956 static inline __u32
 957 lov_mds_md_max_stripe_count(size_t buf_size, __u32 lmm_magic)
 958 {
 959         switch (lmm_magic) {
 960         case LOV_MAGIC_V1: {
 961                 struct lov_mds_md_v1 lmm;
 962
 963                 if (buf_size < sizeof(lmm))
 964                         return 0;
 965
 966                 return (buf_size - sizeof(lmm)) / sizeof(lmm.lmm_objects[0]);
 967         }
 968         case LOV_MAGIC_V3: {
 969                 struct lov_mds_md_v3 lmm;
 970
 971                 if (buf_size < sizeof(lmm))
 972                         return 0;
 973
 974                 return (buf_size - sizeof(lmm)) / sizeof(lmm.lmm_objects[0]);
 975         }
 976         default:
 977                 return 0;
 978         }
 979 }
 980
 981 #define OBD_MD_FLID        (0x00000001ULL) /* object ID */
 982 #define OBD_MD_FLATIME     (0x00000002ULL) /* access time */
 983 #define OBD_MD_FLMTIME     (0x00000004ULL) /* data modification time */
 984 #define OBD_MD_FLCTIME     (0x00000008ULL) /* change time */
 985 #define OBD_MD_FLSIZE      (0x00000010ULL) /* size */
 986 #define OBD_MD_FLBLOCKS    (0x00000020ULL) /* allocated blocks count */
 987 #define OBD_MD_FLBLKSZ     (0x00000040ULL) /* block size */
 988 #define OBD_MD_FLMODE      (0x00000080ULL) /* access bits (mode & ~S_IFMT) */
 989 #define OBD_MD_FLTYPE      (0x00000100ULL) /* object type (mode & S_IFMT) */
 990 #define OBD_MD_FLUID       (0x00000200ULL) /* user ID */
 991 #define OBD_MD_FLGID       (0x00000400ULL) /* group ID */
 992 #define OBD_MD_FLFLAGS     (0x00000800ULL) /* flags word */
 993 #define OBD_MD_FLNLINK     (0x00002000ULL) /* link count */
 994 #define OBD_MD_FLGENER     (0x00004000ULL) /* generation number */
 995 /*#define OBD_MD_FLINLINE    (0x00008000ULL)  inline data. used until 1.6.5 */
 996 #define OBD_MD_FLRDEV      (0x00010000ULL) /* device number */
 997 #define OBD_MD_FLEASIZE    (0x00020000ULL) /* extended attribute data */
 998 #define OBD_MD_LINKNAME    (0x00040000ULL) /* symbolic link target */
 999 #define OBD_MD_FLHANDLE    (0x00080000ULL) /* file/lock handle */
1000 #define OBD_MD_FLCKSUM     (0x00100000ULL) /* bulk data checksum */
1001 #define OBD_MD_FLQOS       (0x00200000ULL) /* quality of service stats */
1002 /*#define OBD_MD_FLOSCOPQ    (0x00400000ULL) osc opaque data, never used */
1003 /*      OBD_MD_FLCOOKIE    (0x00800000ULL) obsolete in 2.8 */
1004 #define OBD_MD_FLGROUP     (0x01000000ULL) /* group */
1005 #define OBD_MD_FLFID       (0x02000000ULL) /* ->ost write inline fid */
1006 #define OBD_MD_FLEPOCH     (0x04000000ULL) /* ->ost write with ioepoch */
1007                                            /* ->mds if epoch opens or closes
1008                                             */
1009 #define OBD_MD_FLGRANT     (0x08000000ULL) /* ost preallocation space grant */
1010 #define OBD_MD_FLDIREA     (0x10000000ULL) /* dir's extended attribute data */
1011 #define OBD_MD_FLUSRQUOTA  (0x20000000ULL) /* over quota flags sent from ost */
1012 #define OBD_MD_FLGRPQUOTA  (0x40000000ULL) /* over quota flags sent from ost */
1013 #define OBD_MD_FLMODEASIZE (0x80000000ULL) /* EA size will be changed */
1014
1015 #define OBD_MD_MDS         (0x0000000100000000ULL) /* where an inode lives on */
1016 #define OBD_MD_REINT       (0x0000000200000000ULL) /* reintegrate oa */
1017 #define OBD_MD_MEA         (0x0000000400000000ULL) /* CMD split EA  */
1018 #define OBD_MD_TSTATE      (0x0000000800000000ULL) /* transient state field */
1019
1020 #define OBD_MD_FLXATTR       (0x0000001000000000ULL) /* xattr */
1021 #define OBD_MD_FLXATTRLS     (0x0000002000000000ULL) /* xattr list */
1022 #define OBD_MD_FLXATTRRM     (0x0000004000000000ULL) /* xattr remove */
1023 #define OBD_MD_FLACL         (0x0000008000000000ULL) /* ACL */
1024 /*      OBD_MD_FLRMTPERM     (0x0000010000000000ULL) remote perm, obsolete */
1025 #define OBD_MD_FLMDSCAPA     (0x0000020000000000ULL) /* MDS capability */
1026 #define OBD_MD_FLOSSCAPA     (0x0000040000000000ULL) /* OSS capability */
1027 #define OBD_MD_FLCKSPLIT     (0x0000080000000000ULL) /* Check split on server */
1028 #define OBD_MD_FLCROSSREF    (0x0000100000000000ULL) /* Cross-ref case */
1029 #define OBD_MD_FLGETATTRLOCK (0x0000200000000000ULL) /* Get IOEpoch attributes
1030                                                       * under lock; for xattr
1031                                                       * requests means the
1032                                                       * client holds the lock
1033                                                       */
1034 #define OBD_MD_FLOBJCOUNT    (0x0000400000000000ULL) /* for multiple destroy */
1035
1036 /*      OBD_MD_FLRMTLSETFACL (0x0001000000000000ULL) lfs lsetfacl, obsolete */
1037 /*      OBD_MD_FLRMTLGETFACL (0x0002000000000000ULL) lfs lgetfacl, obsolete */
1038 /*      OBD_MD_FLRMTRSETFACL (0x0004000000000000ULL) lfs rsetfacl, obsolete */
1039 /*      OBD_MD_FLRMTRGETFACL (0x0008000000000000ULL) lfs rgetfacl, obsolete */
1040
1041 #define OBD_MD_FLDATAVERSION (0x0010000000000000ULL) /* iversion sum */
1042 #define OBD_MD_CLOSE_INTENT_EXECED (0x0020000000000000ULL) /* close intent
1043                                                             * executed
1044                                                             */
1045
1046 #define OBD_MD_DEFAULT_MEA   (0x0040000000000000ULL) /* default MEA */
1047
1048 #define OBD_MD_FLGETATTR (OBD_MD_FLID    | OBD_MD_FLATIME | OBD_MD_FLMTIME | \
1049                           OBD_MD_FLCTIME | OBD_MD_FLSIZE  | OBD_MD_FLBLKSZ | \
1050                           OBD_MD_FLMODE  | OBD_MD_FLTYPE  | OBD_MD_FLUID   | \
1051                           OBD_MD_FLGID   | OBD_MD_FLFLAGS | OBD_MD_FLNLINK | \
1052                           OBD_MD_FLGENER | OBD_MD_FLRDEV  | OBD_MD_FLGROUP)
1053
1054 #define OBD_MD_FLXATTRALL (OBD_MD_FLXATTR | OBD_MD_FLXATTRLS)
1055
1056 /* don't forget obdo_fid which is way down at the bottom so it can
1057  * come after the definition of llog_cookie
1058  */
1059
1060 enum hss_valid {
1061         HSS_SETMASK     = 0x01,
1062         HSS_CLEARMASK   = 0x02,
1063         HSS_ARCHIVE_ID  = 0x04,
1064 };
1065
1066 struct hsm_state_set {
1067         __u32   hss_valid;
1068         __u32   hss_archive_id;
1069         __u64   hss_setmask;
1070         __u64   hss_clearmask;
1071 };
1072
1073 /* ost_body.data values for OST_BRW */
1074
1075 #define OBD_BRW_READ            0x01
1076 #define OBD_BRW_WRITE           0x02
1077 #define OBD_BRW_RWMASK          (OBD_BRW_READ | OBD_BRW_WRITE)
1078 #define OBD_BRW_SYNC            0x08 /* this page is a part of synchronous
1079                                       * transfer and is not accounted in
1080                                       * the grant.
1081                                       */
1082 #define OBD_BRW_CHECK           0x10
1083 #define OBD_BRW_FROM_GRANT      0x20 /* the osc manages this under llite */
1084 #define OBD_BRW_GRANTED         0x40 /* the ost manages this */
1085 #define OBD_BRW_NOCACHE         0x80 /* this page is a part of non-cached IO */
1086 #define OBD_BRW_NOQUOTA        0x100
1087 #define OBD_BRW_SRVLOCK        0x200 /* Client holds no lock over this page */
1088 #define OBD_BRW_ASYNC          0x400 /* Server may delay commit to disk */
1089 #define OBD_BRW_MEMALLOC       0x800 /* Client runs in the "kswapd" context */
1090 #define OBD_BRW_OVER_USRQUOTA 0x1000 /* Running out of user quota */
1091 #define OBD_BRW_OVER_GRPQUOTA 0x2000 /* Running out of group quota */
1092 #define OBD_BRW_SOFT_SYNC     0x4000 /* This flag notifies the server
1093                                       * that the client is running low on
1094                                       * space for unstable pages; asking
1095                                       * it to sync quickly
1096                                       */
1097
1098 #define OBD_OBJECT_EOF  LUSTRE_EOF
1099
1100 #define OST_MIN_PRECREATE 32
1101 #define OST_MAX_PRECREATE 20000
1102
1103 struct obd_ioobj {
1104         struct ost_id   ioo_oid;        /* object ID, if multi-obj BRW */
1105         __u32           ioo_max_brw;    /* low 16 bits were o_mode before 2.4,
1106                                          * now (PTLRPC_BULK_OPS_COUNT - 1) in
1107                                          * high 16 bits in 2.4 and later
1108                                          */
1109         __u32           ioo_bufcnt;     /* number of niobufs for this object */
1110 };
1111
1112 /*
1113  * NOTE: IOOBJ_MAX_BRW_BITS defines the _offset_ of the max_brw field in
1114  * ioo_max_brw, NOT the maximum number of bits in PTLRPC_BULK_OPS_BITS.
1115  * That said, ioo_max_brw is a 32-bit field so the limit is also 16 bits.
1116  */
1117 #define IOOBJ_MAX_BRW_BITS      16
1118 #define ioobj_max_brw_get(ioo)  (((ioo)->ioo_max_brw >> IOOBJ_MAX_BRW_BITS) + 1)
1119 #define ioobj_max_brw_set(ioo, num)                                     \
1120 do { (ioo)->ioo_max_brw = ((num) - 1) << IOOBJ_MAX_BRW_BITS; } while (0)
1121
1122 /* multiple of 8 bytes => can array */
1123 struct niobuf_remote {
1124         __u64   rnb_offset;
1125         __u32   rnb_len;
1126         __u32   rnb_flags;
1127 };
1128
1129 /* lock value block communicated between the filter and llite */
1130
1131 /* OST_LVB_ERR_INIT is needed because the return code in rc is
1132  * negative, i.e. because ((MASK + rc) & MASK) != MASK.
1133  */
1134 #define OST_LVB_ERR_INIT 0xffbadbad80000000ULL
1135 #define OST_LVB_ERR_MASK 0xffbadbad00000000ULL
1136 #define OST_LVB_IS_ERR(blocks)                                    \
1137         ((blocks & OST_LVB_ERR_MASK) == OST_LVB_ERR_MASK)
1138 #define OST_LVB_SET_ERR(blocks, rc)                                  \
1139         do { blocks = OST_LVB_ERR_INIT + rc; } while (0)
1140 #define OST_LVB_GET_ERR(blocks)    (int)(blocks - OST_LVB_ERR_INIT)
1141
1142 struct ost_lvb_v1 {
1143         __u64           lvb_size;
1144         __s64           lvb_mtime;
1145         __s64           lvb_atime;
1146         __s64           lvb_ctime;
1147         __u64           lvb_blocks;
1148 };
1149
1150 struct ost_lvb {
1151         __u64           lvb_size;
1152         __s64           lvb_mtime;
1153         __s64           lvb_atime;
1154         __s64           lvb_ctime;
1155         __u64           lvb_blocks;
1156         __u32           lvb_mtime_ns;
1157         __u32           lvb_atime_ns;
1158         __u32           lvb_ctime_ns;
1159         __u32           lvb_padding;
1160 };
1161
1162 /*
1163  *   lquota data structures
1164  */
1165
1166 /* The lquota_id structure is a union of all the possible identifier types that
1167  * can be used with quota, this includes:
1168  * - 64-bit user ID
1169  * - 64-bit group ID
1170  * - a FID which can be used for per-directory quota in the future
1171  */
1172 union lquota_id {
1173         struct lu_fid   qid_fid; /* FID for per-directory quota */
1174         __u64           qid_uid; /* user identifier */
1175         __u64           qid_gid; /* group identifier */
1176 };
1177
1178 /* quotactl management */
1179 struct obd_quotactl {
1180         __u32                   qc_cmd;
1181         __u32                   qc_type; /* see Q_* flag below */
1182         __u32                   qc_id;
1183         __u32                   qc_stat;
1184         struct obd_dqinfo       qc_dqinfo;
1185         struct obd_dqblk        qc_dqblk;
1186 };
1187
1188 #define Q_COPY(out, in, member) (out)->member = (in)->member
1189
1190 #define QCTL_COPY(out, in)              \
1191 do {                                    \
1192         Q_COPY(out, in, qc_cmd);        \
1193         Q_COPY(out, in, qc_type);       \
1194         Q_COPY(out, in, qc_id);         \
1195         Q_COPY(out, in, qc_stat);       \
1196         Q_COPY(out, in, qc_dqinfo);     \
1197         Q_COPY(out, in, qc_dqblk);      \
1198 } while (0)
1199
1200 /* Data structures associated with the quota locks */
1201
1202 /* Glimpse descriptor used for the index & per-ID quota locks */
1203 struct ldlm_gl_lquota_desc {
1204         union lquota_id gl_id;    /* quota ID subject to the glimpse */
1205         __u64           gl_flags; /* see LQUOTA_FL* below */
1206         __u64           gl_ver;   /* new index version */
1207         __u64           gl_hardlimit; /* new hardlimit or qunit value */
1208         __u64           gl_softlimit; /* new softlimit */
1209         __u64           gl_time;
1210         __u64           gl_pad2;
1211 };
1212
1213 /* quota glimpse flags */
1214 #define LQUOTA_FL_EDQUOT 0x1 /* user/group out of quota space on QMT */
1215
1216 /* LVB used with quota (global and per-ID) locks */
1217 struct lquota_lvb {
1218         __u64   lvb_flags;      /* see LQUOTA_FL* above */
1219         __u64   lvb_id_may_rel; /* space that might be released later */
1220         __u64   lvb_id_rel;     /* space released by the slave for this ID */
1221         __u64   lvb_id_qunit;   /* current qunit value */
1222         __u64   lvb_pad1;
1223 };
1224
1225 /* op codes */
1226 enum quota_cmd {
1227         QUOTA_DQACQ     = 601,
1228         QUOTA_DQREL     = 602,
1229         QUOTA_LAST_OPC
1230 };
1231 #define QUOTA_FIRST_OPC QUOTA_DQACQ
1232
1233 /*
1234  *   MDS REQ RECORDS
1235  */
1236
1237 /* opcodes */
1238 enum mds_cmd {
1239         MDS_GETATTR             = 33,
1240         MDS_GETATTR_NAME        = 34,
1241         MDS_CLOSE               = 35,
1242         MDS_REINT               = 36,
1243         MDS_READPAGE            = 37,
1244         MDS_CONNECT             = 38,
1245         MDS_DISCONNECT          = 39,
1246         MDS_GETSTATUS           = 40,
1247         MDS_STATFS              = 41,
1248         MDS_PIN                 = 42, /* obsolete, never used in a release */
1249         MDS_UNPIN               = 43, /* obsolete, never used in a release */
1250         MDS_SYNC                = 44,
1251         MDS_DONE_WRITING        = 45, /* obsolete since 2.8.0 */
1252         MDS_SET_INFO            = 46,
1253         MDS_QUOTACHECK          = 47, /* not used since 2.4 */
1254         MDS_QUOTACTL            = 48,
1255         MDS_GETXATTR            = 49,
1256         MDS_SETXATTR            = 50, /* obsolete, now it's MDS_REINT op */
1257         MDS_WRITEPAGE           = 51,
1258         MDS_IS_SUBDIR           = 52, /* obsolete, never used in a release */
1259         MDS_GET_INFO            = 53,
1260         MDS_HSM_STATE_GET       = 54,
1261         MDS_HSM_STATE_SET       = 55,
1262         MDS_HSM_ACTION          = 56,
1263         MDS_HSM_PROGRESS        = 57,
1264         MDS_HSM_REQUEST         = 58,
1265         MDS_HSM_CT_REGISTER     = 59,
1266         MDS_HSM_CT_UNREGISTER   = 60,
1267         MDS_SWAP_LAYOUTS        = 61,
1268         MDS_LAST_OPC
1269 };
1270
1271 #define MDS_FIRST_OPC    MDS_GETATTR
1272
1273 /*
1274  * Do not exceed 63
1275  */
1276
1277 enum mdt_reint_cmd {
1278         REINT_SETATTR  = 1,
1279         REINT_CREATE   = 2,
1280         REINT_LINK     = 3,
1281         REINT_UNLINK   = 4,
1282         REINT_RENAME   = 5,
1283         REINT_OPEN     = 6,
1284         REINT_SETXATTR = 7,
1285         REINT_RMENTRY  = 8,
1286         REINT_MIGRATE  = 9,
1287         REINT_MAX
1288 };
1289
1290 /* the disposition of the intent outlines what was executed */
1291 #define DISP_IT_EXECD   0x00000001
1292 #define DISP_LOOKUP_EXECD    0x00000002
1293 #define DISP_LOOKUP_NEG      0x00000004
1294 #define DISP_LOOKUP_POS      0x00000008
1295 #define DISP_OPEN_CREATE     0x00000010
1296 #define DISP_OPEN_OPEN       0x00000020
1297 #define DISP_ENQ_COMPLETE    0x00400000         /* obsolete and unused */
1298 #define DISP_ENQ_OPEN_REF    0x00800000
1299 #define DISP_ENQ_CREATE_REF  0x01000000
1300 #define DISP_OPEN_LOCK       0x02000000
1301 #define DISP_OPEN_LEASE      0x04000000
1302 #define DISP_OPEN_STRIPE     0x08000000
1303 #define DISP_OPEN_DENY          0x10000000
1304
1305 /* INODE LOCK PARTS */
1306 #define MDS_INODELOCK_LOOKUP 0x000001   /* For namespace, dentry etc, and also
1307                                          * was used to protect permission (mode,
1308                                          * owner, group etc) before 2.4.
1309                                          */
1310 #define MDS_INODELOCK_UPDATE 0x000002   /* size, links, timestamps */
1311 #define MDS_INODELOCK_OPEN   0x000004   /* For opened files */
1312 #define MDS_INODELOCK_LAYOUT 0x000008   /* for layout */
1313
1314 /* The PERM bit is added int 2.4, and it is used to protect permission(mode,
1315  * owner, group, acl etc), so to separate the permission from LOOKUP lock.
1316  * Because for remote directories(in DNE), these locks will be granted by
1317  * different MDTs(different ldlm namespace).
1318  *
1319  * For local directory, MDT will always grant UPDATE_LOCK|PERM_LOCK together.
1320  * For Remote directory, the master MDT, where the remote directory is, will
1321  * grant UPDATE_LOCK|PERM_LOCK, and the remote MDT, where the name entry is,
1322  * will grant LOOKUP_LOCK.
1323  */
1324 #define MDS_INODELOCK_PERM   0x000010
1325 #define MDS_INODELOCK_XATTR  0x000020   /* extended attributes */
1326
1327 #define MDS_INODELOCK_MAXSHIFT 5
1328 /* This FULL lock is useful to take on unlink sort of operations */
1329 #define MDS_INODELOCK_FULL ((1 << (MDS_INODELOCK_MAXSHIFT + 1)) - 1)
1330
1331 /* NOTE: until Lustre 1.8.7/2.1.1 the fid_ver() was packed into name[2],
1332  * but was moved into name[1] along with the OID to avoid consuming the
1333  * name[2,3] fields that need to be used for the quota id (also a FID).
1334  */
1335 enum {
1336         LUSTRE_RES_ID_SEQ_OFF = 0,
1337         LUSTRE_RES_ID_VER_OID_OFF = 1,
1338         LUSTRE_RES_ID_WAS_VER_OFF = 2, /* see note above */
1339         LUSTRE_RES_ID_QUOTA_SEQ_OFF = 2,
1340         LUSTRE_RES_ID_QUOTA_VER_OID_OFF = 3,
1341         LUSTRE_RES_ID_HSH_OFF = 3
1342 };
1343
1344 #define MDS_STATUS_CONN 1
1345 #define MDS_STATUS_LOV 2
1346
1347 /* these should be identical to their EXT4_*_FL counterparts, they are
1348  * redefined here only to avoid dragging in fs/ext4/ext4.h
1349  */
1350 #define LUSTRE_SYNC_FL   0x00000008 /* Synchronous updates */
1351 #define LUSTRE_IMMUTABLE_FL    0x00000010 /* Immutable file */
1352 #define LUSTRE_APPEND_FL       0x00000020 /* writes to file may only append */
1353 #define LUSTRE_NODUMP_FL        0x00000040 /* do not dump file */
1354 #define LUSTRE_NOATIME_FL      0x00000080 /* do not update atime */
1355 #define LUSTRE_INDEX_FL         0x00001000 /* hash-indexed directory */
1356 #define LUSTRE_DIRSYNC_FL      0x00010000 /* dirsync behaviour (dir only) */
1357 #define LUSTRE_TOPDIR_FL        0x00020000 /* Top of directory hierarchies*/
1358 #define LUSTRE_DIRECTIO_FL      0x00100000 /* Use direct i/o */
1359 #define LUSTRE_INLINE_DATA_FL   0x10000000 /* Inode has inline data. */
1360
1361 /* Convert wire LUSTRE_*_FL to corresponding client local VFS S_* values
1362  * for the client inode i_flags.  The LUSTRE_*_FL are the Lustre wire
1363  * protocol equivalents of LDISKFS_*_FL values stored on disk, while
1364  * the S_* flags are kernel-internal values that change between kernel
1365  * versions.  These flags are set/cleared via FSFILT_IOC_{GET,SET}_FLAGS.
1366  * See b=16526 for a full history.
1367  */
1368 static inline int ll_ext_to_inode_flags(int flags)
1369 {
1370         return (((flags & LUSTRE_SYNC_FL)      ? S_SYNC      : 0) |
1371                 ((flags & LUSTRE_NOATIME_FL)   ? S_NOATIME   : 0) |
1372                 ((flags & LUSTRE_APPEND_FL)    ? S_APPEND    : 0) |
1373                 ((flags & LUSTRE_DIRSYNC_FL)   ? S_DIRSYNC   : 0) |
1374                 ((flags & LUSTRE_IMMUTABLE_FL) ? S_IMMUTABLE : 0));
1375 }
1376
1377 static inline int ll_inode_to_ext_flags(int iflags)
1378 {
1379         return (((iflags & S_SYNC)      ? LUSTRE_SYNC_FL      : 0) |
1380                 ((iflags & S_NOATIME)   ? LUSTRE_NOATIME_FL   : 0) |
1381                 ((iflags & S_APPEND)    ? LUSTRE_APPEND_FL    : 0) |
1382                 ((iflags & S_DIRSYNC)   ? LUSTRE_DIRSYNC_FL   : 0) |
1383                 ((iflags & S_IMMUTABLE) ? LUSTRE_IMMUTABLE_FL : 0));
1384 }
1385
1386 /* 64 possible states */
1387 enum md_transient_state {
1388         MS_RESTORE      = (1 << 0),     /* restore is running */
1389 };
1390
1391 struct mdt_body {
1392         struct lu_fid mbo_fid1;
1393         struct lu_fid mbo_fid2;
1394         struct lustre_handle mbo_handle;
1395         __u64   mbo_valid;
1396         __u64   mbo_size;       /* Offset, in the case of MDS_READPAGE */
1397         __s64   mbo_mtime;
1398         __s64   mbo_atime;
1399         __s64   mbo_ctime;
1400         __u64   mbo_blocks;     /* XID, in the case of MDS_READPAGE */
1401         __u64   mbo_ioepoch;
1402         __u64   mbo_t_state;    /* transient file state defined in
1403                                  * enum md_transient_state
1404                                  * was "ino" until 2.4.0
1405                                  */
1406         __u32   mbo_fsuid;
1407         __u32   mbo_fsgid;
1408         __u32   mbo_capability;
1409         __u32   mbo_mode;
1410         __u32   mbo_uid;
1411         __u32   mbo_gid;
1412         __u32   mbo_flags;      /* LUSTRE_*_FL file attributes */
1413         __u32   mbo_rdev;
1414         __u32   mbo_nlink;      /* #bytes to read in the case of MDS_READPAGE */
1415         __u32   mbo_unused2;    /* was "generation" until 2.4.0 */
1416         __u32   mbo_suppgid;
1417         __u32   mbo_eadatasize;
1418         __u32   mbo_aclsize;
1419         __u32   mbo_max_mdsize;
1420         __u32   mbo_unused3;    /* was max_cookiesize until 2.8 */
1421         __u32   mbo_uid_h;      /* high 32-bits of uid, for FUID */
1422         __u32   mbo_gid_h;      /* high 32-bits of gid, for FUID */
1423         __u32   mbo_padding_5;  /* also fix lustre_swab_mdt_body */
1424         __u64   mbo_padding_6;
1425         __u64   mbo_padding_7;
1426         __u64   mbo_padding_8;
1427         __u64   mbo_padding_9;
1428         __u64   mbo_padding_10;
1429 }; /* 216 */
1430
1431 struct mdt_ioepoch {
1432         struct lustre_handle mio_handle;
1433         __u64 mio_unused1; /* was ioepoch */
1434         __u32 mio_unused2; /* was flags */
1435         __u32 mio_padding;
1436 };
1437
1438 /* permissions for md_perm.mp_perm */
1439 enum {
1440         CFS_SETUID_PERM = 0x01,
1441         CFS_SETGID_PERM = 0x02,
1442         CFS_SETGRP_PERM = 0x04,
1443 };
1444
1445 struct mdt_rec_setattr {
1446         __u32      sa_opcode;
1447         __u32      sa_cap;
1448         __u32      sa_fsuid;
1449         __u32      sa_fsuid_h;
1450         __u32      sa_fsgid;
1451         __u32      sa_fsgid_h;
1452         __u32      sa_suppgid;
1453         __u32      sa_suppgid_h;
1454         __u32      sa_padding_1;
1455         __u32      sa_padding_1_h;
1456         struct lu_fid   sa_fid;
1457         __u64      sa_valid;
1458         __u32      sa_uid;
1459         __u32      sa_gid;
1460         __u64      sa_size;
1461         __u64      sa_blocks;
1462         __s64      sa_mtime;
1463         __s64      sa_atime;
1464         __s64      sa_ctime;
1465         __u32      sa_attr_flags;
1466         __u32      sa_mode;
1467         __u32      sa_bias;      /* some operation flags */
1468         __u32      sa_padding_3;
1469         __u32      sa_padding_4;
1470         __u32      sa_padding_5;
1471 };
1472
1473 /*
1474  * Attribute flags used in mdt_rec_setattr::sa_valid.
1475  * The kernel's #defines for ATTR_* should not be used over the network
1476  * since the client and MDS may run different kernels (see bug 13828)
1477  * Therefore, we should only use MDS_ATTR_* attributes for sa_valid.
1478  */
1479 #define MDS_ATTR_MODE          0x1ULL /* = 1 */
1480 #define MDS_ATTR_UID           0x2ULL /* = 2 */
1481 #define MDS_ATTR_GID           0x4ULL /* = 4 */
1482 #define MDS_ATTR_SIZE          0x8ULL /* = 8 */
1483 #define MDS_ATTR_ATIME        0x10ULL /* = 16 */
1484 #define MDS_ATTR_MTIME        0x20ULL /* = 32 */
1485 #define MDS_ATTR_CTIME        0x40ULL /* = 64 */
1486 #define MDS_ATTR_ATIME_SET    0x80ULL /* = 128 */
1487 #define MDS_ATTR_MTIME_SET   0x100ULL /* = 256 */
1488 #define MDS_ATTR_FORCE       0x200ULL /* = 512, Not a change, but a change it */
1489 #define MDS_ATTR_ATTR_FLAG   0x400ULL /* = 1024 */
1490 #define MDS_ATTR_KILL_SUID   0x800ULL /* = 2048 */
1491 #define MDS_ATTR_KILL_SGID  0x1000ULL /* = 4096 */
1492 #define MDS_ATTR_CTIME_SET  0x2000ULL /* = 8192 */
1493 #define MDS_ATTR_FROM_OPEN  0x4000ULL /* = 16384, called from open path,
1494                                        * ie O_TRUNC
1495                                        */
1496 #define MDS_ATTR_BLOCKS     0x8000ULL /* = 32768 */
1497
1498 #define MDS_FMODE_CLOSED         00000000
1499 #define MDS_FMODE_EXEC     00000004
1500 /*      MDS_FMODE_EPOCH         01000000 obsolete since 2.8.0 */
1501 /*      MDS_FMODE_TRUNC         02000000 obsolete since 2.8.0 */
1502 /*      MDS_FMODE_SOM           04000000 obsolete since 2.8.0 */
1503
1504 #define MDS_OPEN_CREATED         00000010
1505 #define MDS_OPEN_CROSS     00000020
1506
1507 #define MDS_OPEN_CREAT     00000100
1508 #define MDS_OPEN_EXCL       00000200
1509 #define MDS_OPEN_TRUNC     00001000
1510 #define MDS_OPEN_APPEND   00002000
1511 #define MDS_OPEN_SYNC       00010000
1512 #define MDS_OPEN_DIRECTORY       00200000
1513
1514 #define MDS_OPEN_BY_FID         040000000 /* open_by_fid for known object */
1515 #define MDS_OPEN_DELAY_CREATE  0100000000 /* delay initial object create */
1516 #define MDS_OPEN_OWNEROVERRIDE 0200000000 /* NFSD rw-reopen ro file for owner */
1517 #define MDS_OPEN_JOIN_FILE     0400000000 /* open for join file.
1518                                            * We do not support JOIN FILE
1519                                            * anymore, reserve this flags
1520                                            * just for preventing such bit
1521                                            * to be reused.
1522                                            */
1523
1524 #define MDS_OPEN_LOCK         04000000000 /* This open requires open lock */
1525 #define MDS_OPEN_HAS_EA      010000000000 /* specify object create pattern */
1526 #define MDS_OPEN_HAS_OBJS    020000000000 /* Just set the EA the obj exist */
1527 #define MDS_OPEN_NORESTORE  0100000000000ULL /* Do not restore file at open */
1528 #define MDS_OPEN_NEWSTRIPE  0200000000000ULL /* New stripe needed (restripe or
1529                                               * hsm restore) */
1530 #define MDS_OPEN_VOLATILE   0400000000000ULL /* File is volatile = created
1531                                                 unlinked */
1532 #define MDS_OPEN_LEASE     01000000000000ULL /* Open the file and grant lease
1533                                               * delegation, succeed if it's not
1534                                               * being opened with conflict mode.
1535                                               */
1536 #define MDS_OPEN_RELEASE   02000000000000ULL /* Open the file for HSM release */
1537
1538 #define MDS_OPEN_FL_INTERNAL (MDS_OPEN_HAS_EA | MDS_OPEN_HAS_OBJS |     \
1539                               MDS_OPEN_OWNEROVERRIDE | MDS_OPEN_LOCK |  \
1540                               MDS_OPEN_BY_FID | MDS_OPEN_LEASE |        \
1541                               MDS_OPEN_RELEASE)
1542
1543 enum mds_op_bias {
1544         MDS_CHECK_SPLIT         = 1 << 0,
1545         MDS_CROSS_REF           = 1 << 1,
1546         MDS_VTX_BYPASS          = 1 << 2,
1547         MDS_PERM_BYPASS         = 1 << 3,
1548 /*      MDS_SOM                 = 1 << 4, obsolete since 2.8.0 */
1549         MDS_QUOTA_IGNORE        = 1 << 5,
1550         MDS_CLOSE_CLEANUP       = 1 << 6,
1551         MDS_KEEP_ORPHAN         = 1 << 7,
1552         MDS_RECOV_OPEN          = 1 << 8,
1553         MDS_DATA_MODIFIED       = 1 << 9,
1554         MDS_CREATE_VOLATILE     = 1 << 10,
1555         MDS_OWNEROVERRIDE       = 1 << 11,
1556         MDS_HSM_RELEASE         = 1 << 12,
1557         MDS_RENAME_MIGRATE      = 1 << 13,
1558         MDS_CLOSE_LAYOUT_SWAP   = 1 << 14,
1559 };
1560
1561 /* instance of mdt_reint_rec */
1562 struct mdt_rec_create {
1563         __u32      cr_opcode;
1564         __u32      cr_cap;
1565         __u32      cr_fsuid;
1566         __u32      cr_fsuid_h;
1567         __u32      cr_fsgid;
1568         __u32      cr_fsgid_h;
1569         __u32      cr_suppgid1;
1570         __u32      cr_suppgid1_h;
1571         __u32      cr_suppgid2;
1572         __u32      cr_suppgid2_h;
1573         struct lu_fid   cr_fid1;
1574         struct lu_fid   cr_fid2;
1575         struct lustre_handle cr_old_handle; /* handle in case of open replay */
1576         __s64      cr_time;
1577         __u64      cr_rdev;
1578         __u64      cr_ioepoch;
1579         __u64      cr_padding_1;   /* rr_blocks */
1580         __u32      cr_mode;
1581         __u32      cr_bias;
1582         /* use of helpers set/get_mrc_cr_flags() is needed to access
1583          * 64 bits cr_flags [cr_flags_l, cr_flags_h], this is done to
1584          * extend cr_flags size without breaking 1.8 compat
1585          */
1586         __u32      cr_flags_l;     /* for use with open, low  32 bits  */
1587         __u32      cr_flags_h;     /* for use with open, high 32 bits */
1588         __u32      cr_umask;       /* umask for create */
1589         __u32      cr_padding_4;   /* rr_padding_4 */
1590 };
1591
1592 /* instance of mdt_reint_rec */
1593 struct mdt_rec_link {
1594         __u32      lk_opcode;
1595         __u32      lk_cap;
1596         __u32      lk_fsuid;
1597         __u32      lk_fsuid_h;
1598         __u32      lk_fsgid;
1599         __u32      lk_fsgid_h;
1600         __u32      lk_suppgid1;
1601         __u32      lk_suppgid1_h;
1602         __u32      lk_suppgid2;
1603         __u32      lk_suppgid2_h;
1604         struct lu_fid   lk_fid1;
1605         struct lu_fid   lk_fid2;
1606         __s64      lk_time;
1607         __u64      lk_padding_1;   /* rr_atime */
1608         __u64      lk_padding_2;   /* rr_ctime */
1609         __u64      lk_padding_3;   /* rr_size */
1610         __u64      lk_padding_4;   /* rr_blocks */
1611         __u32      lk_bias;
1612         __u32      lk_padding_5;   /* rr_mode */
1613         __u32      lk_padding_6;   /* rr_flags */
1614         __u32      lk_padding_7;   /* rr_padding_2 */
1615         __u32      lk_padding_8;   /* rr_padding_3 */
1616         __u32      lk_padding_9;   /* rr_padding_4 */
1617 };
1618
1619 /* instance of mdt_reint_rec */
1620 struct mdt_rec_unlink {
1621         __u32      ul_opcode;
1622         __u32      ul_cap;
1623         __u32      ul_fsuid;
1624         __u32      ul_fsuid_h;
1625         __u32      ul_fsgid;
1626         __u32      ul_fsgid_h;
1627         __u32      ul_suppgid1;
1628         __u32      ul_suppgid1_h;
1629         __u32      ul_suppgid2;
1630         __u32      ul_suppgid2_h;
1631         struct lu_fid   ul_fid1;
1632         struct lu_fid   ul_fid2;
1633         __s64      ul_time;
1634         __u64      ul_padding_2;   /* rr_atime */
1635         __u64      ul_padding_3;   /* rr_ctime */
1636         __u64      ul_padding_4;   /* rr_size */
1637         __u64      ul_padding_5;   /* rr_blocks */
1638         __u32      ul_bias;
1639         __u32      ul_mode;
1640         __u32      ul_padding_6;   /* rr_flags */
1641         __u32      ul_padding_7;   /* rr_padding_2 */
1642         __u32      ul_padding_8;   /* rr_padding_3 */
1643         __u32      ul_padding_9;   /* rr_padding_4 */
1644 };
1645
1646 /* instance of mdt_reint_rec */
1647 struct mdt_rec_rename {
1648         __u32      rn_opcode;
1649         __u32      rn_cap;
1650         __u32      rn_fsuid;
1651         __u32      rn_fsuid_h;
1652         __u32      rn_fsgid;
1653         __u32      rn_fsgid_h;
1654         __u32      rn_suppgid1;
1655         __u32      rn_suppgid1_h;
1656         __u32      rn_suppgid2;
1657         __u32      rn_suppgid2_h;
1658         struct lu_fid   rn_fid1;
1659         struct lu_fid   rn_fid2;
1660         __s64      rn_time;
1661         __u64      rn_padding_1;   /* rr_atime */
1662         __u64      rn_padding_2;   /* rr_ctime */
1663         __u64      rn_padding_3;   /* rr_size */
1664         __u64      rn_padding_4;   /* rr_blocks */
1665         __u32      rn_bias;     /* some operation flags */
1666         __u32      rn_mode;     /* cross-ref rename has mode */
1667         __u32      rn_padding_5;   /* rr_flags */
1668         __u32      rn_padding_6;   /* rr_padding_2 */
1669         __u32      rn_padding_7;   /* rr_padding_3 */
1670         __u32      rn_padding_8;   /* rr_padding_4 */
1671 };
1672
1673 /* instance of mdt_reint_rec */
1674 struct mdt_rec_setxattr {
1675         __u32      sx_opcode;
1676         __u32      sx_cap;
1677         __u32      sx_fsuid;
1678         __u32      sx_fsuid_h;
1679         __u32      sx_fsgid;
1680         __u32      sx_fsgid_h;
1681         __u32      sx_suppgid1;
1682         __u32      sx_suppgid1_h;
1683         __u32      sx_suppgid2;
1684         __u32      sx_suppgid2_h;
1685         struct lu_fid   sx_fid;
1686         __u64      sx_padding_1;   /* These three are rr_fid2 */
1687         __u32      sx_padding_2;
1688         __u32      sx_padding_3;
1689         __u64      sx_valid;
1690         __s64      sx_time;
1691         __u64      sx_padding_5;   /* rr_ctime */
1692         __u64      sx_padding_6;   /* rr_size */
1693         __u64      sx_padding_7;   /* rr_blocks */
1694         __u32      sx_size;
1695         __u32      sx_flags;
1696         __u32      sx_padding_8;   /* rr_flags */
1697         __u32      sx_padding_9;   /* rr_padding_2 */
1698         __u32      sx_padding_10;  /* rr_padding_3 */
1699         __u32      sx_padding_11;  /* rr_padding_4 */
1700 };
1701
1702 /*
1703  * mdt_rec_reint is the template for all mdt_reint_xxx structures.
1704  * Do NOT change the size of various members, otherwise the value
1705  * will be broken in lustre_swab_mdt_rec_reint().
1706  *
1707  * If you add new members in other mdt_reint_xxx structures and need to use the
1708  * rr_padding_x fields, then update lustre_swab_mdt_rec_reint() also.
1709  */
1710 struct mdt_rec_reint {
1711         __u32      rr_opcode;
1712         __u32      rr_cap;
1713         __u32      rr_fsuid;
1714         __u32      rr_fsuid_h;
1715         __u32      rr_fsgid;
1716         __u32      rr_fsgid_h;
1717         __u32      rr_suppgid1;
1718         __u32      rr_suppgid1_h;
1719         __u32      rr_suppgid2;
1720         __u32      rr_suppgid2_h;
1721         struct lu_fid   rr_fid1;
1722         struct lu_fid   rr_fid2;
1723         __s64      rr_mtime;
1724         __s64      rr_atime;
1725         __s64      rr_ctime;
1726         __u64      rr_size;
1727         __u64      rr_blocks;
1728         __u32      rr_bias;
1729         __u32      rr_mode;
1730         __u32      rr_flags;
1731         __u32      rr_flags_h;
1732         __u32      rr_umask;
1733         __u32      rr_padding_4; /* also fix lustre_swab_mdt_rec_reint */
1734 };
1735
1736 /* lmv structures */
1737 struct lmv_desc {
1738         __u32 ld_tgt_count;             /* how many MDS's */
1739         __u32 ld_active_tgt_count;       /* how many active */
1740         __u32 ld_default_stripe_count;     /* how many objects are used */
1741         __u32 ld_pattern;                 /* default hash pattern */
1742         __u64 ld_default_hash_size;
1743         __u64 ld_padding_1;             /* also fix lustre_swab_lmv_desc */
1744         __u32 ld_padding_2;             /* also fix lustre_swab_lmv_desc */
1745         __u32 ld_qos_maxage;           /* in second */
1746         __u32 ld_padding_3;             /* also fix lustre_swab_lmv_desc */
1747         __u32 ld_padding_4;             /* also fix lustre_swab_lmv_desc */
1748         struct obd_uuid ld_uuid;
1749 };
1750
1751 /* LMV layout EA, and it will be stored both in master and slave object */
1752 struct lmv_mds_md_v1 {
1753         __u32 lmv_magic;
1754         __u32 lmv_stripe_count;
1755         __u32 lmv_master_mdt_index;     /* On master object, it is master
1756                                          * MDT index, on slave object, it
1757                                          * is stripe index of the slave obj
1758                                          */
1759         __u32 lmv_hash_type;            /* dir stripe policy, i.e. indicate
1760                                          * which hash function to be used,
1761                                          * Note: only lower 16 bits is being
1762                                          * used for now. Higher 16 bits will
1763                                          * be used to mark the object status,
1764                                          * for example migrating or dead.
1765                                          */
1766         __u32 lmv_layout_version;       /* Used for directory restriping */
1767         __u32 lmv_padding1;
1768         __u64 lmv_padding2;
1769         __u64 lmv_padding3;
1770         char lmv_pool_name[LOV_MAXPOOLNAME + 1];/* pool name */
1771         struct lu_fid lmv_stripe_fids[0];       /* FIDs for each stripe */
1772 };
1773
1774 #define LMV_MAGIC_V1     0x0CD20CD0     /* normal stripe lmv magic */
1775 #define LMV_MAGIC        LMV_MAGIC_V1
1776
1777 /* #define LMV_USER_MAGIC 0x0CD30CD0 */
1778 #define LMV_MAGIC_STRIPE 0x0CD40CD0     /* magic for dir sub_stripe */
1779
1780 /*
1781  *Right now only the lower part(0-16bits) of lmv_hash_type is being used,
1782  * and the higher part will be the flag to indicate the status of object,
1783  * for example the object is being migrated. And the hash function
1784  * might be interpreted differently with different flags.
1785  */
1786 #define LMV_HASH_TYPE_MASK              0x0000ffff
1787
1788 #define LMV_HASH_FLAG_MIGRATION         0x80000000
1789 #define LMV_HASH_FLAG_DEAD              0x40000000
1790
1791 /**
1792  * The FNV-1a hash algorithm is as follows:
1793  *     hash = FNV_offset_basis
1794  *     for each octet_of_data to be hashed
1795  *             hash = hash XOR octet_of_data
1796  *             hash = hash × FNV_prime
1797  *     return hash
1798  * http://en.wikipedia.org/wiki/Fowler–Noll–Vo_hash_function#FNV-1a_hash
1799  *
1800  * http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-reference-source
1801  * FNV_prime is 2^40 + 2^8 + 0xb3 = 0x100000001b3ULL
1802  **/
1803 #define LUSTRE_FNV_1A_64_PRIME          0x100000001b3ULL
1804 #define LUSTRE_FNV_1A_64_OFFSET_BIAS    0xcbf29ce484222325ULL
1805 static inline __u64 lustre_hash_fnv_1a_64(const void *buf, size_t size)
1806 {
1807         __u64 hash = LUSTRE_FNV_1A_64_OFFSET_BIAS;
1808         const unsigned char *p = buf;
1809         size_t i;
1810
1811         for (i = 0; i < size; i++) {
1812                 hash ^= p[i];
1813                 hash *= LUSTRE_FNV_1A_64_PRIME;
1814         }
1815
1816         return hash;
1817 }
1818
1819 union lmv_mds_md {
1820         __u32                   lmv_magic;
1821         struct lmv_mds_md_v1    lmv_md_v1;
1822         struct lmv_user_md      lmv_user_md;
1823 };
1824
1825 static inline ssize_t lmv_mds_md_size(int stripe_count, unsigned int lmm_magic)
1826 {
1827         ssize_t len = -EINVAL;
1828
1829         switch (lmm_magic) {
1830         case LMV_MAGIC_V1: {
1831                 struct lmv_mds_md_v1 *lmm1;
1832
1833                 len = sizeof(*lmm1);
1834                 len += stripe_count * sizeof(lmm1->lmv_stripe_fids[0]);
1835                 break; }
1836         default:
1837                 break;
1838         }
1839         return len;
1840 }
1841
1842 static inline int lmv_mds_md_stripe_count_get(const union lmv_mds_md *lmm)
1843 {
1844         switch (__le32_to_cpu(lmm->lmv_magic)) {
1845         case LMV_MAGIC_V1:
1846                 return __le32_to_cpu(lmm->lmv_md_v1.lmv_stripe_count);
1847         case LMV_USER_MAGIC:
1848                 return __le32_to_cpu(lmm->lmv_user_md.lum_stripe_count);
1849         default:
1850                 return -EINVAL;
1851         }
1852 }
1853
1854 enum fld_rpc_opc {
1855         FLD_QUERY       = 900,
1856         FLD_READ        = 901,
1857         FLD_LAST_OPC,
1858         FLD_FIRST_OPC   = FLD_QUERY
1859 };
1860
1861 enum seq_rpc_opc {
1862         SEQ_QUERY                      = 700,
1863         SEQ_LAST_OPC,
1864         SEQ_FIRST_OPC              = SEQ_QUERY
1865 };
1866
1867 enum seq_op {
1868         SEQ_ALLOC_SUPER = 0,
1869         SEQ_ALLOC_META = 1
1870 };
1871
1872 enum fld_op {
1873         FLD_CREATE = 0,
1874         FLD_DELETE = 1,
1875         FLD_LOOKUP = 2,
1876 };
1877
1878 /*
1879  *  LOV data structures
1880  */
1881
1882 #define LOV_MAX_UUID_BUFFER_SIZE  8192
1883 /* The size of the buffer the lov/mdc reserves for the
1884  * array of UUIDs returned by the MDS.  With the current
1885  * protocol, this will limit the max number of OSTs per LOV
1886  */
1887
1888 #define LOV_DESC_MAGIC 0xB0CCDE5C
1889 #define LOV_DESC_QOS_MAXAGE_DEFAULT 5  /* Seconds */
1890 #define LOV_DESC_STRIPE_SIZE_DEFAULT (1 << LNET_MTU_BITS)
1891
1892 /* LOV settings descriptor (should only contain static info) */
1893 struct lov_desc {
1894         __u32 ld_tgt_count;             /* how many OBD's */
1895         __u32 ld_active_tgt_count;      /* how many active */
1896         __u32 ld_default_stripe_count;  /* how many objects are used */
1897         __u32 ld_pattern;               /* default PATTERN_RAID0 */
1898         __u64 ld_default_stripe_size;   /* in bytes */
1899         __u64 ld_default_stripe_offset; /* in bytes */
1900         __u32 ld_padding_0;             /* unused */
1901         __u32 ld_qos_maxage;            /* in second */
1902         __u32 ld_padding_1;             /* also fix lustre_swab_lov_desc */
1903         __u32 ld_padding_2;             /* also fix lustre_swab_lov_desc */
1904         struct obd_uuid ld_uuid;
1905 };
1906
1907 #define ld_magic ld_active_tgt_count       /* for swabbing from llogs */
1908
1909 /*
1910  *   LDLM requests:
1911  */
1912 /* opcodes -- MUST be distinct from OST/MDS opcodes */
1913 enum ldlm_cmd {
1914         LDLM_ENQUEUE     = 101,
1915         LDLM_CONVERT     = 102,
1916         LDLM_CANCEL      = 103,
1917         LDLM_BL_CALLBACK = 104,
1918         LDLM_CP_CALLBACK = 105,
1919         LDLM_GL_CALLBACK = 106,
1920         LDLM_SET_INFO    = 107,
1921         LDLM_LAST_OPC
1922 };
1923 #define LDLM_FIRST_OPC LDLM_ENQUEUE
1924
1925 #define RES_NAME_SIZE 4
1926 struct ldlm_res_id {
1927         __u64 name[RES_NAME_SIZE];
1928 };
1929
1930 #define DLDLMRES        "[%#llx:%#llx:%#llx].%llx"
1931 #define PLDLMRES(res)   (res)->lr_name.name[0], (res)->lr_name.name[1], \
1932                         (res)->lr_name.name[2], (res)->lr_name.name[3]
1933
1934 /* lock types */
1935 enum ldlm_mode {
1936         LCK_MINMODE = 0,
1937         LCK_EX      = 1,
1938         LCK_PW      = 2,
1939         LCK_PR      = 4,
1940         LCK_CW      = 8,
1941         LCK_CR      = 16,
1942         LCK_NL      = 32,
1943         LCK_GROUP   = 64,
1944         LCK_COS     = 128,
1945         LCK_MAXMODE
1946 };
1947
1948 #define LCK_MODE_NUM    8
1949
1950 enum ldlm_type {
1951         LDLM_PLAIN     = 10,
1952         LDLM_EXTENT    = 11,
1953         LDLM_FLOCK     = 12,
1954         LDLM_IBITS     = 13,
1955         LDLM_MAX_TYPE
1956 };
1957
1958 #define LDLM_MIN_TYPE LDLM_PLAIN
1959
1960 struct ldlm_extent {
1961         __u64 start;
1962         __u64 end;
1963         __u64 gid;
1964 };
1965
1966 struct ldlm_inodebits {
1967         __u64 bits;
1968 };
1969
1970 struct ldlm_flock_wire {
1971         __u64 lfw_start;
1972         __u64 lfw_end;
1973         __u64 lfw_owner;
1974         __u32 lfw_padding;
1975         __u32 lfw_pid;
1976 };
1977
1978 /* it's important that the fields of the ldlm_extent structure match
1979  * the first fields of the ldlm_flock structure because there is only
1980  * one ldlm_swab routine to process the ldlm_policy_data_t union. if
1981  * this ever changes we will need to swab the union differently based
1982  * on the resource type.
1983  */
1984
1985 union ldlm_wire_policy_data {
1986         struct ldlm_extent l_extent;
1987         struct ldlm_flock_wire l_flock;
1988         struct ldlm_inodebits l_inodebits;
1989 };
1990
1991 union ldlm_gl_desc {
1992         struct ldlm_gl_lquota_desc      lquota_desc;
1993 };
1994
1995 enum ldlm_intent_flags {
1996         IT_OPEN         = 0x00000001,
1997         IT_CREAT        = 0x00000002,
1998         IT_OPEN_CREAT   = 0x00000003,
1999         IT_READDIR      = 0x00000004,
2000         IT_GETATTR      = 0x00000008,
2001         IT_LOOKUP       = 0x00000010,
2002         IT_UNLINK       = 0x00000020,
2003         IT_TRUNC        = 0x00000040,
2004         IT_GETXATTR     = 0x00000080,
2005         IT_EXEC         = 0x00000100,
2006         IT_PIN          = 0x00000200,
2007         IT_LAYOUT       = 0x00000400,
2008         IT_QUOTA_DQACQ  = 0x00000800,
2009         IT_QUOTA_CONN   = 0x00001000,
2010         IT_SETXATTR     = 0x00002000,
2011 };
2012
2013 struct ldlm_intent {
2014         __u64 opc;
2015 };
2016
2017 struct ldlm_resource_desc {
2018         enum ldlm_type lr_type;
2019         __u32 lr_padding;       /* also fix lustre_swab_ldlm_resource_desc */
2020         struct ldlm_res_id lr_name;
2021 };
2022
2023 struct ldlm_lock_desc {
2024         struct ldlm_resource_desc l_resource;
2025         enum ldlm_mode l_req_mode;
2026         enum ldlm_mode l_granted_mode;
2027         union ldlm_wire_policy_data l_policy_data;
2028 };
2029
2030 #define LDLM_LOCKREQ_HANDLES 2
2031 #define LDLM_ENQUEUE_CANCEL_OFF 1
2032
2033 struct ldlm_request {
2034         __u32 lock_flags;
2035         __u32 lock_count;
2036         struct ldlm_lock_desc lock_desc;
2037         struct lustre_handle lock_handle[LDLM_LOCKREQ_HANDLES];
2038 };
2039
2040 struct ldlm_reply {
2041         __u32 lock_flags;
2042         __u32 lock_padding;     /* also fix lustre_swab_ldlm_reply */
2043         struct ldlm_lock_desc lock_desc;
2044         struct lustre_handle lock_handle;
2045         __u64  lock_policy_res1;
2046         __u64  lock_policy_res2;
2047 };
2048
2049 #define ldlm_flags_to_wire(flags)    ((__u32)(flags))
2050 #define ldlm_flags_from_wire(flags)  ((__u64)(flags))
2051
2052 /*
2053  * Opcodes for mountconf (mgs and mgc)
2054  */
2055 enum mgs_cmd {
2056         MGS_CONNECT = 250,
2057         MGS_DISCONNECT,
2058         MGS_EXCEPTION,   /* node died, etc. */
2059         MGS_TARGET_REG, /* whenever target starts up */
2060         MGS_TARGET_DEL,
2061         MGS_SET_INFO,
2062         MGS_CONFIG_READ,
2063         MGS_LAST_OPC
2064 };
2065 #define MGS_FIRST_OPC MGS_CONNECT
2066
2067 #define MGS_PARAM_MAXLEN 1024
2068 #define KEY_SET_INFO "set_info"
2069
2070 struct mgs_send_param {
2071         char         mgs_param[MGS_PARAM_MAXLEN];
2072 };
2073
2074 /* We pass this info to the MGS so it can write config logs */
2075 #define MTI_NAME_MAXLEN  64
2076 #define MTI_PARAM_MAXLEN 4096
2077 #define MTI_NIDS_MAX     32
2078 struct mgs_target_info {
2079         __u32       mti_lustre_ver;
2080         __u32       mti_stripe_index;
2081         __u32       mti_config_ver;
2082         __u32       mti_flags;
2083         __u32       mti_nid_count;
2084         __u32       mti_instance; /* Running instance of target */
2085         char         mti_fsname[MTI_NAME_MAXLEN];
2086         char         mti_svname[MTI_NAME_MAXLEN];
2087         char         mti_uuid[sizeof(struct obd_uuid)];
2088         __u64       mti_nids[MTI_NIDS_MAX];     /* host nids (lnet_nid_t)*/
2089         char         mti_params[MTI_PARAM_MAXLEN];
2090 };
2091
2092 struct mgs_nidtbl_entry {
2093         __u64      mne_version;    /* table version of this entry */
2094         __u32      mne_instance;   /* target instance # */
2095         __u32      mne_index;      /* target index */
2096         __u32      mne_length;     /* length of this entry - by bytes */
2097         __u8        mne_type;       /* target type LDD_F_SV_TYPE_OST/MDT */
2098         __u8        mne_nid_type;   /* type of nid(mbz). for ipv6. */
2099         __u8        mne_nid_size;   /* size of each NID, by bytes */
2100         __u8        mne_nid_count;  /* # of NIDs in buffer */
2101         union {
2102                 lnet_nid_t nids[0];     /* variable size buffer for NIDs. */
2103         } u;
2104 };
2105
2106 struct mgs_config_body {
2107         char     mcb_name[MTI_NAME_MAXLEN]; /* logname */
2108         __u64    mcb_offset;    /* next index of config log to request */
2109         __u16    mcb_type;      /* type of log: CONFIG_T_[CONFIG|RECOVER] */
2110         __u8     mcb_reserved;
2111         __u8     mcb_bits;      /* bits unit size of config log */
2112         __u32    mcb_units;     /* # of units for bulk transfer */
2113 };
2114
2115 struct mgs_config_res {
2116         __u64    mcr_offset;    /* index of last config log */
2117         __u64    mcr_size;      /* size of the log */
2118 };
2119
2120 /* Config marker flags (in config log) */
2121 #define CM_START       0x01
2122 #define CM_END   0x02
2123 #define CM_SKIP 0x04
2124 #define CM_UPGRADE146  0x08
2125 #define CM_EXCLUDE     0x10
2126 #define CM_START_SKIP (CM_START | CM_SKIP)
2127
2128 struct cfg_marker {
2129         __u32        cm_step;       /* aka config version */
2130         __u32        cm_flags;
2131         __u32        cm_vers;       /* lustre release version number */
2132         __u32        cm_padding;    /* 64 bit align */
2133         __s64        cm_createtime; /*when this record was first created */
2134         __s64        cm_canceltime; /*when this record is no longer valid*/
2135         char          cm_tgtname[MTI_NAME_MAXLEN];
2136         char          cm_comment[MTI_NAME_MAXLEN];
2137 };
2138
2139 /*
2140  * Opcodes for multiple servers.
2141  */
2142
2143 enum obd_cmd {
2144         OBD_PING = 400,
2145         OBD_LOG_CANCEL,
2146         OBD_QC_CALLBACK, /* not used since 2.4 */
2147         OBD_IDX_READ,
2148         OBD_LAST_OPC
2149 };
2150 #define OBD_FIRST_OPC OBD_PING
2151
2152 /**
2153  * llog contexts indices.
2154  *
2155  * There is compatibility problem with indexes below, they are not
2156  * continuous and must keep their numbers for compatibility needs.
2157  * See LU-5218 for details.
2158  */
2159 enum llog_ctxt_id {
2160         LLOG_CONFIG_ORIG_CTXT  =  0,
2161         LLOG_CONFIG_REPL_CTXT = 1,
2162         LLOG_MDS_OST_ORIG_CTXT = 2,
2163         LLOG_MDS_OST_REPL_CTXT = 3, /* kept just to avoid re-assignment */
2164         LLOG_SIZE_ORIG_CTXT = 4,
2165         LLOG_SIZE_REPL_CTXT = 5,
2166         LLOG_TEST_ORIG_CTXT = 8,
2167         LLOG_TEST_REPL_CTXT = 9, /* kept just to avoid re-assignment */
2168         LLOG_CHANGELOG_ORIG_CTXT = 12, /**< changelog generation on mdd */
2169         LLOG_CHANGELOG_REPL_CTXT = 13, /**< changelog access on clients */
2170         /* for multiple changelog consumers */
2171         LLOG_CHANGELOG_USER_ORIG_CTXT = 14,
2172         LLOG_AGENT_ORIG_CTXT = 15, /**< agent requests generation on cdt */
2173         LLOG_MAX_CTXTS
2174 };
2175
2176 /** Identifier for a single log object */
2177 struct llog_logid {
2178         struct ost_id           lgl_oi;
2179         __u32              lgl_ogen;
2180 } __packed;
2181
2182 /** Records written to the CATALOGS list */
2183 #define CATLIST "CATALOGS"
2184 struct llog_catid {
2185         struct llog_logid       lci_logid;
2186         __u32              lci_padding1;
2187         __u32              lci_padding2;
2188         __u32              lci_padding3;
2189 } __packed;
2190
2191 /* Log data record types - there is no specific reason that these need to
2192  * be related to the RPC opcodes, but no reason not to (may be handy later?)
2193  */
2194 #define LLOG_OP_MAGIC 0x10600000
2195 #define LLOG_OP_MASK  0xfff00000
2196
2197 enum llog_op_type {
2198         LLOG_PAD_MAGIC          = LLOG_OP_MAGIC | 0x00000,
2199         OST_SZ_REC              = LLOG_OP_MAGIC | 0x00f00,
2200         /* OST_RAID1_REC        = LLOG_OP_MAGIC | 0x01000, never used */
2201         MDS_UNLINK_REC          = LLOG_OP_MAGIC | 0x10000 | (MDS_REINT << 8) |
2202                                   REINT_UNLINK, /* obsolete after 2.5.0 */
2203         MDS_UNLINK64_REC        = LLOG_OP_MAGIC | 0x90000 | (MDS_REINT << 8) |
2204                                   REINT_UNLINK,
2205         /* MDS_SETATTR_REC      = LLOG_OP_MAGIC | 0x12401, obsolete 1.8.0 */
2206         MDS_SETATTR64_REC       = LLOG_OP_MAGIC | 0x90000 | (MDS_REINT << 8) |
2207                                   REINT_SETATTR,
2208         OBD_CFG_REC             = LLOG_OP_MAGIC | 0x20000,
2209         /* PTL_CFG_REC          = LLOG_OP_MAGIC | 0x30000, obsolete 1.4.0 */
2210         LLOG_GEN_REC            = LLOG_OP_MAGIC | 0x40000,
2211         /* LLOG_JOIN_REC        = LLOG_OP_MAGIC | 0x50000, obsolete  1.8.0 */
2212         CHANGELOG_REC           = LLOG_OP_MAGIC | 0x60000,
2213         CHANGELOG_USER_REC      = LLOG_OP_MAGIC | 0x70000,
2214         HSM_AGENT_REC           = LLOG_OP_MAGIC | 0x80000,
2215         LLOG_HDR_MAGIC          = LLOG_OP_MAGIC | 0x45539,
2216         LLOG_LOGID_MAGIC        = LLOG_OP_MAGIC | 0x4553b,
2217 };
2218
2219 #define LLOG_REC_HDR_NEEDS_SWABBING(r) \
2220         (((r)->lrh_type & __swab32(LLOG_OP_MASK)) == __swab32(LLOG_OP_MAGIC))
2221
2222 /** Log record header - stored in little endian order.
2223  * Each record must start with this struct, end with a llog_rec_tail,
2224  * and be a multiple of 256 bits in size.
2225  */
2226 struct llog_rec_hdr {
2227         __u32   lrh_len;
2228         __u32   lrh_index;
2229         __u32   lrh_type;
2230         __u32   lrh_id;
2231 };
2232
2233 struct llog_rec_tail {
2234         __u32   lrt_len;
2235         __u32   lrt_index;
2236 };
2237
2238 /* Where data follow just after header */
2239 #define REC_DATA(ptr)                                           \
2240         ((void *)((char *)ptr + sizeof(struct llog_rec_hdr)))
2241
2242 #define REC_DATA_LEN(rec)                                       \
2243         (rec->lrh_len - sizeof(struct llog_rec_hdr) -           \
2244          sizeof(struct llog_rec_tail))
2245
2246 struct llog_logid_rec {
2247         struct llog_rec_hdr     lid_hdr;
2248         struct llog_logid       lid_id;
2249         __u32                   lid_padding1;
2250         __u64                   lid_padding2;
2251         __u64                   lid_padding3;
2252         struct llog_rec_tail    lid_tail;
2253 } __packed;
2254
2255 struct llog_unlink_rec {
2256         struct llog_rec_hdr     lur_hdr;
2257         __u64                   lur_oid;
2258         __u32                   lur_oseq;
2259         __u32                   lur_count;
2260         struct llog_rec_tail    lur_tail;
2261 } __packed;
2262
2263 struct llog_unlink64_rec {
2264         struct llog_rec_hdr     lur_hdr;
2265         struct lu_fid           lur_fid;
2266         __u32                   lur_count; /* to destroy the lost precreated */
2267         __u32                   lur_padding1;
2268         __u64                   lur_padding2;
2269         __u64                   lur_padding3;
2270         struct llog_rec_tail    lur_tail;
2271 } __packed;
2272
2273 struct llog_setattr64_rec {
2274         struct llog_rec_hdr     lsr_hdr;
2275         struct ost_id           lsr_oi;
2276         __u32                   lsr_uid;
2277         __u32                   lsr_uid_h;
2278         __u32                   lsr_gid;
2279         __u32                   lsr_gid_h;
2280         __u64                   lsr_valid;
2281         struct llog_rec_tail    lsr_tail;
2282 } __packed;
2283
2284 struct llog_size_change_rec {
2285         struct llog_rec_hdr     lsc_hdr;
2286         struct ll_fid           lsc_fid;
2287         __u32                   lsc_ioepoch;
2288         __u32                   lsc_padding1;
2289         __u64                   lsc_padding2;
2290         __u64                   lsc_padding3;
2291         struct llog_rec_tail    lsc_tail;
2292 } __packed;
2293
2294 /* changelog llog name, needed by client replicators */
2295 #define CHANGELOG_CATALOG "changelog_catalog"
2296
2297 struct changelog_setinfo {
2298         __u64 cs_recno;
2299         __u32 cs_id;
2300 } __packed;
2301
2302 /** changelog record */
2303 struct llog_changelog_rec {
2304         struct llog_rec_hdr     cr_hdr;
2305         struct changelog_rec    cr;             /**< Variable length field */
2306         struct llog_rec_tail    cr_do_not_use;  /**< for_sizezof_only */
2307 } __packed;
2308
2309 struct llog_changelog_user_rec {
2310         struct llog_rec_hdr   cur_hdr;
2311         __u32            cur_id;
2312         __u32            cur_padding;
2313         __u64            cur_endrec;
2314         struct llog_rec_tail  cur_tail;
2315 } __packed;
2316
2317 enum agent_req_status {
2318         ARS_WAITING,
2319         ARS_STARTED,
2320         ARS_FAILED,
2321         ARS_CANCELED,
2322         ARS_SUCCEED,
2323 };
2324
2325 static inline const char *agent_req_status2name(const enum agent_req_status ars)
2326 {
2327         switch (ars) {
2328         case ARS_WAITING:
2329                 return "WAITING";
2330         case ARS_STARTED:
2331                 return "STARTED";
2332         case ARS_FAILED:
2333                 return "FAILED";
2334         case ARS_CANCELED:
2335                 return "CANCELED";
2336         case ARS_SUCCEED:
2337                 return "SUCCEED";
2338         default:
2339                 return "UNKNOWN";
2340         }
2341 }
2342
2343 struct llog_agent_req_rec {
2344         struct llog_rec_hdr     arr_hdr;        /**< record header */
2345         __u32                   arr_status;     /**< status of the request */
2346                                                 /* must match enum
2347                                                  * agent_req_status
2348                                                  */
2349         __u32                   arr_archive_id; /**< backend archive number */
2350         __u64                   arr_flags;      /**< req flags */
2351         __u64                   arr_compound_id;/**< compound cookie */
2352         __u64                   arr_req_create; /**< req. creation time */
2353         __u64                   arr_req_change; /**< req. status change time */
2354         struct hsm_action_item  arr_hai;        /**< req. to the agent */
2355         struct llog_rec_tail    arr_tail;   /**< record tail for_sizezof_only */
2356 } __packed;
2357
2358 /* Old llog gen for compatibility */
2359 struct llog_gen {
2360         __u64 mnt_cnt;
2361         __u64 conn_cnt;
2362 } __packed;
2363
2364 struct llog_gen_rec {
2365         struct llog_rec_hdr     lgr_hdr;
2366         struct llog_gen         lgr_gen;
2367         __u64                   padding1;
2368         __u64                   padding2;
2369         __u64                   padding3;
2370         struct llog_rec_tail    lgr_tail;
2371 };
2372
2373 /* flags for the logs */
2374 enum llog_flag {
2375         LLOG_F_ZAP_WHEN_EMPTY   = 0x1,
2376         LLOG_F_IS_CAT           = 0x2,
2377         LLOG_F_IS_PLAIN         = 0x4,
2378         LLOG_F_EXT_JOBID        = 0x8,
2379         LLOG_F_IS_FIXSIZE       = 0x10,
2380
2381         /*
2382          * Note: Flags covered by LLOG_F_EXT_MASK will be inherited from
2383          * catlog to plain log, so do not add LLOG_F_IS_FIXSIZE here,
2384          * because the catlog record is usually fixed size, but its plain
2385          * log record can be variable
2386          */
2387         LLOG_F_EXT_MASK = LLOG_F_EXT_JOBID,
2388 };
2389
2390 /* On-disk header structure of each log object, stored in little endian order */
2391 #define LLOG_MIN_CHUNK_SIZE     8192
2392 #define LLOG_HEADER_SIZE        (96)    /* sizeof (llog_log_hdr) +
2393                                          * sizeof(llh_tail) - sizeof(llh_bitmap)
2394                                          */
2395 #define LLOG_BITMAP_BYTES       (LLOG_MIN_CHUNK_SIZE - LLOG_HEADER_SIZE)
2396 #define LLOG_MIN_REC_SIZE       (24)    /* round(llog_rec_hdr + llog_rec_tail) */
2397
2398 /* flags for the logs */
2399 struct llog_log_hdr {
2400         struct llog_rec_hdr     llh_hdr;
2401         __s64              llh_timestamp;
2402         __u32              llh_count;
2403         __u32              llh_bitmap_offset;
2404         __u32              llh_size;
2405         __u32              llh_flags;
2406         __u32              llh_cat_idx;
2407         /* for a catalog the first plain slot is next to it */
2408         struct obd_uuid  llh_tgtuuid;
2409         __u32              llh_reserved[LLOG_HEADER_SIZE / sizeof(__u32) - 23];
2410         /* These fields must always be at the end of the llog_log_hdr.
2411          * Note: llh_bitmap size is variable because llog chunk size could be
2412          * bigger than LLOG_MIN_CHUNK_SIZE, i.e. sizeof(llog_log_hdr) > 8192
2413          * bytes, and the real size is stored in llh_hdr.lrh_len, which means
2414          * llh_tail should only be referred by LLOG_HDR_TAIL().
2415          * But this structure is also used by client/server llog interface
2416          * (see llog_client.c), it will be kept in its original way to avoid
2417          * compatibility issue.
2418          */
2419         __u32              llh_bitmap[LLOG_BITMAP_BYTES / sizeof(__u32)];
2420         struct llog_rec_tail    llh_tail;
2421 } __packed;
2422
2423 #undef LLOG_HEADER_SIZE
2424 #undef LLOG_BITMAP_BYTES
2425
2426 #define LLOG_HDR_BITMAP_SIZE(llh) (__u32)((llh->llh_hdr.lrh_len -       \
2427                                            llh->llh_bitmap_offset -     \
2428                                            sizeof(llh->llh_tail)) * 8)
2429 #define LLOG_HDR_BITMAP(llh)    (__u32 *)((char *)(llh) +               \
2430                                           (llh)->llh_bitmap_offset)
2431 #define LLOG_HDR_TAIL(llh)      ((struct llog_rec_tail *)((char *)llh + \
2432                                                          llh->llh_hdr.lrh_len - \
2433                                                          sizeof(llh->llh_tail)))
2434
2435 /** log cookies are used to reference a specific log file and a record
2436  * therein
2437  */
2438 struct llog_cookie {
2439         struct llog_logid       lgc_lgl;
2440         __u32              lgc_subsys;
2441         __u32              lgc_index;
2442         __u32              lgc_padding;
2443 } __packed;
2444
2445 /** llog protocol */
2446 enum llogd_rpc_ops {
2447         LLOG_ORIGIN_HANDLE_CREATE       = 501,
2448         LLOG_ORIGIN_HANDLE_NEXT_BLOCK   = 502,
2449         LLOG_ORIGIN_HANDLE_READ_HEADER  = 503,
2450         LLOG_ORIGIN_HANDLE_WRITE_REC    = 504,
2451         LLOG_ORIGIN_HANDLE_CLOSE        = 505,
2452         LLOG_ORIGIN_CONNECT             = 506,
2453         LLOG_CATINFO                    = 507,  /* deprecated */
2454         LLOG_ORIGIN_HANDLE_PREV_BLOCK   = 508,
2455         LLOG_ORIGIN_HANDLE_DESTROY      = 509,  /* for destroy llog object*/
2456         LLOG_LAST_OPC,
2457         LLOG_FIRST_OPC            = LLOG_ORIGIN_HANDLE_CREATE
2458 };
2459
2460 struct llogd_body {
2461         struct llog_logid  lgd_logid;
2462         __u32 lgd_ctxt_idx;
2463         __u32 lgd_llh_flags;
2464         __u32 lgd_index;
2465         __u32 lgd_saved_index;
2466         __u32 lgd_len;
2467         __u64 lgd_cur_offset;
2468 } __packed;
2469
2470 struct llogd_conn_body {
2471         struct llog_gen  lgdc_gen;
2472         struct llog_logid       lgdc_logid;
2473         __u32              lgdc_ctxt_idx;
2474 } __packed;
2475
2476 /* Note: 64-bit types are 64-bit aligned in structure */
2477 struct obdo {
2478         __u64           o_valid;        /* hot fields in this obdo */
2479         struct ost_id   o_oi;
2480         __u64           o_parent_seq;
2481         __u64           o_size;  /* o_size-o_blocks == ost_lvb */
2482         __s64           o_mtime;
2483         __s64           o_atime;
2484         __s64           o_ctime;
2485         __u64           o_blocks;       /* brw: cli sent cached bytes */
2486         __u64           o_grant;
2487
2488         /* 32-bit fields start here: keep an even number of them via padding */
2489         __u32           o_blksize;      /* optimal IO blocksize */
2490         __u32           o_mode;  /* brw: cli sent cache remain */
2491         __u32           o_uid;
2492         __u32           o_gid;
2493         __u32           o_flags;
2494         __u32           o_nlink;        /* brw: checksum */
2495         __u32           o_parent_oid;
2496         __u32           o_misc;         /* brw: o_dropped */
2497
2498         __u64              o_ioepoch;      /* epoch in ost writes */
2499         __u32              o_stripe_idx;   /* holds stripe idx */
2500         __u32              o_parent_ver;
2501         struct lustre_handle    o_handle;  /* brw: lock handle to prolong locks
2502                                             */
2503         struct llog_cookie      o_lcookie; /* destroy: unlink cookie from MDS,
2504                                             * obsolete in 2.8, reused in OSP
2505                                             */
2506         __u32                   o_uid_h;
2507         __u32                   o_gid_h;
2508
2509         __u64                   o_data_version; /* getattr: sum of iversion for
2510                                                  * each stripe.
2511                                                  * brw: grant space consumed on
2512                                                  * the client for the write
2513                                                  */
2514         __u64                   o_padding_4;
2515         __u64                   o_padding_5;
2516         __u64                   o_padding_6;
2517 };
2518
2519 #define o_dirty   o_blocks
2520 #define o_undirty o_mode
2521 #define o_dropped o_misc
2522 #define o_cksum   o_nlink
2523 #define o_grant_used o_data_version
2524
2525 /* request structure for OST's */
2526 struct ost_body {
2527         struct  obdo oa;
2528 };
2529
2530 /* Key for FIEMAP to be used in get_info calls */
2531 struct ll_fiemap_info_key {
2532         char            lfik_name[8];
2533         struct obdo     lfik_oa;
2534         struct fiemap   lfik_fiemap;
2535 };
2536
2537 /* security opcodes */
2538 enum sec_cmd {
2539         SEC_CTX_INIT        = 801,
2540         SEC_CTX_INIT_CONT       = 802,
2541         SEC_CTX_FINI        = 803,
2542         SEC_LAST_OPC,
2543         SEC_FIRST_OPC      = SEC_CTX_INIT
2544 };
2545
2546 /*
2547  * capa related definitions
2548  */
2549 #define CAPA_HMAC_MAX_LEN       64
2550 #define CAPA_HMAC_KEY_MAX_LEN   56
2551
2552 /* NB take care when changing the sequence of elements this struct,
2553  * because the offset info is used in find_capa()
2554  */
2555 struct lustre_capa {
2556         struct lu_fid   lc_fid;  /** fid */
2557         __u64      lc_opc;       /** operations allowed */
2558         __u64      lc_uid;       /** file owner */
2559         __u64      lc_gid;       /** file group */
2560         __u32      lc_flags;       /** HMAC algorithm & flags */
2561         __u32      lc_keyid;       /** key# used for the capability */
2562         __u32      lc_timeout;     /** capa timeout value (sec) */
2563 /* FIXME: y2038 time_t overflow: */
2564         __u32      lc_expiry;      /** expiry time (sec) */
2565         __u8        lc_hmac[CAPA_HMAC_MAX_LEN];   /** HMAC */
2566 } __packed;
2567
2568 /** lustre_capa::lc_opc */
2569 enum {
2570         CAPA_OPC_BODY_WRITE   = 1 << 0,  /**< write object data */
2571         CAPA_OPC_BODY_READ    = 1 << 1,  /**< read object data */
2572         CAPA_OPC_INDEX_LOOKUP = 1 << 2,  /**< lookup object fid */
2573         CAPA_OPC_INDEX_INSERT = 1 << 3,  /**< insert object fid */
2574         CAPA_OPC_INDEX_DELETE = 1 << 4,  /**< delete object fid */
2575         CAPA_OPC_OSS_WRITE    = 1 << 5,  /**< write oss object data */
2576         CAPA_OPC_OSS_READ     = 1 << 6,  /**< read oss object data */
2577         CAPA_OPC_OSS_TRUNC    = 1 << 7,  /**< truncate oss object */
2578         CAPA_OPC_OSS_DESTROY  = 1 << 8,  /**< destroy oss object */
2579         CAPA_OPC_META_WRITE   = 1 << 9,  /**< write object meta data */
2580         CAPA_OPC_META_READ    = 1 << 10, /**< read object meta data */
2581 };
2582
2583 #define CAPA_OPC_OSS_RW (CAPA_OPC_OSS_READ | CAPA_OPC_OSS_WRITE)
2584 #define CAPA_OPC_MDS_ONLY                                                  \
2585         (CAPA_OPC_BODY_WRITE | CAPA_OPC_BODY_READ | CAPA_OPC_INDEX_LOOKUP | \
2586          CAPA_OPC_INDEX_INSERT | CAPA_OPC_INDEX_DELETE)
2587 #define CAPA_OPC_OSS_ONLY                                                  \
2588         (CAPA_OPC_OSS_WRITE | CAPA_OPC_OSS_READ | CAPA_OPC_OSS_TRUNC |      \
2589          CAPA_OPC_OSS_DESTROY)
2590 #define CAPA_OPC_MDS_DEFAULT ~CAPA_OPC_OSS_ONLY
2591 #define CAPA_OPC_OSS_DEFAULT ~(CAPA_OPC_MDS_ONLY | CAPA_OPC_OSS_ONLY)
2592
2593 struct lustre_capa_key {
2594         __u64   lk_seq;       /**< mds# */
2595         __u32   lk_keyid;     /**< key# */
2596         __u32   lk_padding;
2597         __u8    lk_key[CAPA_HMAC_KEY_MAX_LEN];    /**< key */
2598 } __packed;
2599
2600 /** The link ea holds 1 \a link_ea_entry for each hardlink */
2601 #define LINK_EA_MAGIC 0x11EAF1DFUL
2602 struct link_ea_header {
2603         __u32 leh_magic;
2604         __u32 leh_reccount;
2605         __u64 leh_len;      /* total size */
2606         __u32 leh_overflow_time;
2607         __u32 leh_padding;
2608 };
2609
2610 /** Hardlink data is name and parent fid.
2611  * Stored in this crazy struct for maximum packing and endian-neutrality
2612  */
2613 struct link_ea_entry {
2614         /** __u16 stored big-endian, unaligned */
2615         unsigned char      lee_reclen[2];
2616         unsigned char      lee_parent_fid[sizeof(struct lu_fid)];
2617         char           lee_name[0];
2618 } __packed;
2619
2620 /** fid2path request/reply structure */
2621 struct getinfo_fid2path {
2622         struct lu_fid   gf_fid;
2623         __u64      gf_recno;
2624         __u32      gf_linkno;
2625         __u32      gf_pathlen;
2626         char        gf_path[0];
2627 } __packed;
2628
2629 /** path2parent request/reply structures */
2630 struct getparent {
2631         struct lu_fid   gp_fid;         /**< parent FID */
2632         __u32           gp_linkno;      /**< hardlink number */
2633         __u32           gp_name_size;   /**< size of the name field */
2634         char            gp_name[0];     /**< zero-terminated link name */
2635 } __packed;
2636
2637 enum {
2638         LAYOUT_INTENT_ACCESS    = 0,
2639         LAYOUT_INTENT_READ      = 1,
2640         LAYOUT_INTENT_WRITE     = 2,
2641         LAYOUT_INTENT_GLIMPSE   = 3,
2642         LAYOUT_INTENT_TRUNC     = 4,
2643         LAYOUT_INTENT_RELEASE   = 5,
2644         LAYOUT_INTENT_RESTORE   = 6
2645 };
2646
2647 /* enqueue layout lock with intent */
2648 struct layout_intent {
2649         __u32 li_opc; /* intent operation for enqueue, read, write etc */
2650         __u32 li_flags;
2651         __u64 li_start;
2652         __u64 li_end;
2653 };
2654
2655 /**
2656  * On the wire version of hsm_progress structure.
2657  *
2658  * Contains the userspace hsm_progress and some internal fields.
2659  */
2660 struct hsm_progress_kernel {
2661         /* Field taken from struct hsm_progress */
2662         struct lu_fid           hpk_fid;
2663         __u64                   hpk_cookie;
2664         struct hsm_extent       hpk_extent;
2665         __u16                   hpk_flags;
2666         __u16                   hpk_errval; /* positive val */
2667         __u32                   hpk_padding1;
2668         /* Additional fields */
2669         __u64                   hpk_data_version;
2670         __u64                   hpk_padding2;
2671 } __packed;
2672
2673 /** layout swap request structure
2674  * fid1 and fid2 are in mdt_body
2675  */
2676 struct mdc_swap_layouts {
2677         __u64      msl_flags;
2678 } __packed;
2679
2680 struct close_data {
2681         struct lustre_handle    cd_handle;
2682         struct lu_fid           cd_fid;
2683         __u64                   cd_data_version;
2684         __u64                   cd_reserved[8];
2685 };
2686
2687 #endif
2688 /** @} lustreidl */