X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Finclude%2Flustre%2Flustre_user.h;h=500082c57ec6c473dab637b176a251f75d21e0fe;hp=eab9d3c7a2a6b9e58244d412aed451b89668fdbf;hb=22b4247fe2d724a192661a911cd295c1bb566f97;hpb=cc6ce9c787a9a119ac2df673d68114908c34b0a8 diff --git a/lustre/include/lustre/lustre_user.h b/lustre/include/lustre/lustre_user.h index eab9d3c..500082c 100644 --- a/lustre/include/lustre/lustre_user.h +++ b/lustre/include/lustre/lustre_user.h @@ -1,6 +1,4 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: - * +/* * GPL HEADER START * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. @@ -28,9 +26,8 @@ /* * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. - */ -/* - * Copyright (c) 2011 Whamcloud, Inc. + * + * Copyright (c) 2010, 2012, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -99,7 +96,9 @@ struct obd_statfs { __u32 os_namelen; __u64 os_maxbytes; __u32 os_state; /**< obd_statfs_state OS_STATE_* flag */ - __u32 os_spare1; + __u32 os_fprecreated; /* objs available now to the caller */ + /* used in QoS code to find preferred + * OSTs */ __u32 os_spare2; __u32 os_spare3; __u32 os_spare4; @@ -110,6 +109,40 @@ struct obd_statfs { __u32 os_spare9; }; +/** + * File IDentifier. + * + * FID is a cluster-wide unique identifier of a file or an object (stripe). + * FIDs are never reused. + **/ +struct lu_fid { + /** + * FID sequence. Sequence is a unit of migration: all files (objects) + * with FIDs from a given sequence are stored on the same server. + * Lustre should support 2^64 objects, so even if each sequence + * has only a single object we can still enumerate 2^64 objects. + **/ + __u64 f_seq; + /* FID number within sequence. */ + __u32 f_oid; + /** + * FID version, used to distinguish different versions (in the sense + * of snapshots, etc.) of the same file system object. Not currently + * used. + **/ + __u32 f_ver; +}; + +struct filter_fid { + struct lu_fid ff_parent; /* ff_parent.f_ver == file stripe number */ + __u64 ff_objid; + __u64 ff_seq; +}; + +/* Userspace should treat lu_fid as opaque, and only use the following methods + * to print or parse them. Other functions (e.g. compare, swab) could be moved + * here from lustre_idl.h if needed. */ +typedef struct lu_fid lustre_fid; /* * The ioctl naming rules: @@ -153,12 +186,30 @@ struct obd_statfs { #define LL_IOC_PATH2FID _IOR ('f', 173, long) #define LL_IOC_GET_CONNECT_FLAGS _IOWR('f', 174, __u64 *) #define LL_IOC_GET_MDTIDX _IOR ('f', 175, int) -#define LL_IOC_HSM_CT_START _IOW ('f', 176,struct lustre_kernelcomm) -/* see for ioctl numbers 177-210 */ +/* see for ioctl numbers 177-210 */ -#define LL_STATFS_MDC 1 +#define LL_IOC_HSM_STATE_GET _IOR('f', 211, struct hsm_user_state) +#define LL_IOC_HSM_STATE_SET _IOW('f', 212, struct hsm_state_set) +#define LL_IOC_HSM_CT_START _IOW('f', 213, struct lustre_kernelcomm) +#define LL_IOC_HSM_COPY_START _IOW('f', 214, struct hsm_copy *) +#define LL_IOC_HSM_COPY_END _IOW('f', 215, struct hsm_copy *) +#define LL_IOC_HSM_PROGRESS _IOW('f', 216, struct hsm_user_request) +#define LL_IOC_HSM_REQUEST _IOW('f', 217, struct hsm_user_request) +#define LL_IOC_DATA_VERSION _IOR('f', 218, struct ioc_data_version) +#define LL_IOC_LOV_SWAP_LAYOUTS _IOW('f', 219, \ + struct lustre_swap_layouts) +#define LL_IOC_HSM_ACTION _IOR('f', 220, \ + struct hsm_current_action) +/* see for ioctl numbers 221-232 */ + +#define LL_IOC_LMV_SETSTRIPE _IOWR('f', 240, struct lmv_user_md) +#define LL_IOC_LMV_GETSTRIPE _IOWR('f', 241, struct lmv_user_md) +#define LL_IOC_REMOVE_ENTRY _IOWR('f', 242, __u64) + +#define LL_STATFS_LMV 1 #define LL_STATFS_LOV 2 +#define LL_STATFS_NODELAY 4 #define IOC_MDC_TYPE 'i' #define IOC_MDC_LOOKUP _IOWR(IOC_MDC_TYPE, 20, struct obd_device *) @@ -170,7 +221,16 @@ struct obd_statfs { #define LL_IOC_OBD_STATFS IOC_OBD_STATFS #define IOC_MDC_GETSTRIPE IOC_MDC_GETFILESTRIPE -#define O_LOV_DELAY_CREATE 0100000000 /* hopefully this does not conflict */ + +#define MAX_OBD_NAME 128 /* If this changes, a NEW ioctl must be added */ + +/* Hopefully O_LOV_DELAY_CREATE does not conflict with standard O_xxx flags. + * Previously it was defined as 0100000000 and conflicts with FMODE_NONOTIFY + * which was added since kernel 2.6.36, so we redefine it as 020000000. + * To be compatible with old version's statically linked binary, finally we + * define it as (020000000 | 0100000000). + * */ +#define O_LOV_DELAY_CREATE 0120000000 #define LL_FILE_IGNORE_LOCK 0x00000001 #define LL_FILE_GROUP_LOCKED 0x00000002 @@ -184,6 +244,9 @@ struct obd_statfs { #define LOV_USER_MAGIC_JOIN_V1 0x0BD20BD0 #define LOV_USER_MAGIC_V3 0x0BD30BD0 +#define LMV_MAGIC_V1 0x0CD10CD0 /*normal stripe lmv magic */ +#define LMV_USER_MAGIC 0x0CD20CD0 /*default lmv magic*/ + #define LOV_PATTERN_RAID0 0x001 #define LOV_PATTERN_RAID1 0x002 #define LOV_PATTERN_FIRST 0x100 @@ -191,6 +254,22 @@ struct obd_statfs { #define LOV_MAXPOOLNAME 16 #define LOV_POOLNAMEF "%.16s" +#define LOV_MIN_STRIPE_BITS 16 /* maximum PAGE_SIZE (ia64), power of 2 */ +#define LOV_MIN_STRIPE_SIZE (1 << LOV_MIN_STRIPE_BITS) +#define LOV_MAX_STRIPE_COUNT_OLD 160 +/* This calculation is crafted so that input of 4096 will result in 160 + * which in turn is equal to old maximal stripe count. + * XXX: In fact this is too simpified for now, what it also need is to get + * ea_type argument to clearly know how much space each stripe consumes. + * + * The limit of 12 pages is somewhat arbitrary, but is a reasonably large + * allocation that is sufficient for the current generation of systems. + * + * (max buffer size - lov+rpc header) / sizeof(struct lov_ost_data_v1) */ +#define LOV_MAX_STRIPE_COUNT 2000 /* ((12 * 4096 - 256) / 24) */ +#define LOV_ALL_STRIPES 0xffff /* only valid for directories */ +#define LOV_V1_INSANE_STRIPE_COUNT 65532 /* maximum stripe count bz13933 */ + #define lov_user_ost_data lov_user_ost_data_v1 struct lov_user_ost_data_v1 { /* per-stripe data structure */ __u64 l_object_id; /* OST object ID */ @@ -200,6 +279,7 @@ struct lov_user_ost_data_v1 { /* per-stripe data structure */ } __attribute__((packed)); #define lov_user_md lov_user_md_v1 +#define lmm_stripe_offset u.lum_stripe_offset struct lov_user_md_v1 { /* LOV EA user data (host-endian) */ __u32 lmm_magic; /* magic number = LOV_USER_MAGIC_V1 */ __u32 lmm_pattern; /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */ @@ -207,7 +287,12 @@ struct lov_user_md_v1 { /* LOV EA user data (host-endian) */ __u64 lmm_object_seq; /* LOV object seq */ __u32 lmm_stripe_size; /* size of stripe in bytes */ __u16 lmm_stripe_count; /* num stripes in use for this object */ - __u16 lmm_stripe_offset; /* starting stripe offset in lmm_objects */ + union { + __u16 lum_stripe_offset; /* starting stripe offset in + * lmm_objects, use when writing */ + __u16 lum_layout_gen; /* layout generation number + * used when reading */ + } u; struct lov_user_ost_data_v1 lmm_objects[0]; /* per-stripe data */ } __attribute__((packed, __may_alias__)); @@ -218,7 +303,12 @@ struct lov_user_md_v3 { /* LOV EA user data (host-endian) */ __u64 lmm_object_seq; /* LOV object seq */ __u32 lmm_stripe_size; /* size of stripe in bytes */ __u16 lmm_stripe_count; /* num stripes in use for this object */ - __u16 lmm_stripe_offset; /* starting stripe offset in lmm_objects */ + union { + __u16 lum_stripe_offset; /* starting stripe offset in + * lmm_objects, use when writing */ + __u16 lum_layout_gen; /* layout generation number + * used when reading */ + } u; char lmm_pool_name[LOV_MAXPOOLNAME]; /* pool name */ struct lov_user_ost_data_v1 lmm_objects[0]; /* per-stripe data */ } __attribute__((packed)); @@ -239,6 +329,41 @@ struct lov_user_mds_data_v3 { } __attribute__((packed)); #endif +/* keep this to be the same size as lov_user_ost_data_v1 */ +struct lmv_user_mds_data { + struct lu_fid lum_fid; + __u32 lum_padding; + __u32 lum_mds; +}; + +/* lum_type */ +enum { + LMV_STRIPE_TYPE = 0, + LMV_DEFAULT_TYPE = 1, +}; + +#define lmv_user_md lmv_user_md_v1 +struct lmv_user_md_v1 { + __u32 lum_magic; /* must be the first field */ + __u32 lum_stripe_count; /* dirstripe count */ + __u32 lum_stripe_offset; /* MDT idx for default dirstripe */ + __u32 lum_hash_type; /* Dir stripe policy */ + __u32 lum_type; /* LMV type: default or normal */ + __u32 lum_padding1; + __u32 lum_padding2; + __u32 lum_padding3; + char lum_pool_name[LOV_MAXPOOLNAME]; + struct lmv_user_mds_data lum_objects[0]; +}; + +static inline int lmv_user_md_size(int stripes, int lmm_magic) +{ + return sizeof(struct lmv_user_md) + + stripes * sizeof(struct lmv_user_mds_data); +} + +extern void lustre_swab_lmv_user_md(struct lmv_user_md *lum); + struct ll_recreate_obj { __u64 lrc_id; __u32 lrc_ost_idx; @@ -301,41 +426,6 @@ static inline void obd_uuid2fsname(char *buf, char *uuid, int buflen) *p = '\0'; } -/** - * File IDentifier. - * - * FID is a cluster-wide unique identifier of a file or an object (stripe). - * FIDs are never reused. - */ -struct lu_fid { - /** - * FID sequence. Sequence is a unit of migration: all files (objects) - * with FIDs from a given sequence are stored on the same server. - * Lustre should support 2^64 objects, so even if each sequence - * has only a single object we can still enumerate 2^64 objects. - */ - __u64 f_seq; - /** FID number within sequence. */ - __u32 f_oid; - /** - * FID version, used to distinguish different versions (in the sense - * of snapshots, etc.) of the same file system object. Not currently - * used. - */ - __u32 f_ver; -}; - -struct filter_fid { - struct lu_fid ff_parent; /* ff_parent.f_ver == file stripe number */ - __u64 ff_objid; - __u64 ff_seq; -}; - -/* Userspace should treat lu_fid as opaque, and only use the following methods - to print or parse them. Other functions (e.g. compare, swab) could be moved - here from lustre_idl.h if needed. */ -typedef struct lu_fid lustre_fid; - /* printf display format e.g. printf("file FID is "DFID"\n", PFID(fid)); */ #define DFID_NOBRACE LPX64":0x%x:0x%x" @@ -429,6 +519,14 @@ enum { #endif /* !__KERNEL__ */ +/* lustre volatile file support + * file name header: .^L^S^T^R:volatile" + */ +#define LUSTRE_VOLATILE_HDR ".\x0c\x13\x14\x12:VOLATILE" +#define LUSTRE_VOLATILE_HDR_LEN 14 +/* hdr + MDT index */ +#define LUSTRE_VOLATILE_IDX LUSTRE_VOLATILE_HDR":%.4X:" + typedef enum lustre_quota_version { LUSTRE_QUOTA_V2 = 1 } lustre_quota_version_t; @@ -475,6 +573,12 @@ struct if_quotactl { struct obd_uuid obd_uuid; }; +struct lustre_swap_layouts { + __u64 sl_flags; + __u32 sl_fd; + __u32 sl_gid; +}; + /********* Changelogs **********/ /** Changelog record types */ @@ -503,23 +607,29 @@ enum changelog_rec_type { }; static inline const char *changelog_type2str(int type) { - static const char *changelog_str[] = { - "MARK", "CREAT", "MKDIR", "HLINK", "SLINK", "MKNOD", "UNLNK", - "RMDIR", "RNMFM", "RNMTO", "OPEN", "CLOSE", "IOCTL", "TRUNC", - "SATTR", "XATTR", "HSM", "MTIME", "CTIME", "ATIME" }; - if (type >= 0 && type < CL_LAST) - return changelog_str[type]; - return NULL; + static const char *changelog_str[] = { + "MARK", "CREAT", "MKDIR", "HLINK", "SLINK", "MKNOD", "UNLNK", + "RMDIR", "RENME", "RNMTO", "OPEN", "CLOSE", "IOCTL", "TRUNC", + "SATTR", "XATTR", "HSM", "MTIME", "CTIME", "ATIME" }; + if (type >= 0 && type < CL_LAST) + return changelog_str[type]; + return NULL; } /* per-record flags */ -#define CLF_VERSION 0x1000 -#define CLF_FLAGMASK 0x0FFF +#define CLF_VERSION 0x1000 +#define CLF_EXT_VERSION 0x2000 +#define CLF_FLAGSHIFT 12 +#define CLF_FLAGMASK ((1U << CLF_FLAGSHIFT) - 1) +#define CLF_VERMASK (~CLF_FLAGMASK) /* Anything under the flagmask may be per-type (if desired) */ /* Flags for unlink */ #define CLF_UNLINK_LAST 0x0001 /* Unlink of last hardlink */ #define CLF_UNLINK_HSM_EXISTS 0x0002 /* File has something in HSM */ /* HSM cleaning needed */ +/* Flags for rename */ +#define CLF_RENAME_LAST 0x0001 /* rename unlink last hardlink of target */ + /* Flags for HSM */ /* 12b used (from high weight to low weight): * 2b for flags @@ -536,9 +646,10 @@ static inline const char *changelog_type2str(int type) { #define CLF_HSM_SPARE_H 15 #define CLF_HSM_LAST 15 -#define CLF_GET_BITS(_b, _h, _l) \ - _b &= (0xFFFF << (CLF_HSM_LAST - _h)); \ - _b = _b >> (_l + CLF_HSM_LAST - _h) +/* Remove bits higher than _h, then extract the value + * between _h and _l by shifting lower weigth to bit 0. */ +#define CLF_GET_BITS(_b, _h, _l) (((_b << (CLF_HSM_LAST - _h)) & 0xFFFF) \ + >> (CLF_HSM_LAST - _h + _l)) #define CLF_HSM_SUCCESS 0x00 #define CLF_HSM_MAXERROR 0x7E @@ -560,11 +671,7 @@ enum hsm_event { static inline enum hsm_event hsm_get_cl_event(__u16 flags) { - enum hsm_event he; - - CLF_GET_BITS(flags, CLF_HSM_EVENT_H, CLF_HSM_EVENT_L); - he = flags; - return he; + return CLF_GET_BITS(flags, CLF_HSM_EVENT_H, CLF_HSM_EVENT_L); } static inline void hsm_set_cl_event(int *flags, enum hsm_event he) @@ -574,8 +681,7 @@ static inline void hsm_set_cl_event(int *flags, enum hsm_event he) static inline __u16 hsm_get_cl_flags(int flags) { - CLF_GET_BITS(flags, CLF_HSM_FLAG_H, CLF_HSM_FLAG_L); - return flags; + return CLF_GET_BITS(flags, CLF_HSM_FLAG_H, CLF_HSM_FLAG_L); } static inline void hsm_set_cl_flags(int *flags, int bits) @@ -585,8 +691,7 @@ static inline void hsm_set_cl_flags(int *flags, int bits) static inline int hsm_get_cl_error(int flags) { - CLF_GET_BITS(flags, CLF_HSM_ERR_H, CLF_HSM_ERR_L); - return flags; + return CLF_GET_BITS(flags, CLF_HSM_ERR_H, CLF_HSM_ERR_L); } static inline void hsm_set_cl_error(int *flags, int error) @@ -594,7 +699,8 @@ static inline void hsm_set_cl_error(int *flags, int error) *flags |= (error << CLF_HSM_ERR_L); } -#define CR_MAXSIZE (PATH_MAX + sizeof(struct changelog_rec)) +#define CR_MAXSIZE cfs_size_round(2*NAME_MAX + 1 + sizeof(struct changelog_rec)) + struct changelog_rec { __u16 cr_namelen; __u16 cr_flags; /**< (flags&CLF_FLAGMASK)|CLF_VERSION */ @@ -610,6 +716,53 @@ struct changelog_rec { char cr_name[0]; /**< last element */ } __attribute__((packed)); +/* changelog_ext_rec is 2*sizeof(lu_fid) bigger than changelog_rec, to save + * space, only rename uses changelog_ext_rec, while others use changelog_rec to + * store records. + */ +struct changelog_ext_rec { + __u16 cr_namelen; + __u16 cr_flags; /**< (flags & CLF_FLAGMASK) | + CLF_EXT_VERSION */ + __u32 cr_type; /**< \a changelog_rec_type */ + __u64 cr_index; /**< changelog record number */ + __u64 cr_prev; /**< last index for this target fid */ + __u64 cr_time; + union { + lustre_fid cr_tfid; /**< target fid */ + __u32 cr_markerflags; /**< CL_MARK flags */ + }; + lustre_fid cr_pfid; /**< target parent fid */ + lustre_fid cr_sfid; /**< source fid, or zero */ + lustre_fid cr_spfid; /**< source parent fid, or zero */ + char cr_name[0]; /**< last element */ +} __attribute__((packed)); + +#define CHANGELOG_REC_EXTENDED(rec) \ + (((rec)->cr_flags & CLF_VERMASK) == CLF_EXT_VERSION) + +static inline int changelog_rec_size(struct changelog_rec *rec) +{ + return CHANGELOG_REC_EXTENDED(rec) ? sizeof(struct changelog_ext_rec): + sizeof(*rec); +} + +static inline char *changelog_rec_name(struct changelog_rec *rec) +{ + return CHANGELOG_REC_EXTENDED(rec) ? + ((struct changelog_ext_rec *)rec)->cr_name: rec->cr_name; +} + +static inline int changelog_rec_snamelen(struct changelog_ext_rec *rec) +{ + return rec->cr_namelen - strlen(rec->cr_name) - 1; +} + +static inline char *changelog_rec_sname(struct changelog_ext_rec *rec) +{ + return rec->cr_name + strlen(rec->cr_name) + 1; +} + struct ioc_changelog { __u64 icc_recno; __u32 icc_mdtindex; @@ -624,6 +777,13 @@ enum changelog_message_type { /********* Misc **********/ +struct ioc_data_version { + __u64 idv_version; + __u64 idv_flags; /* See LL_DV_xxx */ +}; +#define LL_DV_NOFLUSH 0x01 /* Do not take READ EXTENT LOCK before sampling + version. Dirty caches are left unchanged. */ + #ifndef offsetof # define offsetof(typ,memb) ((unsigned long)((char *)&(((typ *)0)->memb))) #endif @@ -637,13 +797,13 @@ enum changelog_message_type { * See HSM_FLAGS below. */ enum hsm_states { - HS_EXISTS = 0x00000001, - HS_DIRTY = 0x00000002, - HS_RELEASED = 0x00000004, - HS_ARCHIVED = 0x00000008, - HS_NORELEASE = 0x00000010, - HS_NOARCHIVE = 0x00000020, - HS_LOST = 0x00000040, + HS_EXISTS = 0x00000001, + HS_DIRTY = 0x00000002, + HS_RELEASED = 0x00000004, + HS_ARCHIVED = 0x00000008, + HS_NORELEASE = 0x00000010, + HS_NOARCHIVE = 0x00000020, + HS_LOST = 0x00000040, }; /* HSM user-setable flags. */ @@ -662,25 +822,25 @@ enum hsm_states { * HSM request progress state */ enum hsm_progress_states { - HPS_WAITING = 1, - HPS_RUNNING = 2, - HPS_DONE = 3, + HPS_WAITING = 1, + HPS_RUNNING = 2, + HPS_DONE = 3, }; -#define HPS_NONE 0 +#define HPS_NONE 0 static inline char *hsm_progress_state2name(enum hsm_progress_states s) { - switch (s) { - case HPS_WAITING: return "waiting"; - case HPS_RUNNING: return "running"; - case HPS_DONE: return "done"; - default: return "unknown"; - } + switch (s) { + case HPS_WAITING: return "waiting"; + case HPS_RUNNING: return "running"; + case HPS_DONE: return "done"; + default: return "unknown"; + } } struct hsm_extent { - __u64 offset; - __u64 length; + __u64 offset; + __u64 length; } __attribute__((packed)); /** @@ -690,20 +850,33 @@ struct hsm_extent { * current HSM flags and in-progress action. */ struct hsm_user_state { - /** Current HSM states, from enum hsm_states. */ - __u32 hus_states; - __u32 hus_archive_num; - /** The current undergoing action, if there is one */ - __u32 hus_in_progress_state; - __u32 hus_in_progress_action; - struct hsm_extent hus_in_progress_location; - char hus_extended_info[]; + /** Current HSM states, from enum hsm_states. */ + __u32 hus_states; + __u32 hus_archive_id; + /** The current undergoing action, if there is one */ + __u32 hus_in_progress_state; + __u32 hus_in_progress_action; + struct hsm_extent hus_in_progress_location; + char hus_extended_info[]; }; struct hsm_state_set_ioc { - struct lu_fid hssi_fid; - __u64 hssi_setmask; - __u64 hssi_clearmask; + struct lu_fid hssi_fid; + __u64 hssi_setmask; + __u64 hssi_clearmask; +}; + +/* + * This structure describes the current in-progress action for a file. + * it is retuned to user space and send over the wire + */ +struct hsm_current_action { + /** The current undergoing action, if there is one */ + /* state is one of hsm_progress_states */ + __u32 hca_state; + /* action is one of hsm_user_action */ + __u32 hca_action; + struct hsm_extent hca_location; }; /***** HSM user requests ******/ @@ -730,35 +903,50 @@ static inline char *hsm_user_action2name(enum hsm_user_action a) } } +/* + * List of hr_flags (bit field) + */ +#define HSM_FORCE_ACTION 0x0001 +/* used by CT, connot be set by user */ +#define HSM_GHOST_COPY 0x0002 + +/** + * Contains all the fixed part of struct hsm_user_request. + * + */ +struct hsm_request { + __u32 hr_action; /* enum hsm_user_action */ + __u32 hr_archive_id; /* archive id, used only with HUA_ARCHIVE */ + __u64 hr_flags; /* request flags */ + __u32 hr_itemcount; /* item count in hur_user_item vector */ + __u32 hr_data_len; +}; + struct hsm_user_item { lustre_fid hui_fid; struct hsm_extent hui_extent; } __attribute__((packed)); struct hsm_user_request { - __u32 hur_action; /* enum hsm_user_action */ - __u32 hur_archive_num; /* archive number, used only with HUA_ARCHIVE */ - __u32 hur_itemcount; - __u32 hur_data_len; - struct hsm_user_item hur_user_item[0]; - /* extra data blob at end of struct (after all - * hur_user_items), only use helpers to access it - */ + struct hsm_request hur_request; + struct hsm_user_item hur_user_item[0]; + /* extra data blob at end of struct (after all + * hur_user_items), only use helpers to access it + */ } __attribute__((packed)); /** Return pointer to data field in a hsm user request */ static inline void *hur_data(struct hsm_user_request *hur) { - return &(hur->hur_user_item[hur->hur_itemcount]); + return &(hur->hur_user_item[hur->hur_request.hr_itemcount]); } /** Compute the current length of the provided hsm_user_request. */ static inline int hur_len(struct hsm_user_request *hur) { - int data_offset; - - data_offset = hur_data(hur) - (void *)hur; - return (data_offset + hur->hur_data_len); + return offsetof(struct hsm_user_request, + hur_user_item[hur->hur_request.hr_itemcount]) + + hur->hur_request.hr_data_len; } /****** HSM RPCs to copytool *****/ @@ -790,13 +978,14 @@ static inline char *hsm_copytool_action2name(enum hsm_copytool_action a) /* Copytool item action description */ struct hsm_action_item { - __u32 hai_len; /* valid size of this struct */ - __u32 hai_action; /* hsm_copytool_action, but use known size */ - lustre_fid hai_fid; /* Lustre FID to operated on */ - struct hsm_extent hai_extent; /* byte range to operate on */ - __u64 hai_cookie; /* action cookie from coordinator */ - __u64 hai_gid; /* grouplock id */ - char hai_data[0]; /* variable length */ + __u32 hai_len; /* valid size of this struct */ + __u32 hai_action; /* hsm_copytool_action, but use known size */ + lustre_fid hai_fid; /* Lustre FID to operated on */ + lustre_fid hai_dfid; /* fid used for data access */ + struct hsm_extent hai_extent; /* byte range to operate on */ + __u64 hai_cookie; /* action cookie from coordinator */ + __u64 hai_gid; /* grouplock id */ + char hai_data[0]; /* variable length */ } __attribute__((packed)); /* @@ -831,16 +1020,17 @@ static inline char *hai_dump_data_field(struct hsm_action_item *hai, /* Copytool action list */ #define HAL_VERSION 1 -#define HAL_MAXSIZE 4096 /* bytes, used in userspace only */ +#define HAL_MAXSIZE LNET_MTU /* bytes, used in userspace only */ struct hsm_action_list { - __u32 hal_version; - __u32 hal_count; /* number of hai's to follow */ - __u64 hal_compound_id; /* returned by coordinator */ - __u32 hal_archive_num; /* which archive backend */ - __u32 padding1; - char hal_fsname[0]; /* null-terminated */ - /* struct hsm_action_item[hal_count] follows, aligned on 8-byte - boundaries. See hai_zero */ + __u32 hal_version; + __u32 hal_count; /* number of hai's to follow */ + __u64 hal_compound_id; /* returned by coordinator */ + __u64 hal_flags; + __u32 hal_archive_id; /* which archive backend */ + __u32 padding1; + char hal_fsname[0]; /* null-terminated */ + /* struct hsm_action_item[hal_count] follows, aligned on 8-byte + boundaries. See hai_zero */ } __attribute__((packed)); #ifndef HAVE_CFS_SIZE_ROUND @@ -885,12 +1075,27 @@ static inline int hal_size(struct hsm_action_list *hal) #define HP_FLAG_RETRY 0x02 struct hsm_progress { - lustre_fid hp_fid; - __u64 hp_cookie; - struct hsm_extent hp_extent; - __u16 hp_flags; - __u16 hp_errval; /* positive val */ -} __attribute__((packed)); + lustre_fid hp_fid; + __u64 hp_cookie; + struct hsm_extent hp_extent; + __u16 hp_flags; + __u16 hp_errval; /* positive val */ + __u32 padding; +}; + +/** + * Use by copytool during any hsm request they handled. + * This structure is initialized by llapi_hsm_copy_start() + * which is an helper over the ioctl() interface + * Store Lustre, internal use only, data. + */ +struct hsm_copy { + __u64 hc_data_version; + __u16 hc_flags; + __u16 hc_errval; /* positive val */ + __u32 padding; + struct hsm_action_item hc_hai; +}; /** @} lustreuser */