lustre/include/linux/lustre_idl.h

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Copyright (C) 2001 Cluster File Systems, Inc. <braam@clusterfs.com>
   5  *
   6  *   This file is part of Lustre, http://www.lustre.org.
   7  *
   8  *   Lustre is free software; you can redistribute it and/or
   9  *   modify it under the terms of version 2 of the GNU General Public
  10  *   License as published by the Free Software Foundation.
  11  *
  12  *   Lustre is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with Lustre; if not, write to the Free Software
  19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  * Lustre wire protocol definitions.
  22  *
  23  * All structs passing over the wire should be declared here (lov_mds_md
  24  * being the lone exception).  Structs must be properly aligned to put
  25  * 64-bit values on an 8-byte boundary.  Any structs being added here
  26  * must also be added to utils/wirecheck.c and "make newwiretest" run
  27  * to regenerate the utils/wiretest.c sources.  This allows us to verify
  28  * that wire structs have the proper alignment/size on all architectures.
  29  *
  30  * We assume all nodes are either little-endian or big-endian, and we
  31  * always send messages in the sender's native format.  The receiver
  32  * detects the message format by checking the 'magic' field of the message
  33  * (see lustre_msg_swabbed() below).
  34  *
  35  * Each wire type has corresponding 'lustre_swab_xxxtypexxx()' routines,
  36  * implemented either here, inline (trivial implementations) or in
  37  * ptlrpc/pack_generic.c.  These 'swabbers' convert the type from "other"
  38  * endian, in-place in the message buffer.
  39  *
  40  * A swabber takes a single pointer argument.  The caller must already have
  41  * verified that the length of the message buffer >= sizeof (type).
  42  *
  43  * For variable length types, a second 'lustre_swab_v_xxxtypexxx()' routine
  44  * may be defined that swabs just the variable part, after the caller has
  45  * verified that the message buffer is large enough.
  46  */
  47
  48 #ifndef _LUSTRE_IDL_H_
  49 #define _LUSTRE_IDL_H_
  50
  51 #ifdef __KERNEL__
  52 # include <linux/ioctl.h>
  53 # include <asm/types.h>
  54 # include <linux/types.h>
  55 # include <linux/list.h>
  56 # include <linux/string.h> /* for strncpy, below */
  57 # include <asm/byteorder.h>
  58 # include <linux/fs.h> /* to check for FMODE_EXEC, lest we redefine */
  59 #else
  60 #ifdef __CYGWIN__
  61 # include <sys/types.h>
  62 #else
  63 # include <asm/types.h>
  64 # include <stdint.h>
  65 #endif
  66 # include <portals/list.h>
  67 # include <string.h>
  68 #endif
  69
  70 /* Defn's shared with user-space. */
  71 #include <linux/lustre_user.h>
  72
  73 /*
  74  * this file contains all data structures used in Lustre interfaces:
  75  * - obdo and obd_request records
  76  * - mds_request records
  77  * - ldlm data
  78  * - ioctl's
  79  */
  80
  81 /*
  82  *  GENERAL STUFF
  83  */
  84 struct obd_uuid {
  85         __u8 uuid[40];
  86 };
  87
  88 static inline int obd_uuid_equals(struct obd_uuid *u1, struct obd_uuid *u2)
  89 {
  90         return strcmp(u1->uuid, u2->uuid) == 0;
  91 }
  92
  93 static inline void obd_str2uuid(struct obd_uuid *uuid, char *tmp)
  94 {
  95         strncpy(uuid->uuid, tmp, sizeof(*uuid));
  96         uuid->uuid[sizeof(*uuid) - 1] = '\0';
  97 }
  98
  99 /* FOO_REQUEST_PORTAL is for incoming requests on the FOO
 100  * FOO_REPLY_PORTAL   is for incoming replies on the FOO
 101  * FOO_BULK_PORTAL    is for incoming bulk on the FOO
 102  */
 103
 104 #define CONNMGR_REQUEST_PORTAL          1
 105 #define CONNMGR_REPLY_PORTAL            2
 106 //#define OSC_REQUEST_PORTAL            3
 107 #define OSC_REPLY_PORTAL                4
 108 //#define OSC_BULK_PORTAL               5
 109 #define OST_REQUEST_PORTAL              6
 110 #define OST_CREATE_PORTAL               7
 111 #define OST_BULK_PORTAL                 8
 112 //#define MDC_REQUEST_PORTAL            9
 113 #define MDC_REPLY_PORTAL               10
 114 //#define MDC_BULK_PORTAL              11
 115 #define MDS_REQUEST_PORTAL             12
 116 //#define MDS_REPLY_PORTAL             13
 117 #define MDS_BULK_PORTAL                14
 118 #define LDLM_CB_REQUEST_PORTAL         15
 119 #define LDLM_CB_REPLY_PORTAL           16
 120 #define LDLM_CANCEL_REQUEST_PORTAL     17
 121 #define LDLM_CANCEL_REPLY_PORTAL       18
 122 #define PTLBD_REQUEST_PORTAL           19
 123 #define PTLBD_REPLY_PORTAL             20
 124 #define PTLBD_BULK_PORTAL              21
 125 #define MDS_SETATTR_PORTAL             22
 126 #define MDS_READPAGE_PORTAL            23
 127 #define MGMT_REQUEST_PORTAL            24
 128 #define MGMT_REPLY_PORTAL              25
 129 #define MGMT_CLI_REQUEST_PORTAL        26
 130 #define MGMT_CLI_REPLY_PORTAL          27
 131
 132 #define SVC_KILLED               1
 133 #define SVC_EVENT                2
 134 #define SVC_SIGNAL               4
 135 #define SVC_RUNNING              8
 136 #define SVC_STOPPING            16
 137 #define SVC_STOPPED             32
 138
 139 /* packet types */
 140 #define PTL_RPC_MSG_REQUEST 4711
 141 #define PTL_RPC_MSG_ERR     4712
 142 #define PTL_RPC_MSG_REPLY   4713
 143
 144 #define PTLRPC_MSG_MAGIC    0x0BD00BD0
 145
 146
 147 #define PTLRPC_MSG_VERSION  0x00000003
 148 #define LUSTRE_MDS_VERSION  (0x00040000|PTLRPC_MSG_VERSION)
 149 #define LUSTRE_OST_VERSION  (0x00040000|PTLRPC_MSG_VERSION)
 150 #define LUSTRE_DLM_VERSION  (0x00040000|PTLRPC_MSG_VERSION)
 151
 152 struct lustre_handle {
 153         __u64 cookie;
 154 };
 155 #define DEAD_HANDLE_MAGIC 0xdeadbeefcafebabeULL
 156
 157 /* we depend on this structure to be 8-byte aligned */
 158 /* this type is only endian-adjusted in lustre_unpack_msg() */
 159 struct lustre_msg {
 160         struct lustre_handle handle;
 161         __u32 magic;
 162         __u32 type;
 163         __u32 version;
 164         __u32 opc;
 165         __u64 last_xid;
 166         __u64 last_committed;
 167         __u64 transno;
 168         __u32 status;
 169         __u32 flags;
 170         __u32 conn_cnt;
 171         __u32 bufcount;
 172         __u32 buflens[0];
 173 };
 174
 175 /* Flags that are operation-specific go in the top 16 bits. */
 176 #define MSG_OP_FLAG_MASK   0xffff0000
 177 #define MSG_OP_FLAG_SHIFT  16
 178
 179 /* Flags that apply to all requests are in the bottom 16 bits */
 180 #define MSG_GEN_FLAG_MASK      0x0000ffff
 181 #define MSG_LAST_REPLAY        1
 182 #define MSG_RESENT             2
 183
 184 static inline int lustre_msg_get_flags(struct lustre_msg *msg)
 185 {
 186         return (msg->flags & MSG_GEN_FLAG_MASK);
 187 }
 188
 189 static inline void lustre_msg_add_flags(struct lustre_msg *msg, int flags)
 190 {
 191         msg->flags |= MSG_GEN_FLAG_MASK & flags;
 192 }
 193
 194 static inline void lustre_msg_set_flags(struct lustre_msg *msg, int flags)
 195 {
 196         msg->flags &= ~MSG_GEN_FLAG_MASK;
 197         lustre_msg_add_flags(msg, flags);
 198 }
 199
 200 static inline void lustre_msg_clear_flags(struct lustre_msg *msg, int flags)
 201 {
 202         msg->flags &= ~(MSG_GEN_FLAG_MASK & flags);
 203 }
 204
 205 static inline int lustre_msg_get_op_flags(struct lustre_msg *msg)
 206 {
 207         return (msg->flags >> MSG_OP_FLAG_SHIFT);
 208 }
 209
 210 static inline void lustre_msg_add_op_flags(struct lustre_msg *msg, int flags)
 211 {
 212         msg->flags |= ((flags & MSG_GEN_FLAG_MASK) << MSG_OP_FLAG_SHIFT);
 213 }
 214
 215 static inline void lustre_msg_set_op_flags(struct lustre_msg *msg, int flags)
 216 {
 217         msg->flags &= ~MSG_OP_FLAG_MASK;
 218         lustre_msg_add_op_flags(msg, flags);
 219 }
 220
 221 /*
 222  * Flags for all connect opcodes (MDS_CONNECT, OST_CONNECT)
 223  */
 224
 225 #define MSG_CONNECT_RECOVERING  0x1
 226 #define MSG_CONNECT_RECONNECT   0x2
 227 #define MSG_CONNECT_REPLAYABLE  0x4
 228 //#define MSG_CONNECT_PEER        0x8
 229
 230 /*
 231  *   OST requests: OBDO & OBD request records
 232  */
 233
 234 /* opcodes */
 235 typedef enum {
 236         OST_REPLY      =  0,       /* reply ? */
 237         OST_GETATTR    =  1,
 238         OST_SETATTR    =  2,
 239         OST_READ       =  3,
 240         OST_WRITE      =  4,
 241         OST_CREATE     =  5,
 242         OST_DESTROY    =  6,
 243         OST_GET_INFO   =  7,
 244         OST_CONNECT    =  8,
 245         OST_DISCONNECT =  9,
 246         OST_PUNCH      = 10,
 247         OST_OPEN       = 11,
 248         OST_CLOSE      = 12,
 249         OST_STATFS     = 13,
 250         OST_SAN_READ   = 14,
 251         OST_SAN_WRITE  = 15,
 252         OST_SYNC       = 16,
 253         OST_SET_INFO   = 17,
 254         OST_LAST_OPC
 255 } ost_cmd_t;
 256 #define OST_FIRST_OPC  OST_REPLY
 257
 258 typedef uint64_t        obd_id;
 259 typedef uint64_t        obd_gr;
 260 typedef uint64_t        obd_time;
 261 typedef uint64_t        obd_size;
 262 typedef uint64_t        obd_off;
 263 typedef uint64_t        obd_blocks;
 264 typedef uint32_t        obd_blksize;
 265 typedef uint32_t        obd_mode;
 266 typedef uint32_t        obd_uid;
 267 typedef uint32_t        obd_gid;
 268 typedef uint64_t        obd_rdev;
 269 typedef uint32_t        obd_flag;
 270 typedef uint32_t        obd_count;
 271
 272 #define OBD_FL_INLINEDATA   (0x00000001)
 273 #define OBD_FL_OBDMDEXISTS  (0x00000002)
 274 #define OBD_FL_DELORPHAN    (0x00000004) /* if set in o_flags delete orphans */
 275 #define OBD_FL_NORPC        (0x00000008) // if set in o_flags set in OSC not OST
 276 #define OBD_FL_IDONLY       (0x00000010) // if set in o_flags only adjust obj id
 277
 278 #define OBD_INLINESZ    64
 279
 280 /* Note: 64-bit types are 64-bit aligned in structure */
 281 struct obdo {
 282         obd_id                  o_id;
 283         obd_gr                  o_gr;
 284         obd_time                o_atime;
 285         obd_time                o_mtime;
 286         obd_time                o_ctime;
 287         obd_size                o_size;
 288         obd_blocks              o_blocks; /* brw: clients sent cached bytes */
 289         obd_rdev                o_rdev; /* brw: clients/servers sent grant */
 290         obd_blksize             o_blksize;      /* optimal IO blocksize */
 291         obd_mode                o_mode;
 292         obd_uid                 o_uid;
 293         obd_gid                 o_gid;
 294         obd_flag                o_flags;
 295         obd_count               o_nlink; /* brw: checksum */
 296         obd_count               o_generation;
 297         obd_flag                o_valid;        /* hot fields in this obdo */
 298         obd_flag                o_obdflags;
 299         __u32                   o_easize;       /* epoch in ost writes */
 300         char                    o_inline[OBD_INLINESZ]; /* fid in ost writes */
 301 };
 302
 303 extern void lustre_swab_obdo (struct obdo *o);
 304
 305 #define LOV_MAGIC_V1      0x0BD10BD0
 306 #define LOV_MAGIC         LOV_MAGIC_V1
 307
 308 #define LOV_PATTERN_RAID0 0x001   /* stripes are used round-robin */
 309 #define LOV_PATTERN_RAID1 0x002   /* stripes are mirrors of each other */
 310 #define LOV_PATTERN_FIRST 0x100   /* first stripe is not in round-robin */
 311
 312 #define lov_ost_data lov_ost_data_v1
 313 struct lov_ost_data_v1 {          /* per-stripe data structure (little-endian)*/
 314         __u64 l_object_id;        /* OST object ID */
 315         __u64 l_object_gr;        /* OST object group (creating MDS number) */
 316         __u32 l_ost_gen;          /* generation of this l_ost_idx */
 317         __u32 l_ost_idx;          /* OST index in LOV (lov_tgt_desc->tgts) */
 318 };
 319
 320 #define lov_mds_md lov_mds_md_v1
 321 struct lov_mds_md_v1 {            /* LOV EA mds/wire data (little-endian) */
 322         __u32 lmm_magic;          /* magic number = LOV_MAGIC_V1 */
 323         __u32 lmm_pattern;        /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */
 324         __u64 lmm_object_id;      /* LOV object ID */
 325         __u64 lmm_object_gr;      /* LOV object group */
 326         __u32 lmm_stripe_size;    /* size of stripe in bytes */
 327         __u32 lmm_stripe_count;   /* num stripes in use for this object */
 328         struct lov_ost_data_v1 lmm_objects[0]; /* per-stripe data */
 329 };
 330
 331 #define LOV_MAGIC_V0      0x0BD00BD0
 332
 333 struct lov_ost_data_v0 {          /* per-stripe data structure (little-endian)*/
 334         __u64 l_object_id;        /* OST object ID */
 335 };
 336
 337 struct lov_mds_md_v0 {            /* LOV EA mds/wire data (little-endian) */
 338         __u32 lmm_magic;          /* magic number = LOV_MAGIC_V0 */
 339         __u64 lmm_object_id;      /* LOV object ID */
 340         __u32 lmm_stripe_size;    /* size of the stripe in bytes (not RAID1) */
 341         __u32 lmm_stripe_offset;  /* starting stripe offset in lmm_objects */
 342         __u16 lmm_stripe_count;   /* number of stipes in use for this object */
 343         __u16 lmm_ost_count;      /* how many OST idx are in this LOV md */
 344         struct lov_ost_data_v0 lmm_objects[0];
 345 } __attribute__((packed));
 346
 347 #define OBD_MD_FLALL    (0xffffffff)
 348 #define OBD_MD_FLID     (0x00000001)    /* object ID */
 349 #define OBD_MD_FLATIME  (0x00000002)    /* access time */
 350 #define OBD_MD_FLMTIME  (0x00000004)    /* data modification time */
 351 #define OBD_MD_FLCTIME  (0x00000008)    /* change time */
 352 #define OBD_MD_FLSIZE   (0x00000010)    /* size */
 353 #define OBD_MD_FLBLOCKS (0x00000020)    /* allocated blocks count */
 354 #define OBD_MD_FLBLKSZ  (0x00000040)    /* block size */
 355 #define OBD_MD_FLMODE   (0x00000080)    /* access bits (mode & ~S_IFMT) */
 356 #define OBD_MD_FLTYPE   (0x00000100)    /* object type (mode & S_IFMT) */
 357 #define OBD_MD_FLUID    (0x00000200)    /* user ID */
 358 #define OBD_MD_FLGID    (0x00000400)    /* group ID */
 359 #define OBD_MD_FLFLAGS  (0x00000800)    /* flags word */
 360 #define OBD_MD_FLOBDFLG (0x00001000)
 361 #define OBD_MD_FLNLINK  (0x00002000)    /* link count */
 362 #define OBD_MD_FLGENER  (0x00004000)    /* generation number */
 363 #define OBD_MD_FLINLINE (0x00008000)    /* inline data */
 364 #define OBD_MD_FLRDEV   (0x00010000)    /* device number */
 365 #define OBD_MD_FLEASIZE (0x00020000)    /* extended attribute data */
 366 #define OBD_MD_LINKNAME (0x00040000)    /* symbolic link target */
 367 #define OBD_MD_FLHANDLE (0x00080000)    /* file handle */
 368 #define OBD_MD_FLCKSUM  (0x00100000)    /* bulk data checksum */
 369 #define OBD_MD_FLQOS    (0x00200000)    /* quality of service stats */
 370 #define OBD_MD_FLOSCOPQ (0x00400000)    /* osc opaque data */
 371 #define OBD_MD_FLCOOKIE (0x00800000)    /* log cancellation cookie */
 372 #define OBD_MD_FLGROUP  (0x01000000)    /* group */
 373 #define OBD_MD_FLIFID   (0x02000000)    /* ->ost write inline fid */
 374 #define OBD_MD_FLEPOCH  (0x04000000)    /* ->ost write easize is epoch */
 375 #define OBD_MD_FLNOTOBD (~(OBD_MD_FLOBDFLG | OBD_MD_FLBLOCKS | OBD_MD_LINKNAME|\
 376                            OBD_MD_FLEASIZE | OBD_MD_FLHANDLE | OBD_MD_FLCKSUM|\
 377                            OBD_MD_FLQOS | OBD_MD_FLOSCOPQ | OBD_MD_FLCOOKIE))
 378
 379
 380 static inline struct lustre_handle *obdo_handle(struct obdo *oa)
 381 {
 382         return (struct lustre_handle *)oa->o_inline;
 383 }
 384
 385 static inline struct llog_cookie *obdo_logcookie(struct obdo *oa)
 386 {
 387         return (struct llog_cookie *)(oa->o_inline +
 388                                       sizeof(struct lustre_handle));
 389 }
 390 /* don't forget obdo_fid which is way down at the bottom so it can
 391  * come after the definition of llog_cookie */
 392
 393 struct obd_statfs {
 394         __u64           os_type;
 395         __u64           os_blocks;
 396         __u64           os_bfree;
 397         __u64           os_bavail;
 398         __u64           os_files;
 399         __u64           os_ffree;
 400         __u8            os_fsid[40];
 401         __u32           os_bsize;
 402         __u32           os_namelen;
 403         __u64           os_maxbytes;
 404         __u32           os_spare[10];
 405 };
 406
 407 extern void lustre_swab_obd_statfs (struct obd_statfs *os);
 408
 409 /* ost_body.data values for OST_BRW */
 410
 411 #define OBD_BRW_READ       0x01
 412 #define OBD_BRW_WRITE      0x02
 413 #define OBD_BRW_RWMASK     (OBD_BRW_READ | OBD_BRW_WRITE)
 414 #define OBD_BRW_CREATE     0x04
 415 #define OBD_BRW_SYNC       0x08
 416 #define OBD_BRW_CHECK      0x10
 417 #define OBD_BRW_FROM_GRANT 0x20 /* the osc manages this under llite */
 418
 419 #define OBD_OBJECT_EOF 0xffffffffffffffffULL
 420
 421 struct obd_ioobj {
 422         obd_id               ioo_id;
 423         obd_gr               ioo_gr;
 424         __u32                ioo_type;
 425         __u32                ioo_bufcnt;
 426 };
 427
 428 extern void lustre_swab_obd_ioobj (struct obd_ioobj *ioo);
 429
 430 /* multiple of 8 bytes => can array */
 431 struct niobuf_remote {
 432         __u64 offset;
 433         __u32 len;
 434         __u32 flags;
 435 };
 436
 437 extern void lustre_swab_niobuf_remote (struct niobuf_remote *nbr);
 438
 439 /* request structure for OST's */
 440
 441 #define OST_REQ_HAS_OA1  0x1
 442
 443 struct ost_body {
 444         struct  obdo oa;
 445 };
 446
 447 extern void lustre_swab_ost_body (struct ost_body *b);
 448 extern void lustre_swab_ost_last_id(obd_id *id);
 449
 450 /*
 451  *   MDS REQ RECORDS
 452  */
 453
 454 /* opcodes */
 455 typedef enum {
 456         MDS_GETATTR      = 33,
 457         MDS_GETATTR_NAME = 34,
 458         MDS_CLOSE        = 35,
 459         MDS_REINT        = 36,
 460         MDS_READPAGE     = 37,
 461         MDS_CONNECT      = 38,
 462         MDS_DISCONNECT   = 39,
 463         MDS_GETSTATUS    = 40,
 464         MDS_STATFS       = 41,
 465         MDS_PIN          = 42,
 466         MDS_UNPIN        = 43,
 467         MDS_SYNC         = 44,
 468         MDS_DONE_WRITING = 45,
 469         MDS_LAST_OPC
 470 } mds_cmd_t;
 471 #define MDS_FIRST_OPC    MDS_GETATTR
 472
 473 /*
 474  * Do not exceed 63
 475  */
 476
 477 #define REINT_SETATTR  1
 478 #define REINT_CREATE   2
 479 #define REINT_LINK     3
 480 #define REINT_UNLINK   4
 481 #define REINT_RENAME   5
 482 #define REINT_OPEN     6
 483 #define REINT_MAX      6
 484
 485 /* the disposition of the intent outlines what was executed */
 486 #define DISP_IT_EXECD   1
 487 #define DISP_LOOKUP_EXECD  (1 << 1)
 488 #define DISP_LOOKUP_NEG     (1 << 2)
 489 #define DISP_LOOKUP_POS     (1 << 3)
 490 #define DISP_OPEN_CREATE  (1 << 4)
 491 #define DISP_OPEN_OPEN    (1 << 5)
 492 #define DISP_ENQ_COMPLETE (1<<6)
 493
 494
 495 struct ll_uctxt {
 496         __u32 gid1;
 497         __u32 gid2;
 498 };
 499
 500 struct ll_fid {
 501         __u64 id;
 502         __u32 generation;
 503         __u32 f_type;
 504 };
 505
 506 extern void lustre_swab_ll_fid (struct ll_fid *fid);
 507
 508 #define MDS_STATUS_CONN 1
 509 #define MDS_STATUS_LOV 2
 510
 511 struct mds_status_req {
 512         __u32  flags;
 513         __u32  repbuf;
 514 };
 515
 516 extern void lustre_swab_mds_status_req (struct mds_status_req *r);
 517
 518 #define MDS_BFLAG_UNCOMMITTED_WRITES   0x1
 519
 520 struct mds_body {
 521         struct ll_fid  fid1;
 522         struct ll_fid  fid2;
 523         struct lustre_handle handle;
 524         __u64          size;   /* Offset, in the case of MDS_READPAGE */
 525         __u64          blocks; /* XID, in the case of MDS_READPAGE */
 526         __u64          io_epoch;
 527         __u32          ino;   /* make this a __u64 */
 528         __u32          valid;
 529         __u32          fsuid;
 530         __u32          fsgid;
 531         __u32          capability;
 532         __u32          mode;
 533         __u32          uid;
 534         __u32          gid;
 535         __u32          mtime;
 536         __u32          ctime;
 537         __u32          atime;
 538         __u32          flags; /* from vfs for pin/unpin, MDS_BFLAG for close */
 539         __u32          rdev;
 540         __u32          nlink; /* #bytes to read in the case of MDS_READPAGE */
 541         __u32          generation;
 542         __u32          suppgid;
 543         __u32          eadatasize;
 544         __u32          packing;
 545 };
 546
 547 extern void lustre_swab_mds_body (struct mds_body *b);
 548
 549
 550 /* MDS update records */
 551
 552 //struct mds_update_record_hdr {
 553 //        __u32 ur_opcode;
 554 //};
 555
 556 struct mds_rec_setattr {
 557         __u32           sa_opcode;
 558         __u32           sa_fsuid;
 559         __u32           sa_fsgid;
 560         __u32           sa_cap;
 561         __u32           sa_suppgid;
 562         __u32           sa_valid;
 563         struct ll_fid   sa_fid;
 564         __u32           sa_mode;
 565         __u32           sa_uid;
 566         __u32           sa_gid;
 567         __u32           sa_attr_flags;
 568         __u64           sa_size;
 569         __u64           sa_atime;
 570         __u64           sa_mtime;
 571         __u64           sa_ctime;
 572 };
 573
 574 /* Remove this once we declare it in include/linux/fs.h (v21 kernel patch?) */
 575 #ifndef ATTR_CTIME_SET
 576 #define ATTR_CTIME_SET 0x2000
 577 #endif
 578
 579 extern void lustre_swab_mds_rec_setattr (struct mds_rec_setattr *sa);
 580
 581 #ifndef FMODE_READ
 582 #define FMODE_READ               00000001
 583 #define FMODE_WRITE              00000002
 584 #endif
 585 #ifndef FMODE_EXEC
 586 #define FMODE_EXEC               00000004
 587 #endif
 588 #define MDS_OPEN_CREAT           00000100
 589 #define MDS_OPEN_EXCL            00000200
 590 #define MDS_OPEN_TRUNC           00001000
 591 #define MDS_OPEN_APPEND          00002000
 592 #define MDS_OPEN_SYNC            00010000
 593 #define MDS_OPEN_DIRECTORY       00200000
 594
 595 #define MDS_OPEN_DELAY_CREATE  0100000000 /* delay initial object create */
 596 #define MDS_OPEN_HAS_EA      010000000000 /* specify object create pattern */
 597
 598 struct mds_rec_create {
 599         __u32           cr_opcode;
 600         __u32           cr_fsuid;
 601         __u32           cr_fsgid;
 602         __u32           cr_cap;
 603         __u32           cr_flags; /* for use with open */
 604         __u32           cr_mode;
 605         struct ll_fid   cr_fid;
 606         struct ll_fid   cr_replayfid;
 607         __u64           cr_time;
 608         __u64           cr_rdev;
 609         __u32           cr_suppgid;
 610         __u32           cr_packing;
 611 };
 612
 613 extern void lustre_swab_mds_rec_create (struct mds_rec_create *cr);
 614
 615 struct mds_rec_link {
 616         __u32           lk_opcode;
 617         __u32           lk_fsuid;
 618         __u32           lk_fsgid;
 619         __u32           lk_cap;
 620         __u32           lk_suppgid1;
 621         __u32           lk_suppgid2;
 622         struct ll_fid   lk_fid1;
 623         struct ll_fid   lk_fid2;
 624         __u64           lk_time;
 625 };
 626
 627 extern void lustre_swab_mds_rec_link (struct mds_rec_link *lk);
 628
 629 struct mds_rec_unlink {
 630         __u32           ul_opcode;
 631         __u32           ul_fsuid;
 632         __u32           ul_fsgid;
 633         __u32           ul_cap;
 634         __u32           ul_suppgid;
 635         __u32           ul_mode;
 636         struct ll_fid   ul_fid1;
 637         struct ll_fid   ul_fid2;
 638         __u64           ul_time;
 639 };
 640
 641 extern void lustre_swab_mds_rec_unlink (struct mds_rec_unlink *ul);
 642
 643 struct mds_rec_rename {
 644         __u32           rn_opcode;
 645         __u32           rn_fsuid;
 646         __u32           rn_fsgid;
 647         __u32           rn_cap;
 648         __u32           rn_suppgid1;
 649         __u32           rn_suppgid2;
 650         struct ll_fid   rn_fid1;
 651         struct ll_fid   rn_fid2;
 652         __u64           rn_time;
 653 };
 654
 655 extern void lustre_swab_mds_rec_rename (struct mds_rec_rename *rn);
 656
 657 /*
 658  *  LOV data structures
 659  */
 660
 661 #define LOV_MAX_UUID_BUFFER_SIZE  8192
 662 /* The size of the buffer the lov/mdc reserves for the
 663  * array of UUIDs returned by the MDS.  With the current
 664  * protocol, this will limit the max number of OSTs per LOV */
 665
 666 struct lov_desc {
 667         __u32 ld_tgt_count;                /* how many OBD's */
 668         __u32 ld_active_tgt_count;         /* how many active */
 669         __u32 ld_default_stripe_count;     /* how many objects are used */
 670         __u32 ld_pattern;                  /* PATTERN_RAID0, PATTERN_RAID1 */
 671         __u64 ld_default_stripe_size;      /* in bytes */
 672         __u64 ld_default_stripe_offset;    /* in bytes */
 673         struct obd_uuid ld_uuid;
 674 };
 675
 676 extern void lustre_swab_lov_desc (struct lov_desc *ld);
 677
 678 /*
 679  *   LDLM requests:
 680  */
 681 /* opcodes -- MUST be distinct from OST/MDS opcodes */
 682 typedef enum {
 683         LDLM_ENQUEUE     = 101,
 684         LDLM_CONVERT     = 102,
 685         LDLM_CANCEL      = 103,
 686         LDLM_BL_CALLBACK = 104,
 687         LDLM_CP_CALLBACK = 105,
 688         LDLM_LAST_OPC
 689 } ldlm_cmd_t;
 690 #define LDLM_FIRST_OPC LDLM_ENQUEUE
 691
 692 #define RES_NAME_SIZE 4
 693 #define RES_VERSION_SIZE 4
 694
 695 struct ldlm_res_id {
 696         __u64 name[RES_NAME_SIZE];
 697 };
 698
 699 extern void lustre_swab_ldlm_res_id (struct ldlm_res_id *id);
 700
 701 /* lock types */
 702 typedef enum {
 703         LCK_EX = 1,
 704         LCK_PW,
 705         LCK_PR,
 706         LCK_CW,
 707         LCK_CR,
 708         LCK_NL
 709 } ldlm_mode_t;
 710
 711 struct ldlm_extent {
 712         __u64 start;
 713         __u64 end;
 714 };
 715
 716 struct ldlm_flock {
 717         __u64 start;
 718         __u64 end;
 719         __u64 blocking_export;
 720         pid_t blocking_pid;
 721         pid_t pid;
 722 };
 723
 724 /* it's important that the fields of the ldlm_extent structure match
 725  * the first fields of the ldlm_flock structure because there is only
 726  * one ldlm_swab routine to process the ldlm_policy_data_t union. if
 727  * this ever changes we will need to swab the union differently based
 728  * on the resource type. */
 729
 730 typedef union {
 731         struct ldlm_extent l_extent;
 732         struct ldlm_flock  l_flock;
 733 } ldlm_policy_data_t;
 734
 735 extern void lustre_swab_ldlm_policy_data (ldlm_policy_data_t *d);
 736
 737 struct ldlm_intent {
 738         __u64 opc;
 739 };
 740
 741 extern void lustre_swab_ldlm_intent (struct ldlm_intent *i);
 742
 743 /* Note this unaligned structure; as long as it's only used in ldlm_request
 744  * below, we're probably fine. */
 745 struct ldlm_resource_desc {
 746         __u32 lr_type;
 747         struct ldlm_res_id lr_name;
 748         __u32 lr_version[RES_VERSION_SIZE];
 749 } __attribute__((packed));
 750
 751 extern void lustre_swab_ldlm_resource_desc (struct ldlm_resource_desc *r);
 752
 753 struct ldlm_lock_desc {
 754         struct ldlm_resource_desc l_resource;
 755         ldlm_mode_t l_req_mode;
 756         ldlm_mode_t l_granted_mode;
 757         ldlm_policy_data_t l_policy_data;
 758         __u32 l_version[RES_VERSION_SIZE];
 759 } __attribute__((packed));
 760
 761 extern void lustre_swab_ldlm_lock_desc (struct ldlm_lock_desc *l);
 762
 763 struct ldlm_request {
 764         __u32 lock_flags;
 765         struct ldlm_lock_desc lock_desc;
 766         struct lustre_handle lock_handle1;
 767         struct lustre_handle lock_handle2;
 768 } __attribute__((packed));
 769
 770 extern void lustre_swab_ldlm_request (struct ldlm_request *rq);
 771
 772 struct ldlm_reply {
 773         __u32 lock_flags;
 774         __u32 lock_mode;
 775         struct ldlm_res_id lock_resource_name;
 776         struct lustre_handle lock_handle;
 777         ldlm_policy_data_t lock_policy_data;
 778         __u64  lock_policy_res1;
 779         __u64  lock_policy_res2;
 780 };
 781
 782 extern void lustre_swab_ldlm_reply (struct ldlm_reply *r);
 783
 784 /*
 785  * ptlbd, portal block device requests
 786  */
 787 typedef enum {
 788         PTLBD_QUERY = 200,
 789         PTLBD_READ = 201,
 790         PTLBD_WRITE = 202,
 791         PTLBD_FLUSH = 203,
 792         PTLBD_CONNECT = 204,
 793         PTLBD_DISCONNECT = 205,
 794         PTLBD_LAST_OPC
 795 } ptlbd_cmd_t;
 796 #define PTLBD_FIRST_OPC PTLBD_QUERY
 797
 798 struct ptlbd_op {
 799         __u16 op_cmd;
 800         __u16 op_lun;
 801         __u16 op_niob_cnt;
 802         __u16 op__padding;
 803         __u32 op_block_cnt;
 804 };
 805
 806 extern void lustre_swab_ptlbd_op (struct ptlbd_op *op);
 807
 808 struct ptlbd_niob {
 809         __u64 n_xid;
 810         __u64 n_block_nr;
 811         __u32 n_offset;
 812         __u32 n_length;
 813 };
 814
 815 extern void lustre_swab_ptlbd_niob (struct ptlbd_niob *n);
 816
 817 struct ptlbd_rsp {
 818         __u16 r_status;
 819         __u16 r_error_cnt;
 820 };
 821
 822 extern void lustre_swab_ptlbd_rsp (struct ptlbd_rsp *r);
 823
 824 /*
 825  * Opcodes for management/monitoring node.
 826  */
 827 #define MGMT_CONNECT    250
 828 #define MGMT_DISCONNECT 251
 829 #define MGMT_EXCEPTION  252 /* node died, etc. */
 830
 831 /*
 832  * Opcodes for multiple servers.
 833  */
 834
 835 #define OBD_PING       400
 836 #define OBD_LOG_CANCEL 401
 837 #define OBD_LAST_OPC  (OBD_LOG_CANCEL + 1)
 838 #define OBD_FIRST_OPC OBD_PING
 839
 840 /* catalog of log objects */
 841
 842 /* Identifier for a single log object */
 843 struct llog_logid {
 844         __u64                   lgl_oid;
 845         __u64                   lgl_ogr;
 846         __u32                   lgl_ogen;
 847 } __attribute__((packed));
 848
 849 /* Log data record types - there is no specific reason that these need to
 850  * be related to the RPC opcodes, but no reason not to (may be handy later?)
 851  */
 852 typedef enum {
 853         OST_SZ_REC       = 0x10600000 | (OST_SAN_WRITE << 8),
 854         OST_RAID1_REC    = 0x10600000 | ((OST_SAN_WRITE + 1) << 8),
 855         MDS_UNLINK_REC   = 0x10610000 | (MDS_REINT << 8) | REINT_UNLINK,
 856         OBD_CFG_REC      = 0x10620000,
 857         PTL_CFG_REC      = 0x10630000,
 858         LLOG_HDR_MAGIC   = 0x10645539,
 859         LLOG_LOGID_MAGIC = 0x1064553a,
 860 } llog_op_type;
 861
 862 /* Log record header - stored in little endian order.
 863  * Each record must start with this struct, end with a llog_rec_tail,
 864  * and be a multiple of 256 bits in size.
 865  */
 866 struct llog_rec_hdr {
 867         __u32                   lrh_len;
 868         __u32                   lrh_index;
 869         __u32                   lrh_type;
 870         __u32                   padding;
 871 };
 872
 873 struct llog_rec_tail {
 874         __u32 lrt_len;
 875         __u32 lrt_index;
 876 };
 877
 878 struct llog_logid_rec {
 879         struct llog_rec_hdr     lid_hdr;
 880         struct llog_logid       lid_id;
 881         __u32                   padding;
 882         struct llog_rec_tail    lid_tail;
 883 } __attribute__((packed));
 884
 885 struct llog_create_rec {
 886         struct llog_rec_hdr     lcr_hdr;
 887         struct ll_fid           lcr_fid;
 888         obd_id                  lcr_oid;
 889         obd_count               lcr_ogen;
 890         __u32                   padding;
 891         struct llog_rec_tail    lcr_tail;
 892 } __attribute__((packed));
 893
 894 struct llog_orphan_rec {
 895         struct llog_rec_hdr     lor_hdr;
 896         obd_id                  lor_oid;
 897         obd_count               lor_ogen;
 898         __u32                   padding;
 899         struct llog_rec_tail    lor_tail;
 900 } __attribute__((packed));
 901
 902 struct llog_unlink_rec {
 903         struct llog_rec_hdr     lur_hdr;
 904         obd_id                  lur_oid;
 905         obd_count               lur_ogen;
 906         __u32                   padding;
 907         struct llog_rec_tail    lur_tail;
 908 } __attribute__((packed));
 909
 910 struct llog_size_change_rec {
 911         struct llog_rec_hdr     lsc_hdr;
 912         struct ll_fid           lsc_fid;
 913         __u32                   lsc_io_epoch;
 914         __u32                   padding;
 915         struct llog_rec_tail    lsc_tail;
 916 } __attribute__((packed));
 917
 918 /* On-disk header structure of each log object, stored in little endian order */
 919 #define LLOG_CHUNK_SIZE         4096
 920 #define LLOG_HEADER_SIZE        (96)
 921 #define LLOG_BITMAP_BYTES       (LLOG_CHUNK_SIZE - LLOG_HEADER_SIZE)
 922
 923 #define LLOG_MIN_REC_SIZE       (24) /* round(llog_rec_hdr + llog_rec_tail) */
 924
 925 /* flags for the logs */
 926 #define LLOG_F_ZAP_WHEN_EMPTY   0x1
 927 #define LLOG_F_IS_CAT           0x2
 928 #define LLOG_F_IS_PLAIN         0x4
 929
 930 struct llog_log_hdr {
 931         struct llog_rec_hdr     llh_hdr;
 932         __u64                   llh_timestamp;
 933         __u32                   llh_count;
 934         __u32                   llh_bitmap_offset;
 935         __u32                   llh_size;
 936         __u32                   llh_flags;
 937         __u32                   llh_cat_idx;
 938         struct obd_uuid         llh_tgtuuid;
 939         __u32                   llh_reserved[LLOG_HEADER_SIZE/sizeof(__u32) - 23];
 940         __u32                   llh_bitmap[LLOG_BITMAP_BYTES/sizeof(__u32)];
 941         struct llog_rec_tail    llh_tail;
 942 } __attribute__((packed));
 943
 944 /* log cookies are used to reference a specific log file and a record therein */
 945 struct llog_cookie {
 946         struct llog_logid       lgc_lgl;
 947         __u32                   lgc_subsys;
 948         __u32                   lgc_index;
 949         __u32                   lgc_padding;
 950 } __attribute__((packed));
 951
 952 /* llog protocol */
 953 enum llogd_rpc_ops {
 954         LLOG_ORIGIN_HANDLE_CREATE       = 501,
 955         LLOG_ORIGIN_HANDLE_NEXT_BLOCK   = 502,
 956         LLOG_ORIGIN_HANDLE_READ_HEADER  = 503,
 957         LLOG_ORIGIN_HANDLE_WRITE_REC    = 504,
 958         LLOG_ORIGIN_HANDLE_CLOSE        = 505,
 959         LLOG_ORIGIN_CONNECT             = 506,
 960         LLOG_CATINFO                    = 507,  /* for lfs catinfo */
 961 };
 962
 963 struct llogd_body {
 964         struct llog_logid  lgd_logid;
 965         __u32 lgd_ctxt_idx;
 966         __u32 lgd_llh_flags;
 967         __u32 lgd_index;
 968         __u32 lgd_saved_index;
 969         __u32 lgd_len;
 970         __u64 lgd_cur_offset;
 971 } __attribute__((packed));
 972
 973 struct llog_ctxt_gen {
 974         __u64 mnt_cnt;
 975         __u64 conn_cnt;
 976 };
 977
 978 struct llogd_conn_body {
 979         struct llog_ctxt_gen    lgdc_gen;
 980         struct llog_logid       lgdc_logid;
 981         __u32                   lgdc_ctxt_idx;
 982 } __attribute__((packed));
 983
 984 extern void lustre_swab_llogd_body (struct llogd_body *d);
 985 extern void lustre_swab_llog_hdr (struct llog_log_hdr *h);
 986 extern void lustre_swab_llogd_conn_body (struct llogd_conn_body *d);
 987
 988 static inline struct ll_fid *obdo_fid(struct obdo *oa)
 989 {
 990         return (struct ll_fid *)(oa->o_inline + sizeof(struct lustre_handle) +
 991                                  sizeof(struct llog_cookie));
 992 }
 993
 994 #endif