staging: lustre: lov: move LSM to LOV layer
Move the definition of struct lov_stripe_md along with supporting functions from obd.h to lov_internal.h. Remove the unused functions obd_packmd() and obd_free_diskmd(). Simplify lov_obd_packmd() according to the reduced use cases and rename it lov_packmd(). Signed-off-by: John L. Hammond <john.hammond@intel.com> Signed-off-by: Jinshan Xiong <jinshan.xiong@intel.com> Intel-bug-id: https://jira.hpdd.intel.com/browse/LU-5814 Reviewed-on: http://review.whamcloud.com/13696 Reviewed-by: James Simmons <uja.ornl@yahoo.com> Reviewed-by: Oleg Drokin <oleg.drokin@intel.com> Signed-off-by: James Simmons <jsimmons@infradead.org> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
John L. Hammond
Greg Kroah-Hartman
parent
48a2a12afc
commit
e10a431b3f
|
|
@ -73,53 +73,7 @@ static inline void loi_init(struct lov_oinfo *loi)
|
|||
{
|
||||
}
|
||||
|
||||
/*
|
||||
* If we are unable to get the maximum object size from the OST in
|
||||
* ocd_maxbytes using OBD_CONNECT_MAXBYTES, then we fall back to using
|
||||
* the old maximum object size from ext3.
|
||||
*/
|
||||
#define LUSTRE_EXT3_STRIPE_MAXBYTES 0x1fffffff000ULL
|
||||
|
||||
struct lov_stripe_md {
|
||||
atomic_t lsm_refc;
|
||||
spinlock_t lsm_lock;
|
||||
pid_t lsm_lock_owner; /* debugging */
|
||||
|
||||
/* maximum possible file size, might change as OSTs status changes,
|
||||
* e.g. disconnected, deactivated
|
||||
*/
|
||||
loff_t lsm_maxbytes;
|
||||
struct ost_id lsm_oi;
|
||||
__u32 lsm_magic;
|
||||
__u32 lsm_stripe_size;
|
||||
__u32 lsm_pattern; /* striping pattern (RAID0, RAID1) */
|
||||
__u16 lsm_stripe_count;
|
||||
__u16 lsm_layout_gen;
|
||||
char lsm_pool_name[LOV_MAXPOOLNAME + 1];
|
||||
struct lov_oinfo *lsm_oinfo[0];
|
||||
};
|
||||
|
||||
static inline bool lsm_is_released(struct lov_stripe_md *lsm)
|
||||
{
|
||||
return !!(lsm->lsm_pattern & LOV_PATTERN_F_RELEASED);
|
||||
}
|
||||
|
||||
static inline bool lsm_has_objects(struct lov_stripe_md *lsm)
|
||||
{
|
||||
if (!lsm)
|
||||
return false;
|
||||
if (lsm_is_released(lsm))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline int lov_stripe_md_size(unsigned int stripe_count)
|
||||
{
|
||||
struct lov_stripe_md lsm;
|
||||
|
||||
return sizeof(lsm) + stripe_count * sizeof(lsm.lsm_oinfo[0]);
|
||||
}
|
||||
|
||||
struct lov_stripe_md;
|
||||
struct obd_info;
|
||||
|
||||
typedef int (*obd_enqueue_update_f)(void *cookie, int rc);
|
||||
|
|
@ -854,8 +808,6 @@ struct obd_ops {
|
|||
struct obd_statfs *osfs, __u64 max_age, __u32 flags);
|
||||
int (*statfs_async)(struct obd_export *exp, struct obd_info *oinfo,
|
||||
__u64 max_age, struct ptlrpc_request_set *set);
|
||||
int (*packmd)(struct obd_export *exp, struct lov_mds_md **disk_tgt,
|
||||
struct lov_stripe_md *mem_src);
|
||||
int (*unpackmd)(struct obd_export *exp,
|
||||
struct lov_stripe_md **mem_tgt,
|
||||
struct lov_mds_md *disk_src, int disk_len);
|
||||
|
|
@ -1033,33 +985,6 @@ struct md_ops {
|
|||
*/
|
||||
};
|
||||
|
||||
struct lsm_operations {
|
||||
void (*lsm_free)(struct lov_stripe_md *);
|
||||
void (*lsm_stripe_by_index)(struct lov_stripe_md *, int *, u64 *,
|
||||
u64 *);
|
||||
void (*lsm_stripe_by_offset)(struct lov_stripe_md *, int *, u64 *,
|
||||
u64 *);
|
||||
int (*lsm_lmm_verify)(struct lov_mds_md *lmm, int lmm_bytes,
|
||||
__u16 *stripe_count);
|
||||
int (*lsm_unpackmd)(struct lov_obd *lov, struct lov_stripe_md *lsm,
|
||||
struct lov_mds_md *lmm);
|
||||
};
|
||||
|
||||
extern const struct lsm_operations lsm_v1_ops;
|
||||
extern const struct lsm_operations lsm_v3_ops;
|
||||
static inline const struct lsm_operations *lsm_op_find(int magic)
|
||||
{
|
||||
switch (magic) {
|
||||
case LOV_MAGIC_V1:
|
||||
return &lsm_v1_ops;
|
||||
case LOV_MAGIC_V3:
|
||||
return &lsm_v3_ops;
|
||||
default:
|
||||
CERROR("Cannot recognize lsm_magic %08x\n", magic);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static inline struct md_open_data *obd_mod_alloc(void)
|
||||
{
|
||||
struct md_open_data *mod;
|
||||
|
|
|
|||
|
|
@ -609,44 +609,6 @@ obd_process_config(struct obd_device *obd, int datalen, void *data)
|
|||
return rc;
|
||||
}
|
||||
|
||||
/* Pack an in-memory MD struct for storage on disk.
|
||||
* Returns +ve size of packed MD (0 for free), or -ve error.
|
||||
*
|
||||
* If @disk_tgt == NULL, MD size is returned (max size if @mem_src == NULL).
|
||||
* If @*disk_tgt != NULL and @mem_src == NULL, @*disk_tgt will be freed.
|
||||
* If @*disk_tgt == NULL, it will be allocated
|
||||
*/
|
||||
static inline int obd_packmd(struct obd_export *exp,
|
||||
struct lov_mds_md **disk_tgt,
|
||||
struct lov_stripe_md *mem_src)
|
||||
{
|
||||
int rc;
|
||||
|
||||
EXP_CHECK_DT_OP(exp, packmd);
|
||||
EXP_COUNTER_INCREMENT(exp, packmd);
|
||||
|
||||
rc = OBP(exp->exp_obd, packmd)(exp, disk_tgt, mem_src);
|
||||
return rc;
|
||||
}
|
||||
|
||||
static inline int obd_free_diskmd(struct obd_export *exp,
|
||||
struct lov_mds_md **disk_tgt)
|
||||
{
|
||||
LASSERT(disk_tgt);
|
||||
LASSERT(*disk_tgt);
|
||||
/*
|
||||
* LU-2590, for caller's convenience, *disk_tgt could be host
|
||||
* endianness, it needs swab to LE if necessary, while just
|
||||
* lov_mds_md header needs it for figuring out how much memory
|
||||
* needs to be freed.
|
||||
*/
|
||||
if ((cpu_to_le32(LOV_MAGIC) != LOV_MAGIC) &&
|
||||
(((*disk_tgt)->lmm_magic == LOV_MAGIC_V1) ||
|
||||
((*disk_tgt)->lmm_magic == LOV_MAGIC_V3)))
|
||||
lustre_swab_lov_mds_md(*disk_tgt);
|
||||
return obd_packmd(exp, disk_tgt, NULL);
|
||||
}
|
||||
|
||||
/* Unpack an MD struct from disk to in-memory format.
|
||||
* Returns +ve size of unpacked MD (0 for free), or -ve error.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -609,8 +609,6 @@ struct ll_file_data {
|
|||
struct list_head fd_lccs; /* list of ll_cl_context */
|
||||
};
|
||||
|
||||
struct lov_stripe_md;
|
||||
|
||||
extern struct dentry *llite_root;
|
||||
extern struct kset *llite_kset;
|
||||
|
||||
|
|
|
|||
|
|
@ -42,7 +42,6 @@
|
|||
|
||||
enum obd_notify_event;
|
||||
struct inode;
|
||||
struct lov_stripe_md;
|
||||
struct lustre_md;
|
||||
struct obd_device;
|
||||
struct obd_export;
|
||||
|
|
|
|||
|
|
@ -2736,90 +2736,6 @@ static int lmv_set_info_async(const struct lu_env *env, struct obd_export *exp,
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
static int lmv_pack_md_v1(const struct lmv_stripe_md *lsm,
|
||||
struct lmv_mds_md_v1 *lmm1)
|
||||
{
|
||||
int cplen;
|
||||
int i;
|
||||
|
||||
lmm1->lmv_magic = cpu_to_le32(lsm->lsm_md_magic);
|
||||
lmm1->lmv_stripe_count = cpu_to_le32(lsm->lsm_md_stripe_count);
|
||||
lmm1->lmv_master_mdt_index = cpu_to_le32(lsm->lsm_md_master_mdt_index);
|
||||
lmm1->lmv_hash_type = cpu_to_le32(lsm->lsm_md_hash_type);
|
||||
cplen = strlcpy(lmm1->lmv_pool_name, lsm->lsm_md_pool_name,
|
||||
sizeof(lmm1->lmv_pool_name));
|
||||
if (cplen >= sizeof(lmm1->lmv_pool_name))
|
||||
return -E2BIG;
|
||||
|
||||
for (i = 0; i < lsm->lsm_md_stripe_count; i++)
|
||||
fid_cpu_to_le(&lmm1->lmv_stripe_fids[i],
|
||||
&lsm->lsm_md_oinfo[i].lmo_fid);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
lmv_pack_md(union lmv_mds_md **lmmp, const struct lmv_stripe_md *lsm,
|
||||
int stripe_count)
|
||||
{
|
||||
int lmm_size = 0, rc = 0;
|
||||
bool allocated = false;
|
||||
|
||||
LASSERT(lmmp);
|
||||
|
||||
/* Free lmm */
|
||||
if (*lmmp && !lsm) {
|
||||
int stripe_cnt;
|
||||
|
||||
stripe_cnt = lmv_mds_md_stripe_count_get(*lmmp);
|
||||
lmm_size = lmv_mds_md_size(stripe_cnt,
|
||||
le32_to_cpu((*lmmp)->lmv_magic));
|
||||
if (!lmm_size)
|
||||
return -EINVAL;
|
||||
kvfree(*lmmp);
|
||||
*lmmp = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Alloc lmm */
|
||||
if (!*lmmp && !lsm) {
|
||||
lmm_size = lmv_mds_md_size(stripe_count, LMV_MAGIC);
|
||||
LASSERT(lmm_size > 0);
|
||||
*lmmp = libcfs_kvzalloc(lmm_size, GFP_NOFS);
|
||||
if (!*lmmp)
|
||||
return -ENOMEM;
|
||||
lmv_mds_md_stripe_count_set(*lmmp, stripe_count);
|
||||
(*lmmp)->lmv_magic = cpu_to_le32(LMV_MAGIC);
|
||||
return lmm_size;
|
||||
}
|
||||
|
||||
/* pack lmm */
|
||||
LASSERT(lsm);
|
||||
lmm_size = lmv_mds_md_size(lsm->lsm_md_stripe_count,
|
||||
lsm->lsm_md_magic);
|
||||
if (!*lmmp) {
|
||||
*lmmp = libcfs_kvzalloc(lmm_size, GFP_NOFS);
|
||||
if (!*lmmp)
|
||||
return -ENOMEM;
|
||||
allocated = true;
|
||||
}
|
||||
|
||||
switch (lsm->lsm_md_magic) {
|
||||
case LMV_MAGIC_V1:
|
||||
rc = lmv_pack_md_v1(lsm, &(*lmmp)->lmv_md_v1);
|
||||
break;
|
||||
default:
|
||||
rc = -EINVAL;
|
||||
break;
|
||||
}
|
||||
|
||||
if (rc && allocated) {
|
||||
kvfree(*lmmp);
|
||||
*lmmp = NULL;
|
||||
}
|
||||
|
||||
return lmm_size;
|
||||
}
|
||||
|
||||
static int lmv_unpack_md_v1(struct obd_export *exp, struct lmv_stripe_md *lsm,
|
||||
const struct lmv_mds_md_v1 *lmm1)
|
||||
{
|
||||
|
|
@ -2959,26 +2875,6 @@ static int lmv_unpackmd(struct obd_export *exp, struct lov_stripe_md **lsmp,
|
|||
(union lmv_mds_md *)lmm, disk_len);
|
||||
}
|
||||
|
||||
static int lmv_packmd(struct obd_export *exp, struct lov_mds_md **lmmp,
|
||||
struct lov_stripe_md *lsm)
|
||||
{
|
||||
const struct lmv_stripe_md *lmv = (struct lmv_stripe_md *)lsm;
|
||||
struct obd_device *obd = exp->exp_obd;
|
||||
struct lmv_obd *lmv_obd = &obd->u.lmv;
|
||||
int stripe_count;
|
||||
|
||||
if (!lmmp) {
|
||||
if (lsm)
|
||||
stripe_count = lmv->lsm_md_stripe_count;
|
||||
else
|
||||
stripe_count = lmv_obd->desc.ld_tgt_count;
|
||||
|
||||
return lmv_mds_md_size(stripe_count, LMV_MAGIC_V1);
|
||||
}
|
||||
|
||||
return lmv_pack_md((union lmv_mds_md **)lmmp, lmv, 0);
|
||||
}
|
||||
|
||||
static int lmv_cancel_unused(struct obd_export *exp, const struct lu_fid *fid,
|
||||
ldlm_policy_data_t *policy, enum ldlm_mode mode,
|
||||
enum ldlm_cancel_flags flags, void *opaque)
|
||||
|
|
@ -3282,7 +3178,6 @@ static struct obd_ops lmv_obd_ops = {
|
|||
.statfs = lmv_statfs,
|
||||
.get_info = lmv_get_info,
|
||||
.set_info_async = lmv_set_info_async,
|
||||
.packmd = lmv_packmd,
|
||||
.unpackmd = lmv_unpackmd,
|
||||
.notify = lmv_notify,
|
||||
.get_uuid = lmv_get_uuid,
|
||||
|
|
|
|||
|
|
@ -206,7 +206,7 @@ static int lsm_unpackmd_common(struct lov_obd *lov,
|
|||
|
||||
static void
|
||||
lsm_stripe_by_index_plain(struct lov_stripe_md *lsm, int *stripeno,
|
||||
u64 *lov_off, u64 *swidth)
|
||||
loff_t *lov_off, loff_t *swidth)
|
||||
{
|
||||
if (swidth)
|
||||
*swidth = (u64)lsm->lsm_stripe_size * lsm->lsm_stripe_count;
|
||||
|
|
@ -214,7 +214,7 @@ lsm_stripe_by_index_plain(struct lov_stripe_md *lsm, int *stripeno,
|
|||
|
||||
static void
|
||||
lsm_stripe_by_offset_plain(struct lov_stripe_md *lsm, int *stripeno,
|
||||
u64 *lov_off, u64 *swidth)
|
||||
loff_t *lov_off, loff_t *swidth)
|
||||
{
|
||||
if (swidth)
|
||||
*swidth = (u64)lsm->lsm_stripe_size * lsm->lsm_stripe_count;
|
||||
|
|
|
|||
|
|
@ -36,6 +36,84 @@
|
|||
#include "../include/obd_class.h"
|
||||
#include "../include/lustre/lustre_user.h"
|
||||
|
||||
/*
|
||||
* If we are unable to get the maximum object size from the OST in
|
||||
* ocd_maxbytes using OBD_CONNECT_MAXBYTES, then we fall back to using
|
||||
* the old maximum object size from ext3.
|
||||
*/
|
||||
#define LUSTRE_EXT3_STRIPE_MAXBYTES 0x1fffffff000ULL
|
||||
|
||||
struct lov_stripe_md {
|
||||
atomic_t lsm_refc;
|
||||
spinlock_t lsm_lock;
|
||||
pid_t lsm_lock_owner; /* debugging */
|
||||
|
||||
/*
|
||||
* maximum possible file size, might change as OSTs status changes,
|
||||
* e.g. disconnected, deactivated
|
||||
*/
|
||||
loff_t lsm_maxbytes;
|
||||
struct ost_id lsm_oi;
|
||||
u32 lsm_magic;
|
||||
u32 lsm_stripe_size;
|
||||
u32 lsm_pattern; /* RAID0, RAID1, released, ... */
|
||||
u16 lsm_stripe_count;
|
||||
u16 lsm_layout_gen;
|
||||
char lsm_pool_name[LOV_MAXPOOLNAME + 1];
|
||||
struct lov_oinfo *lsm_oinfo[0];
|
||||
};
|
||||
|
||||
static inline bool lsm_is_released(struct lov_stripe_md *lsm)
|
||||
{
|
||||
return !!(lsm->lsm_pattern & LOV_PATTERN_F_RELEASED);
|
||||
}
|
||||
|
||||
static inline bool lsm_has_objects(struct lov_stripe_md *lsm)
|
||||
{
|
||||
if (!lsm)
|
||||
return false;
|
||||
|
||||
if (lsm_is_released(lsm))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline int lov_stripe_md_size(unsigned int stripe_count)
|
||||
{
|
||||
struct lov_stripe_md lsm;
|
||||
|
||||
return sizeof(lsm) + stripe_count * sizeof(lsm.lsm_oinfo[0]);
|
||||
}
|
||||
|
||||
struct lsm_operations {
|
||||
void (*lsm_free)(struct lov_stripe_md *);
|
||||
void (*lsm_stripe_by_index)(struct lov_stripe_md *, int *, loff_t *,
|
||||
loff_t *);
|
||||
void (*lsm_stripe_by_offset)(struct lov_stripe_md *, int *, loff_t *,
|
||||
loff_t *);
|
||||
int (*lsm_lmm_verify)(struct lov_mds_md *lmm, int lmm_bytes,
|
||||
u16 *stripe_count);
|
||||
int (*lsm_unpackmd)(struct lov_obd *lov, struct lov_stripe_md *lsm,
|
||||
struct lov_mds_md *lmm);
|
||||
};
|
||||
|
||||
extern const struct lsm_operations lsm_v1_ops;
|
||||
extern const struct lsm_operations lsm_v3_ops;
|
||||
|
||||
static inline const struct lsm_operations *lsm_op_find(int magic)
|
||||
{
|
||||
switch (magic) {
|
||||
case LOV_MAGIC_V1:
|
||||
return &lsm_v1_ops;
|
||||
case LOV_MAGIC_V3:
|
||||
return &lsm_v3_ops;
|
||||
default:
|
||||
CERROR("unrecognized lsm_magic %08x\n", magic);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* lov_do_div64(a, b) returns a % b, and a = a / b.
|
||||
* The 32-bit code is LOV-specific due to knowing about stripe limits in
|
||||
* order to reduce the divisor to a 32-bit number. If the divisor is
|
||||
|
|
@ -176,8 +254,6 @@ int lov_del_target(struct obd_device *obd, __u32 index,
|
|||
/* lov_pack.c */
|
||||
ssize_t lov_lsm_pack(const struct lov_stripe_md *lsm, void *buf,
|
||||
size_t buf_size);
|
||||
int lov_packmd(struct obd_export *exp, struct lov_mds_md **lmm,
|
||||
struct lov_stripe_md *lsm);
|
||||
int lov_unpackmd(struct obd_export *exp, struct lov_stripe_md **lsmp,
|
||||
struct lov_mds_md *lmm, int lmm_bytes);
|
||||
int lov_alloc_memmd(struct lov_stripe_md **lsmp, __u16 stripe_count,
|
||||
|
|
|
|||
|
|
@ -971,14 +971,6 @@ out:
|
|||
return rc;
|
||||
}
|
||||
|
||||
#define ASSERT_LSM_MAGIC(lsmp) \
|
||||
do { \
|
||||
LASSERT((lsmp)); \
|
||||
LASSERTF(((lsmp)->lsm_magic == LOV_MAGIC_V1 || \
|
||||
(lsmp)->lsm_magic == LOV_MAGIC_V3), \
|
||||
"%p->lsm_magic=%x\n", (lsmp), (lsmp)->lsm_magic); \
|
||||
} while (0)
|
||||
|
||||
int lov_statfs_interpret(struct ptlrpc_request_set *rqset, void *data, int rc)
|
||||
{
|
||||
struct lov_request_set *lovset = (struct lov_request_set *)data;
|
||||
|
|
@ -1414,7 +1406,6 @@ static struct obd_ops lov_obd_ops = {
|
|||
.disconnect = lov_disconnect,
|
||||
.statfs = lov_statfs,
|
||||
.statfs_async = lov_statfs_async,
|
||||
.packmd = lov_packmd,
|
||||
.unpackmd = lov_unpackmd,
|
||||
.iocontrol = lov_iocontrol,
|
||||
.get_info = lov_get_info,
|
||||
|
|
|
|||
|
|
@ -153,96 +153,6 @@ ssize_t lov_lsm_pack(const struct lov_stripe_md *lsm, void *buf,
|
|||
return lmm_size;
|
||||
}
|
||||
|
||||
/* Pack LOV object metadata for disk storage. It is packed in LE byte
|
||||
* order and is opaque to the networking layer.
|
||||
*
|
||||
* XXX In the future, this will be enhanced to get the EA size from the
|
||||
* underlying OSC device(s) to get their EA sizes so we can stack
|
||||
* LOVs properly. For now lov_mds_md_size() just assumes one u64
|
||||
* per stripe.
|
||||
*/
|
||||
int lov_obd_packmd(struct lov_obd *lov, struct lov_mds_md **lmmp,
|
||||
struct lov_stripe_md *lsm)
|
||||
{
|
||||
__u16 stripe_count;
|
||||
int lmm_size, lmm_magic;
|
||||
|
||||
if (lsm) {
|
||||
lmm_magic = lsm->lsm_magic;
|
||||
} else {
|
||||
if (lmmp && *lmmp)
|
||||
lmm_magic = le32_to_cpu((*lmmp)->lmm_magic);
|
||||
else
|
||||
/* lsm == NULL and lmmp == NULL */
|
||||
lmm_magic = LOV_MAGIC;
|
||||
}
|
||||
|
||||
if ((lmm_magic != LOV_MAGIC_V1) &&
|
||||
(lmm_magic != LOV_MAGIC_V3)) {
|
||||
CERROR("bad mem LOV MAGIC: 0x%08X != 0x%08X nor 0x%08X\n",
|
||||
lmm_magic, LOV_MAGIC_V1, LOV_MAGIC_V3);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (lsm) {
|
||||
/* If we are just sizing the EA, limit the stripe count
|
||||
* to the actual number of OSTs in this filesystem.
|
||||
*/
|
||||
if (!lmmp) {
|
||||
stripe_count = lov_get_stripecnt(lov, lmm_magic,
|
||||
lsm->lsm_stripe_count);
|
||||
lsm->lsm_stripe_count = stripe_count;
|
||||
} else if (!lsm_is_released(lsm)) {
|
||||
stripe_count = lsm->lsm_stripe_count;
|
||||
} else {
|
||||
stripe_count = 0;
|
||||
}
|
||||
} else {
|
||||
/*
|
||||
* To calculate maximum easize by active targets at present,
|
||||
* which is exactly the maximum easize to be seen by LOV
|
||||
*/
|
||||
stripe_count = lov->desc.ld_active_tgt_count;
|
||||
}
|
||||
|
||||
/* XXX LOV STACKING call into osc for sizes */
|
||||
lmm_size = lov_mds_md_size(stripe_count, lmm_magic);
|
||||
|
||||
if (!lmmp)
|
||||
return lmm_size;
|
||||
|
||||
if (*lmmp && !lsm) {
|
||||
stripe_count = le16_to_cpu((*lmmp)->lmm_stripe_count);
|
||||
lmm_size = lov_mds_md_size(stripe_count, lmm_magic);
|
||||
kvfree(*lmmp);
|
||||
*lmmp = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!*lmmp) {
|
||||
*lmmp = libcfs_kvzalloc(lmm_size, GFP_NOFS);
|
||||
if (!*lmmp)
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
CDEBUG(D_INFO, "lov_packmd: LOV_MAGIC 0x%08X, lmm_size = %d\n",
|
||||
lmm_magic, lmm_size);
|
||||
|
||||
if (!lsm)
|
||||
return lmm_size;
|
||||
|
||||
return lov_lsm_pack(lsm, *lmmp, lmm_size);
|
||||
}
|
||||
|
||||
int lov_packmd(struct obd_export *exp, struct lov_mds_md **lmmp,
|
||||
struct lov_stripe_md *lsm)
|
||||
{
|
||||
struct obd_device *obd = class_exp2obd(exp);
|
||||
struct lov_obd *lov = &obd->u.lov;
|
||||
|
||||
return lov_obd_packmd(lov, lmmp, lsm);
|
||||
}
|
||||
|
||||
/* Find the max stripecount we should use */
|
||||
__u16 lov_get_stripecnt(struct lov_obd *lov, __u32 magic, __u16 stripe_count)
|
||||
{
|
||||
|
|
@ -393,15 +303,14 @@ int lov_unpackmd(struct obd_export *exp, struct lov_stripe_md **lsmp,
|
|||
int lov_getstripe(struct lov_object *obj, struct lov_stripe_md *lsm,
|
||||
struct lov_user_md __user *lump)
|
||||
{
|
||||
/*
|
||||
* XXX huge struct allocated on stack.
|
||||
*/
|
||||
/* we use lov_user_md_v3 because it is larger than lov_user_md_v1 */
|
||||
struct lov_obd *lov;
|
||||
struct lov_user_md_v3 lum;
|
||||
struct lov_mds_md *lmmk = NULL;
|
||||
int rc, lmmk_size, lmm_size;
|
||||
int lum_size;
|
||||
struct lov_mds_md *lmmk;
|
||||
u32 stripe_count;
|
||||
ssize_t lmm_size;
|
||||
size_t lmmk_size;
|
||||
size_t lum_size;
|
||||
int rc;
|
||||
mm_segment_t seg;
|
||||
|
||||
if (!lsm)
|
||||
|
|
@ -414,6 +323,18 @@ int lov_getstripe(struct lov_object *obj, struct lov_stripe_md *lsm,
|
|||
seg = get_fs();
|
||||
set_fs(KERNEL_DS);
|
||||
|
||||
if (lsm->lsm_magic != LOV_MAGIC_V1 && lsm->lsm_magic != LOV_MAGIC_V3) {
|
||||
CERROR("bad LSM MAGIC: 0x%08X != 0x%08X nor 0x%08X\n",
|
||||
lsm->lsm_magic, LOV_MAGIC_V1, LOV_MAGIC_V3);
|
||||
rc = -EIO;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (!lsm_is_released(lsm))
|
||||
stripe_count = lsm->lsm_stripe_count;
|
||||
else
|
||||
stripe_count = 0;
|
||||
|
||||
/* we only need the header part from user space to get lmm_magic and
|
||||
* lmm_stripe_count, (the header part is common to v1 and v3)
|
||||
*/
|
||||
|
|
@ -432,32 +353,40 @@ int lov_getstripe(struct lov_object *obj, struct lov_stripe_md *lsm,
|
|||
if (lum.lmm_stripe_count &&
|
||||
(lum.lmm_stripe_count < lsm->lsm_stripe_count)) {
|
||||
/* Return right size of stripe to user */
|
||||
lum.lmm_stripe_count = lsm->lsm_stripe_count;
|
||||
lum.lmm_stripe_count = stripe_count;
|
||||
rc = copy_to_user(lump, &lum, lum_size);
|
||||
rc = -EOVERFLOW;
|
||||
goto out;
|
||||
}
|
||||
lov = lu2lov_dev(obj->lo_cl.co_lu.lo_dev)->ld_lov;
|
||||
rc = lov_obd_packmd(lov, &lmmk, lsm);
|
||||
if (rc < 0)
|
||||
lmmk_size = lov_mds_md_size(stripe_count, lsm->lsm_magic);
|
||||
|
||||
|
||||
lmmk = libcfs_kvzalloc(lmmk_size, GFP_NOFS);
|
||||
if (!lmmk) {
|
||||
rc = -ENOMEM;
|
||||
goto out;
|
||||
lmmk_size = rc;
|
||||
lmm_size = rc;
|
||||
rc = 0;
|
||||
}
|
||||
|
||||
lmm_size = lov_lsm_pack(lsm, lmmk, lmmk_size);
|
||||
if (lmm_size < 0) {
|
||||
rc = lmm_size;
|
||||
goto out_free;
|
||||
}
|
||||
|
||||
/* FIXME: Bug 1185 - copy fields properly when structs change */
|
||||
/* struct lov_user_md_v3 and struct lov_mds_md_v3 must be the same */
|
||||
CLASSERT(sizeof(lum) == sizeof(struct lov_mds_md_v3));
|
||||
CLASSERT(sizeof(lum.lmm_objects[0]) == sizeof(lmmk->lmm_objects[0]));
|
||||
|
||||
if ((cpu_to_le32(LOV_MAGIC) != LOV_MAGIC) &&
|
||||
((lmmk->lmm_magic == cpu_to_le32(LOV_MAGIC_V1)) ||
|
||||
(lmmk->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)))) {
|
||||
if (cpu_to_le32(LOV_MAGIC) != LOV_MAGIC &&
|
||||
(lmmk->lmm_magic == cpu_to_le32(LOV_MAGIC_V1) ||
|
||||
lmmk->lmm_magic == cpu_to_le32(LOV_MAGIC_V3))) {
|
||||
lustre_swab_lov_mds_md(lmmk);
|
||||
lustre_swab_lov_user_md_objects(
|
||||
(struct lov_user_ost_data *)lmmk->lmm_objects,
|
||||
lmmk->lmm_stripe_count);
|
||||
}
|
||||
|
||||
if (lum.lmm_magic == LOV_USER_MAGIC) {
|
||||
/* User request for v1, we need skip lmm_pool_name */
|
||||
if (lmmk->lmm_magic == LOV_MAGIC_V3) {
|
||||
|
|
@ -491,7 +420,7 @@ int lov_getstripe(struct lov_object *obj, struct lov_stripe_md *lsm,
|
|||
rc = -EFAULT;
|
||||
|
||||
out_free:
|
||||
kfree(lmmk);
|
||||
kvfree(lmmk);
|
||||
out:
|
||||
set_fs(seg);
|
||||
return rc;
|
||||
|
|
|
|||
|
|
@ -447,14 +447,6 @@ static int mdc_get_lustre_md(struct obd_export *exp,
|
|||
if (rc < 0)
|
||||
goto out;
|
||||
|
||||
if (rc < (typeof(rc))sizeof(*md->lsm)) {
|
||||
CDEBUG(D_INFO,
|
||||
"lsm size too small: rc < sizeof (*md->lsm) (%d < %d)\n",
|
||||
rc, (int)sizeof(*md->lsm));
|
||||
rc = -EPROTO;
|
||||
goto out;
|
||||
}
|
||||
|
||||
} else if (md->body->mbo_valid & OBD_MD_FLDIREA) {
|
||||
int lmvsize;
|
||||
struct lov_mds_md *lmv;
|
||||
|
|
|
|||
|
|
@ -103,68 +103,6 @@ static void osc_release_ppga(struct brw_page **ppga, u32 count);
|
|||
static int brw_interpret(const struct lu_env *env,
|
||||
struct ptlrpc_request *req, void *data, int rc);
|
||||
|
||||
/* Unpack OSC object metadata from disk storage (LE byte order). */
|
||||
static int osc_unpackmd(struct obd_export *exp, struct lov_stripe_md **lsmp,
|
||||
struct lov_mds_md *lmm, int lmm_bytes)
|
||||
{
|
||||
int lsm_size;
|
||||
struct obd_import *imp = class_exp2cliimp(exp);
|
||||
|
||||
if (lmm) {
|
||||
if (lmm_bytes < sizeof(*lmm)) {
|
||||
CERROR("%s: lov_mds_md too small: %d, need %d\n",
|
||||
exp->exp_obd->obd_name, lmm_bytes,
|
||||
(int)sizeof(*lmm));
|
||||
return -EINVAL;
|
||||
}
|
||||
/* XXX LOV_MAGIC etc check? */
|
||||
|
||||
if (unlikely(ostid_id(&lmm->lmm_oi) == 0)) {
|
||||
CERROR("%s: zero lmm_object_id: rc = %d\n",
|
||||
exp->exp_obd->obd_name, -EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
lsm_size = lov_stripe_md_size(1);
|
||||
if (!lsmp)
|
||||
return lsm_size;
|
||||
|
||||
if (*lsmp && !lmm) {
|
||||
kfree((*lsmp)->lsm_oinfo[0]);
|
||||
kfree(*lsmp);
|
||||
*lsmp = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!*lsmp) {
|
||||
*lsmp = kzalloc(lsm_size, GFP_NOFS);
|
||||
if (unlikely(!*lsmp))
|
||||
return -ENOMEM;
|
||||
(*lsmp)->lsm_oinfo[0] = kzalloc(sizeof(struct lov_oinfo),
|
||||
GFP_NOFS);
|
||||
if (unlikely(!(*lsmp)->lsm_oinfo[0])) {
|
||||
kfree(*lsmp);
|
||||
return -ENOMEM;
|
||||
}
|
||||
loi_init((*lsmp)->lsm_oinfo[0]);
|
||||
} else if (unlikely(ostid_id(&(*lsmp)->lsm_oi) == 0)) {
|
||||
return -EBADF;
|
||||
}
|
||||
|
||||
if (lmm)
|
||||
/* XXX zero *lsmp? */
|
||||
ostid_le_to_cpu(&lmm->lmm_oi, &(*lsmp)->lsm_oi);
|
||||
|
||||
if (imp &&
|
||||
(imp->imp_connect_data.ocd_connect_flags & OBD_CONNECT_MAXBYTES))
|
||||
(*lsmp)->lsm_maxbytes = imp->imp_connect_data.ocd_maxbytes;
|
||||
else
|
||||
(*lsmp)->lsm_maxbytes = LUSTRE_EXT3_STRIPE_MAXBYTES;
|
||||
|
||||
return lsm_size;
|
||||
}
|
||||
|
||||
static inline void osc_pack_req_body(struct ptlrpc_request *req,
|
||||
struct obdo *oa)
|
||||
{
|
||||
|
|
@ -2884,7 +2822,6 @@ static struct obd_ops osc_obd_ops = {
|
|||
.disconnect = osc_disconnect,
|
||||
.statfs = osc_statfs,
|
||||
.statfs_async = osc_statfs_async,
|
||||
.unpackmd = osc_unpackmd,
|
||||
.create = osc_create,
|
||||
.destroy = osc_destroy,
|
||||
.getattr = osc_getattr,
|
||||
|
|
|
|||
Loading…
Reference in New Issue