lustre_idl.h

/*
 * GPL HEADER START
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 only,
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License version 2 for more details (a copy is included
 * in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU General Public License
 * version 2 along with this program; If not, see
 * http://www.gnu.org/licenses/gpl-2.0.html
 *
 * GPL HEADER END
 */
/*
 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright (c) 2011, 2017, Intel Corporation.
 */
/*
 * This file is part of Lustre, http://www.lustre.org/
 * Lustre is a trademark of Sun Microsystems, Inc.
 *
 * Lustre wire protocol definitions.
 */

/** \defgroup lustreidl lustreidl
 *
 * Lustre wire protocol definitions.
 *
 * ALL structs passing over the wire should be declared here.  Structs
 * that are used in interfaces with userspace should go in lustre_user.h.
 *
 * All structs being declared here should be built from simple fixed-size
 * types defined in linux/types.h or be built from other types or
 * structs also declared in this file.  Similarly, all flags and magic
 * values in those structs should also be declared here.  This ensures
 * that the Lustre wire protocol is not influenced by external dependencies.
 *
 * The only other acceptable items in this file are VERY SIMPLE accessor
 * functions to avoid callers grubbing inside the structures. Nothing that
 * depends on external functions or definitions should be in here.
 *
 * Structs must be properly aligned to put 64-bit values on an 8-byte
 * boundary.  Any structs being added here must also be added to
 * utils/wirecheck.c and "make newwiretest" run to regenerate the
 * utils/wiretest.c sources.  This allows us to verify that wire structs
 * have the proper alignment/size on all architectures.
 *
 * DO NOT CHANGE any of the structs, flags, values declared here and used
 * in released Lustre versions.  Some structs may have padding fields that
 * can be used.  Some structs might allow addition at the end (verify this
 * in the code to ensure that new/old clients that see this larger struct
 * do not fail, otherwise you need to implement protocol compatibility).
 *
 * @{
 */

#ifndef _LUSTRE_IDL_H_
#define _LUSTRE_IDL_H_

#include <asm/byteorder.h>
#include <linux/errno.h>
#include <linux/fiemap.h>
#include <linux/types.h>
#include <linux/lnet/lnet-types.h>
#include <linux/lustre/lustre_user.h>
#include <linux/lustre/lustre_ver.h>

