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