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 HAVE_ASM_TYPES_H
  52 #include <asm/types.h>
  53 #else
  54 #include "types.h"
  55 #endif
  56
  57
  58 #ifdef __KERNEL__
  59 # include <linux/ioctl.h>
  60 # include <linux/types.h>
  61 # include <linux/list.h>
  62 # include <linux/string.h> /* for strncpy, below */
  63 # include <linux/fs.h>     /* to check for FMODE_EXEC, dev_t, lest we redefine */
  64 # include <linux/posix_acl.h>
  65 #else
  66 #ifdef __CYGWIN__
  67 # include <sys/types.h>
  68 #else
  69 # include <stdint.h>
  70 #endif
  71 # include <libcfs/list.h>
  72 # include <string.h>
  73 #endif
  74
  75 /* Defn's shared with user-space. */
  76 #include <lustre/lustre_user.h>
  77
  78 /*
  79  * this file contains all data structures used in Lustre interfaces:
  80  * - obdo and obd_request records
  81  * - mds_request records
  82  * - ldlm data
  83  * - ioctl's
  84  */
  85
  86 /*
  87  *  GENERAL STUFF
  88  */
  89 /* FOO_REQUEST_PORTAL is for incoming requests on the FOO
  90  * FOO_REPLY_PORTAL   is for incoming replies on the FOO
  91  * FOO_BULK_PORTAL    is for incoming bulk on the FOO
  92  */
  93
  94 #define CONNMGR_REQUEST_PORTAL          1
  95 #define CONNMGR_REPLY_PORTAL            2
  96 //#define OSC_REQUEST_PORTAL            3
  97 #define OSC_REPLY_PORTAL                4
  98 //#define OSC_BULK_PORTAL               5
  99 #define OST_REQUEST_PORTAL              6
 100 #define OST_CREATE_PORTAL               7
 101 #define OST_BULK_PORTAL                 8
 102 //#define MDC_REQUEST_PORTAL            9
 103 #define MDC_REPLY_PORTAL               10
 104 //#define MDC_BULK_PORTAL              11
 105 #define MDS_REQUEST_PORTAL             12
 106 //#define MDS_REPLY_PORTAL             13
 107 #define MDS_BULK_PORTAL                14
 108 #define LDLM_CB_REQUEST_PORTAL         15
 109 #define LDLM_CB_REPLY_PORTAL           16
 110 #define LDLM_CANCEL_REQUEST_PORTAL     17
 111 #define LDLM_CANCEL_REPLY_PORTAL       18
 112 #define PTLBD_REQUEST_PORTAL           19
 113 #define PTLBD_REPLY_PORTAL             20
 114 #define PTLBD_BULK_PORTAL              21
 115 #define MDS_SETATTR_PORTAL             22
 116 #define MDS_READPAGE_PORTAL            23
 117 #define MGMT_REQUEST_PORTAL            24
 118 #define MGMT_REPLY_PORTAL              25
 119 #define MGMT_CLI_REQUEST_PORTAL        26
 120 #define MGMT_CLI_REPLY_PORTAL          27
 121 #define GKS_REQUEST_PORTAL             28
 122 #define GKC_REPLY_PORTAL               29
 123 #define MDS_CLOSE_PORTAL               30
 124 #define OST_DESTROY_PORTAL             31
 125
 126 #define SVC_KILLED               1
 127 #define SVC_EVENT                2
 128 #define SVC_SIGNAL               4
 129 #define SVC_RUNNING              8
 130 #define SVC_STOPPING            16
 131 #define SVC_STOPPED             32
 132
 133 /* packet types */
 134 #define PTL_RPC_MSG_REQUEST 4711
 135 #define PTL_RPC_MSG_ERR     4712
 136 #define PTL_RPC_MSG_REPLY   4713
 137
 138 #define PTLRPC_MSG_MAGIC    0x0BD00BD0
 139
 140
 141 #define PTLRPC_MSG_VERSION  0x00000003
 142 #define LUSTRE_VERSION_MASK 0xffff0000
 143 #define LUSTRE_OBD_VERSION  0x00010000
 144 #define LUSTRE_MDS_VERSION  0x00020000
 145 #define LUSTRE_OST_VERSION  0x00030000
 146 #define LUSTRE_DLM_VERSION  0x00040000
 147 #define LUSTRE_LOG_VERSION  0x00050000
 148 #define LUSTRE_PBD_VERSION  0x00060000
 149 #define LUSTRE_GKS_VERSION  0x00070000
 150
 151 struct lustre_handle {
 152         __u64 cookie;
 153 };
 154 #define DEAD_HANDLE_MAGIC 0xdeadbeefcafebabeULL
 155
 156 /* we depend on this structure to be 8-byte aligned */
 157 /* this type is only endian-adjusted in lustre_unpack_msg() */
 158 struct lustre_msg {
 159         struct lustre_handle handle;
 160         __u32 magic;
 161         __u32 type;
 162         __u32 version;
 163         __u32 opc;
 164         __u64 last_xid;
 165         __u64 last_committed;
 166         __u64 transno;
 167         __u32 status;
 168         __u32 flags;
 169         __u32 conn_cnt;
 170         __u32 bufcount;
 171         __u32 buflens[0];
 172 };
 173
 174 /* Flags that are operation-specific go in the top 16 bits. */
 175 #define MSG_OP_FLAG_MASK   0xffff0000
 176 #define MSG_OP_FLAG_SHIFT  16
 177
 178 /* Flags that apply to all requests are in the bottom 16 bits */
 179 #define MSG_GEN_FLAG_MASK      0x0000ffff
 180 #define MSG_LAST_REPLAY        1
 181 #define MSG_RESENT             2
 182 #define MSG_REPLAY             4
 183 #define MSG_REQ_REPLAY_DONE    8
 184 #define MSG_LOCK_REPLAY_DONE  16
 185
 186 static inline int lustre_msg_get_flags(struct lustre_msg *msg)
 187 {
 188         return (msg->flags & MSG_GEN_FLAG_MASK);
 189 }
 190
 191 static inline void lustre_msg_add_flags(struct lustre_msg *msg, int flags)
 192 {
 193         msg->flags |= MSG_GEN_FLAG_MASK & flags;
 194 }
 195
 196 static inline void lustre_msg_set_flags(struct lustre_msg *msg, int flags)
 197 {
 198         msg->flags &= ~MSG_GEN_FLAG_MASK;
 199         lustre_msg_add_flags(msg, flags);
 200 }
 201
 202 static inline void lustre_msg_clear_flags(struct lustre_msg *msg, int flags)
 203 {
 204         msg->flags &= ~(MSG_GEN_FLAG_MASK & flags);
 205 }
 206
 207 static inline int lustre_msg_get_op_flags(struct lustre_msg *msg)
 208 {
 209         return (msg->flags >> MSG_OP_FLAG_SHIFT);
 210 }
 211
 212 static inline void lustre_msg_add_op_flags(struct lustre_msg *msg, int flags)
 213 {
 214         msg->flags |= ((flags & MSG_GEN_FLAG_MASK) << MSG_OP_FLAG_SHIFT);
 215 }
 216
 217 static inline void lustre_msg_set_op_flags(struct lustre_msg *msg, int flags)
 218 {
 219         msg->flags &= ~MSG_OP_FLAG_MASK;
 220         lustre_msg_add_op_flags(msg, flags);
 221 }
 222
 223 /*
 224  * Flags for all connect opcodes (MDS_CONNECT, OST_CONNECT)
 225  */
 226
 227 #define MSG_CONNECT_RECOVERING  0x1
 228 #define MSG_CONNECT_RECONNECT   0x2
 229 #define MSG_CONNECT_REPLAYABLE  0x4
 230 #define MSG_CONNECT_PEER        0x8
 231 #define MSG_CONNECT_LIBCLIENT   0x10
 232 #define MSG_CONNECT_INITIAL     0x20
 233 #define MSG_CONNECT_ASYNC       0x40
 234 #define MSG_CONNECT_TRANSNO     0X80    /* report transno */
 235
 236 /* Connect flags */
 237
 238 #define OBD_CONNECT_RDONLY      (0x00000001LL)
 239 #define OBD_CONNECT_REMOTE      (0x40000000LL)
 240 #define OBD_CONNECT_LOCAL       (0x80000000LL)
 241
 242 #define OBD_CONNECT_SUPPORTED (OBD_CONNECT_RDONLY |     \
 243                                OBD_CONNECT_REMOTE |     \
 244                                OBD_CONNECT_LOCAL)
 245
 246 /* This structure is used for both request and reply.
 247  *
 248  * If we eventually have separate connect data for different types, which we
 249  * almost certainly will, then perhaps we stick a union in here. */
 250 struct obd_connect_data {
 251         __u64 ocd_connect_flags;
 252         __u32 ocd_nllu[2];
 253         __u64 transno;          /* first transno from client to be replayed */
 254         __u64 padding[5];
 255 };
 256
 257 extern void lustre_swab_connect(struct obd_connect_data *ocd);
 258
 259 /*
 260  *   OST requests: OBDO & OBD request records
 261  */
 262
 263 /* opcodes */
 264 typedef enum {
 265         OST_REPLY      =  0,       /* reply ? */
 266         OST_GETATTR    =  1,
 267         OST_SETATTR    =  2,
 268         OST_READ       =  3,
 269         OST_WRITE      =  4,
 270         OST_CREATE     =  5,
 271         OST_DESTROY    =  6,
 272         OST_GET_INFO   =  7,
 273         OST_CONNECT    =  8,
 274         OST_DISCONNECT =  9,
 275         OST_PUNCH      = 10,
 276         OST_OPEN       = 11,
 277         OST_CLOSE      = 12,
 278         OST_STATFS     = 13,
 279         OST_SAN_READ   = 14,
 280         OST_SAN_WRITE  = 15,
 281         OST_SYNC       = 16,
 282         OST_SET_INFO   = 17,
 283         OST_LAST_OPC
 284 } ost_cmd_t;
 285 #define OST_FIRST_OPC  OST_REPLY
 286
 287 typedef uint64_t        obd_id;
 288 typedef uint64_t        obd_gr;
 289 typedef uint64_t        obd_time;
 290 typedef uint64_t        obd_size;
 291 typedef uint64_t        obd_off;
 292 typedef uint64_t        obd_blocks;
 293 typedef uint32_t        obd_blksize;
 294 typedef uint32_t        obd_mode;
 295 typedef uint32_t        obd_uid;
 296 typedef uint32_t        obd_gid;
 297 typedef uint32_t        obd_flags;
 298 typedef uint64_t        obd_valid;
 299 typedef uint32_t        obd_count;
 300
 301 #define OBD_FL_INLINEDATA    (0x00000001)
 302 #define OBD_FL_OBDMDEXISTS   (0x00000002)
 303 #define OBD_FL_DELORPHAN     (0x00000004) /* if set in o_flags delete orphans */
 304 #define OBD_FL_NORPC         (0x00000008) // if set in o_flags set in OSC not OST
 305 #define OBD_FL_IDONLY        (0x00000010) // if set in o_flags only adjust obj id
 306 #define OBD_FL_RECREATE_OBJS (0x00000020) // recreate missing obj
 307 #define OBD_FL_DEBUG_CHECK   (0x00000040) /* echo client/server debug check */
 308 #define OBD_FL_REINT         (0x00000080) /* reint during cache flush */
 309
 310 /* this should be sizeof(struct lustre_handle) + sizeof(struct llog_cookie) +
 311  * sizeof(struct lustre_id). */
 312 #define OBD_INLINESZ (80)
 313
 314 /* Note: 64-bit types are 64-bit aligned in structure */
 315 struct obdo {
 316         obd_id                  o_id;
 317         obd_gr                  o_gr;
 318         obd_size                o_size;
 319         obd_time                o_mtime;
 320         obd_time                o_atime;
 321         obd_time                o_ctime;
 322         obd_blocks              o_blocks;       /* brw: cli sent cached bytes */
 323         obd_size                o_grant;
 324         obd_blksize             o_blksize;      /* optimal IO blocksize */
 325         obd_mode                o_mode;         /* brw: cli sent cache remain */
 326         obd_uid                 o_uid;
 327         obd_gid                 o_gid;
 328         obd_flags               o_flags;
 329         obd_count               o_nlink;        /* brw: checksum */
 330         obd_count               o_generation;
 331         obd_valid               o_valid;        /* hot fields in this obdo */
 332         obd_count               o_misc;         /* brw: o_dropped */
 333         __u32                   o_easize;       /* epoch in ost writes */
 334         __u32                   o_mds;
 335         __u64                   o_fid;
 336         obd_uid                 o_fsuid;        /* fsuid, used by capability */
 337         char                    o_inline[OBD_INLINESZ]; /* fid in ost writes */
 338 };
 339
 340 #define o_dirty   o_blocks
 341 #define o_undirty o_mode
 342 #define o_dropped o_misc
 343 #define o_cksum   o_nlink
 344
 345 extern void lustre_swab_obdo (struct obdo *o);
 346
 347 #define LOV_MAGIC_V1      0x0BD10BD0
 348 #define LOV_MAGIC         LOV_MAGIC_V1
 349
 350 #define LOV_PATTERN_RAID0 0x001   /* stripes are used round-robin */
 351 #define LOV_PATTERN_RAID1 0x002   /* stripes are mirrors of each other */
 352 #define LOV_PATTERN_FIRST 0x100   /* first stripe is not in round-robin */
 353 #define LOV_PATTERN_CMOBD 0x200
 354
 355 #define lov_ost_data lov_ost_data_v1
 356 struct lov_ost_data_v1 {          /* per-stripe data structure (little-endian)*/
 357         __u64 l_object_id;        /* OST object ID */
 358         __u64 l_object_gr;        /* OST object group (creating MDS number) */
 359         __u32 l_ost_gen;          /* generation of this l_ost_idx */
 360         __u32 l_ost_idx;          /* OST index in LOV (lov_tgt_desc->tgts) */
 361 };
 362
 363 #define lov_mds_md lov_mds_md_v1
 364 struct lov_mds_md_v1 {            /* LOV EA mds/wire data (little-endian) */
 365         __u32 lmm_magic;          /* magic number = LOV_MAGIC_V1 */
 366         __u32 lmm_pattern;        /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */
 367         __u64 lmm_object_id;      /* LOV object ID */
 368         __u64 lmm_object_gr;      /* LOV object group */
 369         __u32 lmm_stripe_size;    /* size of stripe in bytes */
 370         __u32 lmm_stripe_count;   /* num stripes in use for this object */
 371         struct lov_ost_data_v1 lmm_objects[0]; /* per-stripe data */
 372 };
 373
 374 #define LOV_MAGIC_V0      0x0BD00BD0
 375
 376 struct lov_ost_data_v0 {          /* per-stripe data structure (little-endian)*/
 377         __u64 l_object_id;        /* OST object ID */
 378 };
 379
 380 struct lov_mds_md_v0 {            /* LOV EA mds/wire data (little-endian) */
 381         __u32 lmm_magic;          /* magic number = LOV_MAGIC_V0 */
 382         __u64 lmm_object_id;      /* LOV object ID */
 383         __u32 lmm_stripe_size;    /* size of the stripe in bytes (not RAID1) */
 384         __u32 lmm_stripe_offset;  /* starting stripe offset in lmm_objects */
 385         __u16 lmm_stripe_count;   /* number of stipes in use for this object */
 386         __u16 lmm_ost_count;      /* how many OST idx are in this LOV md */
 387         struct lov_ost_data_v0 lmm_objects[0];
 388 } __attribute__((packed));
 389
 390 #define OBD_MD_FLALL    (0xffffffffffffffffLL)
 391 #define OBD_MD_FLID     (0x0000000000000001LL)    /* object ID */
 392 #define OBD_MD_FLATIME  (0x0000000000000002LL)    /* access time */
 393 #define OBD_MD_FLMTIME  (0x0000000000000004LL)    /* data modification time */
 394 #define OBD_MD_FLCTIME  (0x0000000000000008LL)    /* change time */
 395 #define OBD_MD_FLSIZE   (0x0000000000000010LL)    /* size */
 396 #define OBD_MD_FLBLOCKS (0x0000000000000020LL)    /* allocated blocks count */
 397 #define OBD_MD_FLBLKSZ  (0x0000000000000040LL)    /* block size */
 398 #define OBD_MD_FLMODE   (0x0000000000000080LL)    /* access bits (mode & ~S_IFMT) */
 399 #define OBD_MD_FLTYPE   (0x0000000000000100LL)    /* object type (mode & S_IFMT) */
 400 #define OBD_MD_FLUID    (0x0000000000000200LL)    /* user ID */
 401 #define OBD_MD_FLGID    (0x0000000000000400LL)    /* group ID */
 402 #define OBD_MD_FLFLAGS  (0x0000000000000800LL)    /* flags word */
 403 #define OBD_MD_FLXATTR  (0x0000000000001000LL)    /* user xattr */
 404 #define OBD_MD_FLNLINK  (0x0000000000002000LL)    /* link count */
 405 #define OBD_MD_FLGENER  (0x0000000000004000LL)    /* generation number */
 406 #define OBD_MD_FLINLINE (0x0000000000008000LL)    /* inline data */
 407 #define OBD_MD_FLRDEV   (0x0000000000010000LL)    /* device number */
 408 #define OBD_MD_FLEASIZE (0x0000000000020000LL)    /* extended attribute data */
 409 #define OBD_MD_LINKNAME (0x0000000000040000LL)    /* symbolic link target */
 410 #define OBD_MD_FLHANDLE (0x0000000000080000LL)    /* file handle */
 411 #define OBD_MD_FLCKSUM  (0x0000000000100000LL)    /* bulk data checksum */
 412 #define OBD_MD_FLQOS    (0x0000000000200000LL)    /* quality of service stats */
 413 #define OBD_MD_FLOSCOPQ (0x0000000000400000LL)    /* osc opaque data */
 414 #define OBD_MD_FLCOOKIE (0x0000000000800000LL)    /* log cancellation cookie */
 415 #define OBD_MD_FLGROUP  (0x0000000001000000LL)    /* group */
 416 #define OBD_MD_FLIFID   (0x0000000002000000LL)    /* ->ost write inline fid */
 417 #define OBD_MD_FLEPOCH  (0x0000000004000000LL)    /* ->ost write easize is epoch */
 418 #define OBD_MD_FLGRANT  (0x0000000008000000LL)    /* ost preallocation space grant */
 419 #define OBD_MD_MDS      (0x0000000010000000LL)    /* where an inode lives on */
 420 #define OBD_MD_FLDIREA  (0x0000000020000000LL)    /* dir's extended attribute data */
 421 #define OBD_MD_REINT    (0x0000000040000000LL)    /* reintegrate oa */
 422 #define OBD_MD_FID      (0x0000000080000000LL)    /* lustre_id data */
 423 #define OBD_MD_MEA      (0x0000000100000000LL)    /* shows we are interested in MEA */
 424 #define OBD_MD_FLXATTRLIST (0x0000000200000000LL) /* user xattr list */
 425 #define OBD_MD_FLACL    (0x0000000400000000LL)    /* acl */
 426 #define OBD_MD_FLRMTACL (0x0000000800000000LL)    /* remote acl */
 427 #define OBD_MD_FLKEY    (0x0000001000000000LL)    /* mds key extended attributes */
 428 #define OBD_MD_FLAUDIT  (0x0000002000000000LL)    /* audit setting */
 429 #define OBD_MD_CAPA     (0x0000004000000000LL)    /* capability */
 430 #define OBD_MD_FLFSUID  (0x0000008000000000LL)    /* fsuid */
 431
 432 #define OBD_MD_FLNOTOBD (~(OBD_MD_FLBLOCKS | OBD_MD_LINKNAME    |        \
 433                            OBD_MD_FLEASIZE | OBD_MD_FLHANDLE    |        \
 434                            OBD_MD_FLCKSUM  | OBD_MD_FLQOS       |        \
 435                            OBD_MD_FLOSCOPQ | OBD_MD_FLCOOKIE    |        \
 436                            OBD_MD_FLXATTR  | OBD_MD_FLXATTRLIST |        \
 437                            OBD_MD_FLACL    | OBD_MD_MDS         |        \
 438                            OBD_MD_FLKEY    | OBD_MD_FLAUDIT     |        \
 439                            OBD_MD_CAPA     | OBD_MD_FLFSUID))
 440
 441 static inline struct lustre_handle *obdo_handle(struct obdo *oa)
 442 {
 443         return (struct lustre_handle *)oa->o_inline;
 444 }
 445
 446 static inline struct llog_cookie *obdo_logcookie(struct obdo *oa)
 447 {
 448         return (struct llog_cookie *)(oa->o_inline +
 449                                       sizeof(struct lustre_handle));
 450 }
 451
 452 /* don't forget obdo_fid which is way down at the bottom so it can come after
 453  * the definition of llog_cookie */
 454 struct obd_statfs {
 455         __u64           os_type;
 456         __u64           os_blocks;
 457         __u64           os_bfree;
 458         __u64           os_bavail;
 459         __u64           os_files;
 460         __u64           os_ffree;
 461         __u8            os_fsid[40];
 462         __u32           os_bsize;
 463         __u32           os_namelen;
 464         __u64           os_maxbytes;
 465         __u32           os_spare[10];
 466 };
 467
 468 extern void lustre_swab_obd_statfs (struct obd_statfs *os);
 469
 470 /* ost_body.data values for OST_BRW */
 471
 472 #define OBD_BRW_READ       0x01
 473 #define OBD_BRW_WRITE      0x02
 474 #define OBD_BRW_RWMASK     (OBD_BRW_READ | OBD_BRW_WRITE)
 475 #define OBD_BRW_SYNC       0x08
 476 #define OBD_BRW_CHECK      0x10
 477 #define OBD_BRW_FROM_GRANT 0x20 /* the osc manages this under llite */
 478 #define OBD_BRW_GRANTED    0x40 /* the ost manages this */
 479
 480 #define OBD_OBJECT_EOF     0xffffffffffffffffULL
 481
 482 struct obd_ioobj {
 483         obd_id               ioo_id;
 484         obd_gr               ioo_gr;
 485         __u32                ioo_type;
 486         __u32                ioo_bufcnt;
 487 };
 488
 489 extern void lustre_swab_obd_ioobj (struct obd_ioobj *ioo);
 490
 491 /* multiple of 8 bytes => can array */
 492 struct niobuf_remote {
 493         __u64 offset;
 494         __u32 len;
 495         __u32 flags;
 496 };
 497
 498 extern void lustre_swab_niobuf_remote (struct niobuf_remote *nbr);
 499
 500 /* request structure for OST's */
 501
 502 #define OST_REQ_HAS_OA1  0x1
 503
 504 struct ost_body {
 505         struct  obdo oa;
 506 };
 507
 508 extern void lustre_swab_ost_body (struct ost_body *b);
 509 extern void lustre_swab_ost_last_id(obd_id *id);
 510 extern void lustre_swab_generic_32s(__u32 *val);
 511
 512 /* lock value block communicated between the filter and llite */
 513
 514 struct ost_lvb {
 515         __u64 lvb_size;
 516         __u64 lvb_mtime;
 517         __u64 lvb_atime;
 518         __u64 lvb_ctime;
 519         __u64 lvb_blocks;
 520 };
 521
 522 extern void lustre_swab_ost_lvb(struct ost_lvb *);
 523
 524 /*
 525  *   MDS REQ RECORDS
 526  */
 527
 528 /* offsets in the request */
 529 #define MDS_REQ_SECDESC_OFF             0
 530 #define MDS_REQ_REC_OFF                 1
 531
 532 #define MDS_REQ_INTENT_LOCKREQ_OFF      1
 533 #define MDS_REQ_INTENT_IT_OFF           2
 534 #define MDS_REQ_INTENT_REC_OFF          3
 535
 536 /* maximum supplementary groups */
 537 #define LUSTRE_MAX_GROUPS               128
 538
 539 /*
 540  * security descriptor in mds request
 541  */
 542 struct mds_req_sec_desc {
 543         __u32           rsd_uid;
 544         __u32           rsd_gid;
 545         __u32           rsd_fsuid;
 546         __u32           rsd_fsgid;
 547         __u32           rsd_cap;
 548         __u32           rsd_ngroups;
 549         __u32           rsd_groups[0];
 550 };
 551
 552 struct ptlrpc_request;
 553 struct mds_req_sec_desc *lustre_swab_mds_secdesc(struct ptlrpc_request *req,
 554                                                  int offset);
 555
 556 /* opcodes */
 557 typedef enum {
 558         MDS_GETATTR      = 33,
 559         MDS_GETATTR_LOCK = 34,
 560         MDS_CLOSE        = 35,
 561         MDS_REINT        = 36,
 562         MDS_READPAGE     = 37,
 563         MDS_CONNECT      = 38,
 564         MDS_DISCONNECT   = 39,
 565         MDS_GETSTATUS    = 40,
 566         MDS_STATFS       = 41,
 567         MDS_PIN          = 42,
 568         MDS_UNPIN        = 43,
 569         MDS_SYNC         = 44,
 570         MDS_DONE_WRITING = 45,
 571         MDS_ACCESS_CHECK = 46,
 572         MDS_PARSE_ID     = 47,
 573         MDS_LAST_OPC
 574 } mds_cmd_t;
 575
 576 #define MDS_FIRST_OPC    MDS_GETATTR
 577
 578 /*
 579  * Do not exceed 63
 580  */
 581
 582 #define REINT_SETATTR      1
 583 #define REINT_CREATE       2
 584 #define REINT_LINK         3
 585 #define REINT_UNLINK       4
 586 #define REINT_RENAME       5
 587 #define REINT_SETXATTR     6
 588 #define REINT_OPEN         7
 589 #define REINT_CLOSE        8
 590 #define REINT_WRITE        9
 591 #define REINT_MAX          9
 592
 593 /* the disposition of the intent outlines what was executed */
 594 #define DISP_IT_EXECD     (1 << 0)
 595 #define DISP_LOOKUP_EXECD (1 << 1)
 596 #define DISP_LOOKUP_NEG   (1 << 2)
 597 #define DISP_LOOKUP_POS   (1 << 3)
 598 #define DISP_OPEN_CREATE  (1 << 4)
 599 #define DISP_OPEN_OPEN    (1 << 5)
 600 #define DISP_ENQ_COMPLETE (1 << 6)
 601
 602 /* INODE LOCK PARTS */
 603 #define MDS_INODELOCK_LOOKUP 0x000001  /* dentry, mode, owner, group */
 604 #define MDS_INODELOCK_UPDATE 0x000002  /* size, links, timestamps */
 605 #define MDS_INODELOCK_OPEN   0x000004  /* for opened files */
 606
 607 /* do not forget to increase MDS_INODELOCK_MAXSHIFT when adding new bits */
 608 #define MDS_INODELOCK_MAXSHIFT 2
 609
 610 /* this FULL lock is useful to take on unlink sort of operations */
 611 #define MDS_INODELOCK_FULL ((1 << (MDS_INODELOCK_MAXSHIFT + 1)) - 1)
 612
 613 /* lustre store cookie */
 614 struct lustre_stc {
 615         union {
 616                 struct {
 617                     __u64 l3s_ino;     /* inode number on local MDS */
 618                     __u32 l3s_gen;     /* inode generation */
 619                     __u32 l3s_type;    /* inode type */
 620                 } e3s;
 621         } u;
 622 };
 623
 624 struct fid_extent {
 625         __u64 fe_start;
 626         __u64 fe_width;
 627 };
 628
 629 /* lustre file id */
 630 struct lustre_fid {
 631         __u64 lf_id;                   /* fid counter maintained on per
 632                                           group basis */
 633         __u64 lf_group;                /* sequence group num */
 634 #if 0
 635         __u32 lf_version;              /* what snapfs version of inode */
 636         __u32 lf_padding;
 637 #endif
 638 };
 639
 640 struct lustre_id {
 641         struct lustre_stc li_stc;      /* store cookie */
 642         struct lustre_fid li_fid;      /* fid cookie */
 643 };
 644
 645 struct mea_old {
 646         __u32 mea_count;
 647         __u32 mea_master;
 648         struct lustre_id mea_ids[0];
 649 };
 650
 651 #define MEA_MAGIC_LAST_CHAR      0xb2221ca1
 652 #define MEA_MAGIC_ALL_CHARS      0xb222a11c
 653
 654 struct mea {
 655         __u32 mea_magic;
 656         __u32 mea_count;
 657         __u32 mea_master;
 658         struct lustre_id mea_ids[0];
 659 };
 660
 661 #define MDS_STATUS_CONN 1
 662 #define MDS_STATUS_LOV 2
 663
 664 struct mds_status_req {
 665         __u32  flags;
 666         __u32  repbuf;
 667 };
 668
 669 struct parseid_pkg {
 670         __u32                   pp_type;
 671         __u32                   pp_rc;
 672         struct lustre_id        pp_id1;
 673         struct lustre_id        pp_id2;
 674         __u8                    pp_name[NAME_MAX + 1];
 675 };
 676
 677 struct audit_msg {
 678         struct lustre_id id;
 679         __u64 nid;
 680         __u32 result;
 681         __u32 uid;
 682         __u32 gid;
 683         __u32 code;
 684 };
 685
 686 struct audit_attr_msg {
 687         struct lustre_id id;
 688         __u64 attr;
 689 };
 690 #if 0
 691 extern void lustre_swab_lustre_id(struct lustre_id *id);
 692 extern void lustre_swab_lustre_stc(struct lustre_stc *stc);
 693 extern void lustre_swab_lustre_fid(struct lustre_fid *fid);
 694 extern void lustre_swab_parseid_pkg(struct parseid_pkg *pkg);
 695 extern void lustre_swab_mds_status_req (struct mds_status_req *r);
 696 #endif
 697 extern void lustre_swab_audit_msg (struct audit_msg *r);
 698 extern void lustre_swab_audit_attr (struct audit_attr_msg *r);
 699 extern void lustre_swab_parseid_pkg(struct parseid_pkg *pkg);
 700
 701 #define MDS_BFLAG_UNCOMMITTED_WRITES   0x1
 702 #define MDS_BFLAG_CLOSE_EPOCH          0x2
 703 #define MDS_BFLAG_DIRTY_EPOCH          0x4
 704
 705 struct mds_body {
 706         struct lustre_id id1;
 707         struct lustre_id id2;
 708         struct lustre_handle handle;
 709         __u64          size;   /* Offset, in the case of MDS_READPAGE */
 710         __u64          blocks; /* XID, in the case of MDS_READPAGE */
 711         __u64          io_epoch;
 712         __u64          valid;
 713         __u64          audit;
 714         __u32          mode;
 715         __u32          uid;
 716         __u32          gid;
 717         __u32          mtime;
 718         __u32          ctime;
 719         __u32          atime;
 720         __u32          flags;  /* from vfs for pin/unpin, MDS_BFLAG for close */
 721         __u32          rdev;
 722         __u32          nlink;  /* #bytes to read in the case of MDS_READPAGE */
 723         __u32          eadatasize;
 724 };
 725
 726 extern void lustre_swab_mds_body (struct mds_body *b);
 727
 728 struct mds_remote_perm {
 729         __u32           mrp_auth_uid;
 730         __u32           mrp_auth_gid;
 731         __u16           mrp_perm;
 732         __u8            mrp_allow_setuid;
 733         __u8            mrp_allow_setgid;
 734 };
 735
 736 struct lustre_md {
 737         struct mds_body        *body;
 738         struct lov_stripe_md   *lsm;
 739         struct mea             *mea;
 740         struct posix_acl       *posix_acl;
 741         struct mds_remote_perm *remote_perm;
 742         struct lustre_key *key;
 743 };
 744
 745 void lustre_swab_remote_perm(struct mds_remote_perm *p);
 746
 747 struct mdc_op_data {
 748         struct lustre_id id1;
 749         struct lustre_id id2;
 750         __u64            mod_time;
 751         const char      *name;
 752         int              namelen;
 753         __u32            create_mode;
 754         struct mea      *mea1;       /* mea of inode1 */
 755         struct mea      *mea2;       /* mea of inode2 */
 756         __u64            valid;
 757         __u32            flags;
 758 };
 759
 760 #define MDS_MODE_DONT_LOCK      (1 << 30)
 761 #define MDS_MODE_REPLAY         (1 << 31)
 762
 763 /* XXX Following ATTR_XXX should go to vfs patch...  */
 764 #ifdef ATTR_CTIME_SET
 765 #error "ATTR_CTIME_SET has been defined somewhere else"
 766 #endif
 767 #ifdef ATTR_EA
 768 #error "ATTR_EA has been defined somewhere else"
 769 #endif
 770 #ifdef ATTR_EA_RM
 771 #error "ATTR_EA_RM has been defined somewhere else"
 772 #endif
 773
 774 #define ATTR_CTIME_SET  0x00002000
 775 #define ATTR_EA         0x00040000
 776 #define ATTR_EA_RM      0x00080000
 777 #define ATTR_EA_CMOBD   0x00100000
 778 #define ATTR_KEY        0x00200000
 779 #define ATTR_MAC        0x00400000
 780
 781 #ifndef FMODE_READ
 782 #define FMODE_READ               00000001
 783 #define FMODE_WRITE              00000002
 784 #endif
 785 #ifndef FMODE_EXEC
 786 #define FMODE_EXEC               00000004
 787 #endif
 788 #define MDS_OPEN_CREAT           00000100
 789 #define MDS_OPEN_EXCL            00000200
 790 #define MDS_OPEN_TRUNC           00001000
 791 #define MDS_OPEN_APPEND          00002000
 792 #define MDS_OPEN_SYNC            00010000
 793 #define MDS_OPEN_DIRECTORY       00200000
 794 #define MDS_REINT_REQ            01000000
 795
 796 #define MDS_OPEN_DELAY_CREATE    0100000000   /* delay initial object create */
 797 #define MDS_OPEN_HAS_KEY         01000000000 /* just set the EA the obj exist */
 798 #define MDS_OPEN_HAS_EA          010000000000 /* specify object create pattern */
 799 #define MDS_OPEN_HAS_OBJS        020000000000 /* just set the EA the obj exist */
 800
 801 struct mds_rec_create {
 802         __u32            cr_opcode;
 803         __u32            cr_flags; /* for use with open */
 804         __u32            cr_mode;
 805         __u32            cr_padding;
 806         struct lustre_id cr_id;
 807         struct lustre_id cr_replayid;
 808         __u64            cr_time;
 809         __u64            cr_rdev;
 810         __u64            cr_enkey;
 811         __u64            cr_mac;
 812 };
 813
 814 extern void lustre_swab_mds_rec_create (struct mds_rec_create *cr);
 815
 816 struct mds_rec_link {
 817         __u32            lk_opcode;
 818         __u32            lk_flags;
 819         __u32            lk_padding;
 820         struct lustre_id lk_id1;
 821         struct lustre_id lk_id2;
 822         __u64            lk_time;
 823 };
 824
 825 extern void lustre_swab_mds_rec_link (struct mds_rec_link *lk);
 826
 827 struct mds_rec_unlink {
 828         __u32            ul_opcode;
 829         __u32            ul_flags;
 830         __u32            ul_mode;
 831         struct lustre_id ul_id1;
 832         struct lustre_id ul_id2;
 833         __u64            ul_time;
 834 };
 835
 836 extern void lustre_swab_mds_rec_unlink (struct mds_rec_unlink *ul);
 837
 838 struct mds_rec_rename {
 839         __u32            rn_opcode;
 840         __u32            rn_flags;
 841         __u32            rn_padding;
 842         struct lustre_id rn_id1;
 843         struct lustre_id rn_id2;
 844         __u64            rn_time;
 845 };
 846
 847 struct mds_rec_setattr {
 848         __u32            sa_opcode;
 849         __u32            sa_flags;
 850         __u32            sa_valid;
 851         struct lustre_id sa_id;
 852         __u32            sa_mode;
 853         __u32            sa_uid;
 854         __u32            sa_gid;
 855         __u32            sa_attr_flags;
 856         __u64            sa_size;
 857         __u64            sa_atime;
 858         __u64            sa_mtime;
 859         __u64            sa_ctime;
 860 };
 861
 862 extern void lustre_swab_mds_rec_rename (struct mds_rec_rename *rn);
 863
 864 /*
 865  *  LOV data structures
 866  */
 867
 868 #define LOV_MAX_UUID_BUFFER_SIZE  8192
 869 /* The size of the buffer the lov/mdc reserves for the
 870  * array of UUIDs returned by the MDS.  With the current
 871  * protocol, this will limit the max number of OSTs per LOV */
 872
 873 struct lov_desc {
 874         __u32 ld_tgt_count;                /* how many OBD's */
 875         __u32 ld_active_tgt_count;         /* how many active */
 876         __u32 ld_default_stripe_count;     /* how many objects are used */
 877         __u32 ld_pattern;                  /* PATTERN_RAID0, PATTERN_RAID1 */
 878         __u64 ld_default_stripe_size;      /* in bytes */
 879         __u64 ld_default_stripe_offset;    /* in bytes */
 880         struct obd_uuid ld_uuid;
 881 };
 882
 883 struct lmv_desc {
 884         __u32 ld_tgt_count;                /* how many MDS's */
 885         __u32 ld_active_tgt_count;         /* how many active */
 886         struct obd_uuid ld_uuid;
 887 };
 888
 889 /*
 890  *   LDLM requests:
 891  */
 892 /* opcodes -- MUST be distinct from OST/MDS opcodes */
 893 typedef enum {
 894         LDLM_ENQUEUE     = 101,
 895         LDLM_CONVERT     = 102,
 896         LDLM_CANCEL      = 103,
 897         LDLM_BL_CALLBACK = 104,
 898         LDLM_CP_CALLBACK = 105,
 899         LDLM_GL_CALLBACK = 106,
 900         LDLM_LAST_OPC
 901 } ldlm_cmd_t;
 902 #define LDLM_FIRST_OPC LDLM_ENQUEUE
 903
 904 #define RES_NAME_SIZE 4
 905 struct ldlm_res_id {
 906         __u64 name[RES_NAME_SIZE];
 907 };
 908
 909 extern void lustre_swab_ldlm_res_id (struct ldlm_res_id *id);
 910
 911 /* lock types */
 912 typedef enum {
 913         LCK_EX = 1,
 914         LCK_PW = 2,
 915         LCK_PR = 4,
 916         LCK_CW = 8,
 917         LCK_CR = 16,
 918         LCK_NL = 32,
 919         LCK_GROUP = 64
 920 } ldlm_mode_t;
 921
 922 struct ldlm_extent {
 923         __u64 start;
 924         __u64 end;
 925         __u64 gid;
 926 };
 927 struct ldlm_inodebits {
 928         __u64 bits;
 929 };
 930
 931 struct ldlm_flock {
 932         __u64 start;
 933         __u64 end;
 934         __u64 pid;
 935         __u64 blocking_pid;
 936         __u64 blocking_export;
 937 };
 938
 939 /* it's important that the fields of the ldlm_extent structure match
 940  * the first fields of the ldlm_flock structure because there is only
 941  * one ldlm_swab routine to process the ldlm_policy_data_t union. if
 942  * this ever changes we will need to swab the union differently based
 943  * on the resource type. */
 944
 945 typedef union {
 946         struct ldlm_extent l_extent;
 947         struct ldlm_flock  l_flock;
 948         struct ldlm_inodebits l_inodebits;
 949 } ldlm_policy_data_t;
 950
 951 extern void lustre_swab_ldlm_policy_data (ldlm_policy_data_t *d);
 952
 953 struct ldlm_intent {
 954         __u64 opc;
 955 };
 956
 957 extern void lustre_swab_ldlm_intent (struct ldlm_intent *i);
 958
 959 struct ldlm_resource_desc {
 960         __u32 lr_type;
 961         __u32 lr_padding;
 962         struct ldlm_res_id lr_name;
 963 };
 964
 965 extern void lustre_swab_ldlm_resource_desc (struct ldlm_resource_desc *r);
 966
 967 struct ldlm_lock_desc {
 968         struct ldlm_resource_desc l_resource;
 969         ldlm_mode_t l_req_mode;
 970         ldlm_mode_t l_granted_mode;
 971         ldlm_policy_data_t l_policy_data;
 972 };
 973
 974 extern void lustre_swab_ldlm_lock_desc (struct ldlm_lock_desc *l);
 975
 976 struct ldlm_request {
 977         __u32 lock_flags;
 978         __u32 lock_padding;
 979         struct ldlm_lock_desc lock_desc;
 980         struct lustre_handle lock_handle1;
 981         struct lustre_handle lock_handle2;
 982 };
 983
 984 extern void lustre_swab_ldlm_request (struct ldlm_request *rq);
 985
 986 struct ldlm_reply {
 987         __u32 lock_flags;
 988         __u32 lock_padding;
 989         struct ldlm_lock_desc lock_desc;
 990         struct lustre_handle lock_handle;
 991         __u64  lock_policy_res1;
 992         __u64  lock_policy_res2;
 993 };
 994
 995 extern void lustre_swab_ldlm_reply (struct ldlm_reply *r);
 996
 997 /*
 998  * ptlbd, portal block device requests
 999  */
