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 <linux/fs.h>     /* to check for FMODE_EXEC, dev_t, lest we redefine */
  58 #else
  59 #ifdef __CYGWIN__
  60 # include <sys/types.h>
  61 #else
  62 # include <asm/types.h>
  63 # include <stdint.h>
  64 #endif
  65 # include <portals/list.h>
  66 # include <string.h>
  67 #endif
  68
  69 /* Defn's shared with user-space. */
  70 #include <lustre/lustre_user.h>
  71
  72 /*
  73  * this file contains all data structures used in Lustre interfaces:
  74  * - obdo and obd_request records
  75  * - mds_request records
  76  * - ldlm data
  77  * - ioctl's
  78  */
  79
  80 /*
  81  *  GENERAL STUFF
  82  */
  83 /* FOO_REQUEST_PORTAL is for incoming requests on the FOO
  84  * FOO_REPLY_PORTAL   is for incoming replies on the FOO
  85  * FOO_BULK_PORTAL    is for incoming bulk on the FOO
  86  */
  87
  88 #define CONNMGR_REQUEST_PORTAL          1
  89 #define CONNMGR_REPLY_PORTAL            2
  90 //#define OSC_REQUEST_PORTAL            3
  91 #define OSC_REPLY_PORTAL                4
  92 //#define OSC_BULK_PORTAL               5
  93 #define OST_REQUEST_PORTAL              6
  94 #define OST_CREATE_PORTAL               7
  95 #define OST_BULK_PORTAL                 8
  96 //#define MDC_REQUEST_PORTAL            9
  97 #define MDC_REPLY_PORTAL               10
  98 //#define MDC_BULK_PORTAL              11
  99 #define MDS_REQUEST_PORTAL             12
 100 //#define MDS_REPLY_PORTAL             13
 101 #define MDS_BULK_PORTAL                14
 102 #define LDLM_CB_REQUEST_PORTAL         15
 103 #define LDLM_CB_REPLY_PORTAL           16
 104 #define LDLM_CANCEL_REQUEST_PORTAL     17
 105 #define LDLM_CANCEL_REPLY_PORTAL       18
 106 #define PTLBD_REQUEST_PORTAL           19
 107 #define PTLBD_REPLY_PORTAL             20
 108 #define PTLBD_BULK_PORTAL              21
 109 #define MDS_SETATTR_PORTAL             22
 110 #define MDS_READPAGE_PORTAL            23
 111 #define MGMT_REQUEST_PORTAL            24
 112 #define MGMT_REPLY_PORTAL              25
 113 #define MGMT_CLI_REQUEST_PORTAL        26
 114 #define MGMT_CLI_REPLY_PORTAL          27
 115
 116 #define SVC_KILLED               1
 117 #define SVC_EVENT                2
 118 #define SVC_SIGNAL               4
 119 #define SVC_RUNNING              8
 120 #define SVC_STOPPING            16
 121 #define SVC_STOPPED             32
 122
 123 /* packet types */
 124 #define PTL_RPC_MSG_REQUEST 4711
 125 #define PTL_RPC_MSG_ERR     4712
 126 #define PTL_RPC_MSG_REPLY   4713
 127
 128 #define PTLRPC_MSG_MAGIC    0x0BD00BD0
 129
 130
 131 #define PTLRPC_MSG_VERSION  0x00000003
 132 #define LUSTRE_VERSION_MASK 0xffff0000
 133 #define LUSTRE_OBD_VERSION  0x00010000
 134 #define LUSTRE_MDS_VERSION  0x00020000
 135 #define LUSTRE_OST_VERSION  0x00030000
 136 #define LUSTRE_DLM_VERSION  0x00040000
 137 #define LUSTRE_LOG_VERSION  0x00050000
 138 #define LUSTRE_PBD_VERSION  0x00060000
 139
 140 struct lustre_handle {
 141         __u64 cookie;
 142 };
 143 #define DEAD_HANDLE_MAGIC 0xdeadbeefcafebabeULL
 144
 145 /* we depend on this structure to be 8-byte aligned */
 146 /* this type is only endian-adjusted in lustre_unpack_msg() */
 147 struct lustre_msg {
 148         struct lustre_handle handle;
 149         __u32 magic;
 150         __u32 type;
 151         __u32 version;
 152         __u32 opc;
 153         __u64 last_xid;
 154         __u64 last_committed;
 155         __u64 transno;
 156         __u32 status;
 157         __u32 flags;
 158         __u32 conn_cnt;
 159         __u32 bufcount;
 160         __u32 buflens[0];
 161 };
 162
 163 /* Flags that are operation-specific go in the top 16 bits. */
 164 #define MSG_OP_FLAG_MASK   0xffff0000
 165 #define MSG_OP_FLAG_SHIFT  16
 166
 167 /* Flags that apply to all requests are in the bottom 16 bits */
 168 #define MSG_GEN_FLAG_MASK      0x0000ffff
 169 #define MSG_LAST_REPLAY        1
 170 #define MSG_RESENT             2
 171 #define MSG_REPLAY             4
 172
 173 static inline int lustre_msg_get_flags(struct lustre_msg *msg)
 174 {
 175         return (msg->flags & MSG_GEN_FLAG_MASK);
 176 }
 177
 178 static inline void lustre_msg_add_flags(struct lustre_msg *msg, int flags)
 179 {
 180         msg->flags |= MSG_GEN_FLAG_MASK & flags;
 181 }
 182
 183 static inline void lustre_msg_set_flags(struct lustre_msg *msg, int flags)
 184 {
 185         msg->flags &= ~MSG_GEN_FLAG_MASK;
 186         lustre_msg_add_flags(msg, flags);
 187 }
 188
 189 static inline void lustre_msg_clear_flags(struct lustre_msg *msg, int flags)
 190 {
 191         msg->flags &= ~(MSG_GEN_FLAG_MASK & flags);
 192 }
 193
 194 static inline int lustre_msg_get_op_flags(struct lustre_msg *msg)
 195 {
 196         return (msg->flags >> MSG_OP_FLAG_SHIFT);
 197 }
 198
 199 static inline void lustre_msg_add_op_flags(struct lustre_msg *msg, int flags)
 200 {
 201         msg->flags |= ((flags & MSG_GEN_FLAG_MASK) << MSG_OP_FLAG_SHIFT);
 202 }
 203
 204 static inline void lustre_msg_set_op_flags(struct lustre_msg *msg, int flags)
 205 {
 206         msg->flags &= ~MSG_OP_FLAG_MASK;
 207         lustre_msg_add_op_flags(msg, flags);
 208 }
 209
 210 /*
 211  * Flags for all connect opcodes (MDS_CONNECT, OST_CONNECT)
 212  */
 213
 214 #define MSG_CONNECT_RECOVERING  0x1
 215 #define MSG_CONNECT_RECONNECT   0x2
 216 #define MSG_CONNECT_REPLAYABLE  0x4
 217 //#define MSG_CONNECT_PEER        0x8
 218 #define MSG_CONNECT_LIBCLIENT   0x10
 219 #define MSG_CONNECT_INITIAL     0x20
 220
 221 /*
 222  *   OST requests: OBDO & OBD request records
 223  */
 224
 225 /* opcodes */
 226 typedef enum {
 227         OST_REPLY      =  0,       /* reply ? */
 228         OST_GETATTR    =  1,
 229         OST_SETATTR    =  2,
 230         OST_READ       =  3,
 231         OST_WRITE      =  4,
 232         OST_CREATE     =  5,
 233         OST_DESTROY    =  6,
 234         OST_GET_INFO   =  7,
 235         OST_CONNECT    =  8,
 236         OST_DISCONNECT =  9,
 237         OST_PUNCH      = 10,
 238         OST_OPEN       = 11,
 239         OST_CLOSE      = 12,
 240         OST_STATFS     = 13,
 241         OST_SAN_READ   = 14,
 242         OST_SAN_WRITE  = 15,
 243         OST_SYNC       = 16,
 244         OST_SET_INFO   = 17,
 245         OST_LAST_OPC
 246 } ost_cmd_t;
 247 #define OST_FIRST_OPC  OST_REPLY
 248
 249 typedef uint64_t        obd_id;
 250 typedef uint64_t        obd_gr;
 251 typedef uint64_t        obd_time;
 252 typedef uint64_t        obd_size;
 253 typedef uint64_t        obd_off;
 254 typedef uint64_t        obd_blocks;
 255 typedef uint32_t        obd_blksize;
 256 typedef uint32_t        obd_mode;
 257 typedef uint32_t        obd_uid;
 258 typedef uint32_t        obd_gid;
 259 typedef uint32_t        obd_flag;
 260 typedef uint32_t        obd_count;
 261
 262 #define OBD_FL_INLINEDATA   (0x00000001)
 263 #define OBD_FL_OBDMDEXISTS  (0x00000002)
 264 #define OBD_FL_DELORPHAN    (0x00000004) /* if set in o_flags delete orphans */
 265 #define OBD_FL_NORPC        (0x00000008) // if set in o_flags set in OSC not OST
 266 #define OBD_FL_IDONLY       (0x00000010) // if set in o_flags only adjust obj id
 267 #define OBD_FL_RECREATE_OBJS (0x00000020) // recreate missing obj
 268 #define OBD_FL_DEBUG_CHECK  (0x00000040) /* echo client/server debug check */
 269
 270 #define OBD_INLINESZ    64
 271
 272 /* Note: 64-bit types are 64-bit aligned in structure */
 273 struct obdo {
 274         obd_id                  o_id;
 275         obd_gr                  o_gr;
 276         obd_size                o_size;
 277         obd_time                o_mtime;
 278         obd_time                o_atime;
 279         obd_time                o_ctime;
 280         obd_blocks              o_blocks;       /* brw: cli sent cached bytes */
 281         obd_size                o_grant;
 282         obd_blksize             o_blksize;      /* optimal IO blocksize */
 283         obd_mode                o_mode;         /* brw: cli sent cache remain */
 284         obd_uid                 o_uid;
 285         obd_gid                 o_gid;
 286         obd_flag                o_flags;
 287         obd_count               o_nlink;        /* brw: checksum */
 288         obd_count               o_generation;
 289         obd_flag                o_valid;        /* hot fields in this obdo */
 290         obd_count               o_misc;          /* brw: o_dropped */
 291         __u32                   o_easize;       /* epoch in ost writes */
 292         __u32                   o_mds;
 293         __u32                   o_padding;
 294         char                    o_inline[OBD_INLINESZ]; /* fid in ost writes */
 295 };
 296
 297 #define o_dirty   o_blocks
 298 #define o_undirty o_mode
 299 #define o_dropped o_misc
 300 #define o_cksum   o_nlink
 301
 302 extern void lustre_swab_obdo (struct obdo *o);
 303
 304 #define LOV_MAGIC_V1      0x0BD10BD0
 305 #define LOV_MAGIC         LOV_MAGIC_V1
 306
 307 #define LOV_PATTERN_RAID0 0x001   /* stripes are used round-robin */
 308 #define LOV_PATTERN_RAID1 0x002   /* stripes are mirrors of each other */
 309 #define LOV_PATTERN_FIRST 0x100   /* first stripe is not in round-robin */
 310 #define LOV_PATTERN_CMOBD 0x200
 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_FLNLINK  (0x00002000)    /* link count */
 361 #define OBD_MD_FLGENER  (0x00004000)    /* generation number */
 362 #define OBD_MD_FLINLINE (0x00008000)    /* inline data */
 363 #define OBD_MD_FLRDEV   (0x00010000)    /* device number */
 364 #define OBD_MD_FLEASIZE (0x00020000)    /* extended attribute data */
 365 #define OBD_MD_LINKNAME (0x00040000)    /* symbolic link target */
 366 #define OBD_MD_FLHANDLE (0x00080000)    /* file handle */
 367 #define OBD_MD_FLCKSUM  (0x00100000)    /* bulk data checksum */
 368 #define OBD_MD_FLQOS    (0x00200000)    /* quality of service stats */
 369 #define OBD_MD_FLOSCOPQ (0x00400000)    /* osc opaque data */
 370 #define OBD_MD_FLCOOKIE (0x00800000)    /* log cancellation cookie */
 371 #define OBD_MD_FLGROUP  (0x01000000)    /* group */
 372 #define OBD_MD_FLIFID   (0x02000000)    /* ->ost write inline fid */
 373 #define OBD_MD_FLEPOCH  (0x04000000)    /* ->ost write easize is epoch */
 374 #define OBD_MD_FLGRANT  (0x08000000)    /* ost preallocation space grant */
 375 #define OBD_MD_MDS      (0x10000000)    /* where an inode lives on */
 376 #define OBD_MD_FLDIREA  (0x20000000)    /* dir's extended attribute data */
 377 #define OBD_MD_REINT    (0x40000000)    /* reintegrate oa*/
 378 #define OBD_MD_FLNOTOBD (~(OBD_MD_FLBLOCKS | OBD_MD_LINKNAME|\
 379                            OBD_MD_FLEASIZE | OBD_MD_FLHANDLE | OBD_MD_FLCKSUM|\
 380                            OBD_MD_FLQOS | OBD_MD_FLOSCOPQ | OBD_MD_FLCOOKIE|\
 381                            OBD_MD_MDS))
 382
 383
 384 static inline struct lustre_handle *obdo_handle(struct obdo *oa)
 385 {
 386         return (struct lustre_handle *)oa->o_inline;
 387 }
 388
 389 static inline struct llog_cookie *obdo_logcookie(struct obdo *oa)
 390 {
 391         return (struct llog_cookie *)(oa->o_inline +
 392                                       sizeof(struct lustre_handle));
 393 }
 394 /* don't forget obdo_fid which is way down at the bottom so it can
 395  * come after the definition of llog_cookie */
 396
 397 struct obd_statfs {
 398         __u64           os_type;
 399         __u64           os_blocks;
 400         __u64           os_bfree;
 401         __u64           os_bavail;
 402         __u64           os_files;
 403         __u64           os_ffree;
 404         __u8            os_fsid[40];
 405         __u32           os_bsize;
 406         __u32           os_namelen;
 407         __u64           os_maxbytes;
 408         __u32           os_spare[10];
 409 };
 410
 411 extern void lustre_swab_obd_statfs (struct obd_statfs *os);
 412
 413 /* ost_body.data values for OST_BRW */
 414
 415 #define OBD_BRW_READ       0x01
 416 #define OBD_BRW_WRITE      0x02
 417 #define OBD_BRW_RWMASK     (OBD_BRW_READ | OBD_BRW_WRITE)
 418 #define OBD_BRW_SYNC       0x08
 419 #define OBD_BRW_CHECK      0x10
 420 #define OBD_BRW_FROM_GRANT 0x20 /* the osc manages this under llite */
 421 #define OBD_BRW_GRANTED    0x40 /* the ost manages this */
 422
 423 #define OBD_OBJECT_EOF 0xffffffffffffffffULL
 424
 425 struct obd_ioobj {
 426         obd_id               ioo_id;
 427         obd_gr               ioo_gr;
 428         __u32                ioo_type;
 429         __u32                ioo_bufcnt;
 430 };
 431
 432 extern void lustre_swab_obd_ioobj (struct obd_ioobj *ioo);
 433
 434 /* multiple of 8 bytes => can array */
 435 struct niobuf_remote {
 436         __u64 offset;
 437         __u32 len;
 438         __u32 flags;
 439 };
 440
 441 extern void lustre_swab_niobuf_remote (struct niobuf_remote *nbr);
 442
 443 /* request structure for OST's */
 444
 445 #define OST_REQ_HAS_OA1  0x1
 446
 447 struct ost_body {
 448         struct  obdo oa;
 449 };
 450
 451 extern void lustre_swab_ost_body (struct ost_body *b);
 452 extern void lustre_swab_ost_last_id(obd_id *id);
 453
 454 /* lock value block communicated between the filter and llite */
 455
 456 struct ost_lvb {
 457         __u64 lvb_size;
 458         __u64 lvb_mtime;
 459         __u64 lvb_atime;
 460         __u64 lvb_ctime;
 461         __u64 lvb_blocks;
 462 };
 463
 464 extern void lustre_swab_ost_lvb(struct ost_lvb *);
 465
 466 /*
 467  *   MDS REQ RECORDS
 468  */
 469
 470 /* offsets in the request */
 471 #define MDS_REQ_SECDESC_OFF             0
 472 #define MDS_REQ_REC_OFF                 1
 473
 474 #define MDS_REQ_INTENT_LOCKREQ_OFF      1
 475 #define MDS_REQ_INTENT_IT_OFF           2
 476 #define MDS_REQ_INTENT_REC_OFF          3
 477
 478 /* maximum supplementary groups */
 479 #define LUSTRE_MAX_GROUPS               128
 480
 481 /*
 482  * security descriptor in mds request
 483  *
 484  * note gid & cap might need be removed later:
 485  *  - cap should be obtained on mds
 486  *  - gid is actually not used.
 487  */
 488 struct mds_req_sec_desc {
 489         __u32           rsd_uid;
 490         __u32           rsd_gid;
 491         __u32           rsd_fsuid;
 492         __u32           rsd_fsgid;
 493         __u32           rsd_cap;
 494         __u32           rsd_ngroups;
 495         __u32           rsd_groups[0];
 496 };
 497
 498 struct ptlrpc_request;
 499 struct mds_req_sec_desc *lustre_swab_mds_secdesc(struct ptlrpc_request *req,
 500                                                  int offset);
 501
 502 /* opcodes */
 503 typedef enum {
 504         MDS_GETATTR      = 33,
 505         MDS_GETATTR_LOCK = 34,
 506         MDS_CLOSE        = 35,
 507         MDS_REINT        = 36,
 508         MDS_READPAGE     = 37,
 509         MDS_CONNECT      = 38,
 510         MDS_DISCONNECT   = 39,
 511         MDS_GETSTATUS    = 40,
 512         MDS_STATFS       = 41,
 513         MDS_PIN          = 42,
 514         MDS_UNPIN        = 43,
 515         MDS_SYNC         = 44,
 516         MDS_DONE_WRITING = 45,
 517         MDS_LAST_OPC
 518 } mds_cmd_t;
 519
 520 #define MDS_FIRST_OPC    MDS_GETATTR
 521
 522 /*
 523  * Do not exceed 63
 524  */
 525
 526 #define REINT_SETATTR    1
 527 #define REINT_CREATE     2
 528 #define REINT_LINK       3
 529 #define REINT_UNLINK     4
 530 #define REINT_RENAME     5
 531 #define REINT_OPEN       6
 532 #define REINT_CLOSE      7
 533 #define REINT_WRITE      8
 534 #define REINT_MAX        8
 535
 536 /* the disposition of the intent outlines what was executed */
 537 #define DISP_IT_EXECD     0x01
 538 #define DISP_LOOKUP_EXECD 0x02
 539 #define DISP_LOOKUP_NEG   0x04
 540 #define DISP_LOOKUP_POS   0x08
 541 #define DISP_OPEN_CREATE  0x10
 542 #define DISP_OPEN_OPEN    0x20
 543 #define DISP_ENQ_COMPLETE 0x40
 544
 545 /* INODE LOCK PARTS */
 546 #define MDS_INODELOCK_LOOKUP 0x000001       /* dentry, mode, owner, group */
 547 #define MDS_INODELOCK_UPDATE 0x000002       /* size, links, timestamps */
 548 //#define MDS_INODELOCK_MAXSHIFT 1
 549 //#define MDS_INODELOCK_FULL ((1<<(MDS_INODELOCK_MAXSHIFT+1))-1)
 550
 551 struct ll_fid {
 552         __u64 id;
 553         __u32 generation;
 554         __u32 f_type;
 555         __u32 mds;
 556         __u32 padding;
 557 };
 558
 559 struct mea_old {
 560         __u32 mea_count;
 561         __u32 mea_master;
 562         struct ll_fid mea_fids[0];
 563 };
 564
 565 #define MEA_MAGIC_LAST_CHAR      0xb2221ca1
 566 #define MEA_MAGIC_ALL_CHARS      0xb222a11c
 567
 568 struct mea {
 569         __u32 mea_magic;
 570         __u32 mea_count;
 571         __u32 mea_master;
 572         struct ll_fid mea_fids[0];
 573 };
 574
 575 extern void lustre_swab_ll_fid (struct ll_fid *fid);
 576
 577 #define MDS_STATUS_CONN 1
 578 #define MDS_STATUS_LOV 2
 579
 580 struct mds_status_req {
 581         __u32  flags;
 582         __u32  repbuf;
 583 };
 584
 585 extern void lustre_swab_mds_status_req (struct mds_status_req *r);
 586
 587 #define MDS_BFLAG_UNCOMMITTED_WRITES   0x1
 588
 589 struct mds_body {
 590         struct ll_fid  fid1;
 591         struct ll_fid  fid2;
 592         struct lustre_handle handle;
 593         __u64          size;   /* Offset, in the case of MDS_READPAGE */
 594         __u64          blocks; /* XID, in the case of MDS_READPAGE */
 595         __u64          io_epoch;
 596         __u32          ino;   /* make this a __u64 */
 597         __u32          valid;
 598         __u32          mode;
 599         __u32          uid;
 600         __u32          gid;
 601         __u32          mtime;
 602         __u32          ctime;
 603         __u32          atime;
 604         __u32          flags; /* from vfs for pin/unpin, MDS_BFLAG for close */
 605         __u32          rdev;
 606         __u32          nlink; /* #bytes to read in the case of MDS_READPAGE */
 607         __u32          generation;
 608         __u32          eadatasize;
 609         __u32          mds;
 610 };
 611
 612 extern void lustre_swab_mds_body (struct mds_body *b);
 613
 614 struct lustre_md {
 615         struct mds_body *body;
 616         struct lov_stripe_md *lsm;
 617         struct mea *mea;
 618 };
 619
 620 struct mdc_op_data {
 621         struct ll_fid fid1;
 622         struct ll_fid fid2;
 623         __u64 mod_time;
 624         const char *name;
 625         int namelen;
 626         __u32 create_mode;
 627         struct mea *mea1;       /* mea of inode1 */
 628         struct mea *mea2;       /* mea of inode2 */
 629 };
 630
 631 #define MDS_MODE_DONT_LOCK      (1 << 30)
 632 #define MDS_MODE_REPLAY         (1 << 31)
 633
 634 struct mds_rec_setattr {
 635         __u32           sa_opcode;
 636         __u32           sa_valid;
 637         struct ll_fid   sa_fid;
 638         __u32           sa_mode;
 639         __u32           sa_uid;
 640         __u32           sa_gid;
 641         __u32           sa_attr_flags;
 642         __u64           sa_size;
 643         __u64           sa_atime;
 644         __u64           sa_mtime;
 645         __u64           sa_ctime;
 646 };
 647
 648 /* Remove this once we declare it in include/linux/fs.h (v21 kernel patch?) */
 649 #ifndef ATTR_CTIME_SET
 650 #define ATTR_CTIME_SET 0x2000
 651 #endif
 652
 653 extern void lustre_swab_mds_rec_setattr (struct mds_rec_setattr *sa);
 654
 655 #ifndef FMODE_READ
 656 #define FMODE_READ               00000001
 657 #define FMODE_WRITE              00000002
 658 #endif
 659 #ifndef FMODE_EXEC
 660 #define FMODE_EXEC               00000004
 661 #endif
 662 #define MDS_OPEN_CREAT           00000100
 663 #define MDS_OPEN_EXCL            00000200
 664 #define MDS_OPEN_TRUNC           00001000
 665 #define MDS_OPEN_APPEND          00002000
 666 #define MDS_OPEN_SYNC            00010000
 667 #define MDS_OPEN_DIRECTORY       00200000
 668
 669 #define MDS_OPEN_DELAY_CREATE  0100000000 /* delay initial object create */
 670 #define MDS_OPEN_HAS_EA      010000000000 /* specify object create pattern */
 671 #define MDS_OPEN_HAS_OBJS    020000000000 /* Just set the EA the obj exist */
 672
 673 struct mds_rec_create {
 674         __u32           cr_opcode;
 675         __u32           cr_flags; /* for use with open */
 676         __u32           cr_mode;
 677         __u32           cr_padding;
 678         struct ll_fid   cr_fid;
 679         struct ll_fid   cr_replayfid;
 680         __u64           cr_time;
 681         __u64           cr_rdev;
 682 };
 683
 684 extern void lustre_swab_mds_rec_create (struct mds_rec_create *cr);
 685
 686 struct mds_rec_link {
 687         __u32           lk_opcode;
 688         __u32           lk_padding;
 689         struct ll_fid   lk_fid1;
 690         struct ll_fid   lk_fid2;
 691         __u64           lk_time;
 692 };
 693
 694 extern void lustre_swab_mds_rec_link (struct mds_rec_link *lk);
 695
 696 struct mds_rec_unlink {
 697         __u32           ul_opcode;
 698         __u32           ul_mode;
 699         struct ll_fid   ul_fid1;
 700         struct ll_fid   ul_fid2;
 701         __u64           ul_time;
 702 };
 703
 704 extern void lustre_swab_mds_rec_unlink (struct mds_rec_unlink *ul);
 705
 706 struct mds_rec_rename {
 707         __u32           rn_opcode;
 708         __u32           rn_padding;
 709         struct ll_fid   rn_fid1;
 710         struct ll_fid   rn_fid2;
 711         __u64           rn_time;
 712 };
 713
 714 extern void lustre_swab_mds_rec_rename (struct mds_rec_rename *rn);
 715
 716 /*
 717  *  LOV data structures
 718  */
 719
 720 #define LOV_MAX_UUID_BUFFER_SIZE  8192
 721 /* The size of the buffer the lov/mdc reserves for the
 722  * array of UUIDs returned by the MDS.  With the current
 723  * protocol, this will limit the max number of OSTs per LOV */
 724
 725 struct lov_desc {
 726         __u32 ld_tgt_count;                /* how many OBD's */
 727         __u32 ld_active_tgt_count;         /* how many active */
 728         __u32 ld_default_stripe_count;     /* how many objects are used */
 729         __u32 ld_pattern;                  /* PATTERN_RAID0, PATTERN_RAID1 */
 730         __u64 ld_default_stripe_size;      /* in bytes */
 731         __u64 ld_default_stripe_offset;    /* in bytes */
 732         struct obd_uuid ld_uuid;
 733 };
 734
 735 struct lmv_desc {
 736         __u32 ld_tgt_count;                /* how many MDS's */
 737         __u32 ld_active_tgt_count;         /* how many active */
 738         struct obd_uuid ld_uuid;
 739 };
 740
 741 extern void lustre_swab_lov_desc (struct lov_desc *ld);
 742
 743 /*
 744  *   LDLM requests:
 745  */
 746 /* opcodes -- MUST be distinct from OST/MDS opcodes */
 747 typedef enum {
 748         LDLM_ENQUEUE     = 101,
 749         LDLM_CONVERT     = 102,
 750         LDLM_CANCEL      = 103,
 751         LDLM_BL_CALLBACK = 104,
 752         LDLM_CP_CALLBACK = 105,
 753         LDLM_GL_CALLBACK = 106,
 754         LDLM_LAST_OPC
 755 } ldlm_cmd_t;
 756 #define LDLM_FIRST_OPC LDLM_ENQUEUE
 757
 758 #define RES_NAME_SIZE 4
 759 struct ldlm_res_id {
 760         __u64 name[RES_NAME_SIZE];
 761 };
 762
 763 extern void lustre_swab_ldlm_res_id (struct ldlm_res_id *id);
 764
 765 /* lock types */
 766 typedef enum {
 767         LCK_EX = 1,
 768         LCK_PW = 2,
 769         LCK_PR = 4,
 770         LCK_CW = 8,
 771         LCK_CR = 16,
 772         LCK_NL = 32,
 773         LCK_GROUP = 64
 774 } ldlm_mode_t;
 775
 776 struct ldlm_extent {
 777         __u64 start;
 778         __u64 end;
 779         __u64 gid;
 780 };
 781 struct ldlm_inodebits {
 782         __u64 bits;
 783 };
 784
 785 struct ldlm_flock {
 786         __u64 start;
 787         __u64 end;
 788         __u64 pid;
 789         __u64 blocking_pid;
 790         __u64 blocking_export;
 791 };
 792
 793 /* it's important that the fields of the ldlm_extent structure match
 794  * the first fields of the ldlm_flock structure because there is only
 795  * one ldlm_swab routine to process the ldlm_policy_data_t union. if
 796  * this ever changes we will need to swab the union differently based
 797  * on the resource type. */
 798
 799 typedef union {
 800         struct ldlm_extent l_extent;
 801         struct ldlm_flock  l_flock;
 802         struct ldlm_inodebits l_inodebits;
 803 } ldlm_policy_data_t;
 804
 805 extern void lustre_swab_ldlm_policy_data (ldlm_policy_data_t *d);
 806
 807 struct ldlm_intent {
 808         __u64 opc;
 809 };
 810
 811 extern void lustre_swab_ldlm_intent (struct ldlm_intent *i);
 812
 813 struct ldlm_resource_desc {
 814         __u32 lr_type;
 815         __u32 lr_padding;
 816         struct ldlm_res_id lr_name;
 817 };
 818
 819 extern void lustre_swab_ldlm_resource_desc (struct ldlm_resource_desc *r);
 820
 821 struct ldlm_lock_desc {
 822         struct ldlm_resource_desc l_resource;
 823         ldlm_mode_t l_req_mode;
 824         ldlm_mode_t l_granted_mode;
 825         ldlm_policy_data_t l_policy_data;
 826 };
 827
 828 extern void lustre_swab_ldlm_lock_desc (struct ldlm_lock_desc *l);
 829
 830 struct ldlm_request {
 831         __u32 lock_flags;
 832         __u32 lock_padding;
 833         struct ldlm_lock_desc lock_desc;
 834         struct lustre_handle lock_handle1;
 835         struct lustre_handle lock_handle2;
 836 };
 837
 838 extern void lustre_swab_ldlm_request (struct ldlm_request *rq);
 839
 840 struct ldlm_reply {
 841         __u32 lock_flags;
 842         __u32 lock_padding;
 843         struct ldlm_lock_desc lock_desc;
 844         struct lustre_handle lock_handle;
 845         __u64  lock_policy_res1;
 846         __u64  lock_policy_res2;
 847 };
 848
 849 extern void lustre_swab_ldlm_reply (struct ldlm_reply *r);
 850
 851 /*
 852  * ptlbd, portal block device requests
 853  */
 854 typedef enum {
 855         PTLBD_QUERY = 200,
 856         PTLBD_READ = 201,
 857         PTLBD_WRITE = 202,
 858         PTLBD_FLUSH = 203,
 859         PTLBD_CONNECT = 204,
 860         PTLBD_DISCONNECT = 205,
 861         PTLBD_LAST_OPC
 862 } ptlbd_cmd_t;
 863 #define PTLBD_FIRST_OPC PTLBD_QUERY
 864
 865 struct ptlbd_op {
 866         __u16 op_cmd;
 867         __u16 op_lun;
 868         __u16 op_niob_cnt;
 869         __u16 op__padding;
 870         __u32 op_block_cnt;
 871 };
 872
 873 extern void lustre_swab_ptlbd_op (struct ptlbd_op *op);
 874
 875 struct ptlbd_niob {
 876         __u64 n_xid;
 877         __u64 n_block_nr;
 878         __u32 n_offset;
 879         __u32 n_length;
 880 };
 881
 882 extern void lustre_swab_ptlbd_niob (struct ptlbd_niob *n);
 883
 884 struct ptlbd_rsp {
 885         __u16 r_status;
 886         __u16 r_error_cnt;
 887 };
 888
 889 extern void lustre_swab_ptlbd_rsp (struct ptlbd_rsp *r);
 890
 891 /*
 892  * Opcodes for management/monitoring node.
 893  */
 894 typedef enum {
 895         MGMT_CONNECT = 250,
 896         MGMT_DISCONNECT,
 897         MGMT_EXCEPTION,         /* node died, etc. */
 898         MGMT_LAST_OPC
 899 } mgmt_cmd_t;
 900 #define MGMT_FIRST_OPC MGMT_CONNECT
 901
 902 /*
 903  * Opcodes for multiple servers.
 904  */
 905
 906 typedef enum {
 907         OBD_PING = 400,
 908         OBD_LOG_CANCEL,
 909         OBD_LAST_OPC
 910 } obd_cmd_t;
 911 #define OBD_FIRST_OPC OBD_PING
 912
 913 /* catalog of log objects */
 914
 915 /* Identifier for a single log object */
 916 struct llog_logid {
 917         __u64                   lgl_oid;
 918         __u64                   lgl_ogr;
 919         __u32                   lgl_ogen;
 920 } __attribute__((packed));
 921
 922 /* Records written to the CATALOGS list */
 923 #define CATLIST "CATALOGS"
 924 struct llog_catid {
 925         struct llog_logid       lci_logid;
 926         __u32                   lci_padding[3];
 927 } __attribute__((packed));
 928
 929 /* Log data record types - there is no specific reason that these need to
 930  * be related to the RPC opcodes, but no reason not to (may be handy later?)
 931  */
 932 typedef enum {
 933         OST_SZ_REC       = 0x10600000 | (OST_SAN_WRITE << 8),
 934         OST_RAID1_REC    = 0x10600000 | ((OST_SAN_WRITE + 1) << 8),
 935         MDS_UNLINK_REC   = 0x10610000 | (MDS_REINT << 8) | REINT_UNLINK,
 936         OBD_CFG_REC      = 0x10620000,
 937         PTL_CFG_REC      = 0x10630000,
 938         LLOG_GEN_REC     = 0x10640000,
 939         LLOG_HDR_MAGIC   = 0x10645539,
 940         LLOG_LOGID_MAGIC = 0x1064553b,
 941         SMFS_UPDATE_REC  = 0x10650000,
 942         CACHE_LRU_REC    = 0x10660000,
 943 } llog_op_type;
 944
 945 /* Log record header - stored in little endian order.
 946  * Each record must start with this struct, end with a llog_rec_tail,
 947  * and be a multiple of 256 bits in size.
 948  */
 949 struct llog_rec_hdr {
 950         __u32                   lrh_len;
 951         __u32                   lrh_index;
 952         __u32                   lrh_type;
 953         __u32                   padding;
 954 };
 955
 956 struct llog_rec_tail {
 957         __u32 lrt_len;
 958         __u32 lrt_index;
 959 };
 960
 961 struct llog_logid_rec {
 962         struct llog_rec_hdr     lid_hdr;
 963         struct llog_logid       lid_id;
 964         __u32                   padding[5];
 965         struct llog_rec_tail    lid_tail;
 966 } __attribute__((packed));
 967
 968 struct llog_create_rec {
 969         struct llog_rec_hdr     lcr_hdr;
 970         struct ll_fid           lcr_fid;
 971         obd_id                  lcr_oid;
 972         obd_count               lcr_ogen;
 973         __u32                   padding;
 974         struct llog_rec_tail    lcr_tail;
 975 } __attribute__((packed));
 976
 977 struct llog_orphan_rec {
 978         struct llog_rec_hdr     lor_hdr;
 979         obd_id                  lor_oid;
 980         obd_count               lor_ogen;
 981         __u32                   padding;
 982         struct llog_rec_tail    lor_tail;
 983 } __attribute__((packed));
 984
 985 struct llog_unlink_rec {
 986         struct llog_rec_hdr     lur_hdr;
 987         obd_id                  lur_oid;
 988         obd_count               lur_ogen;
 989         __u32                   padding;
 990         struct llog_rec_tail    lur_tail;
 991 } __attribute__((packed));
 992
 993 struct llog_size_change_rec {
 994         struct llog_rec_hdr     lsc_hdr;
 995         struct ll_fid           lsc_fid;
 996         __u32                   lsc_io_epoch;
 997         __u32                   padding;
 998         struct llog_rec_tail    lsc_tail;
 999 } __attribute__((packed));
