lustre/include/lustre/lustre_idl.h

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *   This file is part of Lustre, http://www.lustre.org
   5  *
   6  * Lustre wire protocol definitions.
   7  *
   8  * All structs passing over the wire should be declared here (lov_mds_md
   9  * being the lone exception).  Structs must be properly aligned to put
  10  * 64-bit values on an 8-byte boundary.  Any structs being added here
  11  * must also be added to utils/wirecheck.c and "make newwiretest" run
  12  * to regenerate the utils/wiretest.c sources.  This allows us to verify
  13  * that wire structs have the proper alignment/size on all architectures.
  14  *
  15  * We assume all nodes are either little-endian or big-endian, and we
  16  * always send messages in the sender's native format.  The receiver
  17  * detects the message format by checking the 'magic' field of the message
  18  * (see lustre_msg_swabbed() below).
  19  *
  20  * Each wire type has corresponding 'lustre_swab_xxxtypexxx()' routines,
  21  * implemented either here, inline (trivial implementations) or in
  22  * ptlrpc/pack_generic.c.  These 'swabbers' convert the type from "other"
  23  * endian, in-place in the message buffer.
  24  *
  25  * A swabber takes a single pointer argument.  The caller must already have
  26  * verified that the length of the message buffer >= sizeof (type).
  27  *
  28  * For variable length types, a second 'lustre_swab_v_xxxtypexxx()' routine
  29  * may be defined that swabs just the variable part, after the caller has
  30  * verified that the message buffer is large enough.
  31  */
  32
  33 #ifndef _LUSTRE_IDL_H_
  34 #define _LUSTRE_IDL_H_
  35
  36 #include <libcfs/kp30.h>
  37
  38 #if defined(__linux__)
  39 #include <linux/lustre_types.h>
  40 #elif defined(__APPLE__)
  41 #include <darwin/lustre_types.h>
  42 #elif defined(__WINNT__)
  43 #include <winnt/lustre_types.h>
  44 #else
  45 #error Unsupported operating system.
  46 #endif
  47
  48 #include <lnet/types.h>   /* for lnet_nid_t */
  49
  50 /*
  51  * CLASSERT()
  52  */
  53 #include <libcfs/kp30.h>
  54
  55 /* Defn's shared with user-space. */
  56 #include <lustre/lustre_user.h>
  57
  58 /*
  59  * this file contains all data structures used in Lustre interfaces:
  60  * - obdo and obd_request records
  61  * - mds_request records
  62  * - ldlm data
  63  * - ioctl's
  64  */
  65
  66 /*
  67  *  GENERAL STUFF
  68  */
  69 /* FOO_REQUEST_PORTAL is for incoming requests on the FOO
  70  * FOO_REPLY_PORTAL   is for incoming replies on the FOO
  71  * FOO_BULK_PORTAL    is for incoming bulk on the FOO
  72  */
  73
  74 #define CONNMGR_REQUEST_PORTAL          1
  75 #define CONNMGR_REPLY_PORTAL            2
  76 //#define OSC_REQUEST_PORTAL            3
  77 #define OSC_REPLY_PORTAL                4
  78 //#define OSC_BULK_PORTAL               5
  79 #define OST_IO_PORTAL                   6
  80 #define OST_CREATE_PORTAL               7
  81 #define OST_BULK_PORTAL                 8
  82 //#define MDC_REQUEST_PORTAL            9
  83 #define MDC_REPLY_PORTAL               10
  84 //#define MDC_BULK_PORTAL              11
  85 #define MDS_REQUEST_PORTAL             12
  86 //#define MDS_REPLY_PORTAL             13
  87 #define MDS_BULK_PORTAL                14
  88 #define LDLM_CB_REQUEST_PORTAL         15
  89 #define LDLM_CB_REPLY_PORTAL           16
  90 #define LDLM_CANCEL_REQUEST_PORTAL     17
  91 #define LDLM_CANCEL_REPLY_PORTAL       18
  92 //#define PTLBD_REQUEST_PORTAL           19
  93 //#define PTLBD_REPLY_PORTAL             20
  94 //#define PTLBD_BULK_PORTAL              21
  95 #define MDS_SETATTR_PORTAL             22
  96 #define MDS_READPAGE_PORTAL            23
  97
  98 #define MGC_REPLY_PORTAL               25
  99 #define MGS_REQUEST_PORTAL             26
 100 #define MGS_REPLY_PORTAL               27
 101 #define OST_REQUEST_PORTAL             28
 102 #define FLD_REQUEST_PORTAL             29
 103 #define SEQ_METADATA_PORTAL            30
 104 #define SEQ_DATA_PORTAL                31
 105 #define SEQ_CONTROLLER_PORTAL          32
 106
 107 #define SVC_KILLED               1
 108 #define SVC_EVENT                2
 109 #define SVC_SIGNAL               4
 110 #define SVC_RUNNING              8
 111 #define SVC_STOPPING            16
 112 #define SVC_STOPPED             32
 113
 114 /* packet types */
 115 #define PTL_RPC_MSG_REQUEST 4711
 116 #define PTL_RPC_MSG_ERR     4712
 117 #define PTL_RPC_MSG_REPLY   4713
 118
 119 /* DON'T use swabbed values of MAGIC as magic! */
 120 #define LUSTRE_MSG_MAGIC_V1 0x0BD00BD0
 121 #define LUSTRE_MSG_MAGIC_V2 0x0BD00BD2
 122
 123 #define LUSTRE_MSG_MAGIC_V1_SWABBED 0xD00BD00B
 124 #define LUSTRE_MSG_MAGIC_V2_SWABBED 0xD20BD00B
 125
 126 #define LUSTRE_MSG_MAGIC LUSTRE_MSG_MAGIC_V2
 127
 128 #define PTLRPC_MSG_VERSION  0x00000003
 129 #define LUSTRE_VERSION_MASK 0xffff0000
 130 #define LUSTRE_OBD_VERSION  0x00010000
 131 #define LUSTRE_MDS_VERSION  0x00020000
 132 #define LUSTRE_OST_VERSION  0x00030000
 133 #define LUSTRE_DLM_VERSION  0x00040000
 134 #define LUSTRE_LOG_VERSION  0x00050000
 135 #define LUSTRE_MGS_VERSION  0x00060000
 136
 137 typedef __u64 mdsno_t;
 138 typedef __u64 seqno_t;
 139
 140 struct lu_range {
 141         __u64 lr_start;
 142         __u64 lr_end;
 143 };
 144
 145 static inline __u64 range_space(struct lu_range *r)
 146 {
 147         return r->lr_end - r->lr_start;
 148 }
 149
 150 static inline void range_zero(struct lu_range *r)
 151 {
 152         r->lr_start = r->lr_end = 0;
 153 }
 154
 155 static inline int range_within(struct lu_range *r,
 156                                __u64 s)
 157 {
 158         return s >= r->lr_start && s < r->lr_end;
 159 }
 160
 161 static inline void range_alloc(struct lu_range *r,
 162                                struct lu_range *s,
 163                                __u64 w)
 164 {
 165         r->lr_start = s->lr_start;
 166         r->lr_end = s->lr_start + w;
 167         s->lr_start += w;
 168 }
 169
 170 static inline int range_is_sane(struct lu_range *r)
 171 {
 172         return (r->lr_end >= r->lr_start);
 173 }
 174
 175 static inline int range_is_zero(struct lu_range *r)
 176 {
 177         return (r->lr_start == 0 && r->lr_end == 0);
 178 }
 179
 180 static inline int range_is_exhausted(struct lu_range *r)
 181 {
 182         return range_space(r) == 0;
 183 }
 184
 185 #define DRANGE "["LPX64"-"LPX64"]"
 186
 187 #define PRANGE(range)      \
 188         (range)->lr_start, \
 189         (range)->lr_end
 190
 191 struct lu_fid {
 192         __u64 f_seq;  /* holds fid sequence. Lustre should support 2 ^ 64
 193                        * objects, thus even if one sequence has one object we
 194                        * reach this value. */
 195         __u32 f_oid;  /* fid number within its sequence. */
 196         __u32 f_ver;  /* holds fid version. */
 197 };
 198
 199 /*
 200  * fid constants
 201  */
 202 enum {
 203         LUSTRE_ROOT_FID_SEQ  = 1ULL, /* XXX: should go into mkfs. */
 204         LUSTRE_ROOT_FID_OID  = 2UL,  /* XXX: should go into mkfs. */
 205
 206         /* initial fid id value */
 207         LUSTRE_FID_INIT_OID  = 1UL
 208 };
 209
 210 /* get object sequence */
 211 static inline __u64 fid_seq(const struct lu_fid *fid)
 212 {
 213         return fid->f_seq;
 214 }
 215
 216 /* get object id */
 217 static inline __u32 fid_oid(const struct lu_fid *fid)
 218 {
 219         return fid->f_oid;
 220 }
 221
 222 /* get object version */
 223 static inline __u32 fid_ver(const struct lu_fid *fid)
 224 {
 225         return fid->f_ver;
 226 }
 227
 228 static inline int fid_seq_is_sane(__u64 seq)
 229 {
 230         return seq != 0;
 231 }
 232
 233 static inline void fid_zero(struct lu_fid *fid)
 234 {
 235         memset(fid, 0, sizeof(*fid));
 236 }
 237
 238 static inline int fid_is_sane(const struct lu_fid *fid)
 239 {
 240         return
 241                 fid != NULL &&
 242                 fid_seq_is_sane(fid_seq(fid)) && fid_oid(fid) != 0;
 243 }
 244
 245 #define DFID "[%16.16"LPF64"x/%8.8x:%8.8x]"
 246
 247 #define PFID(fid)     \
 248         fid_seq(fid), \
 249         fid_oid(fid), \
 250         fid_ver(fid)
 251
 252 extern void lustre_swab_lu_fid(struct lu_fid *fid);
 253 extern void lustre_swab_lu_range(struct lu_range *range);
 254
 255 static inline int lu_fid_eq(const struct lu_fid *f0,
 256                             const struct lu_fid *f1)
 257 {
 258         /* check that there is no alignment padding */
 259         CLASSERT(sizeof *f0 ==
 260                  sizeof f0->f_seq + sizeof f0->f_oid + sizeof f0->f_ver);
 261         return memcmp(f0, f1, sizeof *f0) == 0;
 262 }
 263
 264 /*
 265  * Layout of readdir pages, as transmitted on wire.
 266  */
 267 struct lu_dirent {
 268         struct lu_fid lde_fid;
 269         __u32         lde_hash;
 270         __u16         lde_reclen;
 271         __u16         lde_namelen;
 272         char          lde_name[0];
 273 };
 274
 275 struct lu_dirpage {
 276         __u32            ldp_hash_start;
 277         __u32            ldp_hash_end;
 278         __u16            ldp_pad0;
 279         __u32            ldp_pad1;
 280         struct lu_dirent ldp_entries[0];
 281 };
 282
 283 static inline struct lu_dirent *lu_dirent_start(struct lu_dirpage *dp)
 284 {
 285         return dp->ldp_entries;
 286 }
 287
 288 static inline struct lu_dirent *lu_dirent_next(struct lu_dirent *ent)
 289 {
 290         struct lu_dirent *next;
 291
 292         if (ent->lde_reclen != 0)
 293                 next = ((void *)ent) + le16_to_cpu(ent->lde_reclen);
 294         else
 295                 next = NULL;
 296         return next;
 297 }
 298
 299 #define MEA_MAGIC_LAST_CHAR      0xb2221ca1
 300 #define MEA_MAGIC_ALL_CHARS      0xb222a11c
 301 #define MEA_MAGIC_HASH_SEGMENT   0xb222a11b
 302 #define MAX_HASH_SIZE            0x7fffffff
 303
 304 /* TODO: lmv_stripe_md should contain mds capabilities for all slave fids */
 305 struct lmv_stripe_md {
 306         __u32         mea_magic;
 307         __u32         mea_count;
 308         __u32         mea_master;
 309         struct lu_fid mea_ids[0];
 310 };
 311
 312 struct lustre_handle {
 313         __u64 cookie;
 314 };
 315 #define DEAD_HANDLE_MAGIC 0xdeadbeefcafebabeULL
 316
 317 static inline int lustre_handle_is_used(struct lustre_handle *lh)
 318 {
 319         return lh->cookie != 0ull;
 320 }
 321
 322 static inline int lustre_handle_equal(struct lustre_handle *lh1,
 323                                       struct lustre_handle *lh2)
 324 {
 325         return lh1->cookie == lh2->cookie;
 326 }
 327
 328 static inline void lustre_handle_copy(struct lustre_handle *tgt,
 329                                       struct lustre_handle *src)
 330 {
 331         tgt->cookie = src->cookie;
 332 }
 333
 334 /* we depend on this structure to be 8-byte aligned */
 335 /* this type is only endian-adjusted in lustre_unpack_msg() */
 336 struct lustre_msg_v1 {
 337         struct lustre_handle lm_handle;
 338         __u32 lm_magic;
 339         __u32 lm_type;
 340         __u32 lm_version;
 341         __u32 lm_opc;
 342         __u64 lm_last_xid;
 343         __u64 lm_last_committed;
 344         __u64 lm_transno;
 345         __u32 lm_status;
 346         __u32 lm_flags;
 347         __u32 lm_conn_cnt;
 348         __u32 lm_bufcount;
 349         __u32 lm_buflens[0];
 350 };
 351
 352 #define lustre_msg lustre_msg_v2
 353 /* we depend on this structure to be 8-byte aligned */
 354 /* this type is only endian-adjusted in lustre_unpack_msg() */
 355 struct lustre_msg_v2 {
 356         __u32 lm_bufcount;
 357         __u32 lm_secflvr;
 358         __u32 lm_magic;
 359         __u32 lm_repsize;
 360         __u32 lm_buflens[0];
 361 };
 362
 363 /* without gss, ptlrpc_body is put at the first buffer. */
 364 struct ptlrpc_body {
 365         struct lustre_handle pb_handle;
 366         __u32 pb_type;
 367         __u32 pb_version;
 368         __u32 pb_opc;
 369         __u32 pb_status;
 370         __u64 pb_last_xid;
 371         __u64 pb_last_committed;
 372         __u64 pb_transno;
 373         __u32 pb_flags;
 374         __u32 pb_op_flags;
 375         __u32 pb_conn_cnt;
 376         __u32 pb_paddings[3];
 377 };
 378
 379 extern void lustre_swab_ptlrpc_body(struct ptlrpc_body *pb);
 380
 381 /* message body offset for lustre_msg_v2 */
 382 /* ptlrpc body offset in all request/reply messages */
 383 #define MSG_PTLRPC_BODY_OFF             0
 384
 385 /* normal request/reply message record offset */
 386 #define REQ_REC_OFF                     1
 387 #define REPLY_REC_OFF                   1
 388
 389 /* ldlm request message body offset */
 390 #define DLM_LOCKREQ_OFF                 1 /* lockreq offset */
 391 #define DLM_REQ_REC_OFF                 2 /* normal dlm request record offset */
 392
 393 /* ldlm intent lock message body offset */
 394 #define DLM_INTENT_IT_OFF               2 /* intent lock it offset */
 395 #define DLM_INTENT_REC_OFF              3 /* intent lock record offset */
 396
 397 /* ldlm reply message body offset */
 398 #define DLM_LOCKREPLY_OFF               1 /* lockrep offset */
 399 #define DLM_REPLY_REC_OFF               2 /* reply record offset */
 400
 401 /* Flags that are operation-specific go in the top 16 bits. */
 402 #define MSG_OP_FLAG_MASK   0xffff0000
 403 #define MSG_OP_FLAG_SHIFT  16
 404
 405 /* Flags that apply to all requests are in the bottom 16 bits */
 406 #define MSG_GEN_FLAG_MASK      0x0000ffff
 407 #define MSG_LAST_REPLAY        1
 408 #define MSG_RESENT             2
 409 #define MSG_REPLAY             4
 410
 411 /*
 412  * Flags for all connect opcodes (MDS_CONNECT, OST_CONNECT)
 413  */
 414
 415 #define MSG_CONNECT_RECOVERING  0x1
 416 #define MSG_CONNECT_RECONNECT   0x2
 417 #define MSG_CONNECT_REPLAYABLE  0x4
 418 //#define MSG_CONNECT_PEER        0x8
 419 #define MSG_CONNECT_LIBCLIENT   0x10
 420 #define MSG_CONNECT_INITIAL     0x20
 421 #define MSG_CONNECT_ASYNC       0x40
 422 #define MSG_CONNECT_NEXT_VER    0x80 /* use next version of lustre_msg */
 423
 424 /* Connect flags */
 425 #define OBD_CONNECT_RDONLY         0x1ULL /* client allowed read-only access */
 426 #define OBD_CONNECT_INDEX          0x2ULL /* connect to specific LOV idx */
 427 #define OBD_CONNECT_GRANT          0x8ULL /* OSC acquires grant at connect */
 428 #define OBD_CONNECT_SRVLOCK       0x10ULL /* server takes locks for client */
 429 #define OBD_CONNECT_VERSION       0x20ULL /* Server supports versions in ocd */
 430 #define OBD_CONNECT_REQPORTAL     0x40ULL /* Separate portal for non-IO reqs */
 431 #define OBD_CONNECT_ACL           0x80ULL /* client uses access control lists */
 432 #define OBD_CONNECT_XATTR        0x100ULL /* client using extended attributes*/
 433 #define OBD_CONNECT_CROW         0x200ULL /* MDS+OST create objects on write */
 434 #define OBD_CONNECT_TRUNCLOCK    0x400ULL /* locks on server for punch b=9528 */
 435 #define OBD_CONNECT_TRANSNO      0x800ULL /* replay sends initial transno */
 436 #define OBD_CONNECT_IBITS       0x1000ULL /* support for inodebits locks */
 437 #define OBD_CONNECT_JOIN        0x2000ULL /* files can be concatenated */
 438 #define OBD_CONNECT_REAL        0x4000ULL
 439 #define OBD_CONNECT_ATTRFID     0x8000ULL /* Server supports GetAttr By Fid */
 440 #define OBD_CONNECT_NODEVOH     0x10000ULL /* No open handle for special nodes */
 441 #define OBD_CONNECT_LCL_CLIENT  0x20000ULL /* local 1.8 client */
 442 #define OBD_CONNECT_RMT_CLIENT  0x40000ULL /* Remote 1.8 client */
 443 #define OBD_CONNECT_BRW_SIZE    0x80000ULL /* Max bytes per rpc */
 444 #define OBD_CONNECT_QUOTA64     0x100000ULL /* 64bit qunit_data.qd_count b=10707*/
 445 #define OBD_CONNECT_MDS_CAPA    0x200000ULL /* MDS capability */
 446 #define OBD_CONNECT_OSS_CAPA    0x400000ULL /* OSS capability */
 447 /* also update obd_connect_names[] for lprocfs_rd_connect_flags()
 448  * and lustre/utils/wirecheck.c */
 449
 450 #define MDT_CONNECT_SUPPORTED  (OBD_CONNECT_RDONLY | OBD_CONNECT_VERSION | \
 451                                 OBD_CONNECT_ACL | OBD_CONNECT_XATTR | \
 452                                 OBD_CONNECT_IBITS | OBD_CONNECT_JOIN | \
 453                                 OBD_CONNECT_NODEVOH | OBD_CONNECT_ATTRFID | \
 454                                 OBD_CONNECT_LCL_CLIENT | OBD_CONNECT_RMT_CLIENT)
 455 #define OST_CONNECT_SUPPORTED  (OBD_CONNECT_SRVLOCK | OBD_CONNECT_GRANT | \
 456                                 OBD_CONNECT_REQPORTAL | OBD_CONNECT_VERSION | \
 457                                 OBD_CONNECT_TRUNCLOCK | OBD_CONNECT_INDEX | \
 458                                 OBD_CONNECT_BRW_SIZE | OBD_CONNECT_QUOTA64)
 459 #define ECHO_CONNECT_SUPPORTED (0)
 460 #define MGS_CONNECT_SUPPORTED  (OBD_CONNECT_VERSION)
 461
 462 #define MAX_QUOTA_COUNT32 ((0xffffffffULL >> QUOTABLOCK_BITS) << QUOTABLOCK_BITS)
 463
 464 #define OBD_OCD_VERSION(major,minor,patch,fix) (((major)<<24) + ((minor)<<16) +\
 465                                                 ((patch)<<8) + (fix))
 466 #define OBD_OCD_VERSION_MAJOR(version) ((int)((version)>>24)&255)
 467 #define OBD_OCD_VERSION_MINOR(version) ((int)((version)>>16)&255)
 468 #define OBD_OCD_VERSION_PATCH(version) ((int)((version)>>8)&255)
 469 #define OBD_OCD_VERSION_FIX(version)   ((int)(version)&255)
 470
 471 /* This structure is used for both request and reply.
 472  *
 473  * If we eventually have separate connect data for different types, which we
 474  * almost certainly will, then perhaps we stick a union in here. */
 475 struct obd_connect_data {
 476         __u64 ocd_connect_flags;        /* OBD_CONNECT_* per above */
 477         __u32 ocd_version;              /* lustre release version number */
 478         __u32 ocd_grant;                /* initial cache grant amount (bytes) */
 479         __u32 ocd_index;                /* LOV index to connect to */
 480         __u32 ocd_brw_size;             /* Maximum BRW size in bytes */
 481         __u64 ocd_ibits_known;          /* inode bits this client understands */
 482         __u32 ocd_nllu;                 /* non-local-lustre-user */
 483         __u32 ocd_nllg;                 /* non-local-lustre-group */
 484         __u32 ocd_group;                /* MDS group on OST */
 485         __u32 padding1;                 /* also fix lustre_swab_connect */
 486         __u64 padding2;                 /* also fix lustre_swab_connect */
 487         __u64 padding3;                 /* also fix lustre_swab_connect */
 488         __u64 padding4;                 /* also fix lustre_swab_connect */
 489 };
 490
 491 extern void lustre_swab_connect(struct obd_connect_data *ocd);
 492
 493 /*
 494  *   OST requests: OBDO & OBD request records
 495  */
 496
 497 /* opcodes */
 498 typedef enum {
 499         OST_REPLY      =  0,       /* reply ? */
 500         OST_GETATTR    =  1,
 501         OST_SETATTR    =  2,
 502         OST_READ       =  3,
 503         OST_WRITE      =  4,
 504         OST_CREATE     =  5,
 505         OST_DESTROY    =  6,
 506         OST_GET_INFO   =  7,
 507         OST_CONNECT    =  8,
 508         OST_DISCONNECT =  9,
 509         OST_PUNCH      = 10,
 510         OST_OPEN       = 11,
 511         OST_CLOSE      = 12,
 512         OST_STATFS     = 13,
 513 /*      OST_SAN_READ   = 14,    deprecated */
 514 /*      OST_SAN_WRITE  = 15,    deprecated */
 515         OST_SYNC       = 16,
 516         OST_SET_INFO   = 17,
 517         OST_QUOTACHECK = 18,
 518         OST_QUOTACTL   = 19,
 519         OST_LAST_OPC
 520 } ost_cmd_t;
 521 #define OST_FIRST_OPC  OST_REPLY
 522
 523 typedef uint64_t        obd_id;
 524 typedef uint64_t        obd_gr;
 525 typedef uint64_t        obd_time;
 526 typedef uint64_t        obd_size;
 527 typedef uint64_t        obd_off;
 528 typedef uint64_t        obd_blocks;
 529 typedef uint32_t        obd_blksize;
 530 typedef uint32_t        obd_mode;
 531 typedef uint32_t        obd_uid;
 532 typedef uint32_t        obd_gid;
 533 typedef uint32_t        obd_flag;
 534 typedef uint64_t        obd_valid;
 535 typedef uint32_t        obd_count;
 536
 537 #define OBD_FL_INLINEDATA    (0x00000001)
 538 #define OBD_FL_OBDMDEXISTS   (0x00000002)
 539 #define OBD_FL_DELORPHAN     (0x00000004) /* if set in o_flags delete orphans */
 540 #define OBD_FL_NORPC         (0x00000008) /* set in o_flags do in OSC not OST */
 541 #define OBD_FL_IDONLY        (0x00000010) /* set in o_flags only adjust obj id*/
 542 #define OBD_FL_RECREATE_OBJS (0x00000020) /* recreate missing obj */
 543 #define OBD_FL_DEBUG_CHECK   (0x00000040) /* echo client/server debug check */
 544 #define OBD_FL_NO_USRQUOTA   (0x00000100) /* the object's owner is over quota */
 545 #define OBD_FL_NO_GRPQUOTA   (0x00000200) /* the object's group is over quota */
 546 #define OBD_FL_CREATE_CROW   (0x00000400) /* object should be create on write */
 547
 548 /*
 549  * set this to delegate DLM locking during obd_punch() to the OSTs. Only OSTs
 550  * that declared OBD_CONNECT_TRUNCLOCK in their connect flags support this
 551  * functionality.
 552  */
 553 #define OBD_FL_TRUNCLOCK     (0x00000800)
 554
 555 /* this should be not smaller than sizeof(struct lustre_handle) + sizeof(struct
 556  * llog_cookie) + sizeof(ll_fid). Nevertheless struct ll_fid is not longer
 557  * stored in o_inline, we keep this just for case. */
 558 #define OBD_INLINESZ    80
 559
 560 /* Note: 64-bit types are 64-bit aligned in structure */
 561 struct obdo {
 562         obd_valid               o_valid;        /* hot fields in this obdo */
 563         obd_id                  o_id;
 564         obd_gr                  o_gr;
 565         obd_id                  o_fid;
 566         obd_size                o_size;         /* o_size-o_blocks == ost_lvb */
 567         obd_time                o_mtime;
 568         obd_time                o_atime;
 569         obd_time                o_ctime;
 570         obd_blocks              o_blocks;       /* brw: cli sent cached bytes */
 571         obd_size                o_grant;
 572
 573         /* 32-bit fields start here: keep an even number of them via padding */
 574         obd_blksize             o_blksize;      /* optimal IO blocksize */
 575         obd_mode                o_mode;         /* brw: cli sent cache remain */
 576         obd_uid                 o_uid;
 577         obd_gid                 o_gid;
 578         obd_flag                o_flags;
 579         obd_count               o_nlink;        /* brw: checksum */
 580         obd_count               o_generation;
 581         obd_count               o_misc;         /* brw: o_dropped */
 582         __u32                   o_easize;       /* epoch in ost writes */
 583         __u32                   o_mds;
 584         __u32                   o_stripe_idx;   /* holds stripe idx */
 585         __u32                   o_padding_1;
 586         char                    o_inline[OBD_INLINESZ];
 587                                 /* lustre_handle + llog_cookie */
 588 };
 589
 590 #define o_dirty   o_blocks
 591 #define o_undirty o_mode
 592 #define o_dropped o_misc
 593 #define o_cksum   o_nlink
 594
 595 extern void lustre_swab_obdo (struct obdo *o);
 596
 597 struct md_op_data {
 598         struct lu_fid         fid1;
 599         struct lu_fid         fid2;
 600         struct lustre_handle  handle;
 601         __u64                 mod_time;
 602         const char           *name;
 603         int                   namelen;
 604         __u32                 create_mode;
 605         struct lmv_stripe_md *mea1;
 606         struct lmv_stripe_md *mea2;
 607         __u32                 suppgids[2];
 608         __u32                 fsuid;
 609         __u32                 fsgid;
 610         __u32                 cap;
 611
 612         /* iattr fields and blocks. */
 613         struct iattr          attr;
 614 #ifdef __KERNEL__
 615 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14)
 616         unsigned int          attr_flags;
 617 #endif
 618 #endif
 619         loff_t                attr_blocks;
 620
 621         /* Size-on-MDS epoch and flags. */
 622         __u64                 ioepoch;
 623         __u32                 flags;
 624
 625         struct obd_capa      *mod_capa1;
 626         struct obd_capa      *mod_capa2;
 627 };
 628
 629 #define MDS_MODE_DONT_LOCK (1 << 30)
 630 #define MDS_MODE_REPLAY    (1 << 31)
 631
 632 #define LOV_MAGIC_V1      0x0BD10BD0
 633 #define LOV_MAGIC         LOV_MAGIC_V1
 634 #define LOV_MAGIC_JOIN    0x0BD20BD0
 635
 636 #define LOV_PATTERN_RAID0 0x001   /* stripes are used round-robin */
 637 #define LOV_PATTERN_RAID1 0x002   /* stripes are mirrors of each other */
 638 #define LOV_PATTERN_FIRST 0x100   /* first stripe is not in round-robin */
 639 #define LOV_PATTERN_CMOBD 0x200
 640
 641 #define lov_ost_data lov_ost_data_v1
 642 struct lov_ost_data_v1 {          /* per-stripe data structure (little-endian)*/
 643         __u64 l_object_id;        /* OST object ID */
 644         __u64 l_object_gr;        /* OST object group (creating MDS number) */
 645         __u32 l_ost_gen;          /* generation of this l_ost_idx */
 646         __u32 l_ost_idx;          /* OST index in LOV (lov_tgt_desc->tgts) */
 647 };
 648
 649 #define lov_mds_md lov_mds_md_v1
 650 struct lov_mds_md_v1 {            /* LOV EA mds/wire data (little-endian) */
 651         __u32 lmm_magic;          /* magic number = LOV_MAGIC_V1 */
 652         __u32 lmm_pattern;        /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */
 653         __u64 lmm_object_id;      /* LOV object ID */
 654         __u64 lmm_object_gr;      /* LOV object group */
 655         __u32 lmm_stripe_size;    /* size of stripe in bytes */
 656         __u32 lmm_stripe_count;   /* num stripes in use for this object */
 657         struct lov_ost_data_v1 lmm_objects[0]; /* per-stripe data */
 658 };
 659
 660 #define MAX_MD_SIZE (sizeof(struct lov_mds_md) + 4 * sizeof(struct lov_ost_data))
 661 #define MIN_MD_SIZE (sizeof(struct lov_mds_md) + 1 * sizeof(struct lov_ost_data))
 662
 663 #define XATTR_NAME_ACL_ACCESS   "system.posix_acl_access"
 664 #define XATTR_NAME_LOV          "trusted.lov"
 665
 666 /* remote ACL */
 667 #define XATTR_NAME_LUSTRE_ACL   "system.lustre_acl"
 668
 669 #define OBD_MD_FLID        (0x00000001ULL) /* object ID */
 670 #define OBD_MD_FLATIME     (0x00000002ULL) /* access time */
 671 #define OBD_MD_FLMTIME     (0x00000004ULL) /* data modification time */
 672 #define OBD_MD_FLCTIME     (0x00000008ULL) /* change time */
 673 #define OBD_MD_FLSIZE      (0x00000010ULL) /* size */
 674 #define OBD_MD_FLBLOCKS    (0x00000020ULL) /* allocated blocks count */
 675 #define OBD_MD_FLBLKSZ     (0x00000040ULL) /* block size */
 676 #define OBD_MD_FLMODE      (0x00000080ULL) /* access bits (mode & ~S_IFMT) */
 677 #define OBD_MD_FLTYPE      (0x00000100ULL) /* object type (mode & S_IFMT) */
 678 #define OBD_MD_FLUID       (0x00000200ULL) /* user ID */
 679 #define OBD_MD_FLGID       (0x00000400ULL) /* group ID */
 680 #define OBD_MD_FLFLAGS     (0x00000800ULL) /* flags word */
 681 #define OBD_MD_FLNLINK     (0x00002000ULL) /* link count */
 682 #define OBD_MD_FLGENER     (0x00004000ULL) /* generation number */
 683 #define OBD_MD_FLINLINE    (0x00008000ULL) /* inline data */
 684 #define OBD_MD_FLRDEV      (0x00010000ULL) /* device number */
 685 #define OBD_MD_FLEASIZE    (0x00020000ULL) /* extended attribute data */
 686 #define OBD_MD_LINKNAME    (0x00040000ULL) /* symbolic link target */
 687 #define OBD_MD_FLHANDLE    (0x00080000ULL) /* file handle */
 688 #define OBD_MD_FLCKSUM     (0x00100000ULL) /* bulk data checksum */
 689 #define OBD_MD_FLQOS       (0x00200000ULL) /* quality of service stats */
 690 #define OBD_MD_FLOSCOPQ    (0x00400000ULL) /* osc opaque data */
 691 #define OBD_MD_FLCOOKIE    (0x00800000ULL) /* log cancellation cookie */
 692 #define OBD_MD_FLGROUP     (0x01000000ULL) /* group */
 693 #define OBD_MD_FLFID       (0x02000000ULL) /* ->ost write inline fid */
 694 #define OBD_MD_FLEPOCH     (0x04000000ULL) /* ->ost write easize is epoch */
 695                                            /* ->mds if epoch opens or closes */
 696 #define OBD_MD_FLGRANT     (0x08000000ULL) /* ost preallocation space grant */
 697 #define OBD_MD_FLDIREA     (0x10000000ULL) /* dir's extended attribute data */
 698 #define OBD_MD_FLUSRQUOTA  (0x20000000ULL) /* over quota flags sent from ost */
 699 #define OBD_MD_FLGRPQUOTA  (0x40000000ULL) /* over quota flags sent from ost */
 700 #define OBD_MD_FLMODEASIZE (0x80000000ULL) /* EA size will be changed */
 701
 702 #define OBD_MD_MDS         (0x0000000100000000ULL) /* where an inode lives on */
 703 #define OBD_MD_REINT       (0x0000000200000000ULL) /* reintegrate oa */
 704 #define OBD_MD_MEA         (0x0000000400000000ULL) /* CMD EA  */
 705
 706 #define OBD_MD_FLXATTR     (0x0000001000000000ULL) /* xattr */
 707 #define OBD_MD_FLXATTRLS   (0x0000002000000000ULL) /* xattr list */
 708 #define OBD_MD_FLXATTRRM   (0x0000004000000000ULL) /* xattr remove */
 709 #define OBD_MD_FLACL       (0x0000008000000000ULL) /* ACL */
 710 #define OBD_MD_FLRMTPERM   (0x0000010000000000ULL) /* remote permission */
 711 #define OBD_MD_FLMDSCAPA   (0x0000020000000000ULL) /* MDS capability */
 712 #define OBD_MD_FLOSSCAPA   (0x0000040000000000ULL) /* OSS capability */
 713
 714 #define OBD_MD_FLGETATTR (OBD_MD_FLID    | OBD_MD_FLATIME | OBD_MD_FLMTIME | \
 715                           OBD_MD_FLCTIME | OBD_MD_FLSIZE  | OBD_MD_FLBLKSZ | \
 716                           OBD_MD_FLMODE  | OBD_MD_FLTYPE  | OBD_MD_FLUID   | \
 717                           OBD_MD_FLGID   | OBD_MD_FLFLAGS | OBD_MD_FLNLINK | \
 718                           OBD_MD_FLGENER | OBD_MD_FLRDEV  | OBD_MD_FLGROUP)
 719
 720 static inline struct lustre_handle *obdo_handle(struct obdo *oa)
 721 {
 722         return (struct lustre_handle *)oa->o_inline;
 723 }
 724
 725 static inline struct llog_cookie *obdo_logcookie(struct obdo *oa)
 726 {
 727         return (struct llog_cookie *)(oa->o_inline +
 728                                       sizeof(struct lustre_handle));
 729 }
 730 /* don't forget obdo_fid which is way down at the bottom so it can
 731  * come after the definition of llog_cookie */
 732
 733 struct obd_statfs {
 734         __u64           os_type;
 735         __u64           os_blocks;
 736         __u64           os_bfree;
 737         __u64           os_bavail;
 738         __u64           os_files;
 739         __u64           os_ffree;
 740         __u8            os_fsid[40];
 741         __u32           os_bsize;
 742         __u32           os_namelen;
 743         __u64           os_maxbytes;
 744         __u32           os_state;       /* positive error code on server */
 745         __u32           os_spare1;
 746         __u32           os_spare2;
 747         __u32           os_spare3;
 748         __u32           os_spare4;
 749         __u32           os_spare5;
 750         __u32           os_spare6;
 751         __u32           os_spare7;
 752         __u32           os_spare8;
 753         __u32           os_spare9;
 754 };
 755
 756 extern void lustre_swab_obd_statfs (struct obd_statfs *os);
 757
 758 /* ost_body.data values for OST_BRW */
 759
 760 #define OBD_BRW_READ            0x01
 761 #define OBD_BRW_WRITE           0x02
 762 #define OBD_BRW_RWMASK          (OBD_BRW_READ | OBD_BRW_WRITE)
 763 #define OBD_BRW_SYNC            0x08
 764 #define OBD_BRW_CHECK           0x10
 765 #define OBD_BRW_FROM_GRANT      0x20 /* the osc manages this under llite */
 766 #define OBD_BRW_GRANTED         0x40 /* the ost manages this */
 767 #define OBD_BRW_DROP            0x80 /* drop the page after IO */
 768 #define OBD_BRW_NOQUOTA        0x100
 769 #define OBD_BRW_SRVLOCK        0x200 /* Client holds no lock over this page */
 770
 771 #define OBD_OBJECT_EOF 0xffffffffffffffffULL
 772
 773 #define OST_MIN_PRECREATE 32
 774 #define OST_MAX_PRECREATE 20000
 775
 776 struct obd_ioobj {
 777         obd_id               ioo_id;
 778         obd_gr               ioo_gr;
 779         __u32                ioo_type;
 780         __u32                ioo_bufcnt;
 781 };
 782
 783 extern void lustre_swab_obd_ioobj (struct obd_ioobj *ioo);
 784
 785 /* multiple of 8 bytes => can array */
 786 struct niobuf_remote {
 787         __u64 offset;
 788         __u32 len;
 789         __u32 flags;
 790 };
 791
 792 extern void lustre_swab_niobuf_remote (struct niobuf_remote *nbr);
 793
 794 /* request structure for OST's */
 795
 796 struct ost_body {
 797         struct  obdo oa;
 798 };
 799
 800 extern void lustre_swab_ost_body (struct ost_body *b);
 801 extern void lustre_swab_ost_last_id(obd_id *id);
 802 extern void lustre_swab_generic_32s(__u32 *val);
 803
 804 /* lock value block communicated between the filter and llite */
 805
 806 struct ost_lvb {
 807         __u64 lvb_size;
 808         __u64 lvb_mtime;
 809         __u64 lvb_atime;
 810         __u64 lvb_ctime;
 811         __u64 lvb_blocks;
 812 };
 813
 814 extern void lustre_swab_ost_lvb(struct ost_lvb *);
 815
 816 /*
 817  *   MDS REQ RECORDS
 818  */
 819
 820 /* opcodes */
 821 typedef enum {
 822         MDS_GETATTR      = 33,
 823         MDS_GETATTR_NAME = 34,
 824         MDS_CLOSE        = 35,
 825         MDS_REINT        = 36,
 826         MDS_READPAGE     = 37,
 827         MDS_CONNECT      = 38,
 828         MDS_DISCONNECT   = 39,
 829         MDS_GETSTATUS    = 40,
 830         MDS_STATFS       = 41,
 831         MDS_PIN          = 42,
 832         MDS_UNPIN        = 43,
 833         MDS_SYNC         = 44,
 834         MDS_DONE_WRITING = 45,
 835         MDS_SET_INFO     = 46,
 836         MDS_QUOTACHECK   = 47,
 837         MDS_QUOTACTL     = 48,
 838         MDS_GETXATTR     = 49,
 839         MDS_SETXATTR     = 50,
 840         MDS_WRITEPAGE    = 51,
 841         MDS_IS_SUBDIR    = 52,
 842         MDS_RENEW_CAPA   = 53,
 843         MDS_LAST_OPC
 844 } mds_cmd_t;
 845
 846 #define MDS_FIRST_OPC    MDS_GETATTR
 847
 848 /*
 849  * Do not exceed 63
 850  */
 851
 852 typedef enum {
 853         REINT_SETATTR  = 1,
 854         REINT_CREATE   = 2,
 855         REINT_LINK     = 3,
 856         REINT_UNLINK   = 4,
 857         REINT_RENAME   = 5,
 858         REINT_OPEN     = 6,
 859 //      REINT_CLOSE    = 7,
 860 //      REINT_WRITE    = 8,
 861         REINT_MAX
 862 } mds_reint_t, mdt_reint_t;
 863
 864 /* the disposition of the intent outlines what was executed */
 865 #define DISP_IT_EXECD        0x00000001
 866 #define DISP_LOOKUP_EXECD    0x00000002
 867 #define DISP_LOOKUP_NEG      0x00000004
 868 #define DISP_LOOKUP_POS      0x00000008
 869 #define DISP_OPEN_CREATE     0x00000010
 870 #define DISP_OPEN_OPEN       0x00000020
 871 #define DISP_ENQ_COMPLETE    0x00400000
 872 #define DISP_ENQ_OPEN_REF    0x00800000
 873 #define DISP_ENQ_CREATE_REF  0x01000000
 874
 875 /* INODE LOCK PARTS */
 876 #define MDS_INODELOCK_LOOKUP 0x000001       /* dentry, mode, owner, group */
 877 #define MDS_INODELOCK_UPDATE 0x000002       /* size, links, timestamps */
 878 #define MDS_INODELOCK_OPEN   0x000004       /* For opened files */
 879
 880 /* Do not forget to increase MDS_INODELOCK_MAXSHIFT when adding new bits */
 881 #define MDS_INODELOCK_MAXSHIFT 2
 882 /* This FULL lock is useful to take on unlink sort of operations */
 883 #define MDS_INODELOCK_FULL ((1<<(MDS_INODELOCK_MAXSHIFT+1))-1)
 884
 885 #define LUSTRE_CONFIG_SET 0
 886 #define LUSTRE_CONFIG_GET 1
 887
 888 #define LUSTRE_CONFIG_METASEQ "metaseq"
 889 #define LUSTRE_CONFIG_TRANSNO "transno"
 890
 891 struct ll_fid {
 892         __u64 id;         /* holds object id */
 893         __u32 generation; /* holds object generation */
 894
 895         __u32 f_type;     /* holds object type or stripe idx when passing it to
 896                            * OST for saving into EA. */
 897 };
 898
 899 extern void lustre_swab_ll_fid (struct ll_fid *fid);
 900
 901 #define MDS_STATUS_CONN 1
 902 #define MDS_STATUS_LOV 2
 903
 904 struct mds_status_req {
 905         __u32  flags;
 906         __u32  repbuf;
 907 };
 908
 909 extern void lustre_swab_mds_status_req (struct mds_status_req *r);
 910
 911 /* mdt_thread_info.mti_flags. */
 912 enum mdt_ioepoch_flags {
 913         /* The flag indicates Size-on-MDS attributes are changed. */
 914         MF_SOM_CHANGE   = (1 << 0),
 915         /* Flags indicates an epoch opens or closes. */
 916         MF_EPOCH_OPEN   = (1 << 1),
 917         MF_EPOCH_CLOSE  = (1 << 2),
 918 };
 919
 920 #define MDS_BFLAG_EXT_FLAGS     0x80000000 /* == EXT3_RESERVED_FL */
 921
 922 /* these should be identical to their EXT3_*_FL counterparts, and are
 923  * redefined here only to avoid dragging in ext3_fs.h */
 924 #define MDS_SYNC_FL             0x00000008 /* Synchronous updates */
 925 #define MDS_IMMUTABLE_FL        0x00000010 /* Immutable file */
 926 #define MDS_APPEND_FL           0x00000020 /* writes to file may only append */
 927 #define MDS_NOATIME_FL          0x00000080 /* do not update atime */
 928 #define MDS_DIRSYNC_FL          0x00010000 /* dirsync behaviour (dir only) */
 929
 930 #ifdef __KERNEL__
 931 /* If MDS_BFLAG_IOC_FLAGS is set it means we requested EXT3_*_FL inode flags
 932  * and we need to decode these into local S_* flags in the inode.  Otherwise
 933  * we pass flags straight through (see bug 9486). */
 934 static inline int ll_ext_to_inode_flags(int flags)
 935 {
 936         return (flags & MDS_BFLAG_EXT_FLAGS) ?
 937                (((flags & MDS_SYNC_FL)      ? S_SYNC      : 0) |
 938                 ((flags & MDS_NOATIME_FL)   ? S_NOATIME   : 0) |
 939                 ((flags & MDS_APPEND_FL)    ? S_APPEND    : 0) |
 940 #if defined(S_DIRSYNC)
 941                 ((flags & MDS_DIRSYNC_FL)   ? S_DIRSYNC   : 0) |
 942 #endif
 943                 ((flags & MDS_IMMUTABLE_FL) ? S_IMMUTABLE : 0)) :
 944                (flags & ~MDS_BFLAG_EXT_FLAGS);
 945 }
 946
 947 /* If MDS_BFLAG_EXT_FLAGS is set it means we requested EXT3_*_FL inode flags
 948  * and we pass these straight through.  Otherwise we need to convert from
 949  * S_* flags to their EXT3_*_FL equivalents (see bug 9486). */
 950 static inline int ll_inode_to_ext_flags(int oflags, int iflags)
 951 {
 952         return (oflags & MDS_BFLAG_EXT_FLAGS) ? (oflags & ~MDS_BFLAG_EXT_FLAGS):
 953                (((iflags & S_SYNC)      ? MDS_SYNC_FL      : 0) |
 954                 ((iflags & S_NOATIME)   ? MDS_NOATIME_FL   : 0) |
 955                 ((iflags & S_APPEND)    ? MDS_APPEND_FL    : 0) |
 956 #if defined(S_DIRSYNC)
 957                 ((iflags & S_DIRSYNC)   ? MDS_DIRSYNC_FL   : 0) |
 958 #endif
 959                 ((iflags & S_IMMUTABLE) ? MDS_IMMUTABLE_FL : 0));
 960 }
 961 #endif
 962
 963 struct mdt_body {
 964         struct lu_fid  fid1;
 965         struct lu_fid  fid2;
 966         struct lustre_handle handle;
 967         __u64          valid;
 968         __u64          size;   /* Offset, in the case of MDS_READPAGE */
 969         __u64          mtime;
 970         __u64          atime;
 971         __u64          ctime;
 972         __u64          blocks; /* XID, in the case of MDS_READPAGE */
 973         __u64          ioepoch;
 974         __u32          fsuid;
 975         __u32          fsgid;
 976         __u32          capability;
 977         __u32          mode;
 978         __u32          uid;
 979         __u32          gid;
 980         __u32          flags; /* from vfs for pin/unpin, MDS_BFLAG for close */
 981         __u32          rdev;
 982         __u32          nlink; /* #bytes to read in the case of MDS_READPAGE */
 983         __u32          suppgid;
 984         __u32          eadatasize;
 985         __u32          aclsize;
 986         __u32          max_mdsize;
 987         __u32          max_cookiesize; /* also fix lustre_swab_mdt_body */
 988 };
 989
 990 struct mds_body {
 991         struct ll_fid  fid1;
 992         struct ll_fid  fid2;
 993         struct lustre_handle handle;
 994         __u64          valid;
 995         __u64          size;   /* Offset, in the case of MDS_READPAGE */
 996         __u64          mtime;
 997         __u64          atime;
 998         __u64          ctime;
 999         __u64          blocks; /* XID, in the case of MDS_READPAGE */
1000         __u64          io_epoch;
1001         __u64          ino;
1002         __u32          fsuid;
1003         __u32          fsgid;
1004         __u32          capability;
1005         __u32          mode;
1006         __u32          uid;
1007         __u32          gid;
1008         __u32          flags; /* from vfs for pin/unpin, MDS_BFLAG for close */
1009         __u32          rdev;
1010         __u32          nlink; /* #bytes to read in the case of MDS_READPAGE */
1011         __u32          generation;
1012         __u32          suppgid;
1013         __u32          eadatasize;
1014         __u32          aclsize;
1015         __u32          max_mdsize;
1016         __u32          max_cookiesize; /* also fix lustre_swab_mds_body */
1017         __u32          padding_4; /* also fix lustre_swab_mds_body */
1018 };
1019
1020 extern void lustre_swab_mds_body (struct mds_body *b);
1021 extern void lustre_swab_mdt_body (struct mdt_body *b);
1022
1023 struct mdt_epoch {
1024         struct lustre_handle handle;
1025         __u64  ioepoch;
1026         __u32  flags;
1027 };
1028
1029 extern void lustre_swab_mdt_epoch (struct mdt_epoch *b);
1030
1031 struct lustre_md {
1032         struct mdt_body         *body;
1033         struct lov_stripe_md    *lsm;
1034         struct lmv_stripe_md    *mea;
1035 #ifdef CONFIG_FS_POSIX_ACL
1036         struct posix_acl        *posix_acl;
1037 #endif
1038         struct mdt_remote_perm  *remote_perm;
1039         struct obd_capa         *mds_capa;
1040         struct obd_capa         *oss_capa;
1041 };
1042
1043 #define Q_QUOTACHECK    0x800100
1044 #define Q_INITQUOTA     0x800101        /* init slave limits */
1045 #define Q_GETOINFO      0x800102        /* get obd quota info */
1046 #define Q_GETOQUOTA     0x800103        /* get obd quotas */
1047
1048 #define Q_TYPESET(oqc, type) \
1049         ((oqc)->qc_type == type || (oqc)->qc_type == UGQUOTA)
1050
1051 #define Q_GETOCMD(oqc) \
1052         ((oqc)->qc_cmd == Q_GETOINFO || (oqc)->qc_cmd == Q_GETOQUOTA)
1053
1054 struct obd_quotactl {
1055         __u32                   qc_cmd;
1056         __u32                   qc_type;
1057         __u32                   qc_id;
1058         __u32                   qc_stat;
1059         struct obd_dqinfo       qc_dqinfo;
1060         struct obd_dqblk        qc_dqblk;
1061 };
1062
1063 extern void lustre_swab_obd_quotactl(struct obd_quotactl *q);
1064
1065 /* inode access permission for remote user, the inode info are omitted,
1066  * for client knows them. */
1067 struct mds_remote_perm {
1068         __u32           rp_uid;
1069         __u32           rp_gid;
1070         __u32           rp_fsuid;
1071         __u32           rp_fsgid;
1072         __u32           rp_access_perm; /* MAY_READ/WRITE/EXEC */
1073 };
1074
1075 /* setxid permissions for mds_setxid_perm.mp_perm */
1076 #define LUSTRE_SETUID_PERM 0x01
1077 #define LUSTRE_SETGID_PERM 0x02
1078 #define LUSTRE_SETGRP_PERM 0x04
1079
1080 extern void lustre_swab_mds_remote_perm(struct mds_remote_perm *p);
1081
1082 struct mdt_remote_perm {
1083         __u32           rp_uid;
1084         __u32           rp_gid;
1085         __u32           rp_fsuid;
1086         __u32           rp_fsgid;
1087         __u32           rp_access_perm; /* MAY_READ/WRITE/EXEC */
1088 };
1089
1090 extern void lustre_swab_mdt_remote_perm(struct mdt_remote_perm *p);
1091
1092 struct mds_rec_setattr {
1093         __u32           sa_opcode;
1094         __u32           sa_fsuid;
1095         __u32           sa_fsgid;
1096         __u32           sa_cap;
1097         __u32           sa_suppgid;
1098         __u32           sa_mode;
1099         struct ll_fid   sa_fid;
1100         __u64           sa_valid;
1101         __u64           sa_size;
1102         __u64           sa_mtime;
1103         __u64           sa_atime;
1104         __u64           sa_ctime;
1105         __u32           sa_uid;
1106         __u32           sa_gid;
1107         __u32           sa_attr_flags;
1108         __u32           sa_padding; /* also fix lustre_swab_mds_rec_setattr */
1109 };
1110
1111 extern void lustre_swab_mds_rec_setattr (struct mds_rec_setattr *sa);
1112
1113 struct mdt_rec_setattr {
1114         __u32           sa_opcode;
1115         __u32           sa_fsuid;
1116         __u32           sa_fsgid;
1117         __u32           sa_cap;
1118         __u32           sa_suppgid;
1119         __u32           sa_mode;
1120         struct lu_fid   sa_fid;
1121         __u64           sa_valid;
1122         __u64           sa_size;
1123         __u64           sa_blocks;
1124         __u64           sa_mtime;
1125         __u64           sa_atime;
1126         __u64           sa_ctime;
1127         __u32           sa_uid;
1128         __u32           sa_gid;
1129         __u32           sa_attr_flags;
1130         __u32           sa_padding; /* also fix lustre_swab_mds_rec_setattr */
1131 };
1132
1133 extern void lustre_swab_mdt_rec_setattr (struct mdt_rec_setattr *sa);
1134
1135 /* Remove this once we declare it in include/linux/fs.h (v21 kernel patch?) */
1136 #ifndef ATTR_CTIME_SET
1137 #define ATTR_CTIME_SET 0x2000
1138 #endif
1139
1140 #ifndef FMODE_READ
1141 #define FMODE_READ               00000001
1142 #define FMODE_WRITE              00000002
1143 #endif
1144
1145 #define FMODE_EPOCH              01000000
1146 #define FMODE_EPOCHLCK           02000000
1147 #define FMODE_SOM                04000000
1148 #define FMODE_CLOSED             0
1149
1150 #define MDS_OPEN_CREATED         00000010
1151
1152 #define MDS_FMODE_EXEC           00000004
1153 #define MDS_OPEN_CREAT           00000100
1154 #define MDS_OPEN_EXCL            00000200
1155 #define MDS_OPEN_TRUNC           00001000
1156 #define MDS_OPEN_APPEND          00002000
1157 #define MDS_OPEN_SYNC            00010000
1158 #define MDS_OPEN_DIRECTORY       00200000
1159
1160 #define MDS_OPEN_DELAY_CREATE  0100000000 /* delay initial object create */
1161 #define MDS_OPEN_OWNEROVERRIDE 0200000000 /* NFSD rw-reopen ro file for owner */
1162 #define MDS_OPEN_JOIN_FILE     0400000000 /* open for join file*/
1163 #define MDS_CREATE_SLAVE_OBJ  02000000000 /* indicate create slave object
1164                                            * actually, this is for create, not
1165                                            * conflict with other open flags */
1166 #define MDS_OPEN_LOCK         04000000000 /* This open requires open lock */
1167 #define MDS_OPEN_HAS_EA      010000000000 /* specify object create pattern */
1168 #define MDS_OPEN_HAS_OBJS    020000000000 /* Just set the EA the obj exist */
1169
1170 struct mds_rec_join {
1171         struct ll_fid  jr_fid;
1172         __u64          jr_headsize;
1173 };
1174
1175 extern void lustre_swab_mds_rec_join (struct mds_rec_join *jr);
1176
1177 struct mdt_rec_join {
1178         struct lu_fid  jr_fid;
1179         __u64          jr_headsize;
1180 };
1181
1182 extern void lustre_swab_mdt_rec_join (struct mdt_rec_join *jr);
1183
1184 struct mds_rec_create {
1185         __u32           cr_opcode;
1186         __u32           cr_fsuid;
1187         __u32           cr_fsgid;
1188         __u32           cr_cap;
1189         __u32           cr_flags; /* for use with open */
1190         __u32           cr_mode;
1191         struct ll_fid   cr_fid;
1192         struct ll_fid   cr_replayfid;
1193         __u64           cr_time;
1194         __u64           cr_rdev;
1195         __u32           cr_suppgid;
1196         __u32           cr_padding_1; /* also fix lustre_swab_mds_rec_create */
1197         __u32           cr_padding_2; /* also fix lustre_swab_mds_rec_create */
1198         __u32           cr_padding_3; /* also fix lustre_swab_mds_rec_create */
1199         __u32           cr_padding_4; /* also fix lustre_swab_mds_rec_create */
1200         __u32           cr_padding_5; /* also fix lustre_swab_mds_rec_create */
1201 };
1202
1203 extern void lustre_swab_mds_rec_create (struct mds_rec_create *cr);
1204
1205 struct mdt_rec_create {
1206         __u32           cr_opcode;
1207         __u32           cr_fsuid;
1208         __u32           cr_fsgid;
1209         __u32           cr_cap;
1210         __u32           cr_flags; /* for use with open */
1211         __u32           cr_mode;
1212         struct lu_fid   cr_fid1;
1213         struct lu_fid   cr_fid2;
1214         __u64           cr_time;
1215         __u64           cr_rdev;
1216         __u32           cr_suppgid;
1217         __u32           cr_padding_1; /* also fix lustre_swab_mds_rec_create */
1218         __u32           cr_padding_2; /* also fix lustre_swab_mds_rec_create */
1219         __u32           cr_padding_3; /* also fix lustre_swab_mds_rec_create */
1220         __u32           cr_padding_4; /* also fix lustre_swab_mds_rec_create */
1221         __u32           cr_padding_5; /* also fix lustre_swab_mds_rec_create */
1222 };
1223
1224 extern void lustre_swab_mdt_rec_create (struct mdt_rec_create *cr);
1225
1226 struct mds_rec_link {
1227         __u32           lk_opcode;
1228         __u32           lk_fsuid;
1229         __u32           lk_fsgid;
1230         __u32           lk_cap;
1231         __u32           lk_suppgid1;
1232         __u32           lk_suppgid2;
1233         struct ll_fid   lk_fid1;
1234         struct ll_fid   lk_fid2;
1235         __u64           lk_time;
1236         __u32           lk_padding_1;  /* also fix lustre_swab_mds_rec_link */
1237         __u32           lk_padding_2;  /* also fix lustre_swab_mds_rec_link */
1238         __u32           lk_padding_3;  /* also fix lustre_swab_mds_rec_link */
1239         __u32           lk_padding_4;  /* also fix lustre_swab_mds_rec_link */
1240 };
1241
1242 extern void lustre_swab_mds_rec_link (struct mds_rec_link *lk);
1243
1244 struct mdt_rec_link {
1245         __u32           lk_opcode;
1246         __u32           lk_fsuid;
1247         __u32           lk_fsgid;
1248         __u32           lk_cap;
1249         __u32           lk_suppgid1;
1250         __u32           lk_suppgid2;
1251         struct lu_fid   lk_fid1;
1252         struct lu_fid   lk_fid2;
1253         __u64           lk_time;
1254         __u32           lk_padding_1;  /* also fix lustre_swab_mds_rec_link */
1255         __u32           lk_padding_2;  /* also fix lustre_swab_mds_rec_link */
1256         __u32           lk_padding_3;  /* also fix lustre_swab_mds_rec_link */
1257         __u32           lk_padding_4;  /* also fix lustre_swab_mds_rec_link */
1258 };
1259
1260 extern void lustre_swab_mdt_rec_link (struct mdt_rec_link *lk);
1261
1262 struct mds_rec_unlink {
1263         __u32           ul_opcode;
1264         __u32           ul_fsuid;
1265         __u32           ul_fsgid;
1266         __u32           ul_cap;
1267         __u32           ul_suppgid;
1268         __u32           ul_mode;
1269         struct ll_fid   ul_fid1;
1270         struct ll_fid   ul_fid2;
1271         __u64           ul_time;
1272         __u32           ul_padding_1; /* also fix lustre_swab_mds_rec_unlink */
1273         __u32           ul_padding_2; /* also fix lustre_swab_mds_rec_unlink */
1274         __u32           ul_padding_3; /* also fix lustre_swab_mds_rec_unlink */
1275         __u32           ul_padding_4; /* also fix lustre_swab_mds_rec_unlink */
1276 };
1277
1278 extern void lustre_swab_mds_rec_unlink (struct mds_rec_unlink *ul);
1279
1280 struct mdt_rec_unlink {
1281         __u32           ul_opcode;
1282         __u32           ul_fsuid;
1283         __u32           ul_fsgid;
1284         __u32           ul_cap;
1285         __u32           ul_suppgid;
1286         __u32           ul_mode;
1287         struct lu_fid   ul_fid1;
1288         struct lu_fid   ul_fid2;
1289         __u64           ul_time;
1290         __u32           ul_padding_1; /* also fix lustre_swab_mds_rec_unlink */
1291         __u32           ul_padding_2; /* also fix lustre_swab_mds_rec_unlink */
1292         __u32           ul_padding_3; /* also fix lustre_swab_mds_rec_unlink */
1293         __u32           ul_padding_4; /* also fix lustre_swab_mds_rec_unlink */
1294 };
1295
1296 extern void lustre_swab_mdt_rec_unlink (struct mdt_rec_unlink *ul);
1297
1298 struct mds_rec_rename {
1299         __u32           rn_opcode;
1300         __u32           rn_fsuid;
1301         __u32           rn_fsgid;
1302         __u32           rn_cap;
1303         __u32           rn_suppgid1;
1304         __u32           rn_suppgid2;
1305         struct ll_fid   rn_fid1;
1306         struct ll_fid   rn_fid2;
1307         __u64           rn_time;
1308         __u32           rn_padding_1; /* also fix lustre_swab_mds_rec_rename */
1309         __u32           rn_padding_2; /* also fix lustre_swab_mds_rec_rename */
1310         __u32           rn_padding_3; /* also fix lustre_swab_mds_rec_rename */
1311         __u32           rn_padding_4; /* also fix lustre_swab_mds_rec_rename */
1312 };
1313
1314 extern void lustre_swab_mds_rec_rename (struct mds_rec_rename *rn);
1315
1316 struct mdt_rec_rename {
1317         __u32           rn_opcode;
1318         __u32           rn_fsuid;
1319         __u32           rn_fsgid;
1320         __u32           rn_cap;
1321         __u32           rn_suppgid1;
1322         __u32           rn_suppgid2;
1323         struct lu_fid   rn_fid1;
1324         struct lu_fid   rn_fid2;
1325         __u64           rn_time;
1326         __u32           rn_mode;      /* cross-ref rename has mode */
1327         __u32           rn_padding_2; /* also fix lustre_swab_mdt_rec_rename */
1328         __u32           rn_padding_3; /* also fix lustre_swab_mdt_rec_rename */
1329         __u32           rn_padding_4; /* also fix lustre_swab_mdt_rec_rename */
1330 };
1331
1332 extern void lustre_swab_mdt_rec_rename (struct mdt_rec_rename *rn);
1333
1334 /* begin adding MDT by huanghua@clusterfs.com */
1335 struct lmv_desc {
1336         __u32 ld_tgt_count;                /* how many MDS's */
1337         __u32 ld_active_tgt_count;         /* how many active */
1338         struct obd_uuid ld_uuid;
1339 };
1340
1341 extern void lustre_swab_lmv_desc (struct lmv_desc *ld);
1342 /* end adding MDT by huanghua@clusterfs.com */
1343
1344 struct md_fld {
1345         seqno_t mf_seq;
1346         mdsno_t mf_mds;
1347 };
1348
1349 extern void lustre_swab_md_fld (struct md_fld *mf);
1350
1351 enum fld_rpc_opc {
1352         FLD_QUERY                       = 600,
1353         FLD_LAST_OPC,
1354         FLD_FIRST_OPC                   = FLD_QUERY
1355 };
1356
1357 enum seq_rpc_opc {
1358         SEQ_QUERY                       = 700,
1359         SEQ_LAST_OPC,
1360         SEQ_FIRST_OPC                   = SEQ_QUERY
1361 };
1362
1363 enum seq_op {
1364         SEQ_ALLOC_SUPER = 0,
1365         SEQ_ALLOC_META = 1
1366 };
1367
1368 /*
1369  *  LOV data structures
1370  */
1371
1372 #define LOV_MIN_STRIPE_SIZE 65536   /* maximum PAGE_SIZE (ia64), power of 2 */
1373 #define LOV_MAX_STRIPE_COUNT  160   /* until bug 4424 is fixed */
1374
1375 #define LOV_MAX_UUID_BUFFER_SIZE  8192
1376 /* The size of the buffer the lov/mdc reserves for the
1377  * array of UUIDs returned by the MDS.  With the current
1378  * protocol, this will limit the max number of OSTs per LOV */
1379
1380 #define LOV_DESC_MAGIC 0xB0CCDE5C
1381
1382 /* LOV settings descriptor (should only contain static info) */
1383 struct lov_desc {
1384         __u32 ld_tgt_count;                /* how many OBD's */
1385         __u32 ld_active_tgt_count;         /* how many active */
1386         __u32 ld_default_stripe_count;     /* how many objects are used */
1387         __u32 ld_pattern;                  /* default PATTERN_RAID0 */
1388         __u64 ld_default_stripe_size;      /* in bytes */
1389         __u64 ld_default_stripe_offset;    /* in bytes */
1390         __u32 ld_padding_0;                /* unused */
1391         __u32 ld_qos_maxage;               /* in second */
1392         __u32 ld_padding_1;                /* also fix lustre_swab_lov_desc */
1393         __u32 ld_padding_2;                /* also fix lustre_swab_lov_desc */
1394         struct obd_uuid ld_uuid;
1395 };
1396
1397 #define ld_magic ld_active_tgt_count       /* for swabbing from llogs */
1398
1399 extern void lustre_swab_lov_desc (struct lov_desc *ld);
1400
1401 /*
1402  *   LDLM requests:
1403  */
1404 /* opcodes -- MUST be distinct from OST/MDS opcodes */
1405 typedef enum {
1406         LDLM_ENQUEUE     = 101,
1407         LDLM_CONVERT     = 102,
1408         LDLM_CANCEL      = 103,
1409         LDLM_BL_CALLBACK = 104,
1410         LDLM_CP_CALLBACK = 105,
1411         LDLM_GL_CALLBACK = 106,
1412         LDLM_LAST_OPC
1413 } ldlm_cmd_t;
1414 #define LDLM_FIRST_OPC LDLM_ENQUEUE
1415
1416 #define RES_NAME_SIZE 4
1417 struct ldlm_res_id {
1418         __u64 name[RES_NAME_SIZE];
1419 };
1420
1421 extern void lustre_swab_ldlm_res_id (struct ldlm_res_id *id);
1422
1423 /* lock types */
1424 typedef enum {
1425         LCK_MINMODE = 0,
1426         LCK_EX = 1,
1427         LCK_PW = 2,
1428         LCK_PR = 4,
1429         LCK_CW = 8,
1430         LCK_CR = 16,
1431         LCK_NL = 32,
1432         LCK_GROUP = 64,
1433         LCK_MAXMODE
1434 } ldlm_mode_t;
1435
1436 typedef enum {
1437         LDLM_PLAIN     = 10,
1438         LDLM_EXTENT    = 11,
1439         LDLM_FLOCK     = 12,
1440         LDLM_IBITS     = 13,
1441         LDLM_MAX_TYPE
1442 } ldlm_type_t;
1443
1444 #define LDLM_MIN_TYPE LDLM_PLAIN
1445
1446 struct ldlm_extent {
1447         __u64 start;
1448         __u64 end;
1449         __u64 gid;
1450 };
1451
1452 struct ldlm_inodebits {
1453         __u64 bits;
1454 };
1455
1456 struct ldlm_flock {
1457         __u64 start;
1458         __u64 end;
1459         __u64 blocking_export;  /* not actually used over the wire */
1460         __u32 blocking_pid;     /* not actually used over the wire */
1461         __u32 pid;
1462 };
1463
1464 /* it's important that the fields of the ldlm_extent structure match
1465  * the first fields of the ldlm_flock structure because there is only
1466  * one ldlm_swab routine to process the ldlm_policy_data_t union. if
1467  * this ever changes we will need to swab the union differently based
1468  * on the resource type. */
1469
1470 typedef union {
1471         struct ldlm_extent l_extent;
1472         struct ldlm_flock  l_flock;
1473         struct ldlm_inodebits l_inodebits;
1474 } ldlm_policy_data_t;
1475
1476 extern void lustre_swab_ldlm_policy_data (ldlm_policy_data_t *d);
1477
1478 struct ldlm_intent {
1479         __u64 opc;
1480 };
1481
1482 extern void lustre_swab_ldlm_intent (struct ldlm_intent *i);
1483
1484 struct ldlm_resource_desc {
1485         ldlm_type_t lr_type;
1486         __u32 lr_padding;       /* also fix lustre_swab_ldlm_resource_desc */
1487         struct ldlm_res_id lr_name;
1488 };
1489
1490 extern void lustre_swab_ldlm_resource_desc (struct ldlm_resource_desc *r);
1491
1492 struct ldlm_lock_desc {
1493         struct ldlm_resource_desc l_resource;
1494         ldlm_mode_t l_req_mode;
1495         ldlm_mode_t l_granted_mode;
1496         ldlm_policy_data_t l_policy_data;
1497 };
1498
1499 extern void lustre_swab_ldlm_lock_desc (struct ldlm_lock_desc *l);
1500
1501 struct ldlm_request {
1502         __u32 lock_flags;
1503         __u32 lock_padding;     /* also fix lustre_swab_ldlm_request */
1504         struct ldlm_lock_desc lock_desc;
1505         struct lustre_handle lock_handle1;
1506         struct lustre_handle lock_handle2;
1507 };
1508
1509 extern void lustre_swab_ldlm_request (struct ldlm_request *rq);
1510
1511 struct ldlm_reply {
1512         __u32 lock_flags;
1513         __u32 lock_padding;     /* also fix lustre_swab_ldlm_reply */
1514         struct ldlm_lock_desc lock_desc;
1515         struct lustre_handle lock_handle;
1516         __u64  lock_policy_res1;
1517         __u64  lock_policy_res2;
1518 };
1519
1520 extern void lustre_swab_ldlm_reply (struct ldlm_reply *r);
1521
1522
1523 /*
1524  * Opcodes for mountconf (mgs and mgc)
1525  */
1526 typedef enum {
1527         MGS_CONNECT = 250,
1528         MGS_DISCONNECT,
1529         MGS_EXCEPTION,         /* node died, etc. */
1530         MGS_TARGET_REG,        /* whenever target starts up */
1531         MGS_TARGET_DEL,
1532         MGS_LAST_OPC
1533 } mgs_cmd_t;
1534
1535 /* We pass this info to the MGS so it can write config logs */
1536 #define MTI_NAME_MAXLEN 64
1537 #define MTI_NIDS_MAX 32
1538 struct mgs_target_info {
1539         __u32            mti_lustre_ver;
1540         __u32            mti_stripe_index;
1541         __u32            mti_config_ver;
1542         __u32            mti_flags;
1543         __u32            mti_nid_count;
1544         __u32            padding;                    /* 64 bit align */
1545         char             mti_fsname[MTI_NAME_MAXLEN];
1546         char             mti_svname[MTI_NAME_MAXLEN];
1547         char             mti_uuid[sizeof(struct obd_uuid)];
1548         lnet_nid_t       mti_nids[MTI_NIDS_MAX];     /* host nids */
1549         char             mti_params[2048];
1550 };
1551
1552 extern void lustre_swab_mgs_target_info(struct mgs_target_info *oinfo);
1553
1554 #define CM_START       0x01
1555 #define CM_END         0x02
1556 #define CM_SKIP        0x04
1557 #define CM_UPGRADE146  0x08
1558 #define CM_START_SKIP (CM_START | CM_SKIP)
1559
1560 struct cfg_marker {
1561         __u32             cm_step;       /* aka config version */
1562         __u32             cm_flags;
1563         __u32             cm_vers;       /* lustre release version number */
1564         __u32             padding;       /* 64 bit align */
1565         time_t            cm_createtime; /*when this record was first created */
1566         time_t            cm_canceltime; /*when this record is no longer valid*/
1567         char              cm_svname[MTI_NAME_MAXLEN];
1568         char              cm_comment[MTI_NAME_MAXLEN];
1569 };
1570
1571 /*
1572  * Opcodes for multiple servers.
1573  */
1574
1575 typedef enum {
1576         OBD_PING = 400,
1577         OBD_LOG_CANCEL,
1578         OBD_QC_CALLBACK,
1579         OBD_LAST_OPC
1580 } obd_cmd_t;
1581 #define OBD_FIRST_OPC OBD_PING
1582
1583 /* catalog of log objects */
1584
1585 /* Identifier for a single log object */
1586 struct llog_logid {
1587         __u64                   lgl_oid;
1588         __u64                   lgl_ogr;
1589         __u32                   lgl_ogen;
1590 } __attribute__((packed));
1591
1592 /* Records written to the CATALOGS list */
1593 #define CATLIST "CATALOGS"
1594 struct llog_catid {
1595         struct llog_logid       lci_logid;
1596         __u32                   lci_padding1;
1597         __u32                   lci_padding2;
1598         __u32                   lci_padding3;
1599 } __attribute__((packed));
1600
1601 /*join file lov mds md*/
1602 struct lov_mds_md_join {
1603         struct lov_mds_md lmmj_md;
1604         /*join private info*/
1605         struct llog_logid lmmj_array_id; /*array object id*/
1606         __u32  lmmj_extent_count;        /*array extent count*/
1607 };
1608
1609 /* Log data record types - there is no specific reason that these need to
1610  * be related to the RPC opcodes, but no reason not to (may be handy later?)
1611  */
1612 #define LLOG_OP_MAGIC 0x10600000
1613 #define LLOG_OP_MASK  0xfff00000
1614
1615 typedef enum {
1616         LLOG_PAD_MAGIC   = LLOG_OP_MAGIC | 0x00000,
1617         OST_SZ_REC       = LLOG_OP_MAGIC | 0x00f00,
1618         OST_RAID1_REC    = LLOG_OP_MAGIC | 0x01000,
1619         MDS_UNLINK_REC   = LLOG_OP_MAGIC | 0x10000 | (MDS_REINT << 8) | REINT_UNLINK,
1620         MDS_SETATTR_REC  = LLOG_OP_MAGIC | 0x10000 | (MDS_REINT << 8) | REINT_SETATTR,
1621         OBD_CFG_REC      = LLOG_OP_MAGIC | 0x20000,
1622         PTL_CFG_REC      = LLOG_OP_MAGIC | 0x30000, /* obsolete */
1623         LLOG_GEN_REC     = LLOG_OP_MAGIC | 0x40000,
1624         LLOG_JOIN_REC    = LLOG_OP_MAGIC | 0x50000,
1625         LLOG_HDR_MAGIC   = LLOG_OP_MAGIC | 0x45539,
1626         LLOG_LOGID_MAGIC = LLOG_OP_MAGIC | 0x4553b,
1627 } llog_op_type;
1628
1629 /*
1630  * for now, continue to support old pad records which have 0 for their
1631  * type but still need to be swabbed for their length
1632  */
1633 #define LLOG_REC_HDR_NEEDS_SWABBING(r)                                  \
1634         (((r)->lrh_type & __swab32(LLOG_OP_MASK)) ==                    \
1635          __swab32(LLOG_OP_MAGIC) ||                                     \
1636          (((r)->lrh_type == 0) && ((r)->lrh_len > LLOG_CHUNK_SIZE)))
1637
1638 /* Log record header - stored in little endian order.
1639  * Each record must start with this struct, end with a llog_rec_tail,
1640  * and be a multiple of 256 bits in size.
1641  */
1642 struct llog_rec_hdr {
1643         __u32                   lrh_len;
1644         __u32                   lrh_index;
1645         __u32                   lrh_type;
1646         __u32                   padding;
1647 };
1648
1649 struct llog_rec_tail {
1650         __u32 lrt_len;
1651         __u32 lrt_index;
1652 };
1653
1654 struct llog_logid_rec {
1655         struct llog_rec_hdr     lid_hdr;
1656         struct llog_logid       lid_id;
1657         __u32                   padding1;
1658         __u32                   padding2;
1659         __u32                   padding3;
1660         __u32                   padding4;
1661         __u32                   padding5;
1662         struct llog_rec_tail    lid_tail;
1663 } __attribute__((packed));
1664
1665 /* MDS extent description
1666  * It is for joined file extent info, each extent info for joined file
1667  * just like (start, end, lmm).
1668  */
1669 struct mds_extent_desc {
1670         __u64                   med_start; /* extent start */
1671         __u64                   med_len;   /* extent length */
1672         struct lov_mds_md       med_lmm;   /* extent's lmm  */
1673 };
1674 /*Joined file array extent log record*/
1675 struct llog_array_rec {
1676         struct llog_rec_hdr     lmr_hdr;
1677         struct mds_extent_desc  lmr_med;
1678         struct llog_rec_tail    lmr_tail;
1679 };
1680
1681 struct llog_create_rec {
1682         struct llog_rec_hdr     lcr_hdr;
1683         struct ll_fid           lcr_fid;
1684         obd_id                  lcr_oid;
1685         obd_count               lcr_ogen;
1686         __u32                   padding;
1687         struct llog_rec_tail    lcr_tail;
1688 } __attribute__((packed));
1689
1690 struct llog_orphan_rec {
1691         struct llog_rec_hdr     lor_hdr;
1692         obd_id                  lor_oid;
1693         obd_count               lor_ogen;
1694         __u32                   padding;
1695         struct llog_rec_tail    lor_tail;
1696 } __attribute__((packed));
1697
1698 struct llog_unlink_rec {
1699         struct llog_rec_hdr     lur_hdr;
1700         obd_id                  lur_oid;
1701         obd_count               lur_ogen;
1702         __u32                   padding;
1703         struct llog_rec_tail    lur_tail;
1704 } __attribute__((packed));
1705
1706 struct llog_setattr_rec {
1707         struct llog_rec_hdr     lsr_hdr;
1708         obd_id                  lsr_oid;
1709         obd_count               lsr_ogen;
1710         __u32                   lsr_uid;
1711         __u32                   lsr_gid;
1712         __u32                   padding;
1713         struct llog_rec_tail    lsr_tail;
1714 } __attribute__((packed));
1715
1716 struct llog_size_change_rec {
1717         struct llog_rec_hdr     lsc_hdr;
1718         struct ll_fid           lsc_fid;
1719         __u32                   lsc_ioepoch;
1720         __u32                   padding;
1721         struct llog_rec_tail    lsc_tail;
1722 } __attribute__((packed));
1723
1724 struct llog_gen {
1725         __u64 mnt_cnt;
1726         __u64 conn_cnt;
1727 } __attribute__((packed));
1728
1729 struct llog_gen_rec {
1730         struct llog_rec_hdr     lgr_hdr;
1731         struct llog_gen         lgr_gen;
1732         struct llog_rec_tail    lgr_tail;
1733 };
1734 /* On-disk header structure of each log object, stored in little endian order */
1735 #define LLOG_CHUNK_SIZE         8192
1736 #define LLOG_HEADER_SIZE        (96)
1737 #define LLOG_BITMAP_BYTES       (LLOG_CHUNK_SIZE - LLOG_HEADER_SIZE)
1738
1739 #define LLOG_MIN_REC_SIZE       (24) /* round(llog_rec_hdr + llog_rec_tail) */
1740
1741 /* flags for the logs */
1742 #define LLOG_F_ZAP_WHEN_EMPTY   0x1
1743 #define LLOG_F_IS_CAT           0x2
1744 #define LLOG_F_IS_PLAIN         0x4
1745
1746 struct llog_log_hdr {
1747         struct llog_rec_hdr     llh_hdr;
1748         __u64                   llh_timestamp;
1749         __u32                   llh_count;
1750         __u32                   llh_bitmap_offset;
1751         __u32                   llh_size;
1752         __u32                   llh_flags;
1753         __u32                   llh_cat_idx;
1754         /* for a catalog the first plain slot is next to it */
1755         struct obd_uuid         llh_tgtuuid;
1756         __u32                   llh_reserved[LLOG_HEADER_SIZE/sizeof(__u32) - 23];
1757         __u32                   llh_bitmap[LLOG_BITMAP_BYTES/sizeof(__u32)];
1758         struct llog_rec_tail    llh_tail;
1759 } __attribute__((packed));
1760
1761 #define LLOG_BITMAP_SIZE(llh)  ((llh->llh_hdr.lrh_len -         \
1762                                  llh->llh_bitmap_offset -       \
1763                                  sizeof(llh->llh_tail)) * 8)
1764
1765 /* log cookies are used to reference a specific log file and a record therein */
1766 struct llog_cookie {
1767         struct llog_logid       lgc_lgl;
1768         __u32                   lgc_subsys;
1769         __u32                   lgc_index;
1770         __u32                   lgc_padding;
1771 } __attribute__((packed));
1772
1773 /* llog protocol */
1774 enum llogd_rpc_ops {
1775         LLOG_ORIGIN_HANDLE_CREATE       = 501,
1776         LLOG_ORIGIN_HANDLE_NEXT_BLOCK   = 502,
1777         LLOG_ORIGIN_HANDLE_READ_HEADER  = 503,
1778         LLOG_ORIGIN_HANDLE_WRITE_REC    = 504,
1779         LLOG_ORIGIN_HANDLE_CLOSE        = 505,
1780         LLOG_ORIGIN_CONNECT             = 506,
1781         LLOG_CATINFO                    = 507,  /* for lfs catinfo */
1782         LLOG_ORIGIN_HANDLE_PREV_BLOCK   = 508,
1783         LLOG_ORIGIN_HANDLE_DESTROY      = 509,  /* for destroy llog object*/
1784         LLOG_LAST_OPC
1785 };
1786
1787 struct llogd_body {
1788         struct llog_logid  lgd_logid;
1789         __u32 lgd_ctxt_idx;
1790         __u32 lgd_llh_flags;
1791         __u32 lgd_index;
1792         __u32 lgd_saved_index;
1793         __u32 lgd_len;
1794         __u64 lgd_cur_offset;
1795 } __attribute__((packed));
1796
1797 struct llogd_conn_body {
1798         struct llog_gen         lgdc_gen;
1799         struct llog_logid       lgdc_logid;
1800         __u32                   lgdc_ctxt_idx;
1801 } __attribute__((packed));
1802
1803 struct lov_user_ost_data_join {   /* per-stripe data structure */
1804         __u64 l_extent_start;     /* extent start*/
1805         __u64 l_extent_end;       /* extent end*/
1806         __u64 l_object_id;        /* OST object ID */
1807         __u64 l_object_gr;        /* OST object group (creating MDS number) */
1808         __u32 l_ost_gen;          /* generation of this OST index */
1809         __u32 l_ost_idx;          /* OST index in LOV */
1810 } __attribute__((packed));
1811
1812 struct lov_user_md_join {         /* LOV EA user data (host-endian) */
1813         __u32 lmm_magic;          /* magic number = LOV_MAGIC_JOIN */
1814         __u32 lmm_pattern;        /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */
1815         __u64 lmm_object_id;      /* LOV object ID */
1816         __u64 lmm_object_gr;      /* LOV object group */
1817         __u32 lmm_stripe_size;    /* size of stripe in bytes */
1818         __u32 lmm_stripe_count;   /* num stripes in use for this object */
1819         __u32 lmm_extent_count;   /* extent count of lmm*/
1820         __u64 lmm_tree_id;        /* mds tree object id */
1821         __u64 lmm_tree_gen;       /* mds tree object gen */
1822         struct llog_logid lmm_array_id; /* mds extent desc llog object id */
1823         struct lov_user_ost_data_join lmm_objects[0]; /* per-stripe data */
1824 } __attribute__((packed));
1825
1826 extern void lustre_swab_lov_mds_md(struct lov_mds_md *llm);
1827 extern void lustre_swab_lov_user_md(struct lov_user_md *lum);
1828 extern void lustre_swab_lov_user_md_objects(struct lov_user_md *lum);
1829 extern void lustre_swab_lov_user_md_join(struct lov_user_md_join *lumj);
1830
1831 /* llog_swab.c */
1832 extern void lustre_swab_llogd_body (struct llogd_body *d);
1833 extern void lustre_swab_llog_hdr (struct llog_log_hdr *h);
1834 extern void lustre_swab_llogd_conn_body (struct llogd_conn_body *d);
1835 extern void lustre_swab_llog_rec(struct llog_rec_hdr  *rec,
1836                                  struct llog_rec_tail *tail);
1837
1838 struct lustre_cfg;
1839 extern void lustre_swab_lustre_cfg(struct lustre_cfg *lcfg);
1840
1841 /* quota. fixed by tianzy for bug10707 */
1842 #define QUOTA_IS_GRP   0X1UL  /* 0 is user, 1 is group. Used by qd_flags*/
1843 #define QUOTA_IS_BLOCK 0x2UL  /* 0 is inode, 1 is block. Used by qd_flags*/
1844
1845 struct qunit_data {
1846         __u32 qd_id; /* ID appiles to (uid, gid) */
1847         __u32 qd_flags; /* Quota type (USRQUOTA, GRPQUOTA) occupy one bit;
1848                          * Block quota or file quota occupy one bit */
1849         __u64 qd_count; /* acquire/release count (bytes for block quota) */
1850 };
1851
1852 struct qunit_data_old {
1853         __u32 qd_id;    /* ID appiles to (uid, gid) */
1854         __u32 qd_type;  /* Quota type (USRQUOTA, GRPQUOTA) */
1855         __u32 qd_count; /* acquire/release count (bytes for block quota) */
1856         __u32 qd_isblk; /* Block quota or file quota */
1857 };
1858
1859 extern void lustre_swab_qdata(struct qunit_data *d);
1860 extern void lustre_swab_qdata_old(struct qunit_data_old *d);
1861 extern struct qunit_data *lustre_quota_old_to_new(struct qunit_data_old *d);
1862 extern struct qunit_data_old *lustre_quota_new_to_old(struct qunit_data *d);
1863
1864 typedef enum {
1865         QUOTA_DQACQ     = 601,
1866         QUOTA_DQREL     = 602,
1867 } quota_cmd_t;
1868
1869 /*
1870  * Return true if resource is for object identified by fid.
1871  */
1872 static inline int fid_res_name_eq(const struct lu_fid *f,
1873                                   const struct ldlm_res_id *name)
1874 {
1875         return name->name[0] == fid_seq(f) &&
1876                 name->name[1] == fid_oid(f) &&
1877                 name->name[2] == fid_ver(f);
1878 }
1879
1880 #define JOIN_FILE_ALIGN 4096
1881
1882 /* security opcodes */
1883 typedef enum {
1884         SEC_CTX_INIT            = 801,
1885         SEC_CTX_INIT_CONT       = 802,
1886         SEC_CTX_FINI            = 803,
1887         SEC_LAST_OPC
1888 } sec_cmd_t;
1889
1890 /*
1891  * capa related definitions
1892  */
1893 #define CAPA_HMAC_MAX_LEN       64
1894 #define CAPA_HMAC_KEY_MAX_LEN   56
1895
1896 /* NB take care when changing the sequence of elements this struct,
1897  * because the offset info is used in find_capa() */
1898 struct lustre_capa {
1899         struct lu_fid   lc_fid;       /* fid */
1900         __u64           lc_opc;       /* operations allowed */
1901         __u32           lc_flags;     /* HMAC algorithm & flags */
1902         __u32           lc_keyid;     /* key used for the capability */
1903         __u64           lc_expiry;    /* expiry time (sec) */
1904         __u8            lc_hmac[CAPA_HMAC_MAX_LEN];   /* HMAC */
1905 } __attribute__((packed));
1906
1907 extern void lustre_swab_lustre_capa(struct lustre_capa *c);
1908
1909 /* lustre_capa.lc_opc */
1910 enum {
1911         /* MDS only fid capability */
1912         CAPA_OPC_BODY_WRITE   = 1,     /* write fid data */
1913         CAPA_OPC_BODY_READ    = 1<<1,  /* read fid data */
1914         CAPA_OPC_INDEX_LOOKUP = 1<<2,  /* lookup fid */
1915         CAPA_OPC_INDEX_INSERT = 1<<3,  /* insert fid */
1916         CAPA_OPC_INDEX_DELETE = 1<<4,  /* delete fid */
1917         /* OSS only fid capability */
1918         CAPA_OPC_OSS_WRITE    = 1<<5,  /* write oss object data */
1919         CAPA_OPC_OSS_READ     = 1<<6,  /* read oss object data */
1920         CAPA_OPC_OSS_TRUNC    = 1<<7,  /* truncate oss object */
1921         /* MDS & OSS both might have */
1922         CAPA_OPC_META_WRITE   = 1<<8,  /* write fid meta data */
1923         CAPA_OPC_META_READ    = 1<<9,  /* read fid meta data */
1924
1925 };
1926
1927 #define CAPA_OPC_MDS_ONLY                                                      \
1928         (CAPA_OPC_BODY_WRITE | CAPA_OPC_BODY_READ |                            \
1929          CAPA_OPC_INDEX_LOOKUP | CAPA_OPC_INDEX_INSERT | CAPA_OPC_INDEX_DELETE)
1930 #define CAPA_OPC_OSS_ONLY                                                      \
1931         (CAPA_OPC_OSS_WRITE | CAPA_OPC_OSS_READ | CAPA_OPC_OSS_TRUNC)
1932 #define CAPA_OPC_MDS_DEFAULT ~CAPA_OPC_OSS_ONLY
1933 #define CAPA_OPC_OSS_DEFAULT ~(CAPA_OPC_MDS_ONLY | CAPA_OPC_OSS_ONLY)
1934
1935 static inline int capa_for_mds(struct lustre_capa *c)
1936 {
1937         return (c->lc_opc & CAPA_OPC_MDS_ONLY) != 0;
1938 }
1939
1940 static inline int capa_for_oss(struct lustre_capa *c)
1941 {
1942         return (c->lc_opc & CAPA_OPC_OSS_ONLY) != 0;
1943 }
1944
1945 /* lustre_capa.lc_flags */
1946 enum {
1947         CAPA_FL_SHORT_EXPIRY = 1, /* short capa expiry */
1948         CAPA_FL_ROOT         = 2, /* root fid capa, will always renew */
1949 };
1950
1951 /* lustre_capa.lc_hmac_alg */
1952 enum {
1953         CAPA_HMAC_ALG_SHA1 = 1, /* sha1 algorithm */
1954         CAPA_HMAC_ALG_MAX,
1955 };
1956
1957 #define CAPA_FL_MASK            0x00ffffff
1958 #define CAPA_HMAC_ALG_MASK      0xff000000
1959
1960 struct lustre_capa_key {
1961         __u64   lk_mdsid;     /* mds# */
1962         __u32   lk_keyid;     /* key# */
1963         __u32   lk_padding;
1964         __u8    lk_key[CAPA_HMAC_KEY_MAX_LEN];    /* key */
1965 } __attribute__((packed));
1966
1967 extern void lustre_swab_lustre_capa_key(struct lustre_capa_key *k);
1968
1969 typedef int (* renew_capa_cb_t)(struct obd_capa *, struct lustre_capa *);
1970
1971 #endif