#ifndef _LUSTRE_IDL_H_
#define _LUSTRE_IDL_H_
-#if !defined(LPU64)
#include <libcfs/libcfs.h> /* for LPUX64, etc */
-#endif
-
-/* Defn's shared with user-space. */
-#include <lustre/lustre_user.h>
-
+#include <lnet/types.h>
+#include <lustre/lustre_user.h> /* Defn's shared with user-space. */
#include <lustre/lustre_errno.h>
+#include <lustre_ver.h>
/*
* GENERAL STUFF
#define SEQ_DATA_PORTAL 31
#define SEQ_CONTROLLER_PORTAL 32
#define MGS_BULK_PORTAL 33
-#define OST_IDX_PORTAL 34
/* Portal 63 is reserved for the Cray Inc DVS - nic@cray.com, roe@cray.com, n8851@cray.com */
#define LUSTRE_LOG_VERSION 0x00050000
#define LUSTRE_MGS_VERSION 0x00060000
-typedef __u32 mdsno_t;
-typedef __u64 seqno_t;
typedef __u64 obd_id;
typedef __u64 obd_seq;
typedef __s64 obd_time;
return range->lsr_flags & LU_SEQ_RANGE_MASK;
}
-static inline int fld_range_is_ost(const struct lu_seq_range *range)
+static inline bool fld_range_is_ost(const struct lu_seq_range *range)
{
return fld_range_type(range) == LU_SEQ_RANGE_OST;
}
-static inline int fld_range_is_mdt(const struct lu_seq_range *range)
+static inline bool fld_range_is_mdt(const struct lu_seq_range *range)
{
return fld_range_type(range) == LU_SEQ_RANGE_MDT;
}
static inline __u64 range_space(const struct lu_seq_range *range)
{
- return range->lsr_end - range->lsr_start;
+ return range->lsr_end - range->lsr_start;
}
/**
* check if given seq id \a s is within given range \a r
*/
-static inline int range_within(const struct lu_seq_range *range,
- __u64 s)
+static inline bool range_within(const struct lu_seq_range *range,
+ __u64 s)
{
- return s >= range->lsr_start && s < range->lsr_end;
+ return s >= range->lsr_start && s < range->lsr_end;
}
-static inline int range_is_sane(const struct lu_seq_range *range)
+static inline bool range_is_sane(const struct lu_seq_range *range)
{
- return (range->lsr_end >= range->lsr_start);
+ return range->lsr_end >= range->lsr_start;
}
-static inline int range_is_zero(const struct lu_seq_range *range)
+static inline bool range_is_zero(const struct lu_seq_range *range)
{
- return (range->lsr_start == 0 && range->lsr_end == 0);
+ return range->lsr_start == 0 && range->lsr_end == 0;
}
-static inline int range_is_exhausted(const struct lu_seq_range *range)
-
+static inline bool range_is_exhausted(const struct lu_seq_range *range)
{
- return range_space(range) == 0;
+ return range_space(range) == 0;
}
/* return 0 if two range have the same location */
LMAI_AGENT = 0x00000002, /* agent inode */
LMAI_REMOTE_PARENT = 0x00000004, /* the parent of the object
is on the remote MDT */
+ LMAI_STRIPED = 0x00000008, /* striped directory inode */
};
-#define LMA_INCOMPAT_SUPP (LMAI_AGENT | LMAI_REMOTE_PARENT)
+#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,
FID_OID_DOT_LUSTRE_LPF = 3UL,
};
-static inline int fid_seq_is_mdt0(obd_seq seq)
+static inline bool fid_seq_is_mdt0(obd_seq seq)
{
- return (seq == FID_SEQ_OST_MDT0);
+ return seq == FID_SEQ_OST_MDT0;
}
-static inline int fid_seq_is_mdt(const __u64 seq)
+static inline bool fid_seq_is_mdt(__u64 seq)
{
return seq == FID_SEQ_OST_MDT0 || seq >= FID_SEQ_NORMAL;
};
-static inline int fid_seq_is_echo(obd_seq seq)
+static inline bool fid_seq_is_echo(obd_seq seq)
{
- return (seq == FID_SEQ_ECHO);
+ return seq == FID_SEQ_ECHO;
}
-static inline int fid_is_echo(const struct lu_fid *fid)
+static inline bool fid_is_echo(const struct lu_fid *fid)
{
return fid_seq_is_echo(fid_seq(fid));
}
-static inline int fid_seq_is_llog(obd_seq seq)
+static inline bool fid_seq_is_llog(obd_seq seq)
{
- return (seq == FID_SEQ_LLOG);
+ return seq == FID_SEQ_LLOG;
}
-static inline int fid_is_llog(const struct lu_fid *fid)
+static inline bool fid_is_llog(const struct lu_fid *fid)
{
/* file with OID == 0 is not llog but contains last oid */
return fid_seq_is_llog(fid_seq(fid)) && fid_oid(fid) > 0;
}
-static inline int fid_seq_is_rsvd(const __u64 seq)
+static inline bool fid_seq_is_rsvd(__u64 seq)
{
- return (seq > FID_SEQ_OST_MDT0 && seq <= FID_SEQ_RSVD);
+ return seq > FID_SEQ_OST_MDT0 && seq <= FID_SEQ_RSVD;
};
-static inline int fid_seq_is_special(const __u64 seq)
+static inline bool fid_seq_is_special(__u64 seq)
{
return seq == FID_SEQ_SPECIAL;
};
-static inline int fid_seq_is_local_file(const __u64 seq)
+static inline bool fid_seq_is_local_file(__u64 seq)
{
return seq == FID_SEQ_LOCAL_FILE ||
seq == FID_SEQ_LOCAL_NAME;
};
-static inline int fid_seq_is_root(const __u64 seq)
+static inline bool fid_seq_is_root(__u64 seq)
{
return seq == FID_SEQ_ROOT;
}
-static inline int fid_seq_is_dot(const __u64 seq)
+static inline bool fid_seq_is_dot(__u64 seq)
{
return seq == FID_SEQ_DOT_LUSTRE;
}
-static inline int fid_seq_is_default(const __u64 seq)
+static inline bool fid_seq_is_default(__u64 seq)
{
return seq == FID_SEQ_LOV_DEFAULT;
}
-static inline int fid_is_mdt0(const struct lu_fid *fid)
+static inline bool fid_is_mdt0(const struct lu_fid *fid)
{
- return fid_seq_is_mdt0(fid_seq(fid));
+ return fid_seq_is_mdt0(fid_seq(fid));
}
static inline void lu_root_fid(struct lu_fid *fid)
* \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)
+static inline bool fid_seq_is_igif(__u64 seq)
{
- return seq >= FID_SEQ_IGIF && seq <= FID_SEQ_IGIF_MAX;
+ return seq >= FID_SEQ_IGIF && seq <= FID_SEQ_IGIF_MAX;
}
-static inline int fid_is_igif(const struct lu_fid *fid)
+static inline bool fid_is_igif(const struct lu_fid *fid)
{
- return fid_seq_is_igif(fid_seq(fid));
+ return fid_seq_is_igif(fid_seq(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)
+static inline bool fid_seq_is_idif(__u64 seq)
{
- return seq >= FID_SEQ_IDIF && seq <= FID_SEQ_IDIF_MAX;
+ return seq >= FID_SEQ_IDIF && seq <= FID_SEQ_IDIF_MAX;
}
-static inline int fid_is_idif(const struct lu_fid *fid)
+static inline bool fid_is_idif(const struct lu_fid *fid)
{
- return fid_seq_is_idif(fid_seq(fid));
+ return fid_seq_is_idif(fid_seq(fid));
}
-static inline int fid_is_local_file(const struct lu_fid *fid)
+static inline bool fid_is_local_file(const struct lu_fid *fid)
{
return fid_seq_is_local_file(fid_seq(fid));
}
-static inline int fid_seq_is_norm(const __u64 seq)
+static inline bool fid_seq_is_norm(__u64 seq)
{
- return (seq >= FID_SEQ_NORMAL);
+ return (seq >= FID_SEQ_NORMAL);
}
-static inline int fid_is_norm(const struct lu_fid *fid)
+static inline bool fid_is_norm(const struct lu_fid *fid)
{
- return fid_seq_is_norm(fid_seq(fid));
+ return fid_seq_is_norm(fid_seq(fid));
}
static inline int fid_is_layout_rbtree(const struct lu_fid *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);
+ 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;
+ return ((__u64)ver << 48) | ((seq & 0xffff) << 32) | oid;
}
static inline __u32 idif_ost_idx(obd_seq seq)
* been in production for years. This can handle create rates
* of 1M objects/s/OST for 9 years, or combinations thereof. */
if (oid >= IDIF_MAX_OID) {
- CERROR("bad MDT0 id, "DOSTID" ost_idx:%u\n",
- POSTID(ostid), ost_idx);
- return -EBADF;
+ CERROR("bad MDT0 id(1), "DOSTID" ost_idx:%u\n",
+ POSTID(ostid), ost_idx);
+ return -EBADF;
}
fid->f_seq = fid_idif_seq(oid, ost_idx);
/* truncate to 32 bits by assignment */
* 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, "DOSTID" ost_idx:%u\n",
+ CERROR("bad MDT0 id(2), "DOSTID" ost_idx:%u\n",
POSTID(ostid), ost_idx);
return -EBADF;
}
}
/* Check whether the fid is for LAST_ID */
-static inline int fid_is_last_id(const struct lu_fid *fid)
+static inline bool fid_is_last_id(const struct lu_fid *fid)
{
- return (fid_oid(fid) == 0);
+ return fid_oid(fid) == 0;
}
/**
dst->f_ver = be32_to_cpu(fid_ver(src));
}
-static inline int fid_is_sane(const struct lu_fid *fid)
+static inline bool fid_is_sane(const struct lu_fid *fid)
{
return fid != NULL &&
((fid_seq(fid) >= FID_SEQ_START && fid_ver(fid) == 0) ||
fid_seq_is_rsvd(fid_seq(fid)));
}
-static inline int fid_is_zero(const struct lu_fid *fid)
-{
- return fid_seq(fid) == 0 && fid_oid(fid) == 0;
-}
-
extern void lustre_swab_lu_fid(struct lu_fid *fid);
extern void lustre_swab_lu_seq_range(struct lu_seq_range *range);
-static inline int lu_fid_eq(const struct lu_fid *f0, const struct lu_fid *f1)
+static inline bool lu_fid_eq(const struct lu_fid *f0, const struct lu_fid *f1)
{
return memcmp(f0, f1, sizeof *f0) == 0;
}
static inline void ostid_cpu_to_le(const struct ost_id *src_oi,
struct ost_id *dst_oi)
{
- if (fid_seq_is_mdt0(ostid_seq(src_oi))) {
+ if (fid_seq_is_mdt0(src_oi->oi.oi_seq)) {
dst_oi->oi.oi_id = cpu_to_le64(src_oi->oi.oi_id);
dst_oi->oi.oi_seq = cpu_to_le64(src_oi->oi.oi_seq);
} else {
static inline void ostid_le_to_cpu(const struct ost_id *src_oi,
struct ost_id *dst_oi)
{
- if (fid_seq_is_mdt0(ostid_seq(src_oi))) {
+ if (fid_seq_is_mdt0(src_oi->oi.oi_seq)) {
dst_oi->oi.oi_id = le64_to_cpu(src_oi->oi.oi_id);
dst_oi->oi.oi_seq = le64_to_cpu(src_oi->oi.oi_seq);
} else {
return next;
}
-static inline int lu_dirent_calc_size(int namelen, __u16 attr)
+static inline size_t lu_dirent_calc_size(size_t namelen, __u16 attr)
{
- int size;
+ size_t size;
- if (attr & LUDA_TYPE) {
- const unsigned align = sizeof(struct luda_type) - 1;
+ if (attr & LUDA_TYPE) {
+ const size_t align = sizeof(struct luda_type) - 1;
size = (sizeof(struct lu_dirent) + namelen + align) & ~align;
size += sizeof(struct luda_type);
} else
return (size + 7) & ~7;
}
-static inline int lu_dirent_size(struct lu_dirent *ent)
-{
- if (le16_to_cpu(ent->lde_reclen) == 0) {
- return lu_dirent_calc_size(le16_to_cpu(ent->lde_namelen),
- le32_to_cpu(ent->lde_attrs));
- }
- return le16_to_cpu(ent->lde_reclen);
-}
-
#define MDS_DIR_END_OFF 0xfffffffffffffffeULL
/**
};
#define DEAD_HANDLE_MAGIC 0xdeadbeefcafebabeULL
-static inline int lustre_handle_is_used(struct lustre_handle *lh)
+static inline bool lustre_handle_is_used(const struct lustre_handle *lh)
{
- return lh->cookie != 0ull;
+ return lh->cookie != 0;
}
-static inline int lustre_handle_equal(const struct lustre_handle *lh1,
- const struct lustre_handle *lh2)
+static inline bool lustre_handle_equal(const struct lustre_handle *lh1,
+ const struct lustre_handle *lh2)
{
- return lh1->cookie == lh2->cookie;
+ return lh1->cookie == lh2->cookie;
}
static inline void lustre_handle_copy(struct lustre_handle *tgt,
- struct lustre_handle *src)
+ const struct lustre_handle *src)
{
- tgt->cookie = src->cookie;
+ tgt->cookie = src->cookie;
}
/* flags for lm_flags */
/* without gss, ptlrpc_body is put at the first buffer. */
#define PTLRPC_NUM_VERSIONS 4
-#define JOBSTATS_JOBID_SIZE 32 /* 32 bytes string */
struct ptlrpc_body_v3 {
struct lustre_handle pb_handle;
__u32 pb_type;
__u64 pb_pre_versions[PTLRPC_NUM_VERSIONS];
/* padding for future needs */
__u64 pb_padding[4];
- char pb_jobid[JOBSTATS_JOBID_SIZE];
+ char pb_jobid[LUSTRE_JOBID_SIZE];
};
#define ptlrpc_body ptlrpc_body_v3
#define OBD_CONNECT_OPEN_BY_FID 0x20000000000000ULL /* open by fid won't pack
name in request */
#define OBD_CONNECT_LFSCK 0x40000000000000ULL/* support online LFSCK */
+#define OBD_CONNECT_UNLINK_CLOSE 0x100000000000000ULL/* close file in unlink */
+#define OBD_CONNECT_DIR_STRIPE 0x400000000000000ULL /* striped DNE dir */
/* XXX README XXX:
* Please DO NOT add flag values here before first ensuring that this same
OBD_CONNECT_LVB_TYPE | OBD_CONNECT_LAYOUTLOCK |\
OBD_CONNECT_PINGLESS | OBD_CONNECT_MAX_EASIZE |\
OBD_CONNECT_FLOCK_DEAD | \
- OBD_CONNECT_DISP_STRIPE | OBD_CONNECT_LFSCK)
+ OBD_CONNECT_DISP_STRIPE | OBD_CONNECT_LFSCK | \
+ OBD_CONNECT_OPEN_BY_FID | \
+ OBD_CONNECT_DIR_STRIPE)
#define OST_CONNECT_SUPPORTED (OBD_CONNECT_SRVLOCK | OBD_CONNECT_GRANT | \
OBD_CONNECT_REQPORTAL | OBD_CONNECT_VERSION | \
#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))
-#define OBD_OCD_VERSION_MAJOR(version) ((int)((version)>>24)&255)
-#define OBD_OCD_VERSION_MINOR(version) ((int)((version)>>16)&255)
-#define OBD_OCD_VERSION_PATCH(version) ((int)((version)>>8)&255)
-#define OBD_OCD_VERSION_FIX(version) ((int)(version)&255)
-
/* This structure is used for both request and reply.
*
* If we eventually have separate connect data for different types, which we
OBD_FL_LOCAL_MASK = 0xF0000000,
};
-#define LOV_MAGIC_V1 0x0BD10BD0
-#define LOV_MAGIC LOV_MAGIC_V1
-#define LOV_MAGIC_JOIN_V1 0x0BD20BD0
-#define LOV_MAGIC_V3 0x0BD30BD0
-#define LOV_MAGIC_MIGRATE 0x0BD40BD0
+/*
+ * All LOV EA magics should have the same postfix, if some new version
+ * Lustre instroduces new LOV EA magic, then when down-grade to an old
+ * Lustre, even though the old version system does not recognizes such
+ * new magic, it still can distinguish the corrupted cases by checking
+ * the magic's postfix.
+ */
+#define LOV_MAGIC_MAGIC 0x0BD0
+#define LOV_MAGIC_MASK 0xFFFF
+
+#define LOV_MAGIC_V1 (0x0BD10000 | LOV_MAGIC_MAGIC)
+#define LOV_MAGIC_JOIN_V1 (0x0BD20000 | LOV_MAGIC_MAGIC)
+#define LOV_MAGIC_V3 (0x0BD30000 | LOV_MAGIC_MAGIC)
+#define LOV_MAGIC_MIGRATE (0x0BD40000 | LOV_MAGIC_MAGIC)
+/* reserved for specifying OSTs */
+#define LOV_MAGIC_SPECIFIC (0x0BD50000 | LOV_MAGIC_MAGIC)
+#define LOV_MAGIC LOV_MAGIC_V1
/*
* magic for fully defined striping
#define LOV_MAGIC_V1_DEF 0x0CD10BD0
#define LOV_MAGIC_V3_DEF 0x0CD30BD0
-#define LOV_PATTERN_RAID0 0x001 /* stripes are used round-robin */
-#define LOV_PATTERN_RAID1 0x002 /* stripes are mirrors of each other */
-#define LOV_PATTERN_FIRST 0x100 /* first stripe is not in round-robin */
-#define LOV_PATTERN_CMOBD 0x200
-
-#define LOV_PATTERN_F_MASK 0xffff0000
-#define LOV_PATTERN_F_RELEASED 0x80000000 /* HSM released file */
-
#define lov_pattern(pattern) (pattern & ~LOV_PATTERN_F_MASK)
#define lov_pattern_flags(pattern) (pattern & LOV_PATTERN_F_MASK)
oi->oi.oi_id = oid;
}
-static inline __u64 lmm_oi_id(struct ost_id *oi)
+static inline __u64 lmm_oi_id(const struct ost_id *oi)
{
return oi->oi.oi_id;
}
-static inline __u64 lmm_oi_seq(struct ost_id *oi)
+static inline __u64 lmm_oi_seq(const struct ost_id *oi)
{
return oi->oi.oi_seq;
}
static inline void lmm_oi_le_to_cpu(struct ost_id *dst_oi,
- struct ost_id *src_oi)
+ const struct ost_id *src_oi)
{
dst_oi->oi.oi_id = le64_to_cpu(src_oi->oi.oi_id);
dst_oi->oi.oi_seq = le64_to_cpu(src_oi->oi.oi_seq);
}
static inline void lmm_oi_cpu_to_le(struct ost_id *dst_oi,
- struct ost_id *src_oi)
+ const struct ost_id *src_oi)
{
dst_oi->oi.oi_id = cpu_to_le64(src_oi->oi.oi_id);
dst_oi->oi.oi_seq = cpu_to_le64(src_oi->oi.oi_seq);
#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))
+/* This is the default MDT reply size allocated, should the striping be bigger,
+ * it will be reallocated in mdt_fix_reply.
+ * 100 stripes is a bit less than 2.5k of data */
+#define DEF_REP_MD_SIZE (sizeof(struct lov_mds_md) + \
+ 100 * sizeof(struct lov_ost_data))
+
#define XATTR_NAME_ACL_ACCESS "system.posix_acl_access"
#define XATTR_NAME_ACL_DEFAULT "system.posix_acl_default"
#define XATTR_USER_PREFIX "user."
#define XATTR_TRUSTED_PREFIX "trusted."
#define XATTR_SECURITY_PREFIX "security."
-#define XATTR_LUSTRE_PREFIX "lustre."
#define XATTR_NAME_LOV "trusted.lov"
#define XATTR_NAME_LMA "trusted.lma"
#define XATTR_NAME_VERSION "trusted.version"
#define XATTR_NAME_SOM "trusted.som"
#define XATTR_NAME_HSM "trusted.hsm"
-#define XATTR_NAME_LFSCK_NAMESPACE "trusted.lfsck_namespace"
+#define XATTR_NAME_LFSCK_BITMAP "trusted.lfsck_bitmap"
+
+#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. */
struct lov_mds_md_v3 { /* LOV EA mds/wire data (little-endian) */
__u32 lmm_magic; /* magic number = LOV_MAGIC_V3 */
/* 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 */
+ char lmm_pool_name[LOV_MAXPOOLNAME + 1]; /* must be 32bit aligned */
struct lov_ost_data_v1 lmm_objects[0]; /* per-stripe data */
};
* space for unstable pages; asking
* it to sync quickly */
-#define OBD_OBJECT_EOF 0xffffffffffffffffULL
+#define OBD_OBJECT_EOF LUSTRE_EOF
#define OST_MIN_PRECREATE 32
#define OST_MAX_PRECREATE 20000
/* multiple of 8 bytes => can array */
struct niobuf_remote {
- __u64 offset;
- __u32 len;
- __u32 flags;
+ __u64 rnb_offset;
+ __u32 rnb_len;
+ __u32 rnb_flags;
};
-extern void lustre_swab_niobuf_remote (struct niobuf_remote *nbr);
+void lustre_swab_niobuf_remote(struct niobuf_remote *nbr);
/* lock value block communicated between the filter and llite */
*/
#ifndef QUOTABLOCK_BITS
-#define QUOTABLOCK_BITS 10
+# define QUOTABLOCK_BITS LUSTRE_QUOTABLOCK_BITS
#endif
#ifndef QUOTABLOCK_SIZE
-#define QUOTABLOCK_SIZE (1 << QUOTABLOCK_BITS)
+# define QUOTABLOCK_SIZE LUSTRE_QUOTABLOCK_SIZE
#endif
#ifndef toqb
-#define toqb(x) (((x) + QUOTABLOCK_SIZE - 1) >> QUOTABLOCK_BITS)
+# define toqb lustre_stoqb
#endif
/* The lquota_id structure is an union of all the possible identifier types that
extern void lustre_swab_obd_quotactl(struct obd_quotactl *q);
-#define Q_QUOTACHECK 0x800100 /* deprecated as of 2.4 */
-#define Q_INITQUOTA 0x800101 /* deprecated as of 2.4 */
-#define Q_GETOINFO 0x800102 /* get obd quota info */
-#define Q_GETOQUOTA 0x800103 /* get obd quotas */
-#define Q_FINVALIDATE 0x800104 /* deprecated as of 2.4 */
-
#define Q_COPY(out, in, member) (out)->member = (in)->member
#define QCTL_COPY(out, in) \
MDS_DISCONNECT = 39,
MDS_GETSTATUS = 40,
MDS_STATFS = 41,
- MDS_PIN = 42,
- MDS_UNPIN = 43,
+ MDS_PIN = 42, /* obsolete, never used in a release */
+ MDS_UNPIN = 43, /* obsolete, never used in a release */
MDS_SYNC = 44,
MDS_DONE_WRITING = 45,
MDS_SET_INFO = 46,
MDS_GETXATTR = 49,
MDS_SETXATTR = 50, /* obsolete, now it's MDS_REINT op */
MDS_WRITEPAGE = 51,
- MDS_IS_SUBDIR = 52,
+ MDS_IS_SUBDIR = 52, /* obsolete, never used in a release */
MDS_GET_INFO = 53,
MDS_HSM_STATE_GET = 54,
MDS_HSM_STATE_SET = 55,
};
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 */
- obd_time mtime;
- obd_time atime;
- obd_time ctime;
- __u64 blocks; /* XID, in the case of MDS_READPAGE */
- __u64 ioepoch;
- __u64 t_state; /* transient file state defined in
- * enum md_transient_state
- * was "ino" until 2.4.0 */
- __u32 fsuid;
- __u32 fsgid;
- __u32 capability;
- __u32 mode;
- __u32 uid;
- __u32 gid;
- __u32 flags; /* from vfs for pin/unpin, LUSTRE_BFLAG close */
- __u32 rdev;
- __u32 nlink; /* #bytes to read in the case of MDS_READPAGE */
- __u32 unused2; /* was "generation" until 2.4.0 */
- __u32 suppgid;
- __u32 eadatasize;
- __u32 aclsize;
- __u32 max_mdsize;
- __u32 max_cookiesize;
- __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;
- __u64 padding_9;
- __u64 padding_10;
+ struct lu_fid mbo_fid1;
+ struct lu_fid mbo_fid2;
+ struct lustre_handle mbo_handle;
+ __u64 mbo_valid;
+ __u64 mbo_size; /* Offset, in the case of MDS_READPAGE */
+ obd_time mbo_mtime;
+ obd_time mbo_atime;
+ obd_time mbo_ctime;
+ __u64 mbo_blocks; /* XID, in the case of MDS_READPAGE */
+ __u64 mbo_ioepoch;
+ __u64 mbo_t_state; /* transient file state defined in
+ * enum md_transient_state
+ * was "ino" until 2.4.0 */
+ __u32 mbo_fsuid;
+ __u32 mbo_fsgid;
+ __u32 mbo_capability;
+ __u32 mbo_mode;
+ __u32 mbo_uid;
+ __u32 mbo_gid;
+ __u32 mbo_flags;
+ __u32 mbo_rdev;
+ __u32 mbo_nlink; /* #bytes to read in the case of MDS_READPAGE */
+ __u32 mbo_unused2; /* was "generation" until 2.4.0 */
+ __u32 mbo_suppgid;
+ __u32 mbo_eadatasize;
+ __u32 mbo_aclsize;
+ __u32 mbo_max_mdsize;
+ __u32 mbo_max_cookiesize;
+ __u32 mbo_uid_h; /* high 32-bits of uid, for FUID */
+ __u32 mbo_gid_h; /* high 32-bits of gid, for FUID */
+ __u32 mbo_padding_5; /* also fix lustre_swab_mdt_body */
+ __u64 mbo_padding_6;
+ __u64 mbo_padding_7;
+ __u64 mbo_padding_8;
+ __u64 mbo_padding_9;
+ __u64 mbo_padding_10;
}; /* 216 */
extern void lustre_swab_mdt_body (struct mdt_body *b);
*/
#define MDS_OPEN_RELEASE 02000000000000ULL /* Open the file for HSM release */
+/* lustre internal open flags, which should not be set from user space */
+#define MDS_OPEN_FL_INTERNAL (MDS_OPEN_HAS_EA | MDS_OPEN_HAS_OBJS | \
+ MDS_OPEN_OWNEROVERRIDE | MDS_OPEN_LOCK | \
+ 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 */
extern void lustre_swab_lmv_desc (struct lmv_desc *ld);
-/* lmv structures */
-#define LMV_MAGIC_V1 0x0CD10CD0 /* normal stripe lmv magic */
-#define LMV_USER_MAGIC 0x0CD20CD0 /* default lmv magic*/
-#define LMV_MAGIC_MIGRATE 0x0CD30CD0 /* migrate stripe lmv magic */
+/* LMV layout EA, and it will be stored both in master and slave object */
+struct lmv_mds_md_v1 {
+ __u32 lmv_magic;
+ __u32 lmv_stripe_count;
+ __u32 lmv_master_mdt_index; /* On master object, it is master
+ * MDT index, on slave object, it
+ * is stripe index of the slave obj */
+ __u32 lmv_hash_type; /* dir stripe policy, i.e. indicate
+ * which hash function to be used,
+ * Note: only lower 16 bits is being
+ * used for now. Higher 16 bits will
+ * be used to mark the object status,
+ * for example migrating or dead. */
+ __u32 lmv_layout_version; /* Used for directory restriping */
+ __u32 lmv_padding1;
+ __u64 lmv_padding2;
+ __u64 lmv_padding3;
+ char lmv_pool_name[LOV_MAXPOOLNAME + 1]; /* pool name */
+ struct lu_fid lmv_stripe_fids[0]; /* FIDs for each stripe */
+};
+
+#define LMV_MAGIC_V1 0x0CD20CD0 /* normal stripe lmv magic */
#define LMV_MAGIC LMV_MAGIC_V1
-enum lmv_hash_type {
- LMV_HASH_TYPE_ALL_CHARS = 1,
- LMV_HASH_TYPE_FNV_1A_64 = 2,
- LMV_HASH_TYPE_MIGRATION = 3,
-};
+/* #define LMV_USER_MAGIC 0x0CD30CD0 */
+#define LMV_MAGIC_STRIPE 0x0CD40CD0 /* magic for dir sub_stripe */
+
+/* Right now only the lower part(0-16bits) of lmv_hash_type is being used,
+ * and the higher part will be the flag to indicate the status of object,
+ * for example the object is being migrated. And the hash function
+ * might be interpreted differently with different flags. */
+#define LMV_HASH_TYPE_MASK 0x0000ffff
+
+#define LMV_HASH_FLAG_MIGRATION 0x80000000
+#define LMV_HASH_FLAG_DEAD 0x40000000
+#define LMV_HASH_FLAG_BAD_TYPE 0x20000000
-#define LMV_HASH_NAME_ALL_CHARS "all_char"
-#define LMV_HASH_NAME_FNV_1A_64 "fnv_1a_64"
+/* The striped directory has ever lost its master LMV EA, then LFSCK
+ * re-generated it. This flag is used to indicate such case. It is an
+ * on-disk flag. */
+#define LMV_HASH_FLAG_LOST_LMV 0x10000000
/**
* The FNV-1a hash algorithm is as follows:
return hash;
}
-struct lmv_mds_md_v1 {
- __u32 lmv_magic;
- __u32 lmv_stripe_count; /* stripe count */
- __u32 lmv_master_mdt_index; /* master MDT index */
- __u32 lmv_hash_type; /* dir stripe policy, i.e. indicate
- * which hash function to be used */
- __u32 lmv_layout_version; /* Used for directory restriping */
- __u32 lmv_padding;
- char lmv_pool_name[LOV_MAXPOOLNAME]; /* pool name */
- struct lu_fid lmv_stripe_fids[0]; /* FIDs for each stripe */
-};
-
union lmv_mds_md {
__u32 lmv_magic;
struct lmv_mds_md_v1 lmv_md_v1;
static inline int lmv_mds_md_size(int stripe_count, unsigned int lmm_magic)
{
switch (lmm_magic) {
- case LMV_MAGIC_V1:
- case LMV_MAGIC_MIGRATE: {
+ case LMV_MAGIC_V1:{
struct lmv_mds_md_v1 *lmm1;
return sizeof(*lmm1) + stripe_count *
{
switch (le32_to_cpu(lmm->lmv_magic)) {
case LMV_MAGIC_V1:
- case LMV_MAGIC_MIGRATE:
return le32_to_cpu(lmm->lmv_md_v1.lmv_stripe_count);
case LMV_USER_MAGIC:
return le32_to_cpu(lmm->lmv_user_md.lum_stripe_count);
{
switch (le32_to_cpu(lmm->lmv_magic)) {
case LMV_MAGIC_V1:
- case LMV_MAGIC_MIGRATE:
lmm->lmv_md_v1.lmv_stripe_count = cpu_to_le32(stripe_count);
break;
case LMV_USER_MAGIC:
extern void lustre_swab_ldlm_res_id (struct ldlm_res_id *id);
-static inline int ldlm_res_eq(const struct ldlm_res_id *res0,
- const struct ldlm_res_id *res1)
+static inline bool ldlm_res_eq(const struct ldlm_res_id *res0,
+ const struct ldlm_res_id *res1)
{
- return !memcmp(res0, res1, sizeof(*res0));
+ return memcmp(res0, res1, sizeof(*res0)) == 0;
}
/* lock types */
__u64 gid;
};
-static inline int ldlm_extent_overlap(struct ldlm_extent *ex1,
- struct ldlm_extent *ex2)
+#define LDLM_GID_ANY ((__u64) -1)
+
+static inline int ldlm_extent_overlap(const struct ldlm_extent *ex1,
+ const struct ldlm_extent *ex2)
{
- return (ex1->start <= ex2->end) && (ex2->start <= ex1->end);
+ return ex1->start <= ex2->end && ex2->start <= ex1->end;
}
/* check if @ex1 contains @ex2 */
-static inline int ldlm_extent_contain(struct ldlm_extent *ex1,
- struct ldlm_extent *ex2)
+static inline int ldlm_extent_contain(const struct ldlm_extent *ex1,
+ const struct ldlm_extent *ex2)
{
- return (ex1->start <= ex2->start) && (ex1->end >= ex2->end);
+ return ex1->start <= ex2->start && ex1->end >= ex2->end;
}
struct ldlm_inodebits {
} obd_cmd_t;
#define OBD_FIRST_OPC OBD_PING
-/* catalog of log objects */
+/**
+ * llog contexts indices.
+ *
+ * There is compatibility problem with indexes below, they are not
+ * continuous and must keep their numbers for compatibility needs.
+ * See LU-5218 for details.
+ */
+enum llog_ctxt_id {
+ LLOG_CONFIG_ORIG_CTXT = 0,
+ LLOG_CONFIG_REPL_CTXT = 1,
+ LLOG_MDS_OST_ORIG_CTXT = 2,
+ LLOG_MDS_OST_REPL_CTXT = 3, /* kept just to avoid re-assignment */
+ LLOG_SIZE_ORIG_CTXT = 4,
+ LLOG_SIZE_REPL_CTXT = 5,
+ LLOG_TEST_ORIG_CTXT = 8,
+ LLOG_TEST_REPL_CTXT = 9, /* kept just to avoid re-assignment */
+ LLOG_CHANGELOG_ORIG_CTXT = 12, /**< changelog generation on mdd */
+ LLOG_CHANGELOG_REPL_CTXT = 13, /**< changelog access on clients */
+ /* for multiple changelog consumers */
+ LLOG_CHANGELOG_USER_ORIG_CTXT = 14,
+ LLOG_AGENT_ORIG_CTXT = 15, /**< agent requests generation on cdt */
+ LLOG_MAX_CTXTS
+};
/** Identifier for a single log object */
struct llog_logid {
(rec->lrh_len - sizeof(struct llog_rec_hdr) - \
sizeof(struct llog_rec_tail))
+static inline void *rec_tail(struct llog_rec_hdr *rec)
+{
+ return (void *)((char *)rec + rec->lrh_len -
+ sizeof(struct llog_rec_tail));
+}
+
struct llog_logid_rec {
struct llog_rec_hdr lid_hdr;
struct llog_logid lid_id;
__u32 lsr_uid_h;
__u32 lsr_gid;
__u32 lsr_gid_h;
- __u64 lsr_padding;
+ __u64 lsr_valid;
struct llog_rec_tail lsr_tail;
} __attribute__((packed));
/** changelog record */
struct llog_changelog_rec {
- struct llog_rec_hdr cr_hdr;
- struct changelog_rec cr;
- struct llog_rec_tail cr_tail; /**< for_sizezof_only */
-} __attribute__((packed));
-
-struct llog_changelog_ext_rec {
- struct llog_rec_hdr cr_hdr;
- struct changelog_ext_rec cr;
- struct llog_rec_tail cr_tail; /**< for_sizezof_only */
+ struct llog_rec_hdr cr_hdr;
+ struct changelog_rec cr; /**< Variable length field */
+ struct llog_rec_tail cr_do_not_use; /**< for_sizeof_only */
} __attribute__((packed));
#define CHANGELOG_USER_PREFIX "cl"
ARS_SUCCEED,
};
-static inline char *agent_req_status2name(enum agent_req_status ars)
+static inline const char *agent_req_status2name(enum agent_req_status ars)
{
switch (ars) {
case ARS_WAITING:
LLOG_F_ZAP_WHEN_EMPTY = 0x1,
LLOG_F_IS_CAT = 0x2,
LLOG_F_IS_PLAIN = 0x4,
+ LLOG_F_EXT_JOBID = 0x8,
+
+ LLOG_F_EXT_MASK = LLOG_F_EXT_JOBID,
};
struct llog_log_hdr {
union {
__u32 lr_speed;
__u32 lr_status;
+ __u32 lr_type;
};
__u16 lr_version;
__u16 lr_active;
__u16 lr_param;
__u16 lr_async_windows;
- __u32 lr_padding_1;
+ union {
+ __u32 lr_flags2;
+ __u32 lr_layout_version;
+ };
struct lu_fid lr_fid;
struct lu_fid lr_fid2;
- struct lu_fid lr_fid3;
- __u64 lr_padding_2;
+ union {
+ struct lu_fid lr_fid3;
+ char lr_pool_name[LOV_MAXPOOLNAME + 1];
+ };
+ __u32 lr_stripe_count;
+ __u32 lr_hash_type;
__u64 lr_padding_3;
};
LE_PEER_EXIT = 9,
LE_CONDITIONAL_DESTROY = 10,
LE_PAIRS_VERIFY = 11,
+ LE_CREATE_ORPHAN = 12,
+ LE_SKIP_NLINK_DECLARE = 13,
+ LE_SKIP_NLINK = 14,
+ LE_SET_LMV_MASTER = 15,
+ LE_SET_LMV_SLAVE = 16,
};
enum lfsck_event_flags {
LEF_TO_OST = 0x00000001,
LEF_FROM_OST = 0x00000002,
+ LEF_SET_LMV_HASH = 0x00000004,
+ LEF_SET_LMV_ALL = 0x00000008,
+ LEF_RECHECK_NAME_HASH = 0x00000010,
};
-static inline void lustre_set_wire_obdo(struct obd_connect_data *ocd,
+static inline void lustre_set_wire_obdo(const struct obd_connect_data *ocd,
struct obdo *wobdo,
const struct obdo *lobdo)
{
}
}
-static inline void lustre_get_wire_obdo(struct obd_connect_data *ocd,
+static inline void lustre_get_wire_obdo(const struct obd_connect_data *ocd,
struct obdo *lobdo,
const struct obdo *wobdo)
{
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);
II_FL_VARKEY = 1 << 1, /* keys can be of variable size */
II_FL_VARREC = 1 << 2, /* records can be of variable size */
II_FL_NONUNQ = 1 << 3, /* index supports non-unique keys */
+ II_FL_NOKEY = 1 << 4, /* client doesn't care about key */
};
#define LIP_MAGIC 0x8A6D6B6C
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. */
+ if (obj->l_ost_oi.oi.oi_id == 0 && obj->l_ost_oi.oi.oi_seq == 0 &&
+ obj->l_ost_idx == 0 && obj->l_ost_gen == 0)
+ return true;
+
+ return false;
+}
+
/* lustre_capa::lc_hmac_alg */
enum {
CAPA_HMAC_ALG_SHA1 = 1, /**< sha1 algorithm */
void lustre_swab_fid2path (struct getinfo_fid2path *gf);
+/** path2parent request/reply structures */
+struct getparent {
+ struct lu_fid gp_fid; /**< parent FID */
+ __u32 gp_linkno; /**< hardlink number */
+ __u32 gp_name_size; /**< size of the name field */
+ char gp_name[0]; /**< zero-terminated link name */
+} __attribute__((packed));
+
enum {
LAYOUT_INTENT_ACCESS = 0,
LAYOUT_INTENT_READ = 1,
*/
/**
- * Maximum number of updates per UPDATE_OBJ RPC
- */
-#define OUT_UPDATE_PER_TRANS_MAX 10
-
-/**
* Type of each update
*/
enum update_type {
OUT_INDEX_INSERT = 10,
OUT_INDEX_DELETE = 11,
OUT_WRITE = 12,
+ OUT_XATTR_DEL = 13,
OUT_LAST
};
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 */
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_size(const struct object_update *update)
+{
+ const struct object_update_param *param;
+ size_t size;
+ unsigned int i;
+
+ size = offsetof(struct object_update, ou_params[0]);
+ for (i = 0; i < update->ou_params_count; i++) {
+ param = (struct object_update_param *)((char *)update + size);
+ size += object_update_param_size(param);
+ }
+
+ return size;
+}
+
+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;
+}
+
+
/* the result of object update */
struct object_update_result {
__u32 our_rc;
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;
+}
+
/** layout swap request structure
* fid1 and fid2 are in mdt_body
*/
git://git.whamcloud.com / fs / lustre-release.git / blobdiff