/*
* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
+ *
+ * Copyright (c) 2011, 2012, Whamcloud, Inc.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#ifndef _LUSTRE_IDL_H_
#define _LUSTRE_IDL_H_
+#if !defined(LASSERT) && !defined(LPU64)
#include <libcfs/libcfs.h> /* for LASSERT, LPUX64, etc */
+#endif
/* Defn's shared with user-space. */
#include <lustre/lustre_user.h>
#define SEQ_METADATA_PORTAL 30
#define SEQ_DATA_PORTAL 31
#define SEQ_CONTROLLER_PORTAL 32
+#define MGS_BULK_PORTAL 33
/* Portal 63 is reserved for the Cray Inc DVS - nic@cray.com, roe@cray.com, n8851@cray.com */
-#define SVC_KILLED 1
-#define SVC_EVENT 2
-#define SVC_SIGNAL 4
-#define SVC_RUNNING 8
-#define SVC_STOPPING 16
-#define SVC_STOPPED 32
-
/* packet types */
#define PTL_RPC_MSG_REQUEST 4711
#define PTL_RPC_MSG_ERR 4712
typedef __u64 seqno_t;
typedef __u64 obd_id;
typedef __u64 obd_seq;
-typedef __u64 obd_time;
+typedef __s64 obd_time;
typedef __u64 obd_size;
typedef __u64 obd_off;
typedef __u64 obd_blocks;
/**
* 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_mdt field holds mdt id
+ * Same structure is used in fld module where lsr_index field holds mdt id
* of the home mdt.
*/
+#define LU_SEQ_RANGE_MDT 0x0
+#define LU_SEQ_RANGE_OST 0x1
+
struct lu_seq_range {
__u64 lsr_start;
__u64 lsr_end;
- __u32 lsr_mdt;
- __u32 lsr_padding;
+ __u32 lsr_index;
+ __u32 lsr_flags;
};
/**
static inline void range_init(struct lu_seq_range *range)
{
- range->lsr_start = range->lsr_end = range->lsr_mdt = 0;
+ range->lsr_start = range->lsr_end = range->lsr_index = 0;
}
/**
return range_space(range) == 0;
}
-#define DRANGE "[%#16.16"LPF64"x-%#16.16"LPF64"x):%x"
+/* return 0 if two range have the same location */
+static inline int range_compare_loc(const struct lu_seq_range *r1,
+ const struct lu_seq_range *r2)
+{
+ return r1->lsr_index != r2->lsr_index ||
+ r1->lsr_flags != r2->lsr_flags;
+}
+
+#define DRANGE "[%#16.16"LPF64"x-%#16.16"LPF64"x):%x:%x"
#define PRANGE(range) \
(range)->lsr_start, \
(range)->lsr_end, \
- (range)->lsr_mdt
+ (range)->lsr_index, \
+ (range)->lsr_flags
/** \defgroup lu_fid lu_fid
* @{ */
}
/**
+ * 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.
+ *
* Different FID Format
* http://arch.lustre.org/index.php?title=Interoperability_fids_zfs#NEW.0
*/
FID_SEQ_START = 0x200000000ULL,
FID_SEQ_LOCAL_FILE = 0x200000001ULL,
FID_SEQ_DOT_LUSTRE = 0x200000002ULL,
- FID_SEQ_NORMAL = 0x200000400ULL
+ /* XXX 0x200000003ULL is reserved for FID_SEQ_LLOG_OBJ */
+ FID_SEQ_SPECIAL = 0x200000004ULL,
+ FID_SEQ_NORMAL = 0x200000400ULL,
+ FID_SEQ_LOV_DEFAULT= 0xffffffffffffffffULL
};
#define OBIF_OID_MAX_BITS 32
#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,
+};
static inline int fid_seq_is_mdt0(obd_seq seq)
{
static inline int fid_seq_is_rsvd(const __u64 seq)
{
- return seq <= FID_SEQ_RSVD;
+ return (seq > FID_SEQ_OST_MDT0 && seq <= FID_SEQ_RSVD);
};
static inline int fid_is_mdt0(const struct lu_fid *fid)
}
/* pack an IDIF FID into an ostid (id/seq) for the wire/disk */
-static inline void ostid_idif_pack(struct lu_fid *fid, struct ost_id *ostid)
+static inline void ostid_idif_pack(const struct lu_fid *fid,
+ struct ost_id *ostid)
{
ostid->oi_seq = FID_SEQ_OST_MDT0;
ostid->oi_id = fid_idif_id(fid->f_seq, fid->f_oid, fid->f_ver);
}
/* pack a non-IDIF FID into an ostid (id/seq) for the wire/disk */
-static inline void ostid_fid_pack(struct lu_fid *fid, struct ost_id *ostid)
+static inline void ostid_fid_pack(const struct lu_fid *fid,
+ struct ost_id *ostid)
{
ostid->oi_seq = fid_seq(fid);
ostid->oi_id = fid_ver_oid(fid);
}
/* pack any OST FID into an ostid (id/seq) for the wire/disk */
-static inline int fid_ostid_pack(struct lu_fid *fid, struct ost_id *ostid)
+static inline int fid_ostid_pack(const struct lu_fid *fid,
+ struct ost_id *ostid)
{
if (unlikely(fid_seq_is_igif(fid->f_seq))) {
CERROR("bad IGIF, "DFID"\n", PFID(fid));
fid != NULL &&
((fid_seq(fid) >= FID_SEQ_START && fid_oid(fid) != 0
&& fid_ver(fid) == 0) ||
- fid_is_igif(fid));
+ fid_is_igif(fid) || fid_seq_is_rsvd(fid_seq(fid)));
}
static inline int fid_is_zero(const struct lu_fid *fid)
/* Check that there is no alignment padding. */
CLASSERT(sizeof *f0 ==
sizeof f0->f_seq + sizeof f0->f_oid + sizeof f0->f_ver);
- LASSERTF(fid_is_igif(f0) || fid_ver(f0) == 0, DFID, PFID(f0));
- LASSERTF(fid_is_igif(f1) || fid_ver(f1) == 0, DFID, PFID(f1));
+ LASSERTF((fid_is_igif(f0) || fid_is_idif(f0)) ||
+ fid_ver(f0) == 0, DFID, PFID(f0));
+ LASSERTF((fid_is_igif(f1) || fid_is_idif(f1)) ||
+ fid_ver(f1) == 0, DFID, PFID(f1));
return memcmp(f0, f1, sizeof *f0) == 0;
}
* enumeration.
*/
enum lu_dirent_attrs {
- LUDA_FID = 0x0001,
- LUDA_TYPE = 0x0002,
+ LUDA_FID = 0x0001,
+ LUDA_TYPE = 0x0002,
+ LUDA_64BITHASH = 0x0004,
};
/**
};
enum lu_dirpage_flags {
- LDF_EMPTY = 1 << 0
+ /**
+ * 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)
return le16_to_cpu(ent->lde_reclen);
}
-#define DIR_END_OFF 0xfffffffffffffffeULL
+#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 CFS_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 CFS_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 << (CFS_PAGE_SHIFT - LU_PAGE_SHIFT)
/** @} lu_dir */
return lh->cookie != 0ull;
}
-static inline int lustre_handle_equal(struct lustre_handle *lh1,
- struct lustre_handle *lh2)
+static inline int lustre_handle_equal(const struct lustre_handle *lh1,
+ const struct lustre_handle *lh2)
{
return lh1->cookie == lh2->cookie;
}
__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 */
+ __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 */
#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 supports layout lock */
-/* also update obd_connect_names[] for lprocfs_rd_connect_flags()
- * and lustre/utils/wirecheck.c */
+#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
+ * write RPC error properly */
+#define OBD_CONNECT_GRANT_PARAM 0x100000000000ULL/* extra grant params used for
+ * finer space reservation */
+/* 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
+ * and updates obd_connect_names[] for lprocfs_rd_connect_flags(), 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
#define MDT_CONNECT_SUPPORTED (OBD_CONNECT_RDONLY | OBD_CONNECT_VERSION | \
OBD_CONNECT_ACL | OBD_CONNECT_XATTR | \
- OBD_CONNECT_IBITS | OBD_CONNECT_JOIN | \
- OBD_CONNECT_NODEVOH |/* OBD_CONNECT_ATTRFID |*/\
+ OBD_CONNECT_IBITS | \
+ OBD_CONNECT_NODEVOH | OBD_CONNECT_ATTRFID | \
OBD_CONNECT_CANCELSET | OBD_CONNECT_AT | \
OBD_CONNECT_RMT_CLIENT | \
OBD_CONNECT_RMT_CLIENT_FORCE | \
- OBD_CONNECT_MDS_CAPA | OBD_CONNECT_OSS_CAPA | \
- OBD_CONNECT_MDS_MDS | OBD_CONNECT_FID | \
- LRU_RESIZE_CONNECT_FLAG | OBD_CONNECT_VBR | \
- OBD_CONNECT_LOV_V3 | OBD_CONNECT_SOM | \
- OBD_CONNECT_FULL20)
+ OBD_CONNECT_BRW_SIZE | OBD_CONNECT_MDS_CAPA | \
+ OBD_CONNECT_OSS_CAPA | OBD_CONNECT_MDS_MDS | \
+ OBD_CONNECT_FID | LRU_RESIZE_CONNECT_FLAG | \
+ OBD_CONNECT_VBR | OBD_CONNECT_LOV_V3 | \
+ OBD_CONNECT_SOM | OBD_CONNECT_FULL20 | \
+ OBD_CONNECT_64BITHASH)
#define OST_CONNECT_SUPPORTED (OBD_CONNECT_SRVLOCK | OBD_CONNECT_GRANT | \
OBD_CONNECT_REQPORTAL | OBD_CONNECT_VERSION | \
OBD_CONNECT_TRUNCLOCK | OBD_CONNECT_INDEX | \
OBD_CONNECT_CANCELSET | OBD_CONNECT_AT | \
LRU_RESIZE_CONNECT_FLAG | OBD_CONNECT_CKSUM | \
OBD_CONNECT_CHANGE_QS | \
- OBD_CONNECT_OSS_CAPA | OBD_CONNECT_RMT_CLIENT | \
+ OBD_CONNECT_OSS_CAPA | \
+ OBD_CONNECT_RMT_CLIENT | \
OBD_CONNECT_RMT_CLIENT_FORCE | OBD_CONNECT_VBR | \
OBD_CONNECT_MDS | OBD_CONNECT_SKIP_ORPHAN | \
- OBD_CONNECT_GRANT_SHRINK | OBD_CONNECT_FULL20)
+ OBD_CONNECT_GRANT_SHRINK | OBD_CONNECT_FULL20 | \
+ OBD_CONNECT_64BITHASH | OBD_CONNECT_MAXBYTES | \
+ OBD_CONNECT_MAX_EASIZE | \
+ OBD_CONNECT_EINPROGRESS)
#define ECHO_CONNECT_SUPPORTED (0)
#define MGS_CONNECT_SUPPORTED (OBD_CONNECT_VERSION | OBD_CONNECT_AT | \
- OBD_CONNECT_FULL20)
+ OBD_CONNECT_FULL20 | OBD_CONNECT_IMP_RECOV)
+
+/* Features required for this version of the client to work with server */
+#define CLIENT_CONNECT_MDT_REQD (OBD_CONNECT_IBITS | OBD_CONNECT_FID | \
+ OBD_CONNECT_FULL20)
#define OBD_OCD_VERSION(major,minor,patch,fix) (((major)<<24) + ((minor)<<16) +\
((patch)<<8) + (fix))
*
* 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 {
+struct obd_connect_data_v1 {
__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 */
- __u32 ocd_nllu; /* non-local-lustre-user */
- __u32 ocd_nllg; /* non-local-lustre-group */
+ __u8 ocd_blocksize; /* log2 of the backend filesystem blocksize */
+ __u8 ocd_inodespace; /* log2 of the per-inode space consumption */
+ __u16 ocd_grant_extent; /* per-extent grant overhead, in 1K blocks */
+ __u32 ocd_unused; /* also fix lustre_swab_connect */
__u64 ocd_transno; /* first transno from client to be replayed */
__u32 ocd_group; /* MDS group on OST */
__u32 ocd_cksum_types; /* supported checksum algorithms */
- __u64 padding1; /* also fix lustre_swab_connect */
- __u64 padding2; /* also fix lustre_swab_connect */
+ __u32 ocd_max_easize; /* How big LOV EA can be on MDS */
+ __u32 ocd_instance; /* also fix lustre_swab_connect */
+ __u64 ocd_maxbytes; /* Maximum stripe size in bytes */
};
+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_blocksize; /* log2 of the backend filesystem blocksize */
+ __u8 ocd_inodespace; /* log2 of the per-inode space consumption */
+ __u16 ocd_grant_extent; /* per-extent grant overhead, in 1K blocks */
+ __u32 ocd_unused; /* also fix lustre_swab_connect */
+ __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. */
+ __u64 padding1; /* added 2.1.0. also fix lustre_swab_connect */
+ __u64 padding2; /* added 2.1.0. also fix lustre_swab_connect */
+ __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. */
+
+
extern void lustre_swab_connect(struct obd_connect_data *ocd);
/*
typedef enum {
OBD_CKSUM_CRC32 = 0x00000001,
OBD_CKSUM_ADLER = 0x00000002,
+ OBD_CKSUM_CRC32C= 0x00000004,
} cksum_type_t;
/*
OBD_FL_SRVLOCK = 0x00000800, /* delegate DLM locking to server */
OBD_FL_CKSUM_CRC32 = 0x00001000, /* CRC32 checksum type */
OBD_FL_CKSUM_ADLER = 0x00002000, /* ADLER checksum type */
- OBD_FL_CKSUM_RSVD1 = 0x00004000, /* for future cksum types */
+ OBD_FL_CKSUM_CRC32C = 0x00004000, /* CRC32C checksum type */
OBD_FL_CKSUM_RSVD2 = 0x00008000, /* for future cksum types */
OBD_FL_CKSUM_RSVD3 = 0x00010000, /* for future cksum types */
OBD_FL_SHRINK_GRANT = 0x00020000, /* object shrink the grant */
- OBD_FL_MMAP = 0x00040000, /* object is mmapped on the client */
+ OBD_FL_MMAP = 0x00040000, /* object is mmapped on the client.
+ * XXX: obsoleted - reserved for old
+ * clients prior than 2.2 */
+ OBD_FL_RECOV_RESEND = 0x00080000, /* recoverable resent */
+ OBD_FL_NOSPC_BLK = 0x00100000, /* no more block space on OST */
- OBD_FL_CKSUM_ALL = OBD_FL_CKSUM_CRC32 | OBD_FL_CKSUM_ADLER,
+ /* Note that while these checksum values are currently separate bits,
+ * in 2.x we can actually allow all values from 1-31 if we wanted. */
+ OBD_FL_CKSUM_ALL = OBD_FL_CKSUM_CRC32 | OBD_FL_CKSUM_ADLER |
+ OBD_FL_CKSUM_CRC32C,
/* mask for local-only flag, which won't be sent over network */
OBD_FL_LOCAL_MASK = 0xF0000000,
#define LOV_PATTERN_FIRST 0x100 /* first stripe is not in round-robin */
#define LOV_PATTERN_CMOBD 0x200
-#define LOV_OBJECT_GROUP_DEFAULT ~0ULL
-#define LOV_OBJECT_GROUP_CLEAR 0ULL
-
#define lov_ost_data lov_ost_data_v1
struct lov_ost_data_v1 { /* per-stripe data structure (little-endian)*/
__u64 l_object_id; /* OST object ID */
__u64 lmm_object_id; /* LOV object ID */
__u64 lmm_object_seq; /* LOV object seq number */
__u32 lmm_stripe_size; /* size of stripe in bytes */
- __u32 lmm_stripe_count; /* num stripes in use for this object */
+ /* lmm_stripe_count used to be __u32 */
+ __u16 lmm_stripe_count; /* num stripes in use for this object */
+ __u16 lmm_layout_gen; /* layout generation number */
struct lov_ost_data_v1 lmm_objects[0]; /* per-stripe data */
};
#define XATTR_NAME_LMA "trusted.lma"
#define XATTR_NAME_LMV "trusted.lmv"
#define XATTR_NAME_LINK "trusted.link"
+#define XATTR_NAME_FID "trusted.fid"
+#define XATTR_NAME_VERSION "trusted.version"
struct lov_mds_md_v3 { /* LOV EA mds/wire data (little-endian) */
__u64 lmm_object_id; /* LOV object ID */
__u64 lmm_object_seq; /* LOV object seq number */
__u32 lmm_stripe_size; /* size of stripe in bytes */
- __u32 lmm_stripe_count; /* num stripes in use for this object */
+ /* lmm_stripe_count used to be __u32 */
+ __u16 lmm_stripe_count; /* num stripes in use for this object */
+ __u16 lmm_layout_gen; /* layout generation number */
char lmm_pool_name[LOV_MAXPOOLNAME]; /* must be 32bit aligned */
struct lov_ost_data_v1 lmm_objects[0]; /* per-stripe data */
};
#define OBD_MD_MEA (0x0000000400000000ULL) /* CMD split EA */
#define OBD_MD_MDTIDX (0x0000000800000000ULL) /* Get MDT index */
-#define OBD_MD_FLXATTR (0x0000001000000000ULL) /* xattr */
-#define OBD_MD_FLXATTRLS (0x0000002000000000ULL) /* xattr list */
-#define OBD_MD_FLXATTRRM (0x0000004000000000ULL) /* xattr remove */
-#define OBD_MD_FLACL (0x0000008000000000ULL) /* ACL */
-#define OBD_MD_FLRMTPERM (0x0000010000000000ULL) /* remote permission */
-#define OBD_MD_FLMDSCAPA (0x0000020000000000ULL) /* MDS capability */
-#define OBD_MD_FLOSSCAPA (0x0000040000000000ULL) /* OSS capability */
-#define OBD_MD_FLCKSPLIT (0x0000080000000000ULL) /* Check split on server */
-#define OBD_MD_FLCROSSREF (0x0000100000000000ULL) /* Cross-ref case */
+#define OBD_MD_FLXATTR (0x0000001000000000ULL) /* xattr */
+#define OBD_MD_FLXATTRLS (0x0000002000000000ULL) /* xattr list */
+#define OBD_MD_FLXATTRRM (0x0000004000000000ULL) /* xattr remove */
+#define OBD_MD_FLACL (0x0000008000000000ULL) /* ACL */
+#define OBD_MD_FLRMTPERM (0x0000010000000000ULL) /* remote permission */
+#define OBD_MD_FLMDSCAPA (0x0000020000000000ULL) /* MDS capability */
+#define OBD_MD_FLOSSCAPA (0x0000040000000000ULL) /* OSS capability */
+#define OBD_MD_FLCKSPLIT (0x0000080000000000ULL) /* Check split on server */
+#define OBD_MD_FLCROSSREF (0x0000100000000000ULL) /* Cross-ref case */
#define OBD_MD_FLGETATTRLOCK (0x0000200000000000ULL) /* Get IOEpoch attributes
* under lock */
-#define OBD_FL_TRUNC (0x0000200000000000ULL) /* for filter_truncate */
-#define OBD_MD_FLRMTLSETFACL (0x0001000000000000ULL) /* lfs lsetfacl case */
-#define OBD_MD_FLRMTLGETFACL (0x0002000000000000ULL) /* lfs lgetfacl case */
-#define OBD_MD_FLRMTRSETFACL (0x0004000000000000ULL) /* lfs rsetfacl case */
-#define OBD_MD_FLRMTRGETFACL (0x0008000000000000ULL) /* lfs rgetfacl case */
+#define OBD_MD_FLRMTLSETFACL (0x0001000000000000ULL) /* lfs lsetfacl case */
+#define OBD_MD_FLRMTLGETFACL (0x0002000000000000ULL) /* lfs lgetfacl case */
+#define OBD_MD_FLRMTRSETFACL (0x0004000000000000ULL) /* lfs rsetfacl case */
+#define OBD_MD_FLRMTRGETFACL (0x0008000000000000ULL) /* lfs rgetfacl case */
+
+#define OBD_MD_FLDATAVERSION (0x0010000000000000ULL) /* iversion sum */
#define OBD_MD_FLGETATTR (OBD_MD_FLID | OBD_MD_FLATIME | OBD_MD_FLMTIME | \
OBD_MD_FLCTIME | OBD_MD_FLSIZE | OBD_MD_FLBLKSZ | \
extern void lustre_swab_obd_statfs (struct obd_statfs *os);
-#define OBD_STATFS_NODELAY 0x0001 /* requests should be send without delay
- * and resends for avoid deadlocks */
-#define OBD_STATFS_FROM_CACHE 0x0002 /* the statfs callback should not update
- * obd_osfs_age */
-#define OBD_STATFS_PTLRPCD 0x0004 /* requests will be sent via ptlrpcd
- * instead of a specific set. This
- * means that we cannot rely on the set
- * interpret routine to be called.
- * lov_statfs_fini() must thus be called
- * by the request interpret routine */
/* ost_body.data values for OST_BRW */
#define OST_LVB_GET_ERR(blocks) (int)(blocks - OST_LVB_ERR_INIT)
struct ost_lvb {
- __u64 lvb_size;
- __u64 lvb_mtime;
- __u64 lvb_atime;
- __u64 lvb_ctime;
- __u64 lvb_blocks;
+ __u64 lvb_size;
+ obd_time lvb_mtime;
+ obd_time lvb_atime;
+ obd_time lvb_ctime;
+ __u64 lvb_blocks;
};
extern void lustre_swab_ost_lvb(struct ost_lvb *);
#define MDS_INODELOCK_LOOKUP 0x000001 /* dentry, mode, owner, group */
#define MDS_INODELOCK_UPDATE 0x000002 /* size, links, timestamps */
#define MDS_INODELOCK_OPEN 0x000004 /* For opened files */
+#define MDS_INODELOCK_LAYOUT 0x000008 /* for layout */
-/* Do not forget to increase MDS_INODELOCK_MAXSHIFT when adding new bits */
+/* Do not forget to increase MDS_INODELOCK_MAXSHIFT when adding new bits
+ * XXX: MDS_INODELOCK_MAXSHIFT should be increased to 3 once the layout lock is
+ * supported */
#define MDS_INODELOCK_MAXSHIFT 2
/* This FULL lock is useful to take on unlink sort of operations */
#define MDS_INODELOCK_FULL ((1<<(MDS_INODELOCK_MAXSHIFT+1))-1)
extern void lustre_swab_ll_fid (struct ll_fid *fid);
-#define MDS_STATUS_CONN 1
-#define MDS_STATUS_LOV 2
-
-struct mds_status_req {
- __u32 flags;
- __u32 repbuf;
+/* NOTE: until Lustre 1.8.7/2.1.1 the fid_ver() was packed into name[2],
+ * but was moved into name[1] along with the OID to avoid consuming the
+ * name[2,3] fields that need to be used for the quota id (also a FID). */
+enum {
+ LUSTRE_RES_ID_SEQ_OFF = 0,
+ LUSTRE_RES_ID_VER_OID_OFF = 1,
+ LUSTRE_RES_ID_WAS_VER_OFF = 2, /* see note above */
+ LUSTRE_RES_ID_HSH_OFF = 3
};
-extern void lustre_swab_mds_status_req (struct mds_status_req *r);
+#define MDS_STATUS_CONN 1
+#define MDS_STATUS_LOV 2
/* mdt_thread_info.mti_flags. */
enum md_op_flags {
#define MF_SOM_LOCAL_FLAGS (MF_SOM_CHANGE | MF_EPOCH_OPEN | MF_EPOCH_CLOSE)
-#define MDS_BFLAG_UNCOMMITTED_WRITES 0x1
+#define LUSTRE_BFLAG_UNCOMMITTED_WRITES 0x1
-/* these should be identical to their EXT3_*_FL counterparts, and are
- * redefined here only to avoid dragging in ext3_fs.h */
-#define MDS_SYNC_FL 0x00000008 /* Synchronous updates */
-#define MDS_IMMUTABLE_FL 0x00000010 /* Immutable file */
-#define MDS_APPEND_FL 0x00000020 /* writes to file may only append */
-#define MDS_NOATIME_FL 0x00000080 /* do not update atime */
-#define MDS_DIRSYNC_FL 0x00010000 /* dirsync behaviour (dir only) */
+/* these should be identical to their EXT4_*_FL counterparts, they are
+ * redefined here only to avoid dragging in fs/ext4/ext4.h */
+#define LUSTRE_SYNC_FL 0x00000008 /* Synchronous updates */
+#define LUSTRE_IMMUTABLE_FL 0x00000010 /* Immutable file */
+#define LUSTRE_APPEND_FL 0x00000020 /* writes to file may only append */
+#define LUSTRE_NOATIME_FL 0x00000080 /* do not update atime */
+#define LUSTRE_DIRSYNC_FL 0x00010000 /* dirsync behaviour (dir only) */
#ifdef __KERNEL__
-/* Convert wire MDS_*_FL to corresponding client local VFS S_* values
- * for the client inode i_flags. The MDS_*_FL are the Lustre wire
+/* Convert wire LUSTRE_*_FL to corresponding client local VFS S_* values
+ * for the client inode i_flags. The LUSTRE_*_FL are the Lustre wire
* protocol equivalents of LDISKFS_*_FL values stored on disk, while
* the S_* flags are kernel-internal values that change between kernel
* versions. These flags are set/cleared via FSFILT_IOC_{GET,SET}_FLAGS.
* See b=16526 for a full history. */
static inline int ll_ext_to_inode_flags(int flags)
{
- return (((flags & MDS_SYNC_FL) ? S_SYNC : 0) |
- ((flags & MDS_NOATIME_FL) ? S_NOATIME : 0) |
- ((flags & MDS_APPEND_FL) ? S_APPEND : 0) |
+ return (((flags & LUSTRE_SYNC_FL) ? S_SYNC : 0) |
+ ((flags & LUSTRE_NOATIME_FL) ? S_NOATIME : 0) |
+ ((flags & LUSTRE_APPEND_FL) ? S_APPEND : 0) |
#if defined(S_DIRSYNC)
- ((flags & MDS_DIRSYNC_FL) ? S_DIRSYNC : 0) |
+ ((flags & LUSTRE_DIRSYNC_FL) ? S_DIRSYNC : 0) |
#endif
- ((flags & MDS_IMMUTABLE_FL) ? S_IMMUTABLE : 0));
+ ((flags & LUSTRE_IMMUTABLE_FL) ? S_IMMUTABLE : 0));
}
static inline int ll_inode_to_ext_flags(int iflags)
{
- return (((iflags & S_SYNC) ? MDS_SYNC_FL : 0) |
- ((iflags & S_NOATIME) ? MDS_NOATIME_FL : 0) |
- ((iflags & S_APPEND) ? MDS_APPEND_FL : 0) |
+ return (((iflags & S_SYNC) ? LUSTRE_SYNC_FL : 0) |
+ ((iflags & S_NOATIME) ? LUSTRE_NOATIME_FL : 0) |
+ ((iflags & S_APPEND) ? LUSTRE_APPEND_FL : 0) |
#if defined(S_DIRSYNC)
- ((iflags & S_DIRSYNC) ? MDS_DIRSYNC_FL : 0) |
+ ((iflags & S_DIRSYNC) ? LUSTRE_DIRSYNC_FL : 0) |
#endif
- ((iflags & S_IMMUTABLE) ? MDS_IMMUTABLE_FL : 0));
+ ((iflags & S_IMMUTABLE) ? LUSTRE_IMMUTABLE_FL : 0));
}
#endif
-/*
- * while mds_body is to interact with 1.6, mdt_body is to interact with 2.0.
- * both of them should have the same fields layout, because at client side
- * one could be dynamically cast to the other.
- *
- * mdt_body has large size than mds_body, with unused padding (48 bytes)
- * at the end. client always use size of mdt_body to prepare request/reply
- * buffers, and actual data could be interepeted as mdt_body or mds_body
- * accordingly.
- */
-struct mds_body {
- struct ll_fid fid1;
- struct ll_fid fid2;
- struct lustre_handle handle;
- __u64 valid;
- __u64 size; /* Offset, in the case of MDS_READPAGE */
- __u64 mtime;
- __u64 atime;
- __u64 ctime;
- __u64 blocks; /* XID, in the case of MDS_READPAGE */
- __u64 io_epoch;
- __u64 ino;
- __u32 fsuid;
- __u32 fsgid;
- __u32 capability;
- __u32 mode;
- __u32 uid;
- __u32 gid;
- __u32 flags; /* from vfs for pin/unpin, MDS_BFLAG for close */
- __u32 rdev;
- __u32 nlink; /* #bytes to read in the case of MDS_READPAGE */
- __u32 generation;
- __u32 suppgid;
- __u32 eadatasize;
- __u32 aclsize;
- __u32 max_mdsize;
- __u32 max_cookiesize;
- __u32 padding_4; /* also fix lustre_swab_mds_body */
-};
-
-extern void lustre_swab_mds_body (struct mds_body *b);
-
struct mdt_body {
struct lu_fid fid1;
struct lu_fid fid2;
struct lustre_handle handle;
__u64 valid;
__u64 size; /* Offset, in the case of MDS_READPAGE */
- __u64 mtime;
- __u64 atime;
- __u64 ctime;
+ obd_time mtime;
+ obd_time atime;
+ obd_time ctime;
__u64 blocks; /* XID, in the case of MDS_READPAGE */
__u64 ioepoch;
- __u64 ino; /* for 1.6 compatibility */
+ __u64 ino;
__u32 fsuid;
__u32 fsgid;
__u32 capability;
__u32 mode;
__u32 uid;
__u32 gid;
- __u32 flags; /* from vfs for pin/unpin, MDS_BFLAG for close */
+ __u32 flags; /* from vfs for pin/unpin, LUSTRE_BFLAG close */
__u32 rdev;
__u32 nlink; /* #bytes to read in the case of MDS_READPAGE */
- __u32 generation; /* for 1.6 compatibility */
+ __u32 generation;
__u32 suppgid;
__u32 eadatasize;
__u32 aclsize;
#define LQUOTA_FLAGS_ADJINO 8UL /* adjust the inode qunit size */
#define LQUOTA_FLAGS_CHG_QS 16UL /* indicate whether it has capability of
* OBD_CONNECT_CHANGE_QS */
+#define LQUOTA_FLAGS_RECOVERY 32UL /* recovery is going on a uid/gid */
+#define LQUOTA_FLAGS_SETQUOTA 64UL /* being setquota on a uid/gid */
/* flags is specific for quota_adjust_qunit */
-#define LQUOTA_QAQ_CREATE_LQS (1 << 31) /* when it is set, need create lqs */
+#define LQUOTA_QAQ_CREATE_LQS (1UL << 31) /* when it is set, need create lqs */
/* the status of lqs_flags in struct lustre_qunit_size */
#define LQUOTA_QUNIT_FLAGS (LQUOTA_FLAGS_GRP | LQUOTA_FLAGS_BLK)
#define QAQ_SET_ADJINO(qaq) ((qaq)->qaq_flags |= LQUOTA_FLAGS_ADJINO)
#define QAQ_SET_CREATE_LQS(qaq) ((qaq)->qaq_flags |= LQUOTA_QAQ_CREATE_LQS)
-/* inode access permission for remote user, the inode info are omitted,
- * for client knows them. */
-struct mds_remote_perm {
- __u32 rp_uid;
- __u32 rp_gid;
- __u32 rp_fsuid;
- __u32 rp_fsgid;
- __u32 rp_access_perm; /* MAY_READ/WRITE/EXEC */
-};
-
/* permissions for md_perm.mp_perm */
enum {
CFS_SETUID_PERM = 0x01,
CFS_RMTOWN_PERM = 0x10
};
-extern void lustre_swab_mds_remote_perm(struct mds_remote_perm *p);
-
+/* inode access permission for remote user, the inode info are omitted,
+ * for client knows them. */
struct mdt_remote_perm {
__u32 rp_uid;
__u32 rp_gid;
__u32 rp_fsgid;
__u32 rp_fsgid_h;
__u32 rp_access_perm; /* MAY_READ/WRITE/EXEC */
+ __u32 rp_padding;
};
extern void lustre_swab_mdt_remote_perm(struct mdt_remote_perm *p);
__u32 sa_gid;
__u64 sa_size;
__u64 sa_blocks;
- __u64 sa_mtime;
- __u64 sa_atime;
- __u64 sa_ctime;
+ obd_time sa_mtime;
+ obd_time sa_atime;
+ obd_time sa_ctime;
__u32 sa_attr_flags;
__u32 sa_mode;
__u32 sa_padding_2;
#define FMODE_WRITE 00000002
#endif
+#define MDS_FMODE_CLOSED 00000000
+#define MDS_FMODE_EXEC 00000004
/* IO Epoch is opened on a closed file. */
-#define FMODE_EPOCH 01000000
+#define MDS_FMODE_EPOCH 01000000
/* IO Epoch is opened on a file truncate. */
-#define FMODE_TRUNC 02000000
+#define MDS_FMODE_TRUNC 02000000
/* Size-on-MDS Attribute Update is pending. */
-#define FMODE_SOM 04000000
-#define FMODE_CLOSED 0
+#define MDS_FMODE_SOM 04000000
#define MDS_OPEN_CREATED 00000010
#define MDS_OPEN_CROSS 00000020
-#define MDS_FMODE_EXEC 00000004
#define MDS_OPEN_CREAT 00000100
#define MDS_OPEN_EXCL 00000200
#define MDS_OPEN_TRUNC 00001000
#define MDS_OPEN_LOCK 04000000000 /* This open requires open lock */
#define MDS_OPEN_HAS_EA 010000000000 /* specify object create pattern */
#define MDS_OPEN_HAS_OBJS 020000000000 /* Just set the EA the obj exist */
+#define MDS_OPEN_NORESTORE 0100000000000ULL /* Do not restore file at open */
+#define MDS_OPEN_NEWSTRIPE 0200000000000ULL /* New stripe needed (restripe or
+ * hsm restore) */
/* permission for create non-directory file */
#define MAY_CREATE (1 << 7)
MDS_PERM_BYPASS = 1 << 3,
MDS_SOM = 1 << 4,
MDS_QUOTA_IGNORE = 1 << 5,
- MDS_CLOSE_CLEANUP = 1 << 6
+ MDS_CLOSE_CLEANUP = 1 << 6,
+ MDS_KEEP_ORPHAN = 1 << 7,
+ MDS_RECOV_OPEN = 1 << 8,
+ MDS_UNLINK_DESTROY = 1 << 9, /* Destory ost object in mdd_unlink */
};
/* instance of mdt_reint_rec */
struct lu_fid cr_fid1;
struct lu_fid cr_fid2;
struct lustre_handle cr_old_handle; /* handle in case of open replay */
- __u64 cr_time;
+ obd_time cr_time;
__u64 cr_rdev;
__u64 cr_ioepoch;
__u64 cr_padding_1; /* rr_blocks */
__u32 cr_mode;
__u32 cr_bias;
- __u32 cr_flags; /* for use with open */
- __u32 cr_padding_2; /* rr_padding_2 */
+ /* use of helpers set/get_mrc_cr_flags() is needed to access
+ * 64 bits cr_flags [cr_flags_l, cr_flags_h], this is done to
+ * extend cr_flags size without breaking 1.8 compat */
+ __u32 cr_flags_l; /* for use with open, low 32 bits */
+ __u32 cr_flags_h; /* for use with open, high 32 bits */
__u32 cr_padding_3; /* rr_padding_3 */
__u32 cr_padding_4; /* rr_padding_4 */
};
+static inline void set_mrc_cr_flags(struct mdt_rec_create *mrc, __u64 flags)
+{
+ mrc->cr_flags_l = (__u32)(flags & 0xFFFFFFFFUll);
+ mrc->cr_flags_h = (__u32)(flags >> 32);
+}
+
+static inline __u64 get_mrc_cr_flags(struct mdt_rec_create *mrc)
+{
+ return ((__u64)(mrc->cr_flags_l) | ((__u64)mrc->cr_flags_h << 32));
+}
+
/* instance of mdt_reint_rec */
struct mdt_rec_link {
__u32 lk_opcode;
__u32 lk_suppgid2_h;
struct lu_fid lk_fid1;
struct lu_fid lk_fid2;
- __u64 lk_time;
+ obd_time lk_time;
__u64 lk_padding_1; /* rr_atime */
__u64 lk_padding_2; /* rr_ctime */
__u64 lk_padding_3; /* rr_size */
__u32 ul_suppgid2_h;
struct lu_fid ul_fid1;
struct lu_fid ul_fid2;
- __u64 ul_time;
+ obd_time ul_time;
__u64 ul_padding_2; /* rr_atime */
__u64 ul_padding_3; /* rr_ctime */
__u64 ul_padding_4; /* rr_size */
__u32 rn_suppgid2_h;
struct lu_fid rn_fid1;
struct lu_fid rn_fid2;
- __u64 rn_time;
+ obd_time rn_time;
__u64 rn_padding_1; /* rr_atime */
__u64 rn_padding_2; /* rr_ctime */
__u64 rn_padding_3; /* rr_size */
__u32 sx_padding_2;
__u32 sx_padding_3;
__u64 sx_valid;
- __u64 sx_time;
+ obd_time sx_time;
__u64 sx_padding_5; /* rr_ctime */
__u64 sx_padding_6; /* rr_size */
__u64 sx_padding_7; /* rr_blocks */
__u32 rr_suppgid2_h;
struct lu_fid rr_fid1;
struct lu_fid rr_fid2;
- __u64 rr_mtime;
- __u64 rr_atime;
- __u64 rr_ctime;
+ obd_time rr_mtime;
+ obd_time rr_atime;
+ obd_time rr_ctime;
__u64 rr_size;
__u64 rr_blocks;
__u32 rr_bias;
#define MAX_HASH_SIZE 0x7fffffffffffffffULL
#define MAX_HASH_HIGHEST_BIT 0x1000000000000000ULL
-struct md_fld {
- seqno_t mf_seq;
- mdsno_t mf_mds;
-};
-
-extern void lustre_swab_md_fld (struct md_fld *mf);
-
enum fld_rpc_opc {
FLD_QUERY = 900,
FLD_LAST_OPC,
#define LOV_MIN_STRIPE_BITS 16 /* maximum PAGE_SIZE (ia64), power of 2 */
#define LOV_MIN_STRIPE_SIZE (1<<LOV_MIN_STRIPE_BITS)
-#define LOV_MAX_STRIPE_COUNT 160 /* until bug 4424 is fixed */
+#define LOV_MAX_STRIPE_COUNT_OLD 160
+/* This calculation is crafted so that input of 4096 will result in 160
+ * which in turn is equal to old maximal stripe count.
+ * XXX: In fact this is too simpified for now, what it also need is to get
+ * ea_type argument to clearly know how much space each stripe consumes.
+ *
+ * The limit of 12 pages is somewhat arbitrary, but is a reasonably large
+ * allocation that is sufficient for the current generation of systems.
+ *
+ * (max buffer size - lov+rpc header) / sizeof(struct lov_ost_data_v1) */
+#define LOV_MAX_STRIPE_COUNT 2000 /* ((12 * 4096 - 256) / 24) */
+#define LOV_ALL_STRIPES 0xffff /* only valid for directories */
#define LOV_V1_INSANE_STRIPE_COUNT 65532 /* maximum stripe count bz13933 */
#define LOV_MAX_UUID_BUFFER_SIZE 8192
extern void lustre_swab_ldlm_res_id (struct ldlm_res_id *id);
+static inline int ldlm_res_eq(const struct ldlm_res_id *res0,
+ const struct ldlm_res_id *res1)
+{
+ return !memcmp(res0, res1, sizeof(*res0));
+}
+
/* lock types */
typedef enum {
LCK_MINMODE = 0,
return (ex1->start <= ex2->end) && (ex2->start <= ex1->end);
}
+/* check if @ex1 contains @ex2 */
+static inline int ldlm_extent_contain(struct ldlm_extent *ex1,
+ struct ldlm_extent *ex2)
+{
+ return (ex1->start <= ex2->start) && (ex1->end >= ex2->end);
+}
+
struct ldlm_inodebits {
__u64 bits;
};
-struct ldlm_flock {
- __u64 start;
- __u64 end;
- __u64 blocking_export; /* not actually used over the wire */
- __u32 blocking_pid; /* not actually used over the wire */
- __u32 pid;
+struct ldlm_flock_wire {
+ __u64 lfw_start;
+ __u64 lfw_end;
+ __u64 lfw_owner;
+ __u32 lfw_padding;
+ __u32 lfw_pid;
};
/* it's important that the fields of the ldlm_extent structure match
typedef union {
struct ldlm_extent l_extent;
- struct ldlm_flock l_flock;
+ struct ldlm_flock_wire l_flock;
struct ldlm_inodebits l_inodebits;
-} ldlm_policy_data_t;
+} ldlm_wire_policy_data_t;
-extern void lustre_swab_ldlm_policy_data (ldlm_policy_data_t *d);
+extern void lustre_swab_ldlm_policy_data (ldlm_wire_policy_data_t *d);
struct ldlm_intent {
__u64 opc;
struct ldlm_resource_desc l_resource;
ldlm_mode_t l_req_mode;
ldlm_mode_t l_granted_mode;
- ldlm_policy_data_t l_policy_data;
+ ldlm_wire_policy_data_t l_policy_data;
};
extern void lustre_swab_ldlm_lock_desc (struct ldlm_lock_desc *l);
MGS_TARGET_REG, /* whenever target starts up */
MGS_TARGET_DEL,
MGS_SET_INFO,
+ MGS_CONFIG_READ,
MGS_LAST_OPC
} mgs_cmd_t;
#define MGS_FIRST_OPC MGS_CONNECT
};
/* We pass this info to the MGS so it can write config logs */
-#define MTI_NAME_MAXLEN 64
+#define MTI_NAME_MAXLEN 64
#define MTI_PARAM_MAXLEN 4096
-#define MTI_NIDS_MAX 32
+#define MTI_NIDS_MAX 32
struct mgs_target_info {
__u32 mti_lustre_ver;
__u32 mti_stripe_index;
__u32 mti_config_ver;
__u32 mti_flags;
__u32 mti_nid_count;
- __u32 padding; /* 64 bit align */
+ __u32 mti_instance; /* Running instance of target */
char mti_fsname[MTI_NAME_MAXLEN];
char mti_svname[MTI_NAME_MAXLEN];
char mti_uuid[sizeof(struct obd_uuid)];
__u64 mti_nids[MTI_NIDS_MAX]; /* host nids (lnet_nid_t)*/
char mti_params[MTI_PARAM_MAXLEN];
};
-
extern void lustre_swab_mgs_target_info(struct mgs_target_info *oinfo);
+struct mgs_nidtbl_entry {
+ __u64 mne_version; /* table version of this entry */
+ __u32 mne_instance; /* target instance # */
+ __u32 mne_index; /* target index */
+ __u32 mne_length; /* length of this entry - by bytes */
+ __u8 mne_type; /* target type LDD_F_SV_TYPE_OST/MDT */
+ __u8 mne_nid_type; /* type of nid(mbz). for ipv6. */
+ __u8 mne_nid_size; /* size of each NID, by bytes */
+ __u8 mne_nid_count; /* # of NIDs in buffer */
+ union {
+ lnet_nid_t nids[0]; /* variable size buffer for NIDs. */
+ } u;
+};
+extern void lustre_swab_mgs_nidtbl_entry(struct mgs_nidtbl_entry *oinfo);
+
+struct mgs_config_body {
+ char mcb_name[MTI_NAME_MAXLEN]; /* logname */
+ __u64 mcb_offset; /* next index of config log to request */
+ __u16 mcb_type; /* type of log: CONFIG_T_[CONFIG|RECOVER] */
+ __u8 mcb_reserved;
+ __u8 mcb_bits; /* bits unit size of config log */
+ __u32 mcb_units; /* # of units for bulk transfer */
+};
+extern void lustre_swab_mgs_config_body(struct mgs_config_body *body);
+
+struct mgs_config_res {
+ __u64 mcr_offset; /* index of last config log */
+ __u64 mcr_size; /* size of the log */
+};
+extern void lustre_swab_mgs_config_res(struct mgs_config_res *body);
+
/* Config marker flags (in config log) */
#define CM_START 0x01
#define CM_END 0x02
__u32 cm_step; /* aka config version */
__u32 cm_flags;
__u32 cm_vers; /* lustre release version number */
- __u32 padding; /* 64 bit align */
- __u64 cm_createtime; /*when this record was first created */
- __u64 cm_canceltime; /*when this record is no longer valid*/
+ __u32 cm_padding; /* 64 bit align */
+ obd_time cm_createtime; /*when this record was first created */
+ obd_time cm_canceltime; /*when this record is no longer valid*/
char cm_tgtname[MTI_NAME_MAXLEN];
char cm_comment[MTI_NAME_MAXLEN];
};
__u32 lrh_len;
__u32 lrh_index;
__u32 lrh_type;
- __u32 padding;
+ __u32 lrh_padding;
};
struct llog_rec_tail {
struct llog_logid_rec {
struct llog_rec_hdr lid_hdr;
struct llog_logid lid_id;
- __u32 padding1;
- __u32 padding2;
- __u32 padding3;
- __u32 padding4;
- __u32 padding5;
+ __u32 lid_padding1;
+ __u32 lid_padding2;
+ __u32 lid_padding3;
+ __u32 lid_padding4;
+ __u32 lid_padding5;
struct llog_rec_tail lid_tail;
} __attribute__((packed));
struct ll_fid lcr_fid;
obd_id lcr_oid;
obd_count lcr_oseq;
- __u32 padding;
+ __u32 lcr_padding;
struct llog_rec_tail lcr_tail;
} __attribute__((packed));
struct llog_rec_hdr lor_hdr;
obd_id lor_oid;
obd_count lor_ogen;
- __u32 padding;
+ __u32 lor_padding;
struct llog_rec_tail lor_tail;
} __attribute__((packed));
obd_count lsr_oseq;
__u32 lsr_uid;
__u32 lsr_gid;
- __u32 padding;
+ __u32 lsr_padding;
struct llog_rec_tail lsr_tail;
} __attribute__((packed));
struct llog_rec_hdr lsr_hdr;
obd_id lsr_oid;
obd_count lsr_oseq;
- __u32 padding;
+ __u32 lsr_padding;
__u32 lsr_uid;
__u32 lsr_uid_h;
__u32 lsr_gid;
struct llog_rec_hdr lsc_hdr;
struct ll_fid lsc_fid;
__u32 lsc_ioepoch;
- __u32 padding;
+ __u32 lsc_padding;
struct llog_rec_tail lsc_tail;
} __attribute__((packed));
/** bits covering all \a changelog_rec_type's */
#define CHANGELOG_ALLMASK 0XFFFFFFFF
/** default \a changelog_rec_type mask */
-#define CHANGELOG_DEFMASK CHANGELOG_ALLMASK & ~(1 << CL_ATIME)
+#define CHANGELOG_DEFMASK CHANGELOG_ALLMASK & ~(1 << CL_ATIME | 1 << CL_CLOSE)
/* changelog llog name, needed by client replicators */
#define CHANGELOG_CATALOG "changelog_catalog"
struct llog_log_hdr {
struct llog_rec_hdr llh_hdr;
- __u64 llh_timestamp;
+ obd_time llh_timestamp;
__u32 llh_count;
__u32 llh_bitmap_offset;
__u32 llh_size;
__u64 o_ioepoch; /* epoch in ost writes */
__u32 o_stripe_idx; /* holds stripe idx */
__u32 o_parent_ver;
- struct lustre_handle o_handle; /* brw: lock handle to prolong locks */
- struct llog_cookie o_lcookie; /* destroy: unlink cookie from MDS */
-
+ struct lustre_handle o_handle; /* brw: lock handle to prolong
+ * locks */
+ struct llog_cookie o_lcookie; /* destroy: unlink cookie from
+ * MDS */
__u32 o_uid_h;
__u32 o_gid_h;
- __u64 o_padding_3;
+
+ __u64 o_data_version; /* getattr: sum of iversion for
+ * each stripe.
+ * brw: grant space consumed on
+ * the client for the write */
__u64 o_padding_4;
__u64 o_padding_5;
__u64 o_padding_6;
#define o_undirty o_mode
#define o_dropped o_misc
#define o_cksum o_nlink
+#define o_grant_used o_data_version
static inline void lustre_set_wire_obdo(struct obdo *wobdo, struct obdo *lobdo)
{
static inline void lustre_get_wire_obdo(struct obdo *lobdo, struct obdo *wobdo)
{
- obd_flag local_flags = lobdo->o_flags & OBD_FL_LOCAL_MASK;
+ obd_flag local_flags = 0;
+
+ if (lobdo->o_valid & OBD_MD_FLFLAGS)
+ local_flags = lobdo->o_flags & OBD_FL_LOCAL_MASK;
LASSERT(!(wobdo->o_flags & OBD_FL_LOCAL_MASK));
memcpy(lobdo, wobdo, sizeof(*lobdo));
- lobdo->o_flags &= ~OBD_FL_LOCAL_MASK;
- lobdo->o_flags |= local_flags;
+ if (local_flags != 0) {
+ lobdo->o_valid |= OBD_MD_FLFLAGS;
+ lobdo->o_flags &= ~OBD_FL_LOCAL_MASK;
+ lobdo->o_flags |= local_flags;
+ }
}
extern void lustre_swab_obdo (struct obdo *o);