X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Finclude%2Flustre%2Flustre_idl.h;h=e0e22db1bac8e5aa78b7e590f570b8735ada12b9;hp=dfc2c1fe87bee9d752d178a07149b5c6adc30488;hb=51206e8cd42134400fa0b6259a92d7138f3dc984;hpb=42e198d861aae86fce9b105369d96b8eae3b3635 diff --git a/lustre/include/lustre/lustre_idl.h b/lustre/include/lustre/lustre_idl.h index dfc2c1f..e0e22db 100644 --- a/lustre/include/lustre/lustre_idl.h +++ b/lustre/include/lustre/lustre_idl.h @@ -26,8 +26,10 @@ * GPL HEADER END */ /* - * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * 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/ @@ -91,11 +93,12 @@ #ifndef _LUSTRE_IDL_H_ #define _LUSTRE_IDL_H_ -#include +#if !defined(LASSERT) && !defined(LPU64) +#include /* for LASSERT, LPUX64, etc */ +#endif /* Defn's shared with user-space. */ #include -#include /* * GENERAL STUFF @@ -138,16 +141,10 @@ #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 @@ -173,19 +170,35 @@ typedef __u32 mdsno_t; typedef __u64 seqno_t; +typedef __u64 obd_id; +typedef __u64 obd_seq; +typedef __s64 obd_time; +typedef __u64 obd_size; +typedef __u64 obd_off; +typedef __u64 obd_blocks; +typedef __u64 obd_valid; +typedef __u32 obd_blksize; +typedef __u32 obd_mode; +typedef __u32 obd_uid; +typedef __u32 obd_gid; +typedef __u32 obd_flag; +typedef __u32 obd_count; /** * 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; }; /** @@ -203,7 +216,7 @@ static inline __u64 range_space(const struct lu_seq_range *range) 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; } /** @@ -216,18 +229,6 @@ static inline int range_within(const struct lu_seq_range *range, return s >= range->lsr_start && s < range->lsr_end; } -/** - * allocate \a w units of sequence from range \a from. - */ -static inline void range_alloc(struct lu_seq_range *to, - struct lu_seq_range *from, - __u64 width) -{ - to->lsr_start = from->lsr_start; - to->lsr_end = from->lsr_start + width; - from->lsr_start += width; -} - static inline int range_is_sane(const struct lu_seq_range *range) { return (range->lsr_end >= range->lsr_start); @@ -244,12 +245,21 @@ static inline int range_is_exhausted(const struct lu_seq_range *range) 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 * @{ */ @@ -289,10 +299,16 @@ struct lustre_mdt_attrs { __u32 lma_incompat; /** FID of this inode */ struct lu_fid lma_self_fid; - /** SOM state, mdt/ost type, others */ + /** mdt/ost type, others */ __u64 lma_flags; - /** total sectors in objects */ - __u64 lma_som_sectors; + /* IO Epoch SOM attributes belongs to */ + __u64 lma_ioepoch; + /** total file size in objects */ + __u64 lma_som_size; + /** total fs blocks in objects */ + __u64 lma_som_blocks; + /** mds mount id the size is valid for */ + __u64 lma_som_mountid; }; /** @@ -306,13 +322,16 @@ static inline void lustre_lma_init(struct lustre_mdt_attrs *lma, lma->lma_incompat = 0; memcpy(&lma->lma_self_fid, fid, sizeof(*fid)); lma->lma_flags = 0; - lma->lma_som_sectors = 0; + lma->lma_ioepoch = 0; + lma->lma_som_size = 0; + lma->lma_som_blocks = 0; + lma->lma_som_mountid = 0; /* If a field is added in struct lustre_mdt_attrs, zero it explicitly * and change the test below. */ LASSERT(sizeof(*lma) == - (offsetof(struct lustre_mdt_attrs, lma_som_sectors) + - sizeof(lma->lma_som_sectors))); + (offsetof(struct lustre_mdt_attrs, lma_som_mountid) + + sizeof(lma->lma_som_mountid))); }; extern void lustre_swab_lu_fid(struct lu_fid *fid); @@ -329,10 +348,19 @@ static inline void lustre_lma_swab(struct lustre_mdt_attrs *lma) __swab32s(&lma->lma_incompat); lustre_swab_lu_fid(&lma->lma_self_fid); __swab64s(&lma->lma_flags); - __swab64s(&lma->lma_som_sectors); + __swab64s(&lma->lma_ioepoch); + __swab64s(&lma->lma_som_size); + __swab64s(&lma->lma_som_blocks); + __swab64s(&lma->lma_som_mountid); } }; +/* This is the maximum number of MDTs allowed in CMD testing until such + * a time that FID-on-OST is implemented. This is due to the limitations + * of packing non-0-MDT numbers into the FID SEQ namespace. Once FID-on-OST + * is implemented this limit will be virtually unlimited. */ +#define MAX_MDT_COUNT 8 + /** * fid constants @@ -365,20 +393,98 @@ static inline void fid_zero(struct lu_fid *fid) memset(fid, 0, sizeof(*fid)); } -/* Normal FID sequence starts from this value, i.e. 1<<33 */ -#define FID_SEQ_START 0x200000000ULL +static inline obd_id fid_ver_oid(const struct lu_fid *fid) +{ + return ((__u64)fid_ver(fid) << 32 | fid_oid(fid)); +} -/* IDIF sequence starts from this value, i.e. 1<<32 */ -#define IDIF_SEQ_START 0x100000000ULL +/** + * 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 + */ +enum fid_seq { + FID_SEQ_OST_MDT0 = 0, + FID_SEQ_LLOG = 1, + FID_SEQ_ECHO = 2, + FID_SEQ_OST_MDT1 = 3, + FID_SEQ_OST_MAX = 9, /* Max MDT count before OST_on_FID */ + 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, + FID_SEQ_LOCAL_FILE = 0x200000001ULL, + FID_SEQ_DOT_LUSTRE = 0x200000002ULL, + /* 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 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, +}; + +static inline int fid_seq_is_mdt0(obd_seq seq) +{ + return (seq == FID_SEQ_OST_MDT0); +} + +static inline int fid_seq_is_cmd(const __u64 seq) +{ + return (seq >= FID_SEQ_OST_MDT1 && seq <= FID_SEQ_OST_MAX); +}; + +static inline int fid_seq_is_mdt(const __u64 seq) +{ + return seq == FID_SEQ_OST_MDT0 || + (seq >= FID_SEQ_OST_MDT1 && seq <= FID_SEQ_OST_MAX); +}; + +static inline int fid_seq_is_rsvd(const __u64 seq) +{ + return (seq > FID_SEQ_OST_MDT0 && seq <= FID_SEQ_RSVD); +}; + +static inline int fid_is_mdt0(const struct lu_fid *fid) +{ + return fid_seq_is_mdt0(fid_seq(fid)); +} /** * Check if a fid is igif or not. * \param fid the fid to be tested. * \return true if the fid is a igif; otherwise false. */ +static inline int fid_seq_is_igif(const __u64 seq) +{ + return seq >= FID_SEQ_IGIF && seq <= FID_SEQ_IGIF_MAX; +} + static inline int fid_is_igif(const struct lu_fid *fid) { - return fid_seq(fid) > 0 && fid_seq(fid) < IDIF_SEQ_START; + return fid_seq_is_igif(fid_seq(fid)); } /** @@ -386,9 +492,180 @@ static inline int fid_is_igif(const struct lu_fid *fid) * \param fid the fid to be tested. * \return true if the fid is a idif; otherwise false. */ +static inline int fid_seq_is_idif(const __u64 seq) +{ + return seq >= FID_SEQ_IDIF && seq <= FID_SEQ_IDIF_MAX; +} + static inline int fid_is_idif(const struct lu_fid *fid) { - return fid_seq(fid) >= IDIF_SEQ_START && fid_seq(fid) < FID_SEQ_START; + return fid_seq_is_idif(fid_seq(fid)); +} + +struct ost_id { + obd_id oi_id; + obd_seq oi_seq; +}; + +static inline int fid_seq_is_norm(const __u64 seq) +{ + return (seq >= FID_SEQ_NORMAL); +} + +static inline int fid_is_norm(const struct lu_fid *fid) +{ + return fid_seq_is_norm(fid_seq(fid)); +} + +/* convert an OST objid into an IDIF FID SEQ number */ +static inline obd_seq fid_idif_seq(obd_id id, __u32 ost_idx) +{ + return FID_SEQ_IDIF | (ost_idx << 16) | ((id >> 32) & 0xffff); +} + +/* convert a packed IDIF FID into an OST objid */ +static inline obd_id fid_idif_id(obd_seq seq, __u32 oid, __u32 ver) +{ + return ((__u64)ver << 48) | ((seq & 0xffff) << 32) | oid; +} + +/* unpack an ostid (id/seq) from a wire/disk structure into an IDIF FID */ +static inline void ostid_idif_unpack(struct ost_id *ostid, + struct lu_fid *fid, __u32 ost_idx) +{ + fid->f_seq = fid_idif_seq(ostid->oi_id, ost_idx); + fid->f_oid = ostid->oi_id; /* truncate to 32 bits by assignment */ + fid->f_ver = ostid->oi_id >> 48; /* in theory, not currently used */ +} + +/* unpack an ostid (id/seq) from a wire/disk structure into a non-IDIF FID */ +static inline void ostid_fid_unpack(struct ost_id *ostid, struct lu_fid *fid) +{ + fid->f_seq = ostid->oi_seq; + fid->f_oid = ostid->oi_id; /* truncate to 32 bits by assignment */ + fid->f_ver = ostid->oi_id >> 32; /* in theory, not currently used */ +} + +/* Unpack an OST object id/seq (group) into a FID. This is needed for + * converting all obdo, lmm, lsm, etc. 64-bit id/seq pairs into proper + * FIDs. Note that if an id/seq is already in FID/IDIF format it will + * be passed through unchanged. Only legacy OST objects in "group 0" + * will be mapped into the IDIF namespace so that they can fit into the + * struct lu_fid fields without loss. For reference see: + * http://arch.lustre.org/index.php?title=Interoperability_fids_zfs + */ +static inline int fid_ostid_unpack(struct lu_fid *fid, struct ost_id *ostid, + __u32 ost_idx) +{ + if (ost_idx > 0xffff) { + CERROR("bad ost_idx, seq:"LPU64" id:"LPU64" ost_idx:%u\n", + ostid->oi_seq, ostid->oi_id, ost_idx); + return -EBADF; + } + + if (fid_seq_is_mdt0(ostid->oi_seq)) { + /* This is a "legacy" (old 1.x/2.early) OST object in "group 0" + * that we map into the IDIF namespace. It allows up to 2^48 + * objects per OST, as this is the object namespace that has + * been in production for years. This can handle create rates + * of 1M objects/s/OST for 9 years, or combinations thereof. */ + if (ostid->oi_id >= IDIF_MAX_OID) { + CERROR("bad MDT0 id, seq:"LPU64" id:"LPU64" ost_idx:%u\n", + ostid->oi_seq, ostid->oi_id, ost_idx); + return -EBADF; + } + ostid_idif_unpack(ostid, fid, ost_idx); + + } else if (fid_seq_is_rsvd(ostid->oi_seq)) { + /* These are legacy OST objects for LLOG/ECHO and CMD testing. + * We only support 2^32 objects in these groups, and cannot + * uniquely identify them in the system (i.e. they are the + * duplicated on all OSTs), but this is not strictly required + * for the old object protocol, which has a separate ost_idx. */ + if (ostid->oi_id >= 0xffffffffULL) { + CERROR("bad RSVD id, seq:"LPU64" id:"LPU64" ost_idx:%u\n", + ostid->oi_seq, ostid->oi_id, ost_idx); + return -EBADF; + } + ostid_fid_unpack(ostid, fid); + + } else if (unlikely(fid_seq_is_igif(ostid->oi_seq))) { + /* This is an MDT inode number, which should never collide with + * proper OST object IDs, and is probably a broken filesystem */ + CERROR("bad IGIF, seq:"LPU64" id:"LPU64" ost_idx:%u\n", + ostid->oi_seq, ostid->oi_id, ost_idx); + return -EBADF; + + } else /* if (fid_seq_is_idif(seq) || fid_seq_is_norm(seq)) */ { + /* This is either an IDIF object, which identifies objects across + * all OSTs, or a regular FID. The IDIF namespace maps legacy + * OST objects into the FID namespace. In both cases, we just + * pass the FID through, no conversion needed. */ + ostid_fid_unpack(ostid, fid); + } + + return 0; +} + +/* pack an IDIF FID into an ostid (id/seq) for the wire/disk */ +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(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(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)); + return -EBADF; + } + + if (fid_is_idif(fid)) + ostid_idif_pack(fid, ostid); + else + ostid_fid_pack(fid, ostid); + + return 0; +} + +/* extract OST sequence (group) from a wire ost_id (id/seq) pair */ +static inline obd_seq ostid_seq(struct ost_id *ostid) +{ + if (unlikely(fid_seq_is_igif(ostid->oi_seq))) + CWARN("bad IGIF, oi_seq: "LPU64" oi_id: "LPX64"\n", + ostid->oi_seq, ostid->oi_id); + + if (unlikely(fid_seq_is_idif(ostid->oi_seq))) + return FID_SEQ_OST_MDT0; + + return ostid->oi_seq; +} + +/* extract OST objid from a wire ost_id (id/seq) pair */ +static inline obd_id ostid_id(struct ost_id *ostid) +{ + if (ostid->oi_seq == FID_SEQ_OST_MDT0) + return ostid->oi_id & IDIF_OID_MASK; + + if (fid_seq_is_rsvd(ostid->oi_seq)) + return ostid->oi_id & OBIF_OID_MASK; + + if (fid_seq_is_idif(ostid->oi_seq)) + return fid_idif_id(ostid->oi_seq, ostid->oi_id, 0); + + return ostid->oi_id; } /** @@ -402,6 +679,21 @@ static inline ino_t lu_igif_ino(const struct lu_fid *fid) } /** + * Build igif from the inode number/generation. + */ +#define LU_IGIF_BUILD(fid, ino, gen) \ +do { \ + fid->f_seq = ino; \ + fid->f_oid = gen; \ + fid->f_ver = 0; \ +} while(0) +static inline void lu_igif_build(struct lu_fid *fid, __u32 ino, __u32 gen) +{ + LU_IGIF_BUILD(fid, ino, gen); + LASSERT(fid_is_igif(fid)); +} + +/** * Get inode generation from a igif. * \param fid a igif to get inode generation from. * \return inode generation for the igif. @@ -469,7 +761,7 @@ static inline int fid_is_sane(const struct lu_fid *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) @@ -486,8 +778,10 @@ static inline int lu_fid_eq(const struct lu_fid *f0, /* 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; } @@ -520,8 +814,9 @@ static inline int lu_fid_cmp(const struct lu_fid *f0, * enumeration. */ enum lu_dirent_attrs { - LUDA_FID = 0x0001, - LUDA_TYPE = 0x0002, + LUDA_FID = 0x0001, + LUDA_TYPE = 0x0002, + LUDA_64BITHASH = 0x0004, }; /** @@ -584,7 +879,14 @@ struct lu_dirpage { }; 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) @@ -630,7 +932,22 @@ static inline int lu_dirent_size(struct lu_dirent *ent) 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 */ @@ -644,8 +961,8 @@ static inline int lustre_handle_is_used(struct lustre_handle *lh) 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; } @@ -658,6 +975,7 @@ static inline void lustre_handle_copy(struct lustre_handle *tgt, /* flags for lm_flags */ #define MSGHDR_AT_SUPPORT 0x1 +#define MSGHDR_CKSUM_INCOMPAT18 0x2 #define lustre_msg lustre_msg_v2 /* we depend on this structure to be 8-byte aligned */ @@ -690,7 +1008,8 @@ struct ptlrpc_body { __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 */ @@ -796,8 +1115,30 @@ extern void lustre_swab_ptlrpc_body(struct ptlrpc_body *pb); #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 */ -/* also update obd_connect_names[] for lprocfs_rd_connect_flags() - * and lustre/utils/wirecheck.c */ +#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 + * 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 @@ -807,15 +1148,17 @@ extern void lustre_swab_ptlrpc_body(struct ptlrpc_body *pb); #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_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 | \ @@ -823,12 +1166,21 @@ extern void lustre_swab_ptlrpc_body(struct ptlrpc_body *pb); 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_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) +#define MGS_CONNECT_SUPPORTED (OBD_CONNECT_VERSION | OBD_CONNECT_AT | \ + 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)) @@ -841,22 +1193,71 @@ extern void lustre_swab_ptlrpc_body(struct ptlrpc_body *pb); * * 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); /* @@ -868,6 +1269,7 @@ 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; /* @@ -899,20 +1301,6 @@ typedef enum { } ost_cmd_t; #define OST_FIRST_OPC OST_REPLY -typedef __u64 obd_id; -typedef __u64 obd_gr; -typedef __u64 obd_time; -typedef __u64 obd_size; -typedef __u64 obd_off; -typedef __u64 obd_blocks; -typedef __u64 obd_valid; -typedef __u32 obd_blksize; -typedef __u32 obd_mode; -typedef __u32 obd_uid; -typedef __u32 obd_gid; -typedef __u32 obd_flag; -typedef __u32 obd_count; - enum obdo_flags { OBD_FL_INLINEDATA = 0x00000001, OBD_FL_OBDMDEXISTS = 0x00000002, @@ -924,20 +1312,26 @@ enum obdo_flags { OBD_FL_NO_USRQUOTA = 0x00000100, /* the object's owner is over quota */ OBD_FL_NO_GRPQUOTA = 0x00000200, /* the object's group is over quota */ OBD_FL_CREATE_CROW = 0x00000400, /* object should be create on write */ - OBD_FL_TRUNCLOCK = 0x00000800, /* delegate DLM locking during punch*/ + 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. + * 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, - /* temporary OBDO used by osc_brw_async (see bug 18364) */ - OBD_FL_TEMPORARY = 0x10000000, }; #define LOV_MAGIC_V1 0x0BD10BD0 @@ -950,13 +1344,10 @@ enum obdo_flags { #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 l_object_gr; /* OST object group (creating MDS number) */ + __u64 l_object_seq; /* OST object seq number */ __u32 l_ost_gen; /* generation of this l_ost_idx */ __u32 l_ost_idx; /* OST index in LOV (lov_tgt_desc->tgts) */ }; @@ -966,9 +1357,11 @@ struct lov_mds_md_v1 { /* LOV EA mds/wire data (little-endian) */ __u32 lmm_magic; /* magic number = LOV_MAGIC_V1 */ __u32 lmm_pattern; /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */ __u64 lmm_object_id; /* LOV object ID */ - __u64 lmm_object_gr; /* LOV object group */ + __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 */ }; @@ -988,15 +1381,19 @@ struct lov_mds_md_v1 { /* LOV EA mds/wire data (little-endian) */ #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) */ __u32 lmm_magic; /* magic number = LOV_MAGIC_V3 */ __u32 lmm_pattern; /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */ __u64 lmm_object_id; /* LOV object ID */ - __u64 lmm_object_gr; /* LOV object group */ + __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 */ }; @@ -1027,7 +1424,7 @@ struct lov_mds_md_v3 { /* LOV EA mds/wire data (little-endian) */ #define OBD_MD_FLCOOKIE (0x00800000ULL) /* log cancellation cookie */ #define OBD_MD_FLGROUP (0x01000000ULL) /* group */ #define OBD_MD_FLFID (0x02000000ULL) /* ->ost write inline fid */ -#define OBD_MD_FLEPOCH (0x04000000ULL) /* ->ost write easize is epoch */ +#define OBD_MD_FLEPOCH (0x04000000ULL) /* ->ost write with ioepoch */ /* ->mds if epoch opens or closes */ #define OBD_MD_FLGRANT (0x08000000ULL) /* ost preallocation space grant */ #define OBD_MD_FLDIREA (0x10000000ULL) /* dir's extended attribute data */ @@ -1038,23 +1435,26 @@ struct lov_mds_md_v3 { /* LOV EA mds/wire data (little-endian) */ #define OBD_MD_MDS (0x0000000100000000ULL) /* where an inode lives on */ #define OBD_MD_REINT (0x0000000200000000ULL) /* reintegrate oa */ #define OBD_MD_MEA (0x0000000400000000ULL) /* CMD split EA */ - -#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_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_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_FLGETATTRLOCK (0x0000200000000000ULL) /* Get IOEpoch attributes + * under lock */ + +#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 | \ @@ -1067,16 +1467,6 @@ struct lov_mds_md_v3 { /* LOV EA mds/wire data (little-endian) */ 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 */ @@ -1092,6 +1482,7 @@ extern void lustre_swab_obd_statfs (struct obd_statfs *os); #define OBD_BRW_NOCACHE 0x80 /* this page is a part of non-cached IO */ #define OBD_BRW_NOQUOTA 0x100 #define OBD_BRW_SRVLOCK 0x200 /* Client holds no lock over this page */ +#define OBD_BRW_ASYNC 0x400 /* Server may delay commit to disk */ #define OBD_BRW_MEMALLOC 0x800 /* Client runs in the "kswapd" context */ #define OBD_OBJECT_EOF 0xffffffffffffffffULL @@ -1101,7 +1492,7 @@ extern void lustre_swab_obd_statfs (struct obd_statfs *os); struct obd_ioobj { obd_id ioo_id; - obd_gr ioo_gr; + obd_seq ioo_seq; __u32 ioo_type; __u32 ioo_bufcnt; }; @@ -1130,11 +1521,11 @@ extern void lustre_swab_niobuf_remote (struct niobuf_remote *nbr); #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 *); @@ -1206,23 +1597,29 @@ extern void lustre_swab_generic_32s (__u32 *val); #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 { @@ -1235,126 +1632,84 @@ enum md_op_flags { MF_MDC_CANCEL_FID2 = (1 << 4), MF_MDC_CANCEL_FID3 = (1 << 5), MF_MDC_CANCEL_FID4 = (1 << 6), + /* There is a pending attribute update. */ + MF_SOM_AU = (1 << 7), + /* Cancel OST locks while getattr OST attributes. */ + MF_GETATTR_LOCK = (1 << 8), }; -#define MF_SOM_LOCAL_FLAGS (MF_MDC_CANCEL_FID1 | MF_MDC_CANCEL_FID2 | \ - MF_MDC_CANCEL_FID3 | MF_MDC_CANCEL_FID4) +#define MF_SOM_LOCAL_FLAGS (MF_SOM_CHANGE | MF_EPOCH_OPEN | MF_EPOCH_CLOSE) -#define MDS_BFLAG_UNCOMMITTED_WRITES 0x1 -#define MDS_BFLAG_EXT_FLAGS 0x80000000 /* == EXT3_RESERVED_FL */ +#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__ -/* If MDS_BFLAG_IOC_FLAGS is set it means we requested EXT3_*_FL inode flags - * and we need to decode these into local S_* flags in the inode. Otherwise - * we pass flags straight through (see bug 9486). */ +/* 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_BFLAG_EXT_FLAGS) ? - (((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 & ~MDS_BFLAG_EXT_FLAGS); + ((flags & LUSTRE_IMMUTABLE_FL) ? S_IMMUTABLE : 0)); } -/* If MDS_BFLAG_EXT_FLAGS is set it means we requested EXT3_*_FL inode flags - * and we pass these straight through. Otherwise we need to convert from - * S_* flags to their EXT3_*_FL equivalents (see bug 9486). */ -static inline int ll_inode_to_ext_flags(int oflags, int iflags) +static inline int ll_inode_to_ext_flags(int iflags) { - return (oflags & MDS_BFLAG_EXT_FLAGS) ? (oflags & ~MDS_BFLAG_EXT_FLAGS): - (((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; __u32 max_mdsize; __u32 max_cookiesize; - __u32 padding_4; /* also fix lustre_swab_mdt_body */ - __u64 padding_5; + __u32 uid_h; /* high 32-bits of uid, for FUID */ + __u32 gid_h; /* high 32-bits of gid, for FUID */ + __u32 padding_5; /* also fix lustre_swab_mdt_body */ __u64 padding_6; __u64 padding_7; __u64 padding_8; @@ -1424,9 +1779,11 @@ extern void lustre_swab_quota_adjust_qunit(struct quota_adjust_qunit *q); #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) @@ -1441,16 +1798,6 @@ extern void lustre_swab_quota_adjust_qunit(struct quota_adjust_qunit *q); #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, @@ -1460,14 +1807,17 @@ enum { 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_fsuid; + __u32 rp_fsuid_h; __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); @@ -1489,9 +1839,9 @@ struct mdt_rec_setattr { __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; @@ -1530,15 +1880,18 @@ extern void lustre_swab_mdt_rec_setattr (struct mdt_rec_setattr *sa); #define FMODE_WRITE 00000002 #endif -#define FMODE_EPOCH 01000000 -#define FMODE_EPOCHLCK 02000000 -#define FMODE_SOM 04000000 -#define FMODE_CLOSED 0 +#define MDS_FMODE_CLOSED 00000000 +#define MDS_FMODE_EXEC 00000004 +/* IO Epoch is opened on a closed file. */ +#define MDS_FMODE_EPOCH 01000000 +/* IO Epoch is opened on a file truncate. */ +#define MDS_FMODE_TRUNC 02000000 +/* Size-on-MDS Attribute Update is pending. */ +#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 @@ -1561,6 +1914,9 @@ extern void lustre_swab_mdt_rec_setattr (struct mdt_rec_setattr *sa); #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) @@ -1586,9 +1942,13 @@ enum { 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 mdt_rec_create { __u32 cr_opcode; __u32 cr_cap; @@ -1603,18 +1963,33 @@ struct mdt_rec_create { 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; /* pad for 64 bits*/ + __u64 cr_padding_1; /* rr_blocks */ __u32 cr_mode; __u32 cr_bias; - __u32 cr_flags; /* for use with open */ - __u32 cr_padding_2; - __u32 cr_padding_3; - __u32 cr_padding_4; + /* 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_cap; @@ -1628,19 +2003,20 @@ struct mdt_rec_link { __u32 lk_suppgid2_h; struct lu_fid lk_fid1; struct lu_fid lk_fid2; - __u64 lk_time; - __u64 lk_padding_1; - __u64 lk_padding_2; - __u64 lk_padding_3; - __u64 lk_padding_4; + obd_time lk_time; + __u64 lk_padding_1; /* rr_atime */ + __u64 lk_padding_2; /* rr_ctime */ + __u64 lk_padding_3; /* rr_size */ + __u64 lk_padding_4; /* rr_blocks */ __u32 lk_bias; - __u32 lk_padding_5; - __u32 lk_padding_6; - __u32 lk_padding_7; - __u32 lk_padding_8; - __u32 lk_padding_9; + __u32 lk_padding_5; /* rr_mode */ + __u32 lk_padding_6; /* rr_flags */ + __u32 lk_padding_7; /* rr_padding_2 */ + __u32 lk_padding_8; /* rr_padding_3 */ + __u32 lk_padding_9; /* rr_padding_4 */ }; +/* instance of mdt_reint_rec */ struct mdt_rec_unlink { __u32 ul_opcode; __u32 ul_cap; @@ -1654,19 +2030,20 @@ struct mdt_rec_unlink { __u32 ul_suppgid2_h; struct lu_fid ul_fid1; struct lu_fid ul_fid2; - __u64 ul_time; - __u64 ul_padding_2; - __u64 ul_padding_3; - __u64 ul_padding_4; - __u64 ul_padding_5; + obd_time ul_time; + __u64 ul_padding_2; /* rr_atime */ + __u64 ul_padding_3; /* rr_ctime */ + __u64 ul_padding_4; /* rr_size */ + __u64 ul_padding_5; /* rr_blocks */ __u32 ul_bias; __u32 ul_mode; - __u32 ul_padding_6; - __u32 ul_padding_7; - __u32 ul_padding_8; - __u32 ul_padding_9; + __u32 ul_padding_6; /* rr_flags */ + __u32 ul_padding_7; /* rr_padding_2 */ + __u32 ul_padding_8; /* rr_padding_3 */ + __u32 ul_padding_9; /* rr_padding_4 */ }; +/* instance of mdt_reint_rec */ struct mdt_rec_rename { __u32 rn_opcode; __u32 rn_cap; @@ -1680,19 +2057,20 @@ struct mdt_rec_rename { __u32 rn_suppgid2_h; struct lu_fid rn_fid1; struct lu_fid rn_fid2; - __u64 rn_time; - __u64 rn_padding_1; - __u64 rn_padding_2; - __u64 rn_padding_3; - __u64 rn_padding_4; - __u32 rn_bias; /* some operation flags */ - __u32 rn_mode; /* cross-ref rename has mode */ - __u32 rn_padding_5; - __u32 rn_padding_6; - __u32 rn_padding_7; - __u32 rn_padding_8; -}; - + obd_time rn_time; + __u64 rn_padding_1; /* rr_atime */ + __u64 rn_padding_2; /* rr_ctime */ + __u64 rn_padding_3; /* rr_size */ + __u64 rn_padding_4; /* rr_blocks */ + __u32 rn_bias; /* some operation flags */ + __u32 rn_mode; /* cross-ref rename has mode */ + __u32 rn_padding_5; /* rr_flags */ + __u32 rn_padding_6; /* rr_padding_2 */ + __u32 rn_padding_7; /* rr_padding_3 */ + __u32 rn_padding_8; /* rr_padding_4 */ +}; + +/* instance of mdt_reint_rec */ struct mdt_rec_setxattr { __u32 sx_opcode; __u32 sx_cap; @@ -1705,22 +2083,30 @@ struct mdt_rec_setxattr { __u32 sx_suppgid2; __u32 sx_suppgid2_h; struct lu_fid sx_fid; - __u64 sx_padding_1; /* These three members are lu_fid size */ + __u64 sx_padding_1; /* These three are rr_fid2 */ __u32 sx_padding_2; __u32 sx_padding_3; __u64 sx_valid; - __u64 sx_time; - __u64 sx_padding_5; - __u64 sx_padding_6; - __u64 sx_padding_7; + obd_time sx_time; + __u64 sx_padding_5; /* rr_ctime */ + __u64 sx_padding_6; /* rr_size */ + __u64 sx_padding_7; /* rr_blocks */ __u32 sx_size; __u32 sx_flags; - __u32 sx_padding_8; - __u32 sx_padding_9; - __u32 sx_padding_10; - __u32 sx_padding_11; + __u32 sx_padding_8; /* rr_flags */ + __u32 sx_padding_9; /* rr_padding_2 */ + __u32 sx_padding_10; /* rr_padding_3 */ + __u32 sx_padding_11; /* rr_padding_4 */ }; +/* + * mdt_rec_reint is the template for all mdt_reint_xxx structures. + * Do NOT change the size of various members, otherwise the value + * will be broken in lustre_swab_mdt_rec_reint(). + * + * If you add new members in other mdt_reint_xxx structres and need to use the + * rr_padding_x fields, then update lustre_swab_mdt_rec_reint() also. + */ struct mdt_rec_reint { __u32 rr_opcode; __u32 rr_cap; @@ -1734,14 +2120,14 @@ struct mdt_rec_reint { __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; __u32 rr_mode; - __u32 rr_padding_1; /* also fix lustre_swab_mdt_rec_reint */ + __u32 rr_flags; __u32 rr_padding_2; /* also fix lustre_swab_mdt_rec_reint */ __u32 rr_padding_3; /* also fix lustre_swab_mdt_rec_reint */ __u32 rr_padding_4; /* also fix lustre_swab_mdt_rec_reint */ @@ -1786,13 +2172,6 @@ extern void lustre_swab_lmv_stripe_md(struct lmv_stripe_md *mea); #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, @@ -1816,7 +2195,18 @@ enum seq_op { #define LOV_MIN_STRIPE_BITS 16 /* maximum PAGE_SIZE (ia64), power of 2 */ #define LOV_MIN_STRIPE_SIZE (1<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 @@ -1926,11 +2329,11 @@ struct ldlm_flock { 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; @@ -1950,7 +2353,7 @@ struct ldlm_lock_desc { 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); @@ -1999,6 +2402,7 @@ typedef enum { 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 @@ -2011,25 +2415,55 @@ struct mgs_send_param { }; /* 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 @@ -2042,9 +2476,9 @@ struct cfg_marker { __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]; }; @@ -2069,7 +2503,7 @@ typedef enum { /** Identifier for a single log object */ struct llog_logid { __u64 lgl_oid; - __u64 lgl_ogr; + __u64 lgl_oseq; __u32 lgl_ogen; } __attribute__((packed)); @@ -2122,7 +2556,7 @@ struct llog_rec_hdr { __u32 lrh_len; __u32 lrh_index; __u32 lrh_type; - __u32 padding; + __u32 lrh_padding; }; struct llog_rec_tail { @@ -2133,11 +2567,11 @@ 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)); @@ -2145,8 +2579,8 @@ struct llog_create_rec { struct llog_rec_hdr lcr_hdr; struct ll_fid lcr_fid; obd_id lcr_oid; - obd_count lcr_ogr; - __u32 padding; + obd_count lcr_oseq; + __u32 lcr_padding; struct llog_rec_tail lcr_tail; } __attribute__((packed)); @@ -2154,14 +2588,14 @@ struct llog_orphan_rec { 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)); struct llog_unlink_rec { struct llog_rec_hdr lur_hdr; obd_id lur_oid; - obd_count lur_ogr; + obd_count lur_oseq; obd_count lur_count; struct llog_rec_tail lur_tail; } __attribute__((packed)); @@ -2169,18 +2603,18 @@ struct llog_unlink_rec { struct llog_setattr_rec { struct llog_rec_hdr lsr_hdr; obd_id lsr_oid; - obd_count lsr_ogr; + 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_setattr64_rec { struct llog_rec_hdr lsr_hdr; obd_id lsr_oid; - obd_count lsr_ogr; - __u32 padding; + obd_count lsr_oseq; + __u32 lsr_padding; __u32 lsr_uid; __u32 lsr_uid_h; __u32 lsr_gid; @@ -2192,7 +2626,7 @@ struct llog_size_change_rec { 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)); @@ -2203,7 +2637,7 @@ struct llog_size_change_rec { /** bits covering all \a changelog_rec_type's */ #define CHANGELOG_ALLMASK 0XFFFFFFFF /** default \a changelog_rec_type mask */ -#define CHANGELOG_DEFMASK CHANGELOG_ALLMASK +#define CHANGELOG_DEFMASK CHANGELOG_ALLMASK & ~(1 << CL_ATIME | 1 << CL_CLOSE) /* changelog llog name, needed by client replicators */ #define CHANGELOG_CATALOG "changelog_catalog" @@ -2213,12 +2647,6 @@ struct changelog_setinfo { __u32 cs_id; } __attribute__((packed)); -struct changelog_show { - __u64 cs_startrec; - __u32 cs_pid; - __u32 cs_flags; -} __attribute__((packed)); - /** changelog record */ struct llog_changelog_rec { struct llog_rec_hdr cr_hdr; @@ -2260,7 +2688,7 @@ struct llog_gen_rec { 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; @@ -2319,9 +2747,8 @@ struct llogd_conn_body { /* Note: 64-bit types are 64-bit aligned in structure */ struct obdo { obd_valid o_valid; /* hot fields in this obdo */ - obd_id o_id; - obd_gr o_gr; - obd_id o_fid; + struct ost_id o_oi; + obd_id o_parent_seq; obd_size o_size; /* o_size-o_blocks == ost_lvb */ obd_time o_mtime; obd_time o_atime; @@ -2336,25 +2763,34 @@ struct obdo { obd_gid o_gid; obd_flag o_flags; obd_count o_nlink; /* brw: checksum */ - obd_count o_generation; + obd_count o_parent_oid; obd_count o_misc; /* brw: o_dropped */ __u64 o_ioepoch; /* epoch in ost writes */ __u32 o_stripe_idx; /* holds stripe idx */ - __u32 o_padding_1; - struct lustre_handle o_handle; /* brw: lock handle to prolong locks */ - struct llog_cookie o_lcookie; /* destroy: unlink cookie from MDS */ - - __u64 o_padding_2; - __u64 o_padding_3; + __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 */ + __u32 o_uid_h; + __u32 o_gid_h; + + __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_id o_oi.oi_id +#define o_seq o_oi.oi_seq #define o_dirty o_blocks #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) { @@ -2364,13 +2800,19 @@ 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); @@ -2556,7 +2998,7 @@ enum { #define CAPA_HMAC_ALG_MASK 0xff000000 struct lustre_capa_key { - __u64 lk_mdsid; /**< mds# */ + __u64 lk_seq; /**< mds# */ __u32 lk_keyid; /**< key# */ __u32 lk_padding; __u8 lk_key[CAPA_HMAC_KEY_MAX_LEN]; /**< key */ @@ -2579,10 +3021,9 @@ struct link_ea_header { * Stored in this crazy struct for maximum packing and endian-neutrality */ struct link_ea_entry { - struct lu_fid lee_parent_fid; /** __u16 stored big-endian, unaligned */ - char lee_reclen[2]; - __u16 lee_padding; + unsigned char lee_reclen[2]; + unsigned char lee_parent_fid[sizeof(struct lu_fid)]; char lee_name[0]; }__attribute__((packed)); @@ -2597,8 +3038,6 @@ struct getinfo_fid2path { void lustre_swab_fid2path (struct getinfo_fid2path *gf); -extern void lustre_swab_lnlh(struct lnl_hdr *); - #endif /** @} lustreidl */