1000
1001 struct llog_gen {
1002         __u64 mnt_cnt;
1003         __u64 conn_cnt;
1004 };
1005
1006 struct llog_gen_rec {
1007         struct llog_rec_hdr     lgr_hdr;
1008         struct llog_gen         lgr_gen;
1009         struct llog_rec_tail    lgr_tail;
1010 } __attribute__((packed));
1011
1012 struct llog_lru_rec {
1013         struct llog_rec_hdr     llr_hdr;
1014         struct ll_fid           llr_cfid;
1015         struct ll_fid           llr_pfid;
1016         struct llog_rec_tail    llr_tail;
1017 } __attribute__((packed));
1018
1019 /* On-disk header structure of each log object, stored in little endian order */
1020 #define LLOG_CHUNK_SIZE         8192
1021 #define LLOG_HEADER_SIZE        (96)
1022 #define LLOG_BITMAP_BYTES       (LLOG_CHUNK_SIZE - LLOG_HEADER_SIZE)
1023
1024 #define LLOG_MIN_REC_SIZE       (24) /* round(llog_rec_hdr + llog_rec_tail) */
1025
1026 /* flags for the logs */
1027 #define LLOG_F_ZAP_WHEN_EMPTY   0x1
1028 #define LLOG_F_IS_CAT           0x2
1029 #define LLOG_F_IS_PLAIN         0x4
1030
1031 struct llog_log_hdr {
1032         struct llog_rec_hdr     llh_hdr;
1033         __u64                   llh_timestamp;
1034         __u32                   llh_count;
1035         __u32                   llh_bitmap_offset;
1036         __u32                   llh_size;
1037         __u32                   llh_flags;
1038         __u32                   llh_cat_idx;
1039         /* for a catalog the first plain slot is next to it */
1040         struct obd_uuid         llh_tgtuuid;
1041         __u32                 llh_reserved[LLOG_HEADER_SIZE/sizeof(__u32) - 23];
1042         __u32                   llh_bitmap[LLOG_BITMAP_BYTES/sizeof(__u32)];
1043         struct llog_rec_tail    llh_tail;
1044 } __attribute__((packed));
1045
1046 #define LLOG_BITMAP_SIZE(llh)  ((llh->llh_hdr.lrh_len -         \
1047                                  llh->llh_bitmap_offset -       \
1048                                  sizeof(llh->llh_tail)) * 8)
1049
1050 /* log cookies are used to reference a specific log file and a record therein */
1051 struct llog_cookie {
1052         struct llog_logid       lgc_lgl;
1053         __u32                   lgc_subsys;
1054         __u32                   lgc_index;
1055         __u32                   lgc_flags;
1056 } __attribute__((packed));
1057
1058 /* llog protocol */
1059 enum llogd_rpc_ops {
1060         LLOG_ORIGIN_HANDLE_OPEN         = 501,
1061         LLOG_ORIGIN_HANDLE_NEXT_BLOCK   = 502,
1062         LLOG_ORIGIN_HANDLE_READ_HEADER  = 503,
1063         LLOG_ORIGIN_HANDLE_WRITE_REC    = 504,
1064         LLOG_ORIGIN_HANDLE_CLOSE        = 505,
1065         LLOG_ORIGIN_CONNECT             = 506,
1066         LLOG_CATINFO                    = 507,  /* for lfs catinfo */
1067         LLOG_ORIGIN_HANDLE_PREV_BLOCK   = 508,
1068 };
1069
1070 struct llogd_body {
1071         struct llog_logid  lgd_logid;
1072         __u32 lgd_ctxt_idx;
1073         __u32 lgd_llh_flags;
1074         __u32 lgd_index;
1075         __u32 lgd_saved_index;
1076         __u32 lgd_len;
1077         __u64 lgd_cur_offset;
1078 } __attribute__((packed));
1079
1080 struct llogd_conn_body {
1081         struct llog_gen         lgdc_gen;
1082         struct llog_logid       lgdc_logid;
1083         __u32                   lgdc_ctxt_idx;
1084 } __attribute__((packed));
1085
1086 extern void lustre_swab_llogd_body (struct llogd_body *d);
1087 extern void lustre_swab_llog_hdr (struct llog_log_hdr *h);
1088 extern void lustre_swab_llogd_conn_body (struct llogd_conn_body *d);
1089
1090 static inline struct ll_fid *obdo_fid(struct obdo *oa)
1091 {
1092         return (struct ll_fid *)(oa->o_inline + sizeof(struct lustre_handle) +
1093                                  sizeof(struct llog_cookie));
1094 }
1095
1096 #endif