1000 typedef enum {
1001         PTLBD_QUERY      = 200,
1002         PTLBD_READ       = 201,
1003         PTLBD_WRITE      = 202,
1004         PTLBD_FLUSH      = 203,
1005         PTLBD_CONNECT    = 204,
1006         PTLBD_DISCONNECT = 205,
1007         PTLBD_LAST_OPC
1008 } ptlbd_cmd_t;
1009 #define PTLBD_FIRST_OPC PTLBD_QUERY
1010
1011 struct ptlbd_op {
1012         __u16 op_cmd;
1013         __u16 op_lun;
1014         __u16 op_niob_cnt;
1015         __u16 op__padding;
1016         __u32 op_block_cnt;
1017 };
1018
1019 extern void lustre_swab_ptlbd_op (struct ptlbd_op *op);
1020
1021 struct ptlbd_niob {
1022         __u64 n_xid;
1023         __u64 n_block_nr;
1024         __u32 n_offset;
1025         __u32 n_length;
1026 };
1027
1028 extern void lustre_swab_ptlbd_niob (struct ptlbd_niob *n);
1029
1030 struct ptlbd_rsp {
1031         __u16 r_status;
1032         __u16 r_error_cnt;
1033 };
1034
1035 extern void lustre_swab_ptlbd_rsp (struct ptlbd_rsp *r);
1036
1037 #define CAPA_KEY_LEN           16
1038 #define CAPA_DIGEST_SIZE       16
1039
1040 struct lustre_capa {
1041         __u32   lc_uid;       /* uid */
1042         __u32   lc_op;        /* operations allowed */
1043         __u64   lc_ino;       /* inode# */
1044         __u32   lc_mdsid;     /* mds# */
1045         __u32   lc_keyid;     /* key used for the capability */
1046         __u64   lc_expiry;    /* expiry time (sec): servers have clocks */
1047         __u32   lc_flags;     /* security features for capability */
1048         __u8    lc_hmac[CAPA_DIGEST_SIZE]; /* HMAC */
1049 } __attribute__((packed));
1050
1051 extern void lustre_swab_lustre_capa (struct lustre_capa *c);
1052
1053 struct lustre_capa_key {
1054         __u32   lk_mdsid;     /* mds# */
1055         __u32   lk_keyid;     /* key# */
1056         __u64   lk_expiry;    /* expiry (sec) */
1057         __u8    lk_key[CAPA_KEY_LEN];  /* key */
1058 };
1059
1060 extern void lustre_swab_lustre_capa_key (struct lustre_capa_key *k);
1061
1062 /*
1063  * Opcodes for management/monitoring node.
1064  */
1065 typedef enum {
1066         MGMT_CONNECT = 250,
1067         MGMT_DISCONNECT,
1068         MGMT_EXCEPTION,         /* node died, etc. */
1069         MGMT_LAST_OPC
1070 } mgmt_cmd_t;
1071 #define MGMT_FIRST_OPC MGMT_CONNECT
1072
1073 /*
1074  * Opcodes for multiple servers.
1075  */
1076
1077 typedef enum {
1078         OBD_PING = 400,
1079         OBD_LOG_CANCEL,
1080         OBD_LAST_OPC
1081 } obd_cmd_t;
1082 #define OBD_FIRST_OPC OBD_PING
1083
1084 /* catalog of log objects */
1085
1086 /* Identifier for a single log object */
1087 struct llog_logid {
1088         __u64                   lgl_oid;
1089         __u64                   lgl_ogr;
1090         __u32                   lgl_ogen;
1091 } __attribute__((packed));
1092
1093 /* Records written to the CATALOGS list */
1094 #define CATLIST "CATALOGS"
1095 struct llog_catid {
1096         struct llog_logid       lci_logid;
1097         __u32                   lci_padding[3];
1098 } __attribute__((packed));
1099
1100 /* Log data record types - there is no specific reason that these need to
1101  * be related to the RPC opcodes, but no reason not to (may be handy later?)
1102  */
1103 typedef enum {
1104         OST_SZ_REC       = 0x10600000 | (OST_SAN_WRITE << 8),
1105         OST_RAID1_REC    = 0x10600000 | ((OST_SAN_WRITE + 1) << 8),
1106         MDS_UNLINK_REC   = 0x10610000 | (MDS_REINT << 8) | REINT_UNLINK,
1107         OBD_CFG_REC      = 0x10620000,
1108         PTL_CFG_REC      = 0x10630000,
1109         LLOG_GEN_REC     = 0x10640000,
1110         LLOG_HDR_MAGIC   = 0x10645539,
1111         LLOG_LOGID_MAGIC = 0x1064553b,
1112         SMFS_UPDATE_REC  = 0x10650000,
1113         CACHE_LRU_REC    = 0x10660000,
1114         SMFS_AUDIT_GEN_REC = 0x10670000,
1115         SMFS_AUDIT_NAME_REC = 0x10680000,
1116 } llog_op_type;
1117
1118 /* Log record header - stored in little endian order.
1119  * Each record must start with this struct, end with a llog_rec_tail,
1120  * and be a multiple of 256 bits in size.
1121  */
1122 struct llog_rec_hdr {
1123         __u32                   lrh_len;
1124         __u32                   lrh_index;
1125         __u32                   lrh_type;
1126         __u32                   padding;
1127 };
1128
1129 struct llog_rec_tail {
1130         __u32 lrt_len;
1131         __u32 lrt_index;
1132 };
1133
1134 struct llog_logid_rec {
1135         struct llog_rec_hdr     lid_hdr;
1136         struct llog_logid       lid_id;
1137         __u32                   padding[5];
1138         struct llog_rec_tail    lid_tail;
1139 } __attribute__((packed));
1140
1141 struct llog_create_rec {
1142         struct llog_rec_hdr     lcr_hdr;
1143         struct lustre_id        lcr_id;
1144         obd_id                  lcr_oid;
1145         obd_count               lcr_ogen;
1146         __u32                   padding;
1147         struct llog_rec_tail    lcr_tail;
1148 } __attribute__((packed));
1149
1150 struct llog_orphan_rec {
1151         struct llog_rec_hdr     lor_hdr;
1152         obd_id                  lor_oid;
1153         obd_count               lor_ogen;
1154         __u32                   padding;
1155         struct llog_rec_tail    lor_tail;
1156 } __attribute__((packed));
1157
1158 struct llog_unlink_rec {
1159         struct llog_rec_hdr     lur_hdr;
1160         obd_id                  lur_oid;
1161         obd_count               lur_ogen;
1162         __u32                   padding;
1163         struct llog_rec_tail    lur_tail;
1164 } __attribute__((packed));
1165
1166 struct llog_size_change_rec {
1167         struct llog_rec_hdr     lsc_hdr;
1168         struct lustre_id        lsc_id;
1169         __u32                   lsc_io_epoch;
1170         __u32                   padding;
1171         struct llog_rec_tail    lsc_tail;
1172 } __attribute__((packed));
1173
1174 struct llog_gen {
1175         __u64 mnt_cnt;
1176         __u64 conn_cnt;
1177 };
1178
1179 struct llog_gen_rec {
1180         struct llog_rec_hdr     lgr_hdr;
1181         struct llog_gen         lgr_gen;
1182         struct llog_rec_tail    lgr_tail;
1183 } __attribute__((packed));
1184
1185 struct llog_lru_rec {
1186         struct llog_rec_hdr     llr_hdr;
1187         struct lustre_id        llr_cid;
1188         struct lustre_id        llr_pid;
1189         struct llog_rec_tail    llr_tail;
1190 } __attribute__((packed));
1191
1192 /* On-disk header structure of each log object, stored in little endian order */
1193 #define LLOG_CHUNK_SIZE         8192
1194 #define LLOG_HEADER_SIZE        (96)
1195 #define LLOG_BITMAP_BYTES       (LLOG_CHUNK_SIZE - LLOG_HEADER_SIZE)
1196
1197 #define LLOG_MIN_REC_SIZE       (24) /* round(llog_rec_hdr + llog_rec_tail) */
1198
1199 /* flags for the logs */
1200 #define LLOG_F_ZAP_WHEN_EMPTY   0x1
1201 #define LLOG_F_IS_CAT           0x2
1202 #define LLOG_F_IS_PLAIN         0x4
1203
1204 struct llog_log_hdr {
1205         struct llog_rec_hdr     llh_hdr;
1206         __u64                   llh_timestamp;
1207         __u32                   llh_count;
1208         __u32                   llh_bitmap_offset;
1209         __u32                   llh_size;
1210         __u32                   llh_flags;
1211         __u32                   llh_cat_idx;
1212         /* for a catalog the first plain slot is next to it */
1213         struct obd_uuid         llh_tgtuuid;
1214         __u32                 llh_reserved[LLOG_HEADER_SIZE/sizeof(__u32) - 23];
1215         __u32                   llh_bitmap[LLOG_BITMAP_BYTES/sizeof(__u32)];
1216         struct llog_rec_tail    llh_tail;
1217 } __attribute__((packed));
1218
1219 #define LLOG_BITMAP_SIZE(llh)  ((llh->llh_hdr.lrh_len -         \
1220                                  llh->llh_bitmap_offset -       \
1221                                  sizeof(llh->llh_tail)) * 8)
1222
1223 /* log cookies are used to reference a specific log file and a record therein */
1224 struct llog_cookie {
1225         struct llog_logid       lgc_lgl;
1226         __u32                   lgc_subsys;
1227         __u32                   lgc_index;
1228         __u32                   lgc_flags;
1229 } __attribute__((packed));
1230
1231 /* llog protocol */
1232 enum llogd_rpc_ops {
1233         LLOG_ORIGIN_HANDLE_OPEN         = 501,
1234         LLOG_ORIGIN_HANDLE_NEXT_BLOCK   = 502,
1235         LLOG_ORIGIN_HANDLE_READ_HEADER  = 503,
1236         LLOG_ORIGIN_HANDLE_WRITE_REC    = 504,
1237         LLOG_ORIGIN_HANDLE_CLOSE        = 505,
1238         LLOG_ORIGIN_CONNECT             = 506,
1239         LLOG_CATINFO                    = 507,  /* for lfs catinfo */
1240         LLOG_ORIGIN_HANDLE_PREV_BLOCK   = 508,
1241 };
1242
1243 struct llogd_body {
1244         struct llog_logid  lgd_logid;
1245         __u32 lgd_ctxt_idx;
1246         __u32 lgd_llh_flags;
1247         __u32 lgd_index;
1248         __u32 lgd_saved_index;
1249         __u32 lgd_len;
1250         __u64 lgd_cur_offset;
1251 } __attribute__((packed));
1252
1253 struct llogd_conn_body {
1254         struct llog_gen         lgdc_gen;
1255         struct llog_logid       lgdc_logid;
1256         __u32                   lgdc_ctxt_idx;
1257 } __attribute__((packed));
1258
1259 extern void lustre_swab_llogd_body (struct llogd_body *d);
1260 extern void lustre_swab_llog_hdr (struct llog_log_hdr *h);
1261 extern void lustre_swab_llogd_conn_body (struct llogd_conn_body *d);
1262
1263 struct lustre_cfg;
1264 extern void lustre_swab_lustre_cfg(struct lustre_cfg *lcfg);
1265
1266 static inline struct lustre_id *obdo_id(struct obdo *oa)
1267 {
1268         void *raw_id = oa->o_inline + sizeof(struct lustre_handle) +
1269                 sizeof(struct llog_cookie);
1270
1271         return (struct lustre_id *)raw_id;
1272 }
1273
1274 /* security negotiate */
1275 typedef enum {
1276         SEC_INIT                = 600,
1277         SEC_INIT_CONTINUE       = 601,
1278         SEC_FINI                = 602,
1279         SEC_LAST_OPC
1280 } sec_cmd_t;
1281 #define SEC_FIRST_OPC SEC_INIT
1282 /* GS opcodes*/
1283 typedef enum {
1284         GKS_CONNECT      = 700,
1285         GKS_DISCONNECT   = 701,
1286         GKS_GET_KEY      = 702,
1287         GKS_DECRYPT_KEY  = 703,
1288         GKS_GET_MAC      = 704,
1289 } gks_cmd_t;
1290
1291 #ifdef __KERNEL__
1292 #define KEY_SIZE        16
1293 #define MAC_SIZE        16
1294
1295 struct crypto_key {
1296         __u8    ck_mac[MAC_SIZE];
1297         __u8    ck_key[KEY_SIZE];
1298         __u32   ck_type;
1299 };
1300
1301 struct key_perm {
1302         uid_t    kp_uid;
1303         gid_t    kp_gid;
1304         __u32    kp_mode;
1305         __u32    kp_acl_count;
1306         struct   posix_acl_entry kp_acls[0];
1307 };
1308
1309 struct key_context {
1310         struct crypto_key kc_ck;
1311         __u32  kc_command;
1312         __u32  kc_valid;
1313         struct key_perm kc_perm;
1314 };
1315 typedef int (*crypt_cb_t)(struct page *page, __u64 offset, __u64 count,
1316                           int flags);
1317 extern void lustre_swab_key_context (struct key_context *kctxt);
1318 extern void lustre_swab_key_perms (struct key_perm *kperm);
1319 #endif /*for define __KERNEL*/
1320
1321 extern void lustre_swab_lustre_id(struct lustre_id *id);
1322 extern void lustre_swab_lov_desc(struct lov_desc *desc);
1323 extern void lustre_swab_fid_extent(struct fid_extent *ext);
1324 extern void lustre_swab_lustre_stc(struct lustre_stc *stc);
1325 extern void lustre_swab_lustre_fid(struct lustre_fid *fid);
1326 extern void lustre_swab_mds_status_req(struct mds_status_req *r);
1327 extern void lustre_swab_mds_rec_setattr(struct mds_rec_setattr *sa);
1328
1329 #endif