#if defined(__cplusplus)
extern "C" {
#endif

/*
 *  GENERAL STUFF
 */
/* FOO_REQUEST_PORTAL is for incoming requests on the FOO
 * FOO_REPLY_PORTAL   is for incoming replies on the FOO
 * FOO_BULK_PORTAL    is for incoming bulk on the FOO
 */

#define CONNMGR_REQUEST_PORTAL          1
#define CONNMGR_REPLY_PORTAL            2
/* #define OSC_REQUEST_PORTAL		 3*/
#define OSC_REPLY_PORTAL                4
/*#define OSC_BULK_PORTAL		 5*/
#define OST_IO_PORTAL                   6
#define OST_CREATE_PORTAL               7
#define OST_BULK_PORTAL                 8
/*#define MDC_REQUEST_PORTAL		 9*/
#define MDC_REPLY_PORTAL               10
/*#define MDC_BULK_PORTAL		11*/
#define MDS_REQUEST_PORTAL             12
#define MDS_IO_PORTAL			13
#define MDS_BULK_PORTAL                14
#define LDLM_CB_REQUEST_PORTAL         15
#define LDLM_CB_REPLY_PORTAL           16
#define LDLM_CANCEL_REQUEST_PORTAL     17
#define LDLM_CANCEL_REPLY_PORTAL       18
/*#define PTLBD_REQUEST_PORTAL		19*/
/*#define PTLBD_REPLY_PORTAL		20*/
/*#define PTLBD_BULK_PORTAL		21*/
#define MDS_SETATTR_PORTAL             22
#define MDS_READPAGE_PORTAL            23
#define OUT_PORTAL			24
#define MGC_REPLY_PORTAL               25
#define MGS_REQUEST_PORTAL             26
#define MGS_REPLY_PORTAL               27
#define OST_REQUEST_PORTAL             28
#define FLD_REQUEST_PORTAL             29
#define SEQ_METADATA_PORTAL            30
#define SEQ_DATA_PORTAL                31
#define SEQ_CONTROLLER_PORTAL          32
#define MGS_BULK_PORTAL                33
/* #define DVS_PORTAL			63 */
/* reserved for Cray DVS - spitzcor@cray.com, roe@cray.com, n8851@cray.com */

/**
 * Describes a range of sequence, lsr_start is included but lsr_end is
 * not in the range.
 * Same structure is used in fld module where lsr_index field holds mdt id
 * of the home mdt.
 */
struct lu_seq_range {
	__u64 lsr_start;
	__u64 lsr_end;
	__u32 lsr_index;
	__u32 lsr_flags;
};

struct lu_seq_range_array {
	__u32 lsra_count;
	__u32 lsra_padding;
	struct lu_seq_range lsra_lsr[0];
};

#define LU_SEQ_RANGE_MDT	0x0
#define LU_SEQ_RANGE_OST	0x1
#define LU_SEQ_RANGE_ANY	0x3

#define LU_SEQ_RANGE_MASK	0x3

/** \defgroup lu_fid lu_fid
 * @{ */

extern void lustre_lma_swab(struct lustre_mdt_attrs *lma);
extern void lustre_lma_init(struct lustre_mdt_attrs *lma,
			    const struct lu_fid *fid,
			    __u32 compat, __u32 incompat);
extern void lustre_loa_swab(struct lustre_ost_attrs *loa,
			    bool to_cpu);
extern void lustre_loa_init(struct lustre_ost_attrs *loa,
			    const struct lu_fid *fid,
			    __u32 compat, __u32 incompat);

/* copytool can use any nonnegative integer to represent archive-Ids during
 * register with MDT thru kuc.
 * archive num = 0 => all
 * archive num from 1 to MAX_U32
 */
#define LL_HSM_ORIGIN_MAX_ARCHIVE	(sizeof(__u32) * 8)
/* the max count of archive ids that one agent can support */
#define LL_HSM_MAX_ARCHIVES_PER_AGENT	1024

/**
 * HSM on-disk attributes stored in a separate xattr.
 */
struct hsm_attrs {
	/** Bitfield for supported data in this structure. For future use. */
	__u32	hsm_compat;

	/** HSM flags, see hsm_flags enum below */
	__u32	hsm_flags;
	/** backend archive id associated with the file */
	__u64	hsm_arch_id;
	/** version associated with the last archiving, if any */
	__u64	hsm_arch_ver;
};
extern void lustre_hsm_swab(struct hsm_attrs *attrs);

/**
 * fid constants
 */
enum {
	/** LASTID file has zero OID */
	LUSTRE_FID_LASTID_OID = 0UL,
        /** initial fid id value */
        LUSTRE_FID_INIT_OID  = 1UL
};

/**
 * Different FID Format
 * http://arch.lustre.org/index.php?title=Interoperability_fids_zfs#NEW.0
 *
 * FID:
 * File IDentifier generated by client from range allocated by the seq service.
 * First 0x400 sequences [2^33, 2^33 + 0x400] are reserved for system use. Note
 * that on ldiskfs MDTs that IGIF FIDs can use inode numbers starting at 12,
 * but this is in the IGIF SEQ rangeand does not conflict with assigned FIDs.
 *
 * IGIF:
 * Inode and Generation In FID, a surrogate FID used to globally identify an
 * existing object on OLD formatted MDT file system. This would only be used on
 * MDT0 in a DNE filesystem, because there are not expected to be any OLD
 * formatted DNE filesystems. Belongs to a sequence in [12, 2^32 - 1] range,
 * where sequence number is inode number, and inode generation is used as OID.
 * NOTE: This assumes no more than 2^32-1 inodes exist in the MDT filesystem,
 * which is the maximum possible for an ldiskfs backend. NOTE: This assumes
 * that the reserved ext3/ext4/ldiskfs inode numbers [0-11] are never visible
 * to clients, which has always been true.
 *
 * IDIF:
 * Object ID in FID, a surrogate FID used to globally identify an existing
 * object on OLD formatted OST file system. Belongs to a sequence in
 * [2^32, 2^33 - 1]. Sequence number is calculated as:
 *	1 << 32 | (ost_index << 16) | ((objid >> 32) & 0xffff)
 * that is, SEQ consists of 16-bit OST index, and higher 16 bits of object ID.
 * The generation of unique SEQ values per OST allows the IDIF FIDs to be
 * identified in the FLD correctly. The OID field is calculated as:
 *	objid & 0xffffffff
 * that is, it consists of lower 32 bits of object ID. NOTE This assumes that
 * no more than 2^48-1 objects have ever been created on an OST, and that no
 * more than 65535 OSTs are in use. Both are very reasonable assumptions (can
 * uniquely map all objects on an OST that created 1M objects per second for 9
 * years, or combinations thereof).
 *
 * OST_MDT0:
 * Surrogate FID used to identify an existing object on OLD formatted OST
 * filesystem. Belongs to the reserved sequence 0, and is used internally prior
 * to the introduction of FID-on-OST, at which point IDIF will be used to
 * identify objects as residing on a specific OST.
 *
 * LLOG:
 * For Lustre Log objects the object sequence 1 is used. This is compatible with
 * both OLD and NEW.1 namespaces, as this SEQ number is in the ext3/ldiskfs
 * reserved inode range and does not conflict with IGIF sequence numbers.
 *
 * ECHO:
 * For testing OST IO performance the object sequence 2 is used. This is
 * compatible with both OLD and NEW.1 namespaces, as this SEQ number is in the
 * ext3/ldiskfs reserved inode range and does not conflict with IGIF sequence
 * numbers.
 *
 * OST_MDT1 .. OST_MAX:
 * For testing with multiple MDTs the object sequence 3 through 9 is used,
 * allowing direct mapping of MDTs 1 through 7 respectively, for a total of 8
 * MDTs including OST_MDT0. This matches the legacy CMD project "group"
 * mappings. However, this SEQ range is only for testing prior to any production
 * DNE release, as the objects in this range conflict across all OSTs, as the
 * OST index is not part of the FID.
 *
 *
 * For compatibility with existing OLD OST network protocol structures, the FID
 * must map onto the o_id and o_gr in a manner that ensures existing objects are
 * identified consistently for IO, as well as onto the lock namespace to ensure
 * both IDIFs map onto the same objects for IO as well as resources in the DLM.
 *
 * DLM OLD OBIF/IDIF:
 * resource[] = {o_id, o_seq, 0, 0};  // o_seq == 0 for production releases
 *
 * DLM NEW.1 FID (this is the same for both the MDT and OST):
 * resource[] = {SEQ, OID, VER, HASH};
 *
 * Note that for mapping IDIF values to DLM resource names the o_id may be
 * larger than the 2^33 reserved sequence numbers for IDIF, so it is possible
 * for the o_id numbers to overlap FID SEQ numbers in the resource. However, in
 * all production releases the OLD o_seq field is always zero, and all valid FID
 * OID values are non-zero, so the lock resources will not collide.
 *
 * For objects within the IDIF range, group extraction (non-CMD) will be:
 * o_id = (fid->f_seq & 0x7fff) << 16 | fid->f_oid;
 * o_seq = 0;  // formerly group number
 */

/**
 * Note that reserved SEQ numbers below 12 will conflict with ldiskfs
 * inodes in the IGIF namespace, so these reserved SEQ numbers can be
 * used for other purposes and not risk collisions with existing inodes.
 */
enum fid_seq {
	FID_SEQ_OST_MDT0	= 0,
	FID_SEQ_LLOG		= 1, /* unnamed llogs */
	FID_SEQ_ECHO		= 2,
	FID_SEQ_UNUSED_START	= 3,
	FID_SEQ_UNUSED_END	= 9,
	FID_SEQ_LLOG_NAME	= 10, /* named llogs */
	FID_SEQ_RSVD		= 11,
	FID_SEQ_IGIF		= 12,
	FID_SEQ_IGIF_MAX	= 0x0ffffffffULL,
	FID_SEQ_IDIF		= 0x100000000ULL,
	FID_SEQ_IDIF_MAX	= 0x1ffffffffULL,
	/* Normal FID sequence starts from this value, i.e. 1<<33 */
	FID_SEQ_START		= 0x200000000ULL,
	/* sequence for local pre-defined FIDs listed in local_oid */
	FID_SEQ_LOCAL_FILE	= 0x200000001ULL,
	FID_SEQ_DOT_LUSTRE	= 0x200000002ULL,
	/* sequence is used for local named objects FIDs generated
	 * by local_object_storage library */
	FID_SEQ_LOCAL_NAME	= 0x200000003ULL,
	/* Because current FLD will only cache the fid sequence, instead
	 * of oid on the client side, if the FID needs to be exposed to
	 * clients sides, it needs to make sure all of fids under one
	 * sequence will be located in one MDT. */
	FID_SEQ_SPECIAL		= 0x200000004ULL,
	FID_SEQ_QUOTA		= 0x200000005ULL,
	FID_SEQ_QUOTA_GLB	= 0x200000006ULL,
	FID_SEQ_ROOT		= 0x200000007ULL,  /* Located on MDT0 */
	FID_SEQ_LAYOUT_RBTREE	= 0x200000008ULL,
	/* sequence is used for update logs of cross-MDT operation */
	FID_SEQ_UPDATE_LOG	= 0x200000009ULL,
	/* Sequence is used for the directory under which update logs
	 * are created. */
	FID_SEQ_UPDATE_LOG_DIR	= 0x20000000aULL,
	FID_SEQ_NORMAL		= 0x200000400ULL,
	FID_SEQ_LOV_DEFAULT	= 0xffffffffffffffffULL
};

#define OBIF_OID_MAX_BITS           32
#define OBIF_MAX_OID                (1ULL << OBIF_OID_MAX_BITS)
#define OBIF_OID_MASK               ((1ULL << OBIF_OID_MAX_BITS) - 1)
#define IDIF_OID_MAX_BITS           48
#define IDIF_MAX_OID                (1ULL << IDIF_OID_MAX_BITS)
#define IDIF_OID_MASK               ((1ULL << IDIF_OID_MAX_BITS) - 1)

/** OID for FID_SEQ_SPECIAL */
enum special_oid {
        /* Big Filesystem Lock to serialize rename operations */
        FID_OID_SPECIAL_BFL     = 1UL,
};

/** OID for FID_SEQ_DOT_LUSTRE */
enum dot_lustre_oid {
	FID_OID_DOT_LUSTRE	= 1UL,
	FID_OID_DOT_LUSTRE_OBF	= 2UL,
	FID_OID_DOT_LUSTRE_LPF	= 3UL,
};

/** OID for FID_SEQ_ROOT */
enum root_oid {
	FID_OID_ROOT		= 1UL,
	FID_OID_ECHO_ROOT	= 2UL,
};

struct lu_orphan_rec {
	/* The MDT-object's FID referenced by the orphan OST-object */
	struct lu_fid	lor_fid;
	__u32		lor_uid;
	__u32		lor_gid;
};

struct lu_orphan_ent {
	/* The orphan OST-object's FID */
	struct lu_fid		loe_key;
	struct lu_orphan_rec	loe_rec;
};

struct lu_orphan_rec_v2 {
	struct lu_orphan_rec	lor_rec;
	struct ost_layout	lor_layout;
	__u32			lor_padding;
};

struct lu_orphan_ent_v2 {
	/* The orphan OST-object's FID */
	struct lu_fid		loe_key;
	struct lu_orphan_rec_v2	loe_rec;
};

struct lu_orphan_rec_v3 {
	struct lu_orphan_rec	lor_rec;
	struct ost_layout	lor_layout;
	/* The OST-object declared layout version in PFID EA.*/
	__u32			lor_layout_version;
	/* The OST-object declared layout range (of version) in PFID EA.*/
	__u32			lor_range;
	__u32			lor_padding_1;
	__u64			lor_padding_2;
};

struct lu_orphan_ent_v3 {
	/* The orphan OST-object's FID */
	struct lu_fid		loe_key;
	struct lu_orphan_rec_v3	loe_rec;
};

/** @} lu_fid */

/** \defgroup lu_dir lu_dir
 * @{ */

/**
 * Enumeration of possible directory entry attributes.
 *
 * Attributes follow directory entry header in the order they appear in this
 * enumeration.
 */
enum lu_dirent_attrs {
	LUDA_FID		= 0x0001,
	LUDA_TYPE		= 0x0002,
	LUDA_64BITHASH		= 0x0004,

	/* The following attrs are used for MDT internal only,
	 * not visible to client */

	/* Something in the record is unknown, to be verified in further. */
	LUDA_UNKNOWN		= 0x0400,
	/* Ignore this record, go to next directly. */
	LUDA_IGNORE		= 0x0800,
	/* The system is upgraded, has beed or to be repaired (dryrun). */
	LUDA_UPGRADE		= 0x1000,
	/* The dirent has been repaired, or to be repaired (dryrun). */
	LUDA_REPAIR		= 0x2000,
	/* Only check but not repair the dirent inconsistency */
	LUDA_VERIFY_DRYRUN	= 0x4000,
	/* Verify the dirent consistency */
	LUDA_VERIFY		= 0x8000,
};

#define LU_DIRENT_ATTRS_MASK	0xff00

/**
 * Layout of readdir pages, as transmitted on wire.
 */
struct lu_dirent {
        /** valid if LUDA_FID is set. */
        struct lu_fid lde_fid;
        /** a unique entry identifier: a hash or an offset. */
        __u64         lde_hash;
        /** total record length, including all attributes. */
        __u16         lde_reclen;
        /** name length */
        __u16         lde_namelen;
        /** optional variable size attributes following this entry.
         *  taken from enum lu_dirent_attrs.
         */
        __u32         lde_attrs;
        /** name is followed by the attributes indicated in ->ldp_attrs, in
         *  their natural order. After the last attribute, padding bytes are
         *  added to make ->lde_reclen a multiple of 8.
         */
        char          lde_name[0];
};

/*
 * Definitions of optional directory entry attributes formats.
 *
 * Individual attributes do not have their length encoded in a generic way. It
 * is assumed that consumer of an attribute knows its format. This means that
 * it is impossible to skip over an unknown attribute, except by skipping over all
 * remaining attributes (by using ->lde_reclen), which is not too
 * constraining, because new server versions will append new attributes at
 * the end of an entry.
 */

/**
 * Fid directory attribute: a fid of an object referenced by the entry. This
 * will be almost always requested by the client and supplied by the server.
 *
 * Aligned to 8 bytes.
 */
/* To have compatibility with 1.8, lets have fid in lu_dirent struct. */

/**
 * File type.
 *
 * Aligned to 2 bytes.
 */
struct luda_type {
        __u16 lt_type;
};

struct lu_dirpage {
        __u64            ldp_hash_start;
        __u64            ldp_hash_end;
        __u32            ldp_flags;
        __u32            ldp_pad0;
        struct lu_dirent ldp_entries[0];
};

enum lu_dirpage_flags {
        /**
         * dirpage contains no entry.
         */
        LDF_EMPTY   = 1 << 0,
        /**
         * last entry's lde_hash equals ldp_hash_end.
         */
        LDF_COLLIDE = 1 << 1
};

static inline struct lu_dirent *lu_dirent_start(struct lu_dirpage *dp)
{
	if (__le32_to_cpu(dp->ldp_flags) & LDF_EMPTY)
		return NULL;
	else
		return dp->ldp_entries;
}

static inline struct lu_dirent *lu_dirent_next(struct lu_dirent *ent)
{
	struct lu_dirent *next;

	if (__le16_to_cpu(ent->lde_reclen) != 0)
		next = ((void *)ent) + __le16_to_cpu(ent->lde_reclen);
	else
		next = NULL;

	return next;
}

static inline __kernel_size_t lu_dirent_calc_size(size_t namelen, __u16 attr)
{
	__kernel_size_t size;

	if (attr & LUDA_TYPE) {
		const __kernel_size_t align = sizeof(struct luda_type) - 1;

		size = (sizeof(struct lu_dirent) + namelen + 1 + align) &
		       ~align;
		size += sizeof(struct luda_type);
	} else {
		size = sizeof(struct lu_dirent) + namelen + 1;
	}

	return (size + 7) & ~7;
}

static inline __u16 lu_dirent_type_get(struct lu_dirent *ent)
{
	__u16 type = 0;
	struct luda_type *lt;
	int len = 0;

	if (__le32_to_cpu(ent->lde_attrs) & LUDA_TYPE) {
		const unsigned int align = sizeof(struct luda_type) - 1;

		len = __le16_to_cpu(ent->lde_namelen);
		len = (len + align) & ~align;
		lt = (void *)ent->lde_name + len;
		type = __le16_to_cpu(lt->lt_type);
	}

	return type;
}

#define MDS_DIR_END_OFF 0xfffffffffffffffeULL

/**
 * MDS_READPAGE page size
 *
 * This is the directory page size packed in MDS_READPAGE RPC.
 * It's different than PAGE_SIZE because the client needs to
 * access the struct lu_dirpage header packed at the beginning of
 * the "page" and without this there isn't any way to know find the
 * lu_dirpage header is if client and server PAGE_SIZE differ.
 */
#define LU_PAGE_SHIFT 12
#define LU_PAGE_SIZE  (1UL << LU_PAGE_SHIFT)
#define LU_PAGE_MASK  (~(LU_PAGE_SIZE - 1))

#define LU_PAGE_COUNT (1 << (PAGE_SHIFT - LU_PAGE_SHIFT))

/** @} lu_dir */

struct lustre_handle {
        __u64 cookie;
};
#define DEAD_HANDLE_MAGIC 0xdeadbeefcafebabeULL

static inline bool lustre_handle_is_used(const struct lustre_handle *lh)
{
	return lh->cookie != 0;
}

static inline bool lustre_handle_equal(const struct lustre_handle *lh1,
				       const struct lustre_handle *lh2)
{
	return lh1->cookie == lh2->cookie;
}

static inline void lustre_handle_copy(struct lustre_handle *tgt,
				      const struct lustre_handle *src)
{
	tgt->cookie = src->cookie;
}

/* lustre_msg struct magic.  DON'T use swabbed values of MAGIC as magic! */
enum lustre_msg_magic {
	LUSTRE_MSG_MAGIC_V2		= 0x0BD00BD3,
	LUSTRE_MSG_MAGIC_V2_SWABBED	= 0xD30BD00B,
	LUSTRE_MSG_MAGIC		= LUSTRE_MSG_MAGIC_V2
};

/* flags for lm_flags */
enum lustre_msghdr {
	MSGHDR_AT_SUPPORT	= 0x1,	/* adaptive timeouts, lm_cksum valid
					 * in early reply messages */
	MSGHDR_CKSUM_INCOMPAT18	= 0x2,	/* compat for 1.8, needs to be set well
					 * beyond 2.8.0 for compatibility */
};

#define lustre_msg lustre_msg_v2
/* we depend on this structure to be 8-byte aligned */
/* this type is only endian-adjusted in lustre_unpack_msg() */
struct lustre_msg_v2 {
	__u32 lm_bufcount;	/* number of buffers in lm_buflens[] */
	__u32 lm_secflvr;	/* 0 = no crypto, or sptlrpc security flavour */
	__u32 lm_magic;		/* RPC version magic = LUSTRE_MSG_MAGIC_V2 */
	__u32 lm_repsize;	/* size of preallocated reply buffer */
	__u32 lm_cksum;		/* CRC32 of ptlrpc_body early reply messages */
	__u32 lm_flags;		/* enum lustre_msghdr MSGHDR_* flags */
	__u32 lm_padding_2;	/* unused */
	__u32 lm_padding_3;	/* unused */
	__u32 lm_buflens[0];	/* length of additional buffers in bytes,
				 * padded to a multiple of 8 bytes. */
	/*
	 * message buffers are packed after padded lm_buflens[] array,
	 * padded to a multiple of 8 bytes each to align contents.
	 */
};

/* ptlrpc_body packet pb_types */
#define PTL_RPC_MSG_REQUEST	4711	/* normal RPC request message */
#define PTL_RPC_MSG_ERR		4712	/* error reply if request unprocessed */
#define PTL_RPC_MSG_REPLY	4713	/* normal RPC reply message */

/* ptlrpc_body pb_version ((target_version << 16) | rpc_version) */
enum lustre_msg_version {
	PTLRPC_MSG_VERSION	= 0x00000003,
	LUSTRE_VERSION_MASK	= 0xffff0000,
	LUSTRE_OBD_VERSION	= 0x00010000,
	LUSTRE_MDS_VERSION	= 0x00020000,
	LUSTRE_OST_VERSION	= 0x00030000,
	LUSTRE_DLM_VERSION	= 0x00040000,
	LUSTRE_LOG_VERSION	= 0x00050000,
	LUSTRE_MGS_VERSION	= 0x00060000,
};

/* pb_flags that apply to all request messages */
/* #define MSG_LAST_REPLAY	0x0001 obsolete 2.0 => {REQ,LOCK}_REPLAY_DONE */
#define MSG_RESENT		0x0002 /* was previously sent, no reply seen */
#define MSG_REPLAY		0x0004 /* was processed, got reply, recovery */
/* #define MSG_AT_SUPPORT	0x0008 obsolete since 1.5, AT always enabled */
/* #define MSG_DELAY_REPLAY	0x0010 obsolete since 2.0 */
/* #define MSG_VERSION_REPLAY	0x0020 obsolete since 1.8.2, VBR always on */
#define MSG_REQ_REPLAY_DONE	0x0040 /* request replay over, locks next */
#define MSG_LOCK_REPLAY_DONE	0x0080 /* lock replay over, client done */

/* pb_op_flags for connect opcodes: MDS_CONNECT, OST_CONNECT, MGS_CONNECT */
#define MSG_CONNECT_RECOVERING	0x00000001 /* target is in recovery */
#define MSG_CONNECT_RECONNECT	0x00000002 /* tgt already has client import */
#define MSG_CONNECT_REPLAYABLE	0x00000004 /* target supports RPC replay */
/* #define MSG_CONNECT_PEER	0x00000008 obsolete since 1.2, removed in 1.5 */
#define MSG_CONNECT_LIBCLIENT	0x00000010 /* obsolete since 2.3, removed 2.6 */
#define MSG_CONNECT_INITIAL	0x00000020 /* first client connection attempt */
/* #define MSG_CONNECT_ASYNC	0x00000040 obsolete since 1.5 */
#define MSG_CONNECT_NEXT_VER	0x00000080 /* use next version of lustre_msg */
#define MSG_CONNECT_TRANSNO	0x00000100 /* client sent transno in replay */

/* number of previous object versions in pb_pre_versions[] */
#define PTLRPC_NUM_VERSIONS     4
/* without gss, ptlrpc_body is put at the first buffer. */
struct ptlrpc_body_v3 {
	struct lustre_handle pb_handle;
	__u32 pb_type;		/* request/reply/err type: PTL_RPC_MSG_* */
	__u32 pb_version;	/* LUSTRE_*_VERSION | PTLRPC_MSG_VERSION */
	__u32 pb_opc;		/* RPC opcodes: MDS_*, OST_*, LDLM_, ... */
	__u32 pb_status;	/* negative Linux x86 error number */
	__u64 pb_last_xid;	/* highest replied XID w/o lower unreplied XID*/
	__u16 pb_tag;		/* multiple modifying RPCs virtual slot index */
	__u16 pb_padding0;
	__u32 pb_padding1;
	__u64 pb_last_committed;/* rep: highest pb_transno committed to disk */
	__u64 pb_transno;	/* server-assigned transno for modifying RPCs */
	__u32 pb_flags;		/* req: MSG_* flags */
	__u32 pb_op_flags;	/* req: MSG_CONNECT_* flags */
	__u32 pb_conn_cnt;	/* connect instance of this client on server */
	__u32 pb_timeout;	/* req: max wait time; rep: service estimate */
	__u32 pb_service_time;	/* rep: server arrival to reply in seconds */
	__u32 pb_limit;		/* rep: dynamic DLM LRU lock count limit */
	__u64 pb_slv;		/* rep: dynamic DLM LRU server lock volume */
	/* VBR: rep: previous pb_version(s) of objects modified by this RPC */
	__u64 pb_pre_versions[PTLRPC_NUM_VERSIONS];
	__u64 pb_mbits;	/**< match bits for bulk request */
	/* padding for future needs - fix lustre_swab_ptlrpc_body() also */
	__u64 pb_padding64_0;
	__u64 pb_padding64_1;
	__u64 pb_padding64_2;
	char  pb_jobid[LUSTRE_JOBID_SIZE]; /* req: ASCII jobid from env + NUL */
};
#define ptlrpc_body     ptlrpc_body_v3

struct ptlrpc_body_v2 {
        struct lustre_handle pb_handle;
        __u32 pb_type;
        __u32 pb_version;
        __u32 pb_opc;
        __u32 pb_status;
	__u64 pb_last_xid; /* highest replied XID without lower unreplied XID */
	__u16 pb_tag;      /* virtual slot idx for multiple modifying RPCs */
	__u16 pb_padding0;
	__u32 pb_padding1;
        __u64 pb_last_committed;
        __u64 pb_transno;
        __u32 pb_flags;
        __u32 pb_op_flags;
        __u32 pb_conn_cnt;
        __u32 pb_timeout;  /* for req, the deadline, for rep, the service est */
        __u32 pb_service_time; /* for rep, actual service time, also used for
                                  net_latency of req */
        __u32 pb_limit;
        __u64 pb_slv;
        /* VBR: pre-versions */
        __u64 pb_pre_versions[PTLRPC_NUM_VERSIONS];
	__u64 pb_mbits;	/**< unused in V2 */
        /* padding for future needs */
	__u64 pb_padding64_0;
	__u64 pb_padding64_1;
	__u64 pb_padding64_2;
};

/* message body offset for lustre_msg_v2 */
/* ptlrpc body offset in all request/reply messages */
#define MSG_PTLRPC_BODY_OFF             0

/* normal request/reply message record offset */
#define REQ_REC_OFF                     1
#define REPLY_REC_OFF                   1

/* ldlm request message body offset */
#define DLM_LOCKREQ_OFF                 1 /* lockreq offset */
#define DLM_REQ_REC_OFF                 2 /* normal dlm request record offset */

/* ldlm intent lock message body offset */
#define DLM_INTENT_IT_OFF               2 /* intent lock it offset */
#define DLM_INTENT_REC_OFF              3 /* intent lock record offset */

/* ldlm reply message body offset */
#define DLM_LOCKREPLY_OFF               1 /* lockrep offset */
#define DLM_REPLY_REC_OFF               2 /* reply record offset */

/** only use in req->rq_{req,rep}_swab_mask */
#define MSG_PTLRPC_HEADER_OFF           31

/* Connect flags */
#define OBD_CONNECT_RDONLY                0x1ULL /*client has read-only access*/
#define OBD_CONNECT_INDEX                 0x2ULL /*connect specific LOV idx */
#define OBD_CONNECT_MDS                   0x4ULL /*connect from MDT to OST */
#define OBD_CONNECT_GRANT                 0x8ULL /*OSC gets grant at connect */
#define OBD_CONNECT_SRVLOCK              0x10ULL /*server takes locks for cli */
#define OBD_CONNECT_VERSION              0x20ULL /*Lustre versions in ocd */
#define OBD_CONNECT_REQPORTAL            0x40ULL /*Separate non-IO req portal */
#define OBD_CONNECT_ACL                  0x80ULL /*access control lists */
#define OBD_CONNECT_XATTR               0x100ULL /*client use extended attr */
#define OBD_CONNECT_LARGE_ACL		0x200ULL /* more than 32 ACL entries */
#define OBD_CONNECT_TRUNCLOCK           0x400ULL /*locks on server for punch */
#define OBD_CONNECT_TRANSNO             0x800ULL /*replay sends init transno */
#define OBD_CONNECT_IBITS	       0x1000ULL /* not checked in 2.11+ */
#define OBD_CONNECT_BARRIER	       0x2000ULL /* write barrier */
#define OBD_CONNECT_ATTRFID            0x4000ULL /*Server can GetAttr By Fid*/
#define OBD_CONNECT_NODEVOH            0x8000ULL /*No open hndl on specl nodes*/
#define OBD_CONNECT_RMT_CLIENT        0x10000ULL /* Remote client, never used
						  * in production. Removed in
						  * 2.9. Keep this flag to
						  * avoid reusing.
						  */
#define OBD_CONNECT_RMT_CLIENT_FORCE  0x20000ULL /* Remote client by force,
						  * never used in production.
						  * Removed in 2.9. Keep this
						  * flag to avoid reusing.
						  */
#define OBD_CONNECT_BRW_SIZE          0x40000ULL /*Max bytes per rpc */
#define OBD_CONNECT_QUOTA64           0x80000ULL /*Not used since 2.4 */
#define OBD_CONNECT_MDS_CAPA         0x100000ULL /*MDS capability */
#define OBD_CONNECT_OSS_CAPA         0x200000ULL /*OSS capability */
#define OBD_CONNECT_CANCELSET        0x400000ULL /*Early batched cancels. */
#define OBD_CONNECT_SOM              0x800000ULL /*Size on MDS */
#define OBD_CONNECT_AT              0x1000000ULL /*client uses AT */
#define OBD_CONNECT_LRU_RESIZE      0x2000000ULL /*LRU resize feature. */
#define OBD_CONNECT_MDS_MDS         0x4000000ULL /*MDS-MDS connection */
#define OBD_CONNECT_REAL            0x8000000ULL /* obsolete since 2.8 */
#define OBD_CONNECT_CHANGE_QS      0x10000000ULL /*Not used since 2.4 */
#define OBD_CONNECT_CKSUM          0x20000000ULL /*support several cksum algos*/
#define OBD_CONNECT_FID            0x40000000ULL /*FID is supported by server */
#define OBD_CONNECT_VBR            0x80000000ULL /*version based recovery */
#define OBD_CONNECT_LOV_V3        0x100000000ULL /*client supports LOV v3 EA */
#define OBD_CONNECT_GRANT_SHRINK  0x200000000ULL /* support grant shrink */
#define OBD_CONNECT_SKIP_ORPHAN   0x400000000ULL /* don't reuse orphan objids */
#define OBD_CONNECT_MAX_EASIZE    0x800000000ULL /* preserved for large EA */
#define OBD_CONNECT_FULL20       0x1000000000ULL /* it is 2.0 client */
#define OBD_CONNECT_LAYOUTLOCK   0x2000000000ULL /* client uses layout lock */
#define OBD_CONNECT_64BITHASH    0x4000000000ULL /* client supports 64-bits
                                                  * directory hash */
#define OBD_CONNECT_MAXBYTES     0x8000000000ULL /* max stripe size */
#define OBD_CONNECT_IMP_RECOV   0x10000000000ULL /* imp recovery support */
#define OBD_CONNECT_JOBSTATS    0x20000000000ULL /* jobid in ptlrpc_body */
#define OBD_CONNECT_UMASK       0x40000000000ULL /* create uses client umask */
#define OBD_CONNECT_EINPROGRESS 0x80000000000ULL /* client handles -EINPROGRESS
                                                  * RPC error properly */
#define OBD_CONNECT_GRANT_PARAM 0x100000000000ULL/* extra grant params used for
                                                  * finer space reservation */
#define OBD_CONNECT_FLOCK_OWNER 0x200000000000ULL /* for the fixed 1.8
						   * policy and 2.x server */
#define OBD_CONNECT_LVB_TYPE	0x400000000000ULL /* variable type of LVB */
#define OBD_CONNECT_NANOSEC_TIME 0x800000000000ULL /* nanosecond timestamps */
#define OBD_CONNECT_LIGHTWEIGHT 0x1000000000000ULL/* lightweight connection */
#define OBD_CONNECT_SHORTIO     0x2000000000000ULL/* short io */
#define OBD_CONNECT_PINGLESS	0x4000000000000ULL/* pings not required */
#define OBD_CONNECT_FLOCK_DEAD	0x8000000000000ULL/* improved flock deadlock detection */
#define OBD_CONNECT_DISP_STRIPE 0x10000000000000ULL/* create stripe disposition*/
#define OBD_CONNECT_OPEN_BY_FID	0x20000000000000ULL /* open by fid won't pack
						       name in request */
#define OBD_CONNECT_LFSCK      0x40000000000000ULL/* support online LFSCK */
#define OBD_CONNECT_UNLINK_CLOSE 0x100000000000000ULL/* close file in unlink */
#define OBD_CONNECT_MULTIMODRPCS 0x200000000000000ULL /* support multiple modify
							 RPCs in parallel */
#define OBD_CONNECT_DIR_STRIPE	 0x400000000000000ULL /* striped DNE dir */
#define OBD_CONNECT_SUBTREE	0x800000000000000ULL /* fileset mount */
/* was OBD_CONNECT_LOCKAHEAD_OLD 0x1000000000000000ULL old lockahead 2.12-2.13*/

/** bulk matchbits is sent within ptlrpc_body */
#define OBD_CONNECT_BULK_MBITS	 0x2000000000000000ULL
#define OBD_CONNECT_OBDOPACK	 0x4000000000000000ULL /* compact OUT obdo */
#define OBD_CONNECT_FLAGS2	 0x8000000000000000ULL /* second flags word */
/* ocd_connect_flags2 flags */
#define OBD_CONNECT2_FILE_SECCTX	 0x1ULL /* set file security context at create */
#define OBD_CONNECT2_LOCKAHEAD		 0x2ULL /* ladvise lockahead v2 */
#define OBD_CONNECT2_DIR_MIGRATE	 0x4ULL /* migrate striped dir */
#define OBD_CONNECT2_SUM_STATFS		0x8ULL /* MDT return aggregated stats */
#define OBD_CONNECT2_OVERSTRIPING	0x10ULL /* OST overstriping support */
#define OBD_CONNECT2_FLR		0x20ULL /* FLR support */
#define OBD_CONNECT2_WBC_INTENTS	0x40ULL /* create/unlink/... intents for wbc, also operations under client-held parent locks */
#define OBD_CONNECT2_LOCK_CONVERT	0x80ULL /* IBITS lock convert support */
#define OBD_CONNECT2_ARCHIVE_ID_ARRAY	0x100ULL /* store HSM archive_id in array */
#define OBD_CONNECT2_INC_XID		0x200ULL /* Increasing xid */
#define OBD_CONNECT2_SELINUX_POLICY	0x400ULL /* has client SELinux policy */
#define OBD_CONNECT2_LSOM		0x800ULL /* LSOM support */
#define OBD_CONNECT2_PCC		0x1000ULL /* Persistent Client Cache */
#define OBD_CONNECT2_CRUSH		0x2000ULL /* crush hash striped directory */
#define OBD_CONNECT2_ASYNC_DISCARD	0x4000ULL /* support async DoM data discard */
#define OBD_CONNECT2_ENCRYPT		0x8000ULL /* client-to-disk encrypt */
#define OBD_CONNECT2_FIDMAP	       0x10000ULL /* FID map */
#define OBD_CONNECT2_GETATTR_PFID      0x20000ULL /* pack parent FID in getattr */
/* XXX README XXX:
 * Please DO NOT add flag values here before first ensuring that this same
 * flag value is not in use on some other branch.  Please clear any such
 * changes with senior engineers before starting to use a new flag.  Then,
 * submit a small patch against EVERY branch that ONLY adds the new flag,
 * updates obd_connect_names[], adds the flag to check_obd_connect_data(),
 * and updates wiretests accordingly, so it can be approved and landed easily
 * to reserve the flag for future use.
 */

#define OCD_HAS_FLAG(ocd, flg)  \
        (!!((ocd)->ocd_connect_flags & OBD_CONNECT_##flg))


#ifdef HAVE_LRU_RESIZE_SUPPORT
#define LRU_RESIZE_CONNECT_FLAG OBD_CONNECT_LRU_RESIZE
#else
#define LRU_RESIZE_CONNECT_FLAG 0
#endif

#define MDT_CONNECT_SUPPORTED  (OBD_CONNECT_RDONLY | OBD_CONNECT_VERSION | \
				OBD_CONNECT_ACL | OBD_CONNECT_XATTR | \
				OBD_CONNECT_IBITS | OBD_CONNECT_NODEVOH | \
				OBD_CONNECT_ATTRFID | OBD_CONNECT_CANCELSET | \
				OBD_CONNECT_AT | OBD_CONNECT_BRW_SIZE | \
				OBD_CONNECT_MDS_MDS | OBD_CONNECT_FID | \
				LRU_RESIZE_CONNECT_FLAG | OBD_CONNECT_VBR | \
				OBD_CONNECT_LOV_V3 | OBD_CONNECT_FULL20 | \
				OBD_CONNECT_64BITHASH | OBD_CONNECT_JOBSTATS | \
				OBD_CONNECT_EINPROGRESS | \
				OBD_CONNECT_LIGHTWEIGHT | OBD_CONNECT_UMASK | \
				OBD_CONNECT_LVB_TYPE | OBD_CONNECT_LAYOUTLOCK |\
				OBD_CONNECT_PINGLESS | OBD_CONNECT_MAX_EASIZE |\
				OBD_CONNECT_FLOCK_DEAD | \
				OBD_CONNECT_DISP_STRIPE | OBD_CONNECT_LFSCK | \
				OBD_CONNECT_OPEN_BY_FID | \
				OBD_CONNECT_DIR_STRIPE | OBD_CONNECT_GRANT | \
				OBD_CONNECT_TRUNCLOCK | OBD_CONNECT_SRVLOCK | \
				OBD_CONNECT_BULK_MBITS | OBD_CONNECT_CKSUM | \
				OBD_CONNECT_MULTIMODRPCS | \
				OBD_CONNECT_SUBTREE | OBD_CONNECT_LARGE_ACL | \
				OBD_CONNECT_GRANT_PARAM | \
				OBD_CONNECT_SHORTIO | OBD_CONNECT_FLAGS2)

#define MDT_CONNECT_SUPPORTED2 (OBD_CONNECT2_FILE_SECCTX | \
				OBD_CONNECT2_DIR_MIGRATE | \
				OBD_CONNECT2_SUM_STATFS | \
				OBD_CONNECT2_OVERSTRIPING | \
				OBD_CONNECT2_FLR |\
				OBD_CONNECT2_LOCK_CONVERT | \
				OBD_CONNECT2_ARCHIVE_ID_ARRAY | \
				OBD_CONNECT2_INC_XID | \
				OBD_CONNECT2_SELINUX_POLICY | \
				OBD_CONNECT2_LSOM | \
				OBD_CONNECT2_ASYNC_DISCARD | \
				OBD_CONNECT2_PCC | \
				OBD_CONNECT2_CRUSH | \
				OBD_CONNECT2_ENCRYPT | \
				OBD_CONNECT2_GETATTR_PFID)

#define OST_CONNECT_SUPPORTED  (OBD_CONNECT_SRVLOCK | OBD_CONNECT_GRANT | \
				OBD_CONNECT_REQPORTAL | OBD_CONNECT_VERSION | \
				OBD_CONNECT_TRUNCLOCK | OBD_CONNECT_INDEX | \
				OBD_CONNECT_BRW_SIZE | OBD_CONNECT_CANCELSET | \
				OBD_CONNECT_AT | LRU_RESIZE_CONNECT_FLAG | \
				OBD_CONNECT_CKSUM | OBD_CONNECT_VBR | \
				OBD_CONNECT_MDS | OBD_CONNECT_SKIP_ORPHAN | \
				OBD_CONNECT_GRANT_SHRINK | OBD_CONNECT_FULL20 |\
				OBD_CONNECT_64BITHASH | OBD_CONNECT_MAXBYTES | \
				OBD_CONNECT_MAX_EASIZE | \
				OBD_CONNECT_EINPROGRESS | \
				OBD_CONNECT_JOBSTATS | \
				OBD_CONNECT_LIGHTWEIGHT | OBD_CONNECT_LVB_TYPE|\
				OBD_CONNECT_LAYOUTLOCK | OBD_CONNECT_FID | \
				OBD_CONNECT_PINGLESS | OBD_CONNECT_LFSCK | \
				OBD_CONNECT_BULK_MBITS | \
				OBD_CONNECT_GRANT_PARAM | \
				OBD_CONNECT_SHORTIO | OBD_CONNECT_FLAGS2)

