X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Finclude%2Flustre%2Flustre_idl.h;h=b3c7852d3d75f5c2cce716544d6f8e985d909bc1;hb=f35328e1e312259d917726f9e953cb6b834e60cf;hp=538fb2289d6affe191747900ceea9d4affac6a63;hpb=dc689955366c895f9cdcc86d78f4221866fe0926;p=fs%2Flustre-release.git diff --git a/lustre/include/lustre/lustre_idl.h b/lustre/include/lustre/lustre_idl.h index 538fb22..b3c7852 100644 --- a/lustre/include/lustre/lustre_idl.h +++ b/lustre/include/lustre/lustre_idl.h @@ -27,7 +27,7 @@ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2014, Intel Corporation. + * Copyright (c) 2011, 2015, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -52,8 +52,7 @@ * that the Lustre wire protocol is not influenced by external dependencies. * * The only other acceptable items in this file are VERY SIMPLE accessor - * functions to avoid callers grubbing inside the structures, and the - * prototypes of the swabber functions for each struct. Nothing that + * functions to avoid callers grubbing inside the structures. Nothing that * depends on external functions or definitions should be in here. * * Structs must be properly aligned to put 64-bit values on an 8-byte @@ -68,30 +67,14 @@ * in the code to ensure that new/old clients that see this larger struct * do not fail, otherwise you need to implement protocol compatibility). * - * We assume all nodes are either little-endian or big-endian, and we - * always send messages in the sender's native format. The receiver - * detects the message format by checking the 'magic' field of the message - * (see lustre_msg_swabbed() below). - * - * Each wire type has corresponding 'lustre_swab_xxxtypexxx()' routines, - * implemented either here, inline (trivial implementations) or in - * ptlrpc/pack_generic.c. These 'swabbers' convert the type from "other" - * endian, in-place in the message buffer. - * - * A swabber takes a single pointer argument. The caller must already have - * verified that the length of the message buffer >= sizeof (type). - * - * For variable length types, a second 'lustre_swab_v_xxxtypexxx()' routine - * may be defined that swabs just the variable part, after the caller has - * verified that the message buffer is large enough. - * * @{ */ #ifndef _LUSTRE_IDL_H_ #define _LUSTRE_IDL_H_ -#include /* for LPUX64, etc */ +#include +#include #include #include /* Defn's shared with user-space. */ #include @@ -186,113 +169,6 @@ struct lu_seq_range_array { #define LU_SEQ_RANGE_MASK 0x3 -static inline unsigned fld_range_type(const struct lu_seq_range *range) -{ - return range->lsr_flags & LU_SEQ_RANGE_MASK; -} - -static inline bool fld_range_is_ost(const struct lu_seq_range *range) -{ - return fld_range_type(range) == LU_SEQ_RANGE_OST; -} - -static inline bool fld_range_is_mdt(const struct lu_seq_range *range) -{ - return fld_range_type(range) == LU_SEQ_RANGE_MDT; -} - -/** - * This all range is only being used when fld client sends fld query request, - * but it does not know whether the seq is MDT or OST, so it will send req - * with ALL type, which means either seq type gotten from lookup can be - * expected. - */ -static inline unsigned fld_range_is_any(const struct lu_seq_range *range) -{ - return fld_range_type(range) == LU_SEQ_RANGE_ANY; -} - -static inline void fld_range_set_type(struct lu_seq_range *range, - unsigned flags) -{ - range->lsr_flags |= flags; -} - -static inline void fld_range_set_mdt(struct lu_seq_range *range) -{ - fld_range_set_type(range, LU_SEQ_RANGE_MDT); -} - -static inline void fld_range_set_ost(struct lu_seq_range *range) -{ - fld_range_set_type(range, LU_SEQ_RANGE_OST); -} - -static inline void fld_range_set_any(struct lu_seq_range *range) -{ - fld_range_set_type(range, LU_SEQ_RANGE_ANY); -} - -/** - * returns width of given range \a r - */ - -static inline __u64 range_space(const struct lu_seq_range *range) -{ - return range->lsr_end - range->lsr_start; -} - -/** - * initialize range to zero - */ - -static inline void range_init(struct lu_seq_range *range) -{ - memset(range, 0, sizeof(*range)); -} - -/** - * check if given seq id \a s is within given range \a r - */ - -static inline bool range_within(const struct lu_seq_range *range, - __u64 s) -{ - return s >= range->lsr_start && s < range->lsr_end; -} - -static inline bool range_is_sane(const struct lu_seq_range *range) -{ - return range->lsr_end >= range->lsr_start; -} - -static inline bool range_is_zero(const struct lu_seq_range *range) -{ - return range->lsr_start == 0 && range->lsr_end == 0; -} - -static inline bool range_is_exhausted(const struct lu_seq_range *range) -{ - return range_space(range) == 0; -} - -/* 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:%s" - -#define PRANGE(range) \ - (range)->lsr_start, \ - (range)->lsr_end, \ - (range)->lsr_index, \ - fld_range_is_mdt(range) ? "mdt" : "ost" - - /** \defgroup lu_fid lu_fid * @{ */ @@ -320,8 +196,10 @@ enum lma_incompat { LMAI_REMOTE_PARENT = 0x00000004, /* the parent of the object is on the remote MDT */ LMAI_STRIPED = 0x00000008, /* striped directory inode */ + LMAI_ORPHAN = 0x00000010, /* inode is orphan */ + LMA_INCOMPAT_SUPP = (LMAI_AGENT | LMAI_REMOTE_PARENT | \ + LMAI_STRIPED | LMAI_ORPHAN) }; -#define LMA_INCOMPAT_SUPP (LMAI_AGENT | LMAI_REMOTE_PARENT | LMAI_STRIPED) extern void lustre_lma_swab(struct lustre_mdt_attrs *lma); extern void lustre_lma_init(struct lustre_mdt_attrs *lma, @@ -717,15 +595,15 @@ static inline void ostid_set_id(struct ost_id *oi, __u64 oid) { if (fid_seq_is_mdt0(oi->oi.oi_seq)) { if (oid >= IDIF_MAX_OID) { - CERROR("Bad "LPU64" to set "DOSTID"\n", - oid, POSTID(oi)); + CERROR("Too large OID %#llx to set MDT0 "DOSTID"\n", + (unsigned long long)oid, POSTID(oi)); return; } oi->oi.oi_id = oid; } else if (fid_is_idif(&oi->oi_fid)) { if (oid >= IDIF_MAX_OID) { - CERROR("Bad "LPU64" to set "DOSTID"\n", - oid, POSTID(oi)); + CERROR("Too large OID %#llx to set IDIF "DOSTID"\n", + (unsigned long long)oid, POSTID(oi)); return; } oi->oi_fid.f_seq = fid_idif_seq(oid, @@ -734,8 +612,8 @@ static inline void ostid_set_id(struct ost_id *oi, __u64 oid) oi->oi_fid.f_ver = oid >> 48; } else { if (oid > OBIF_MAX_OID) { - CERROR("Bad "LPU64" to set "DOSTID"\n", - oid, POSTID(oi)); + CERROR("Too large oid %#llx to set REG "DOSTID"\n", + (unsigned long long)oid, POSTID(oi)); return; } oi->oi_fid.f_oid = oid; @@ -751,8 +629,8 @@ static inline int fid_set_id(struct lu_fid *fid, __u64 oid) if (fid_is_idif(fid)) { if (oid >= IDIF_MAX_OID) { - CERROR("Bad "LPU64" to set "DFID"\n", - oid, PFID(fid)); + CERROR("Too large OID %#llx to set IDIF "DFID"\n", + (unsigned long long)oid, PFID(fid)); return -EBADF; } fid->f_seq = fid_idif_seq(oid, fid_idif_ost_idx(fid)); @@ -760,8 +638,8 @@ static inline int fid_set_id(struct lu_fid *fid, __u64 oid) fid->f_ver = oid >> 48; } else { if (oid > OBIF_MAX_OID) { - CERROR("Bad "LPU64" to set "DFID"\n", - oid, PFID(fid)); + CERROR("Too large OID %#llx to set REG "DFID"\n", + (unsigned long long)oid, PFID(fid)); return -EBADF; } fid->f_oid = oid; @@ -809,10 +687,10 @@ static inline int ostid_to_fid(struct lu_fid *fid, const struct ost_id *ostid, fid->f_ver = oid >> 48; } else if (likely(!fid_seq_is_default(seq))) /* 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. */ + /* 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. */ if (ostid->oi_fid.f_ver != 0) { CERROR("bad MDT0 id(2), "DOSTID" ost_idx:%u\n", POSTID(ostid), ost_idx); @@ -860,8 +738,6 @@ static inline ino_t lu_igif_ino(const struct lu_fid *fid) return fid_seq(fid); } -extern void lustre_swab_ost_id(struct ost_id *oid); - /** * Get inode generation from an igif. * \param fid an igif to get inode generation from. @@ -922,9 +798,6 @@ static inline bool fid_is_sane(const struct lu_fid *fid) fid_seq_is_rsvd(fid_seq(fid))); } -extern void lustre_swab_lu_fid(struct lu_fid *fid); -extern void lustre_swab_lu_seq_range(struct lu_seq_range *range); - static inline bool lu_fid_eq(const struct lu_fid *f0, const struct lu_fid *f1) { return memcmp(f0, f1, sizeof *f0) == 0; @@ -981,10 +854,6 @@ struct lu_orphan_ent { struct lu_fid loe_key; struct lu_orphan_rec loe_rec; }; -void lustre_swab_orphan_ent(struct lu_orphan_ent *ent); - -struct update_ops; -void lustre_swab_update_ops(struct update_ops *uops, unsigned int op_count); /** @} lu_fid */ @@ -1005,19 +874,21 @@ enum lu_dirent_attrs { /* The following attrs are used for MDT internal only, * not visible to client */ - /* Verify the dirent consistency */ - LUDA_VERIFY = 0x8000, - /* Only check but not repair the dirent inconsistency */ - LUDA_VERIFY_DRYRUN = 0x4000, - /* The dirent has been repaired, or to be repaired (dryrun). */ - LUDA_REPAIR = 0x2000, - /* The system is upgraded, has beed or to be repaired (dryrun). */ - LUDA_UPGRADE = 0x1000, + /* Something in the record is unknown, to be verified in further. */ + LUDA_UNKNOWN = 0x0400, /* Ignore this record, go to next directly. */ LUDA_IGNORE = 0x0800, + /* The system is upgraded, has beed or to be repaired (dryrun). */ + LUDA_UPGRADE = 0x1000, + /* The dirent has been repaired, or to be repaired (dryrun). */ + LUDA_REPAIR = 0x2000, + /* Only check but not repair the dirent inconsistency */ + LUDA_VERIFY_DRYRUN = 0x4000, + /* Verify the dirent consistency */ + LUDA_VERIFY = 0x8000, }; -#define LU_DIRENT_ATTRS_MASK 0xf800 +#define LU_DIRENT_ATTRS_MASK 0xff00 /** * Layout of readdir pages, as transmitted on wire. @@ -1164,6 +1035,11 @@ static inline void lustre_handle_copy(struct lustre_handle *tgt, tgt->cookie = src->cookie; } +struct lustre_handle_array { + unsigned int count; + struct lustre_handle handles[0]; +}; + /* flags for lm_flags */ #define MSGHDR_AT_SUPPORT 0x1 #define MSGHDR_CKSUM_INCOMPAT18 0x2 @@ -1206,8 +1082,11 @@ struct ptlrpc_body_v3 { __u64 pb_slv; /* VBR: pre-versions */ __u64 pb_pre_versions[PTLRPC_NUM_VERSIONS]; + __u64 pb_mbits; /**< match bits for bulk request */ /* padding for future needs */ - __u64 pb_padding[4]; + __u64 pb_padding64_0; + __u64 pb_padding64_1; + __u64 pb_padding64_2; char pb_jobid[LUSTRE_JOBID_SIZE]; }; #define ptlrpc_body ptlrpc_body_v3 @@ -1234,12 +1113,13 @@ struct ptlrpc_body_v2 { __u64 pb_slv; /* VBR: pre-versions */ __u64 pb_pre_versions[PTLRPC_NUM_VERSIONS]; + __u64 pb_mbits; /**< unused in V2 */ /* padding for future needs */ - __u64 pb_padding[4]; + __u64 pb_padding64_0; + __u64 pb_padding64_1; + __u64 pb_padding64_2; }; -extern void lustre_swab_ptlrpc_body(struct ptlrpc_body *pb); - /* message body offset for lustre_msg_v2 */ /* ptlrpc body offset in all request/reply messages */ #define MSG_PTLRPC_BODY_OFF 0 @@ -1316,8 +1196,16 @@ extern void lustre_swab_ptlrpc_body(struct ptlrpc_body *pb); *to be reused.*/ #define OBD_CONNECT_ATTRFID 0x4000ULL /*Server can GetAttr By Fid*/ #define OBD_CONNECT_NODEVOH 0x8000ULL /*No open hndl on specl nodes*/ -#define OBD_CONNECT_RMT_CLIENT 0x10000ULL /*Remote client */ -#define OBD_CONNECT_RMT_CLIENT_FORCE 0x20000ULL /*Remote client by force */ +#define OBD_CONNECT_RMT_CLIENT 0x10000ULL /* Remote client, never used + * in production. Removed in + * 2.9. Keep this flag to + * avoid reusing. + */ +#define OBD_CONNECT_RMT_CLIENT_FORCE 0x20000ULL /* Remote client by force, + * never used in production. + * Removed in 2.9. Keep this + * flag to avoid reusing. + */ #define OBD_CONNECT_BRW_SIZE 0x40000ULL /*Max bytes per rpc */ #define OBD_CONNECT_QUOTA64 0x80000ULL /*Not used since 2.4 */ #define OBD_CONNECT_MDS_CAPA 0x100000ULL /*MDS capability */ @@ -1327,7 +1215,7 @@ extern void lustre_swab_ptlrpc_body(struct ptlrpc_body *pb); #define OBD_CONNECT_AT 0x1000000ULL /*client uses AT */ #define OBD_CONNECT_LRU_RESIZE 0x2000000ULL /*LRU resize feature. */ #define OBD_CONNECT_MDS_MDS 0x4000000ULL /*MDS-MDS connection */ -#define OBD_CONNECT_REAL 0x8000000ULL /*real connection */ +#define OBD_CONNECT_REAL 0x8000000ULL /* obsolete since 2.8 */ #define OBD_CONNECT_CHANGE_QS 0x10000000ULL /*Not used since 2.4 */ #define OBD_CONNECT_CKSUM 0x20000000ULL /*support several cksum algos*/ #define OBD_CONNECT_FID 0x40000000ULL /*FID is supported by server */ @@ -1364,6 +1252,14 @@ extern void lustre_swab_ptlrpc_body(struct ptlrpc_body *pb); #define OBD_CONNECT_MULTIMODRPCS 0x200000000000000ULL /* support multiple modify RPCs in parallel */ #define OBD_CONNECT_DIR_STRIPE 0x400000000000000ULL /* striped DNE dir */ +#define OBD_CONNECT_SUBTREE 0x800000000000000ULL /* fileset mount */ +#define OBD_CONNECT_LOCK_AHEAD 0x1000000000000000ULL /* lock ahead */ +/** bulk matchbits is sent within ptlrpc_body */ +#define OBD_CONNECT_BULK_MBITS 0x2000000000000000ULL +#define OBD_CONNECT_OBDOPACK 0x4000000000000000ULL /* compact OUT obdo */ +#define OBD_CONNECT_FLAGS2 0x8000000000000000ULL /* second flags word */ +/* ocd_connect_flags2 flags */ +#define OBD_CONNECT2_FILE_SECCTX 0x1ULL /* set file security context at create */ /* XXX README XXX: * Please DO NOT add flag values here before first ensuring that this same @@ -1391,17 +1287,13 @@ extern void lustre_swab_ptlrpc_body(struct ptlrpc_body *pb); #endif #define MDT_CONNECT_SUPPORTED (OBD_CONNECT_RDONLY | OBD_CONNECT_VERSION | \ - OBD_CONNECT_ACL | OBD_CONNECT_XATTR | \ - OBD_CONNECT_IBITS | \ - OBD_CONNECT_NODEVOH | OBD_CONNECT_ATTRFID | \ - OBD_CONNECT_CANCELSET | OBD_CONNECT_AT | \ - OBD_CONNECT_RMT_CLIENT | \ - OBD_CONNECT_RMT_CLIENT_FORCE | \ - 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_FULL20 | \ + OBD_CONNECT_ACL | OBD_CONNECT_XATTR | \ + OBD_CONNECT_IBITS | OBD_CONNECT_NODEVOH | \ + OBD_CONNECT_ATTRFID | OBD_CONNECT_CANCELSET | \ + OBD_CONNECT_AT | OBD_CONNECT_BRW_SIZE | \ + OBD_CONNECT_MDS_MDS | OBD_CONNECT_FID | \ + LRU_RESIZE_CONNECT_FLAG | OBD_CONNECT_VBR | \ + OBD_CONNECT_LOV_V3 | OBD_CONNECT_FULL20 | \ OBD_CONNECT_64BITHASH | OBD_CONNECT_JOBSTATS | \ OBD_CONNECT_EINPROGRESS | \ OBD_CONNECT_LIGHTWEIGHT | OBD_CONNECT_UMASK | \ @@ -1410,29 +1302,42 @@ extern void lustre_swab_ptlrpc_body(struct ptlrpc_body *pb); OBD_CONNECT_FLOCK_DEAD | \ OBD_CONNECT_DISP_STRIPE | OBD_CONNECT_LFSCK | \ OBD_CONNECT_OPEN_BY_FID | \ - OBD_CONNECT_DIR_STRIPE) + OBD_CONNECT_DIR_STRIPE | \ + OBD_CONNECT_BULK_MBITS | \ + OBD_CONNECT_MULTIMODRPCS | \ + OBD_CONNECT_SUBTREE | \ + OBD_CONNECT_FLAGS2) + +#define MDT_CONNECT_SUPPORTED2 OBD_CONNECT2_FILE_SECCTX #define OST_CONNECT_SUPPORTED (OBD_CONNECT_SRVLOCK | OBD_CONNECT_GRANT | \ - OBD_CONNECT_REQPORTAL | OBD_CONNECT_VERSION | \ - OBD_CONNECT_TRUNCLOCK | OBD_CONNECT_INDEX | \ - OBD_CONNECT_BRW_SIZE | OBD_CONNECT_OSS_CAPA | \ - OBD_CONNECT_CANCELSET | OBD_CONNECT_AT | \ - LRU_RESIZE_CONNECT_FLAG | OBD_CONNECT_CKSUM | \ - 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_64BITHASH | OBD_CONNECT_MAXBYTES | \ - OBD_CONNECT_MAX_EASIZE | \ + OBD_CONNECT_REQPORTAL | OBD_CONNECT_VERSION | \ + OBD_CONNECT_TRUNCLOCK | OBD_CONNECT_INDEX | \ + OBD_CONNECT_BRW_SIZE | OBD_CONNECT_CANCELSET | \ + OBD_CONNECT_AT | LRU_RESIZE_CONNECT_FLAG | \ + OBD_CONNECT_CKSUM | OBD_CONNECT_VBR | \ + OBD_CONNECT_MDS | OBD_CONNECT_SKIP_ORPHAN | \ + OBD_CONNECT_GRANT_SHRINK | OBD_CONNECT_FULL20 |\ + OBD_CONNECT_64BITHASH | OBD_CONNECT_MAXBYTES | \ + OBD_CONNECT_MAX_EASIZE | \ OBD_CONNECT_EINPROGRESS | \ OBD_CONNECT_JOBSTATS | \ OBD_CONNECT_LIGHTWEIGHT | OBD_CONNECT_LVB_TYPE|\ OBD_CONNECT_LAYOUTLOCK | OBD_CONNECT_FID | \ - OBD_CONNECT_PINGLESS | OBD_CONNECT_LFSCK) -#define ECHO_CONNECT_SUPPORTED (0) + OBD_CONNECT_PINGLESS | OBD_CONNECT_LFSCK | \ + OBD_CONNECT_BULK_MBITS | \ + OBD_CONNECT_GRANT_PARAM) +#define OST_CONNECT_SUPPORTED2 0 + +#define ECHO_CONNECT_SUPPORTED 0 +#define ECHO_CONNECT_SUPPORTED2 0 + #define MGS_CONNECT_SUPPORTED (OBD_CONNECT_VERSION | OBD_CONNECT_AT | \ OBD_CONNECT_FULL20 | OBD_CONNECT_IMP_RECOV | \ - OBD_CONNECT_MNE_SWAB | OBD_CONNECT_PINGLESS) + OBD_CONNECT_MNE_SWAB | OBD_CONNECT_PINGLESS |\ + OBD_CONNECT_BULK_MBITS) + +#define MGS_CONNECT_SUPPORTED2 0 /* Features required for this version of the client to work with server */ #define CLIENT_CONNECT_MDT_REQD (OBD_CONNECT_IBITS | OBD_CONNECT_FID | \ @@ -1449,10 +1354,10 @@ struct obd_connect_data { __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 */ + __u8 ocd_grant_blkbits; /* log2 of the backend filesystem blocksize */ + __u8 ocd_grant_inobits; /* log2 of the per-inode space consumption */ + __u16 ocd_grant_tax_kb; /* extent insertion overhead, in 1K blocks */ + __u32 ocd_grant_max_blks;/* maximum number of blocks per extent */ __u64 ocd_transno; /* first transno from client to be replayed */ __u32 ocd_group; /* MDS group on OST */ __u32 ocd_cksum_types; /* supported checksum algorithms */ @@ -1466,7 +1371,7 @@ struct obd_connect_data { __u16 ocd_maxmodrpcs; /* Maximum modify RPCs in parallel */ __u16 padding0; /* added 2.1.0. also fix lustre_swab_connect */ __u32 padding1; /* added 2.1.0. also fix lustre_swab_connect */ - __u64 padding2; /* added 2.1.0. also fix lustre_swab_connect */ + __u64 ocd_connect_flags2; __u64 padding3; /* added 2.1.0. also fix lustre_swab_connect */ __u64 padding4; /* added 2.1.0. also fix lustre_swab_connect */ __u64 padding5; /* added 2.1.0. also fix lustre_swab_connect */ @@ -1489,9 +1394,6 @@ struct obd_connect_data { * 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); - /* * Supported checksum algorithms. Up to 32 checksum types are supported. * (32-bit mask stored in obd_connect_data::ocd_cksum_types) @@ -1529,7 +1431,8 @@ typedef enum { OST_QUOTACHECK = 18, /* not used since 2.4 */ OST_QUOTACTL = 19, OST_QUOTA_ADJUST_QUNIT = 20, /* not used since 2.4 */ - OST_LAST_OPC + OST_LADVISE = 21, + OST_LAST_OPC /* must be < 33 to avoid MDS_GETATTR */ } ost_cmd_t; #define OST_FIRST_OPC OST_REPLY @@ -1688,8 +1591,6 @@ static inline void lmm_oi_cpu_to_le(struct ost_id *dst_oi, dst_oi->oi.oi_seq = cpu_to_le64(src_oi->oi.oi_seq); } -/* extern void lustre_swab_lov_mds_md(struct lov_mds_md *llm); */ - #define MAX_MD_SIZE (sizeof(struct lov_mds_md) + 4 * sizeof(struct lov_ost_data)) #define MIN_MD_SIZE (sizeof(struct lov_mds_md) + 1 * sizeof(struct lov_ost_data)) @@ -1717,10 +1618,6 @@ static inline void lmm_oi_cpu_to_le(struct ost_id *dst_oi, #define XATTR_NAME_LFSCK_BITMAP "trusted.lfsck_bitmap" #define XATTR_NAME_DUMMY "trusted.dummy" -#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 8, 53, 0) -# define XATTR_NAME_LFSCK_NAMESPACE_OLD "trusted.lfsck_namespace" -#endif - #define XATTR_NAME_LFSCK_NAMESPACE "trusted.lfsck_ns" #define XATTR_NAME_MAX_LEN 32 /* increase this, if there is longer name. */ @@ -1813,7 +1710,7 @@ lov_mds_md_max_stripe_count(size_t buf_size, __u32 lmm_magic) #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 */ +/* OBD_MD_FLRMTPERM (0x0000010000000000ULL) remote perm, obsolete */ #define OBD_MD_FLMDSCAPA (0x0000020000000000ULL) /* MDS capability */ #define OBD_MD_FLOSSCAPA (0x0000040000000000ULL) /* OSS capability */ #define OBD_MD_FLCKSPLIT (0x0000080000000000ULL) /* Check split on server */ @@ -1824,10 +1721,10 @@ lov_mds_md_max_stripe_count(size_t buf_size, __u32 lmm_magic) * client holds the lock */ #define OBD_MD_FLOBJCOUNT (0x0000400000000000ULL) /* for multiple destroy */ -#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 */ +/* OBD_MD_FLRMTLSETFACL (0x0001000000000000ULL) lfs lsetfacl, obsolete */ +/* OBD_MD_FLRMTLGETFACL (0x0002000000000000ULL) lfs lgetfacl, obsolete */ +/* OBD_MD_FLRMTRSETFACL (0x0004000000000000ULL) lfs rsetfacl, obsolete */ +/* OBD_MD_FLRMTRGETFACL (0x0008000000000000ULL) lfs rgetfacl, obsolete */ #define OBD_MD_FLDATAVERSION (0x0010000000000000ULL) /* iversion sum */ #define OBD_MD_CLOSE_INTENT_EXECED (0x0020000000000000ULL) /* close intent @@ -1859,11 +1756,6 @@ struct hsm_state_set { __u64 hss_clearmask; }; -extern void lustre_swab_hsm_user_state(struct hsm_user_state *hus); -extern void lustre_swab_hsm_state_set(struct hsm_state_set *hss); - -extern void lustre_swab_obd_statfs (struct obd_statfs *os); - /* ost_body.data values for OST_BRW */ #define OBD_BRW_READ 0x01 @@ -1900,14 +1792,14 @@ struct obd_ioobj { __u32 ioo_bufcnt; /* number of niobufs for this object */ }; +/* NOTE: IOOBJ_MAX_BRW_BITS defines the _offset_ of the max_brw field in + * ioo_max_brw, NOT the maximum number of bits in PTLRPC_BULK_OPS_BITS. + * That said, ioo_max_brw is a 32-bit field so the limit is also 16 bits. */ #define IOOBJ_MAX_BRW_BITS 16 -#define IOOBJ_TYPE_MASK ((1U << IOOBJ_MAX_BRW_BITS) - 1) #define ioobj_max_brw_get(ioo) (((ioo)->ioo_max_brw >> IOOBJ_MAX_BRW_BITS) + 1) #define ioobj_max_brw_set(ioo, num) \ do { (ioo)->ioo_max_brw = ((num) - 1) << IOOBJ_MAX_BRW_BITS; } while (0) -extern void lustre_swab_obd_ioobj (struct obd_ioobj *ioo); - /* multiple of 8 bytes => can array */ struct niobuf_remote { __u64 rnb_offset; @@ -1915,8 +1807,6 @@ struct niobuf_remote { __u32 rnb_flags; }; -void lustre_swab_niobuf_remote(struct niobuf_remote *nbr); - /* lock value block communicated between the filter and llite */ /* OST_LVB_ERR_INIT is needed because the return code in rc is @@ -1937,8 +1827,6 @@ struct ost_lvb_v1 { __u64 lvb_blocks; }; -extern void lustre_swab_ost_lvb_v1(struct ost_lvb_v1 *lvb); - struct ost_lvb { __u64 lvb_size; __s64 lvb_mtime; @@ -1951,8 +1839,6 @@ struct ost_lvb { __u32 lvb_padding; }; -extern void lustre_swab_ost_lvb(struct ost_lvb *lvb); - /* * lquota data structures */ @@ -1990,8 +1876,6 @@ struct obd_quotactl { struct obd_dqblk qc_dqblk; }; -extern void lustre_swab_obd_quotactl(struct obd_quotactl *q); - #define Q_COPY(out, in, member) (out)->member = (in)->member #define QCTL_COPY(out, in) \ @@ -2033,8 +1917,6 @@ struct quota_body { #define QUOTA_DQACQ_FL_REL 0x4 /* release quota */ #define QUOTA_DQACQ_FL_REPORT 0x8 /* report usage */ -extern void lustre_swab_quota_body(struct quota_body *b); - /* Quota types currently supported */ enum { LQUOTA_TYPE_USR = 0x00, /* maps to USRQUOTA */ @@ -2113,8 +1995,6 @@ struct lquota_lvb { __u64 lvb_pad1; }; -extern void lustre_swab_lquota_lvb(struct lquota_lvb *lvb); - /* LVB used with global quota lock */ #define lvb_glb_ver lvb_id_may_rel /* current version of the global index */ @@ -2139,7 +2019,7 @@ typedef enum { MDS_READPAGE = 37, MDS_CONNECT = 38, MDS_DISCONNECT = 39, - MDS_GETSTATUS = 40, + MDS_GET_ROOT = 40, MDS_STATFS = 41, MDS_PIN = 42, /* obsolete, never used in a release */ MDS_UNPIN = 43, /* obsolete, never used in a release */ @@ -2192,8 +2072,6 @@ typedef enum { REINT_MAX } mds_reint_t, mdt_reint_t; -extern void lustre_swab_generic_32s (__u32 *val); - /* the disposition of the intent outlines what was executed */ #define DISP_IT_EXECD 0x00000001 #define DISP_LOOKUP_EXECD 0x00000002 @@ -2233,8 +2111,6 @@ extern void lustre_swab_generic_32s (__u32 *val); /* 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); - /* 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). */ @@ -2250,15 +2126,44 @@ enum { #define MDS_STATUS_CONN 1 #define MDS_STATUS_LOV 2 -#define LUSTRE_BFLAG_UNCOMMITTED_WRITES 0x1 +enum { + /* these should be identical to their EXT4_*_FL counterparts, they are + * redefined here only to avoid dragging in fs/ext4/ext4.h */ + LUSTRE_SYNC_FL = 0x00000008, /* Synchronous updates */ + LUSTRE_IMMUTABLE_FL = 0x00000010, /* Immutable file */ + LUSTRE_APPEND_FL = 0x00000020, /* writes to file may only append */ + LUSTRE_NODUMP_FL = 0x00000040, /* do not dump file */ + LUSTRE_NOATIME_FL = 0x00000080, /* do not update atime */ + LUSTRE_INDEX_FL = 0x00001000, /* hash-indexed directory */ + LUSTRE_DIRSYNC_FL = 0x00010000, /* dirsync behaviour (dir only) */ + LUSTRE_TOPDIR_FL = 0x00020000, /* Top of directory hierarchies*/ + LUSTRE_DIRECTIO_FL = 0x00100000, /* Use direct i/o */ + LUSTRE_INLINE_DATA_FL = 0x10000000, /* Inode has inline data. */ + + /* These flags will not be identical to any EXT4_*_FL counterparts, + * and only reserved for lustre purpose. Note: these flags might + * be conflict with some of EXT4 flags, so + * 1. these conflict flags needs to be removed when the flag is + * wired by la_flags see osd_attr_get(). + * 2. If these flags needs to be stored into inode, they will be + * stored in LMA. see LMAI_XXXX */ + LUSTRE_ORPHAN_FL = 0x00002000, + + LUSTRE_LMA_FL_MASKS = LUSTRE_ORPHAN_FL, +}; + +/* LUSTRE_LMA_FL_MASKS defines which flags will be stored in LMA */ + +static inline int lma_to_lustre_flags(__u32 lma_flags) +{ + return (lma_flags & LMAI_ORPHAN) ? LUSTRE_ORPHAN_FL : 0; +} + +static inline int lustre_to_lma_flags(__u32 la_flags) +{ + return (la_flags & LUSTRE_ORPHAN_FL) ? LMAI_ORPHAN : 0; +} -/* 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 LUSTRE_*_FL to corresponding client local VFS S_* values @@ -2315,7 +2220,7 @@ struct mdt_body { __u32 mbo_mode; __u32 mbo_uid; __u32 mbo_gid; - __u32 mbo_flags; + __u32 mbo_flags; /* LUSTRE_*_FL file attributes */ __u32 mbo_rdev; __u32 mbo_nlink; /* #bytes to read in the case of MDS_READPAGE */ __u32 mbo_unused2; /* was "generation" until 2.4.0 */ @@ -2334,8 +2239,6 @@ struct mdt_body { __u64 mbo_padding_10; }; /* 216 */ -extern void lustre_swab_mdt_body (struct mdt_body *b); - struct mdt_ioepoch { struct lustre_handle mio_handle; __u64 mio_unused1; /* was ioepoch */ @@ -2343,32 +2246,13 @@ struct mdt_ioepoch { __u32 mio_padding; }; -extern void lustre_swab_mdt_ioepoch (struct mdt_ioepoch *b); - /* permissions for md_perm.mp_perm */ enum { CFS_SETUID_PERM = 0x01, CFS_SETGID_PERM = 0x02, CFS_SETGRP_PERM = 0x04, - CFS_RMTACL_PERM = 0x08, - CFS_RMTOWN_PERM = 0x10 -}; - -/* 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); - struct mdt_rec_setattr { __u32 sa_opcode; __u32 sa_cap; @@ -2397,8 +2281,6 @@ struct mdt_rec_setattr { __u32 sa_padding_5; }; -extern void lustre_swab_mdt_rec_setattr (struct mdt_rec_setattr *sa); - /* * Attribute flags used in mdt_rec_setattr::sa_valid. * The kernel's #defines for ATTR_* should not be used over the network @@ -2472,23 +2354,6 @@ extern void lustre_swab_mdt_rec_setattr (struct mdt_rec_setattr *sa); MDS_OPEN_BY_FID | MDS_OPEN_LEASE | \ MDS_OPEN_RELEASE) -/* permission for create non-directory file */ -#define MAY_CREATE (1 << 7) -/* permission for create directory file */ -#define MAY_LINK (1 << 8) -/* permission for delete from the directory */ -#define MAY_UNLINK (1 << 9) -/* source's permission for rename */ -#define MAY_RENAME_SRC (1 << 10) -/* target's permission for rename */ -#define MAY_RENAME_TAR (1 << 11) -/* part (parent's) VTX permission check */ -#define MAY_VTX_PART (1 << 12) -/* full VTX permission check */ -#define MAY_VTX_FULL (1 << 13) -/* lfs rgetfacl permission check */ -#define MAY_RGETFACL (1 << 14) - enum mds_op_bias { MDS_CHECK_SPLIT = 1 << 0, MDS_CROSS_REF = 1 << 1, @@ -2692,8 +2557,6 @@ struct mdt_rec_reint { __u32 rr_padding_4; /* also fix lustre_swab_mdt_rec_reint */ }; -extern void lustre_swab_mdt_rec_reint(struct mdt_rec_reint *rr); - /* lmv structures */ struct lmv_desc { __u32 ld_tgt_count; /* how many MDS's */ @@ -2709,8 +2572,6 @@ struct lmv_desc { struct obd_uuid ld_uuid; }; -extern void lustre_swab_lmv_desc (struct lmv_desc *ld); - /* LMV layout EA, and it will be stored both in master and slave object */ struct lmv_mds_md_v1 { __u32 lmv_magic; @@ -2745,7 +2606,14 @@ struct lmv_mds_md_v1 { #define LMV_HASH_TYPE_MASK 0x0000ffff #define LMV_HASH_FLAG_MIGRATION 0x80000000 + +#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 10, 53, 0) +/* Since lustre 2.8, this flag will not be needed, instead this DEAD + * and orphan flags will be stored in LMA (see LMAI_ORPHAN) + * Keep this flag just for LFSCK, because it still might meet such + * flag when it checks the old FS */ #define LMV_HASH_FLAG_DEAD 0x40000000 +#endif #define LMV_HASH_FLAG_BAD_TYPE 0x20000000 /* The striped directory has ever lost its master LMV EA, then LFSCK @@ -2787,8 +2655,6 @@ union lmv_mds_md { struct lmv_user_md lmv_user_md; }; -extern void lustre_swab_lmv_mds_md(union lmv_mds_md *lmm); - static inline int lmv_mds_md_size(int stripe_count, unsigned int lmm_magic) { switch (lmm_magic) { @@ -2893,8 +2759,6 @@ struct lov_desc { #define ld_magic ld_active_tgt_count /* for swabbing from llogs */ -extern void lustre_swab_lov_desc (struct lov_desc *ld); - /* * LDLM requests: */ @@ -2916,11 +2780,11 @@ struct ldlm_res_id { __u64 name[RES_NAME_SIZE]; }; -#define DLDLMRES "["LPX64":"LPX64":"LPX64"]."LPX64i -#define PLDLMRES(res) (res)->lr_name.name[0], (res)->lr_name.name[1], \ - (res)->lr_name.name[2], (res)->lr_name.name[3] - -extern void lustre_swab_ldlm_res_id (struct ldlm_res_id *id); +#define DLDLMRES "[%#llx:%#llx:%#llx].%#llx" +#define PLDLMRES(res) (unsigned long long)(res)->lr_name.name[0], \ + (unsigned long long)(res)->lr_name.name[1], \ + (unsigned long long)(res)->lr_name.name[2], \ + (unsigned long long)(res)->lr_name.name[3] static inline bool ldlm_res_eq(const struct ldlm_res_id *res0, const struct ldlm_res_id *res1) @@ -2929,27 +2793,27 @@ static inline bool ldlm_res_eq(const struct ldlm_res_id *res0, } /* lock types */ -typedef enum { - LCK_MINMODE = 0, - LCK_EX = 1, - LCK_PW = 2, - LCK_PR = 4, - LCK_CW = 8, - LCK_CR = 16, - LCK_NL = 32, - LCK_GROUP = 64, - LCK_COS = 128, - LCK_MAXMODE +typedef enum ldlm_mode { + LCK_MINMODE = 0, + LCK_EX = 1, + LCK_PW = 2, + LCK_PR = 4, + LCK_CW = 8, + LCK_CR = 16, + LCK_NL = 32, + LCK_GROUP = 64, + LCK_COS = 128, + LCK_MAXMODE } ldlm_mode_t; #define LCK_MODE_NUM 8 -typedef enum { - LDLM_PLAIN = 10, - LDLM_EXTENT = 11, - LDLM_FLOCK = 12, - LDLM_IBITS = 13, - LDLM_MAX_TYPE +typedef enum ldlm_type { + LDLM_PLAIN = 10, + LDLM_EXTENT = 11, + LDLM_FLOCK = 12, + LDLM_IBITS = 13, + LDLM_MAX_TYPE } ldlm_type_t; #define LDLM_MIN_TYPE LDLM_PLAIN @@ -2991,43 +2855,51 @@ struct ldlm_flock_wire { * this ever changes we will need to swab the union differently based * on the resource type. */ -typedef union { - struct ldlm_extent l_extent; - struct ldlm_flock_wire l_flock; - struct ldlm_inodebits l_inodebits; +typedef union ldlm_wire_policy_data { + struct ldlm_extent l_extent; + struct ldlm_flock_wire l_flock; + struct ldlm_inodebits l_inodebits; } ldlm_wire_policy_data_t; -extern void lustre_swab_ldlm_policy_data (ldlm_wire_policy_data_t *d); - union ldlm_gl_desc { struct ldlm_gl_lquota_desc lquota_desc; }; -extern void lustre_swab_gl_desc(union ldlm_gl_desc *); +enum ldlm_intent_flags { + IT_OPEN = 0x00000001, + IT_CREAT = 0x00000002, + IT_OPEN_CREAT = 0x00000003, + IT_READDIR = 0x00000004, + IT_GETATTR = 0x00000008, + IT_LOOKUP = 0x00000010, + IT_UNLINK = 0x00000020, + IT_TRUNC = 0x00000040, + IT_GETXATTR = 0x00000080, + IT_EXEC = 0x00000100, + IT_PIN = 0x00000200, + IT_LAYOUT = 0x00000400, + IT_QUOTA_DQACQ = 0x00000800, + IT_QUOTA_CONN = 0x00001000, + IT_SETXATTR = 0x00002000, +}; struct ldlm_intent { - __u64 opc; + __u64 opc; }; -extern void lustre_swab_ldlm_intent (struct ldlm_intent *i); - struct ldlm_resource_desc { - ldlm_type_t lr_type; - __u32 lr_padding; /* also fix lustre_swab_ldlm_resource_desc */ - struct ldlm_res_id lr_name; + enum ldlm_type lr_type; + __u32 lr_pad; /* also fix lustre_swab_ldlm_resource_desc */ + struct ldlm_res_id lr_name; }; -extern void lustre_swab_ldlm_resource_desc (struct ldlm_resource_desc *r); - struct ldlm_lock_desc { - struct ldlm_resource_desc l_resource; - ldlm_mode_t l_req_mode; - ldlm_mode_t l_granted_mode; - ldlm_wire_policy_data_t l_policy_data; + struct ldlm_resource_desc l_resource; + enum ldlm_mode l_req_mode; + enum ldlm_mode l_granted_mode; + union ldlm_wire_policy_data l_policy_data; }; -extern void lustre_swab_ldlm_lock_desc (struct ldlm_lock_desc *l); - #define LDLM_LOCKREQ_HANDLES 2 #define LDLM_ENQUEUE_CANCEL_OFF 1 @@ -3038,8 +2910,6 @@ struct ldlm_request { struct lustre_handle lock_handle[LDLM_LOCKREQ_HANDLES]; }; -extern void lustre_swab_ldlm_request (struct ldlm_request *rq); - /* If LDLM_ENQUEUE, 1 slot is already occupied, 1 is available. * Otherwise, 2 are available. */ #define ldlm_request_bufsize(count,type) \ @@ -3060,8 +2930,6 @@ struct ldlm_reply { __u64 lock_policy_res2; }; -extern void lustre_swab_ldlm_reply (struct ldlm_reply *r); - #define ldlm_flags_to_wire(flags) ((__u32)(flags)) #define ldlm_flags_from_wire(flags) ((__u64)(flags)) @@ -3104,7 +2972,6 @@ struct mgs_target_info { __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 */ @@ -3119,7 +2986,6 @@ struct mgs_nidtbl_entry { 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 */ @@ -3129,13 +2995,11 @@ struct mgs_config_body { __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 @@ -3156,9 +3020,6 @@ struct cfg_marker { char cm_comment[MTI_NAME_MAXLEN]; }; -extern void lustre_swab_cfg_marker(struct cfg_marker *marker, - int swab, int size); - /* * Opcodes for multiple servers. */ @@ -3426,7 +3287,12 @@ enum llog_flag { LLOG_F_IS_CAT = 0x2, LLOG_F_IS_PLAIN = 0x4, LLOG_F_EXT_JOBID = 0x8, + LLOG_F_IS_FIXSIZE = 0x10, + /* Note: Flags covered by LLOG_F_EXT_MASK will be inherited from + * catlog to plain log, so do not add LLOG_F_IS_FIXSIZE here, + * because the catlog record is usually fixed size, but its plain + * log record can be variable */ LLOG_F_EXT_MASK = LLOG_F_EXT_JOBID, }; @@ -3444,8 +3310,10 @@ struct llog_log_hdr { __u32 llh_bitmap_offset; __u32 llh_size; __u32 llh_flags; + /* for a catalog the first/oldest and still in-use plain slot is just + * next to it. It will serve as the upper limit after Catalog has + * wrapped around */ __u32 llh_cat_idx; - /* for a catalog the first plain slot is next to it */ struct obd_uuid llh_tgtuuid; __u32 llh_reserved[LLOG_HEADER_SIZE/sizeof(__u32)-23]; /* These fields must always be at the end of the llog_log_hdr. @@ -3580,16 +3448,12 @@ struct lfsck_request { __u64 lr_padding_2; }; -void lustre_swab_lfsck_request(struct lfsck_request *lr); - struct lfsck_reply { __u32 lr_status; __u32 lr_padding_1; - __u64 lr_padding_2; + __u64 lr_repaired; }; -void lustre_swab_lfsck_reply(struct lfsck_reply *lr); - enum lfsck_events { LE_LASTID_REBUILDING = 1, LE_LASTID_REBUILT = 2, @@ -3614,58 +3478,12 @@ enum lfsck_event_flags { LEF_SET_LMV_HASH = 0x00000004, LEF_SET_LMV_ALL = 0x00000008, LEF_RECHECK_NAME_HASH = 0x00000010, + LEF_QUERY_ALL = 0x00000020, }; -static inline void lustre_set_wire_obdo(const struct obd_connect_data *ocd, - struct obdo *wobdo, - const struct obdo *lobdo) -{ - *wobdo = *lobdo; - wobdo->o_flags &= ~OBD_FL_LOCAL_MASK; - if (ocd == NULL) - return; - - if (unlikely(!(ocd->ocd_connect_flags & OBD_CONNECT_FID)) && - fid_seq_is_echo(ostid_seq(&lobdo->o_oi))) { - /* Currently OBD_FL_OSTID will only be used when 2.4 echo - * client communicate with pre-2.4 server */ - wobdo->o_oi.oi.oi_id = fid_oid(&lobdo->o_oi.oi_fid); - wobdo->o_oi.oi.oi_seq = fid_seq(&lobdo->o_oi.oi_fid); - } -} - -static inline void lustre_get_wire_obdo(const struct obd_connect_data *ocd, - struct obdo *lobdo, - const struct obdo *wobdo) -{ - __u32 local_flags = 0; - - if (lobdo->o_valid & OBD_MD_FLFLAGS) - local_flags = lobdo->o_flags & OBD_FL_LOCAL_MASK; - - *lobdo = *wobdo; - if (local_flags != 0) { - lobdo->o_valid |= OBD_MD_FLFLAGS; - lobdo->o_flags &= ~OBD_FL_LOCAL_MASK; - lobdo->o_flags |= local_flags; - } - if (ocd == NULL) - return; - - if (unlikely(!(ocd->ocd_connect_flags & OBD_CONNECT_FID)) && - fid_seq_is_echo(wobdo->o_oi.oi.oi_seq)) { - /* see above */ - lobdo->o_oi.oi_fid.f_seq = wobdo->o_oi.oi.oi_seq; - lobdo->o_oi.oi_fid.f_oid = wobdo->o_oi.oi.oi_id; - lobdo->o_oi.oi_fid.f_ver = 0; - } -} - -extern void lustre_swab_obdo (struct obdo *o); - /* request structure for OST's */ struct ost_body { - struct obdo oa; + struct obdo oa; }; /* Key for FIEMAP to be used in get_info calls */ @@ -3675,32 +3493,12 @@ struct ll_fiemap_info_key { struct fiemap lfik_fiemap; }; -extern void lustre_swab_ost_body (struct ost_body *b); -extern void lustre_swab_ost_last_id(__u64 *id); -extern void lustre_swab_fiemap(struct fiemap *fiemap); - -extern void lustre_swab_lov_user_md_v1(struct lov_user_md_v1 *lum); -extern void lustre_swab_lov_user_md_v3(struct lov_user_md_v3 *lum); -extern void lustre_swab_lov_user_md_objects(struct lov_user_ost_data *lod, - int stripe_count); -extern void lustre_swab_lov_mds_md(struct lov_mds_md *lmm); void lustre_print_user_md(unsigned int level, struct lov_user_md *lum, const char *msg); -/* llog_swab.c */ -extern void lustre_swab_llogd_body (struct llogd_body *d); -extern void lustre_swab_llog_hdr (struct llog_log_hdr *h); -extern void lustre_swab_llogd_conn_body (struct llogd_conn_body *d); -extern void lustre_swab_llog_rec(struct llog_rec_hdr *rec); -extern void lustre_swab_llog_id(struct llog_logid *lid); - -struct lustre_cfg; -extern void lustre_swab_lustre_cfg(struct lustre_cfg *lcfg); - /* Functions for dumping PTLRPC fields */ void dump_rniobuf(struct niobuf_remote *rnb); void dump_ioo(struct obd_ioobj *nb); -void dump_obdo(struct obdo *oa); void dump_ost_body(struct ost_body *ob); void dump_rcs(__u32 *rc); @@ -3747,7 +3545,6 @@ struct idx_info { __u64 ii_pad2; __u64 ii_pad3; }; -extern void lustre_swab_idx_info(struct idx_info *ii); #define II_END_OFF MDS_DIR_END_OFF /* all entries have been read */ @@ -3780,7 +3577,6 @@ struct lu_idxpage { * For the time being, we only support fixed-size key & record. */ char lip_entries[0]; }; -extern void lustre_swab_lip_header(struct lu_idxpage *lip); #define LIP_HDR_SIZE (offsetof(struct lu_idxpage, lip_entries)) @@ -3820,8 +3616,6 @@ struct lustre_capa { __u8 lc_hmac[CAPA_HMAC_MAX_LEN]; /** HMAC */ } __attribute__((packed)); -extern void lustre_swab_lustre_capa(struct lustre_capa *c); - /** lustre_capa::lc_opc */ enum { CAPA_OPC_BODY_WRITE = 1<<0, /**< write object data */ @@ -3847,21 +3641,6 @@ enum { #define CAPA_OPC_MDS_DEFAULT ~CAPA_OPC_OSS_ONLY #define CAPA_OPC_OSS_DEFAULT ~(CAPA_OPC_MDS_ONLY | CAPA_OPC_OSS_ONLY) -/* MDS capability covers object capability for operations of body r/w - * (dir readpage/sendpage), index lookup/insert/delete and meta data r/w, - * while OSS capability only covers object capability for operations of - * oss data(file content) r/w/truncate. - */ -static inline int capa_for_mds(struct lustre_capa *c) -{ - return (c->lc_opc & CAPA_OPC_INDEX_LOOKUP) != 0; -} - -static inline int capa_for_oss(struct lustre_capa *c) -{ - return (c->lc_opc & CAPA_OPC_INDEX_LOOKUP) == 0; -} - static inline bool lovea_slot_is_dummy(const struct lov_ost_data_v1 *obj) { /* zero area does not care about the bytes-order. */ @@ -3888,8 +3667,6 @@ struct lustre_capa_key { __u8 lk_key[CAPA_HMAC_KEY_MAX_LEN]; /**< key */ } __attribute__((packed)); -extern void lustre_swab_lustre_capa_key(struct lustre_capa_key *k); - /** The link ea holds 1 \a link_ea_entry for each hardlink */ #define LINK_EA_MAGIC 0x11EAF1DFUL struct link_ea_header { @@ -3913,15 +3690,16 @@ struct link_ea_entry { /** fid2path request/reply structure */ struct getinfo_fid2path { - struct lu_fid gf_fid; - __u64 gf_recno; - __u32 gf_linkno; - __u32 gf_pathlen; - char gf_path[0]; + struct lu_fid gf_fid; + __u64 gf_recno; + __u32 gf_linkno; + __u32 gf_pathlen; + union { + char gf_path[0]; + struct lu_fid gf_root_fid[0]; + } gf_u; } __attribute__((packed)); -void lustre_swab_fid2path (struct getinfo_fid2path *gf); - /** path2parent request/reply structures */ struct getparent { struct lu_fid gp_fid; /**< parent FID */ @@ -3948,8 +3726,6 @@ struct layout_intent { __u64 li_end; }; -void lustre_swab_layout_intent(struct layout_intent *li); - /** * On the wire version of hsm_progress structure. * @@ -3968,13 +3744,6 @@ struct hsm_progress_kernel { __u64 hpk_padding2; } __attribute__((packed)); -extern void lustre_swab_hsm_user_state(struct hsm_user_state *hus); -extern void lustre_swab_hsm_current_action(struct hsm_current_action *action); -extern void lustre_swab_hsm_progress_kernel(struct hsm_progress_kernel *hpk); -extern void lustre_swab_hsm_user_state(struct hsm_user_state *hus); -extern void lustre_swab_hsm_user_item(struct hsm_user_item *hui); -extern void lustre_swab_hsm_request(struct hsm_request *hr); - /** * OUT_UPDATE RPC Format * @@ -4028,6 +3797,7 @@ enum update_type { OUT_XATTR_DEL = 13, OUT_PUNCH = 14, OUT_READ = 15, + OUT_NOOP = 16, OUT_LAST }; @@ -4045,17 +3815,11 @@ struct object_update_param { char oup_buf[0]; }; -static inline size_t -object_update_param_size(const struct object_update_param *param) -{ - return cfs_size_round(sizeof(*param) + param->oup_len); -} - /* object update */ struct object_update { __u16 ou_type; /* enum update_type */ __u16 ou_params_count; /* update parameters count */ - __u32 ou_master_index; /* master MDT/OST index */ + __u32 ou_result_size; /* how many bytes can return */ __u32 ou_flags; /* enum update_flag */ __u32 ou_padding1; /* padding 1 */ __u64 ou_batchid; /* op transno on master */ @@ -4074,54 +3838,21 @@ struct object_update_request { struct object_update ourq_updates[0]; }; -void lustre_swab_object_update(struct object_update *ou); -void lustre_swab_object_update_request(struct object_update_request *our); - -static inline size_t -object_update_params_size(const struct object_update *update) -{ - const struct object_update_param *param; - size_t total_size = 0; - unsigned int i; - - param = &update->ou_params[0]; - for (i = 0; i < update->ou_params_count; i++) { - size_t size = object_update_param_size(param); - - param = (struct object_update_param *)((char *)param + size); - total_size += size; - } - - return total_size; -} - -static inline size_t -object_update_size(const struct object_update *update) -{ - return offsetof(struct object_update, ou_params[0]) + - object_update_params_size(update); -} - -static inline struct object_update * -object_update_request_get(const struct object_update_request *our, - unsigned int index, size_t *size) -{ - void *ptr; - unsigned int i; - - if (index >= our->ourq_count) - return NULL; - - ptr = (void *)&our->ourq_updates[0]; - for (i = 0; i < index; i++) - ptr += object_update_size(ptr); - - if (size != NULL) - *size = object_update_size(ptr); - - return ptr; -} +#define OUT_UPDATE_HEADER_MAGIC 0xBDDF0001 +#define OUT_UPDATE_MAX_INLINE_SIZE 4096 +/* Header for updates request between MDTs */ +struct out_update_header { + __u32 ouh_magic; + __u32 ouh_count; + __u32 ouh_inline_length; + __u32 ouh_reply_size; + __u32 ouh_inline_data[0]; +}; +struct out_update_buffer { + __u32 oub_size; + __u32 oub_padding; +}; /* the result of object update */ struct object_update_result { @@ -4142,36 +3873,6 @@ struct object_update_reply { __u16 ourp_lens[0]; }; -void lustre_swab_object_update_result(struct object_update_result *our); -void lustre_swab_object_update_reply(struct object_update_reply *our); - -static inline struct object_update_result * -object_update_result_get(const struct object_update_reply *reply, - unsigned int index, size_t *size) -{ - __u16 count = reply->ourp_count; - unsigned int i; - void *ptr; - - if (index >= count) - return NULL; - - ptr = (char *)reply + - cfs_size_round(offsetof(struct object_update_reply, - ourp_lens[count])); - for (i = 0; i < index; i++) { - if (reply->ourp_lens[i] == 0) - return NULL; - - ptr += cfs_size_round(reply->ourp_lens[i]); - } - - if (size != NULL) - *size = reply->ourp_lens[index]; - - return ptr; -} - /* read update result */ struct out_read_reply { __u32 orr_size; @@ -4180,22 +3881,6 @@ struct out_read_reply { char orr_data[0]; }; -static inline void orr_cpu_to_le(struct out_read_reply *orr_dst, - const struct out_read_reply *orr_src) -{ - orr_dst->orr_size = cpu_to_le32(orr_src->orr_size); - orr_dst->orr_padding = cpu_to_le32(orr_src->orr_padding); - orr_dst->orr_offset = cpu_to_le64(orr_dst->orr_offset); -} - -static inline void orr_le_to_cpu(struct out_read_reply *orr_dst, - const struct out_read_reply *orr_src) -{ - orr_dst->orr_size = le32_to_cpu(orr_src->orr_size); - orr_dst->orr_padding = le32_to_cpu(orr_src->orr_padding); - orr_dst->orr_offset = le64_to_cpu(orr_dst->orr_offset); -} - /** layout swap request structure * fid1 and fid2 are in mdt_body */ @@ -4203,8 +3888,6 @@ struct mdc_swap_layouts { __u64 msl_flags; } __packed; -void lustre_swab_swap_layouts(struct mdc_swap_layouts *msl); - struct close_data { struct lustre_handle cd_handle; struct lu_fid cd_fid; @@ -4212,7 +3895,106 @@ struct close_data { __u64 cd_reserved[8]; }; -void lustre_swab_close_data(struct close_data *data); +/* Update llog format */ +struct update_op { + struct lu_fid uop_fid; + __u16 uop_type; + __u16 uop_param_count; + __u16 uop_params_off[0]; +}; + +struct update_ops { + struct update_op uops_op[0]; +}; + +struct update_params { + struct object_update_param up_params[0]; +}; + +enum update_records_flag { + UPDATE_RECORD_CONTINUE = 1 >> 0, +}; +/* + * This is the update record format used to store the updates in + * disk. All updates of the operation will be stored in ur_ops. + * All of parameters for updates of the operation will be stored + * in ur_params. + * To save the space of the record, parameters in ur_ops will only + * remember their offset in ur_params, so to avoid storing duplicate + * parameters in ur_params, which can help us save a lot space for + * operation like creating striped directory. + */ +struct update_records { + __u64 ur_master_transno; + __u64 ur_batchid; + __u32 ur_flags; + /* If the operation includes multiple updates, then ur_index + * means the index of the update inside the whole updates. */ + __u32 ur_index; + __u32 ur_update_count; + __u32 ur_param_count; + struct update_ops ur_ops; + /* Note ur_ops has a variable size, so comment out + * the following ur_params, in case some use it directly + * update_records->ur_params + * + * struct update_params ur_params; + */ +}; + +struct llog_update_record { + struct llog_rec_hdr lur_hdr; + struct update_records lur_update_rec; + /* Note ur_update_rec has a variable size, so comment out + * the following ur_tail, in case someone use it directly + * + * struct llog_rec_tail lur_tail; + */ +}; + +/* nodemap records, uses 32 byte record length */ +#define LUSTRE_NODEMAP_NAME_LENGTH 16 +struct nodemap_cluster_rec { + char ncr_name[LUSTRE_NODEMAP_NAME_LENGTH + 1]; + __u8 ncr_flags; + __u16 ncr_padding1; + __u32 ncr_padding2; + __u32 ncr_squash_uid; + __u32 ncr_squash_gid; +}; + +/* lnet_nid_t is 8 bytes */ +struct nodemap_range_rec { + lnet_nid_t nrr_start_nid; + lnet_nid_t nrr_end_nid; + __u64 nrr_padding1; + __u64 nrr_padding2; +}; + +struct nodemap_id_rec { + __u32 nir_id_fs; + __u32 nir_padding1; + __u64 nir_padding2; + __u64 nir_padding3; + __u64 nir_padding4; +}; + +struct nodemap_global_rec { + __u8 ngr_is_active; + __u8 ngr_padding1; + __u16 ngr_padding2; + __u32 ngr_padding3; + __u64 ngr_padding4; + __u64 ngr_padding5; + __u64 ngr_padding6; +}; + +union nodemap_rec { + struct nodemap_cluster_rec ncr; + struct nodemap_range_rec nrr; + struct nodemap_id_rec nir; + struct nodemap_global_rec ngr; +}; #endif /** @} lustreidl */