#define OST_CONNECT_SUPPORTED2 (OBD_CONNECT2_LOCKAHEAD | OBD_CONNECT2_INC_XID |\
				OBD_CONNECT2_ENCRYPT)

#define ECHO_CONNECT_SUPPORTED (OBD_CONNECT_FID)
#define ECHO_CONNECT_SUPPORTED2 0

#define MGS_CONNECT_SUPPORTED  (OBD_CONNECT_VERSION | OBD_CONNECT_AT | \
				OBD_CONNECT_FULL20 | OBD_CONNECT_IMP_RECOV | \
				OBD_CONNECT_PINGLESS |\
				OBD_CONNECT_BULK_MBITS | OBD_CONNECT_BARRIER)

#define MGS_CONNECT_SUPPORTED2 0

/* Features required for this version of the client to work with server */
#define CLIENT_CONNECT_MDT_REQD (OBD_CONNECT_FID |	\
				 OBD_CONNECT_ATTRFID |	\
				 OBD_CONNECT_FULL20)

/* This structure is used for both request and reply.
 *
 * If we eventually have separate connect data for different types, which we
 * almost certainly will, then perhaps we stick a union in here. */
struct obd_connect_data {
	__u64 ocd_connect_flags; /* OBD_CONNECT_* per above */
	__u32 ocd_version;	 /* lustre release version number */
	__u32 ocd_grant;	 /* initial cache grant amount (bytes) */
	__u32 ocd_index;	 /* LOV index to connect to */
	__u32 ocd_brw_size;	 /* Maximum BRW size in bytes */
        __u64 ocd_ibits_known;   /* inode bits this client understands */
	__u8  ocd_grant_blkbits; /* log2 of the backend filesystem blocksize */
	__u8  ocd_grant_inobits; /* log2 of the per-inode space consumption */
	__u16 ocd_grant_tax_kb;  /* extent insertion overhead, in 1K blocks */
	__u32 ocd_grant_max_blks;/* maximum number of blocks per extent */
        __u64 ocd_transno;       /* first transno from client to be replayed */
        __u32 ocd_group;         /* MDS group on OST */
        __u32 ocd_cksum_types;   /* supported checksum algorithms */
        __u32 ocd_max_easize;    /* How big LOV EA can be on MDS */
        __u32 ocd_instance;      /* instance # of this target */
        __u64 ocd_maxbytes;      /* Maximum stripe size in bytes */
        /* Fields after ocd_maxbytes are only accessible by the receiver
         * if the corresponding flag in ocd_connect_flags is set. Accessing
         * any field after ocd_maxbytes on the receiver without a valid flag
         * may result in out-of-bound memory access and kernel oops. */
	__u16 ocd_maxmodrpcs;    /* Maximum modify RPCs in parallel */
	__u16 padding0;          /* added 2.1.0. also fix lustre_swab_connect */
	__u32 padding1;          /* added 2.1.0. also fix lustre_swab_connect */
	__u64 ocd_connect_flags2;
        __u64 padding3;          /* added 2.1.0. also fix lustre_swab_connect */
        __u64 padding4;          /* added 2.1.0. also fix lustre_swab_connect */
        __u64 padding5;          /* added 2.1.0. also fix lustre_swab_connect */
        __u64 padding6;          /* added 2.1.0. also fix lustre_swab_connect */
        __u64 padding7;          /* added 2.1.0. also fix lustre_swab_connect */
        __u64 padding8;          /* added 2.1.0. also fix lustre_swab_connect */
        __u64 padding9;          /* added 2.1.0. also fix lustre_swab_connect */
        __u64 paddingA;          /* added 2.1.0. also fix lustre_swab_connect */
        __u64 paddingB;          /* added 2.1.0. also fix lustre_swab_connect */
        __u64 paddingC;          /* added 2.1.0. also fix lustre_swab_connect */
        __u64 paddingD;          /* added 2.1.0. also fix lustre_swab_connect */
        __u64 paddingE;          /* added 2.1.0. also fix lustre_swab_connect */
        __u64 paddingF;          /* added 2.1.0. also fix lustre_swab_connect */
};
/* XXX README XXX:
 * Please DO NOT use any fields here before first ensuring that this same
 * field is not in use on some other branch.  Please clear any such changes
 * with senior engineers before starting to use a new field.  Then, submit
 * a small patch against EVERY branch that ONLY adds the new field along with
 * the matching OBD_CONNECT flag, so that can be approved and landed easily to
 * reserve the flag for future use. */

/*