From: Mikhail Pershin Date: Sun, 25 Apr 2010 12:09:48 +0000 (+0400) Subject: b=15936 Unified target cleanups v2 X-Git-Tag: 1.10.0.41~21 X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=commitdiff_plain;h=08b2bc314e2eef39edebd87616ea3a372718b310 b=15936 Unified target cleanups v2 i=rread i=andreas --- diff --git a/lustre/include/lustre_export.h b/lustre/include/lustre_export.h index eb25365..7c0ccfe 100644 --- a/lustre/include/lustre_export.h +++ b/lustre/include/lustre_export.h @@ -51,19 +51,19 @@ struct mdt_client_data; struct mds_idmap_table; struct mdt_idmap_table; -struct lu_export_data { +struct tg_export_data { /** Protects led_lcd below */ - cfs_semaphore_t led_lcd_lock; + cfs_semaphore_t ted_lcd_lock; /** Per-client data for each export */ - struct lsd_client_data *led_lcd; + struct lsd_client_data *ted_lcd; /** Offset of record in last_rcvd file */ - loff_t led_lr_off; + loff_t ted_lr_off; /** Client index in last_rcvd file */ - int led_lr_idx; + int ted_lr_idx; }; struct mdt_export_data { - struct lu_export_data med_led; + struct tg_export_data med_ted; cfs_list_t med_open_head; cfs_spinlock_t med_open_lock; /* lock med_open_head, mfd_list*/ __u64 med_ibits_known; @@ -71,11 +71,6 @@ struct mdt_export_data { struct lustre_idmap_table *med_idmap; }; -#define med_lcd_lock med_led.led_lcd_lock -#define med_lcd med_led.led_lcd -#define med_lr_off med_led.led_lr_off -#define med_lr_idx med_led.led_lr_idx - struct osc_creator { cfs_spinlock_t oscc_lock; cfs_list_t oscc_wait_create_list; @@ -98,7 +93,7 @@ struct ec_export_data { /* echo client */ /* In-memory access to client data from OST struct */ struct filter_export_data { - struct lu_export_data fed_led; + struct tg_export_data fed_ted; cfs_spinlock_t fed_lock; /**< protects fed_mod_list */ long fed_dirty; /* in bytes */ long fed_grant; /* in bytes */ @@ -108,11 +103,6 @@ struct filter_export_data { __u32 fed_group; }; -#define fed_lcd_lock fed_led.led_lcd_lock -#define fed_lcd fed_led.led_lcd -#define fed_lr_off fed_led.led_lr_off -#define fed_lr_idx fed_led.led_lr_idx - typedef struct nid_stat { lnet_nid_t nid; cfs_hlist_node_t nid_hash; @@ -210,7 +200,7 @@ struct obd_export { cfs_time_t exp_flvr_expire[2]; /* seconds */ union { - struct lu_export_data eu_target_data; + struct tg_export_data eu_target_data; struct mdt_export_data eu_mdt_data; struct filter_export_data eu_filter_data; struct ec_export_data eu_ec_data; diff --git a/lustre/include/lustre_log.h b/lustre/include/lustre_log.h index 675b476..a4cd24d 100644 --- a/lustre/include/lustre_log.h +++ b/lustre/include/lustre_log.h @@ -389,12 +389,7 @@ static inline void llog_gen_init(struct llog_ctxt *ctxt) { struct obd_device *obd = ctxt->loc_exp->exp_obd; - if (!strcmp(obd->obd_type->typ_name, LUSTRE_MDS_NAME)) - ctxt->loc_gen.mnt_cnt = obd->u.mds.mds_mount_count; - else if (!strstr(obd->obd_type->typ_name, LUSTRE_OST_NAME)) - ctxt->loc_gen.mnt_cnt = obd->u.filter.fo_mount_count; - else - ctxt->loc_gen.mnt_cnt = 0; + ctxt->loc_gen.mnt_cnt = obd->u.obt.obt_mount_count; ctxt->loc_gen.conn_cnt++; } diff --git a/lustre/include/obd.h b/lustre/include/obd.h index e2aeb48..03691da 100644 --- a/lustre/include/obd.h +++ b/lustre/include/obd.h @@ -356,12 +356,6 @@ struct filter_obd { int fo_sec_level; }; -#define fo_translock fo_obt.obt_lut->lut_translock -#define fo_last_rcvd_slots fo_obt.obt_lut->lut_client_bitmap -#define fo_mount_count fo_obt.obt_lut->lut_mount_count -#define fo_rcvd_filp fo_obt.obt_rcvd_filp -#define fo_vfsmnt fo_obt.obt_vfsmnt - struct timeout_item { enum timeout_event ti_event; cfs_time_t ti_timeout; @@ -553,14 +547,6 @@ struct mds_obd { cfs_rw_semaphore_t mds_notify_lock; }; -#define mds_transno_lock mds_obt.obt_translock -#define mds_rcvd_filp mds_obt.obt_rcvd_filp -#define mds_server_data mds_obt.obt_lsd -#define mds_client_bitmap mds_obt.obt_client_bitmap -#define mds_mount_count mds_obt.obt_mount_count -#define mds_last_transno mds_obt.obt_last_transno -#define mds_vfsmnt mds_obt.obt_vfsmnt - /* lov objid */ extern __u32 mds_max_ost_index; diff --git a/lustre/mds/handler.c b/lustre/mds/handler.c index 44dcd03..61c02ab 100644 --- a/lustre/mds/handler.c +++ b/lustre/mds/handler.c @@ -118,7 +118,7 @@ struct dentry *mds_fid2dentry(struct mds_obd *mds, struct ll_fid *fid, } if (mnt) { - *mnt = mds->mds_vfsmnt; + *mnt = mds->mds_obt.obt_vfsmnt; mntget(*mnt); } @@ -315,7 +315,7 @@ static void mds_init_ctxt(struct obd_device *obd, struct vfsmount *mnt) { struct mds_obd *mds = &obd->u.mds; - mds->mds_vfsmnt = mnt; + mds->mds_obt.obt_vfsmnt = mnt; /* why not mnt->mnt_sb instead of mnt->mnt_root->d_inode->i_sb? */ obd->u.obt.obt_sb = mnt->mnt_root->d_inode->i_sb; diff --git a/lustre/mds/lproc_mds.c b/lustre/mds/lproc_mds.c index 5504ea1..d6c5b08 100644 --- a/lustre/mds/lproc_mds.c +++ b/lustre/mds/lproc_mds.c @@ -49,10 +49,10 @@ static int lprocfs_mds_rd_mntdev(char *page, char **start, off_t off, int count, struct obd_device* obd = (struct obd_device *)data; LASSERT(obd != NULL); - LASSERT(obd->u.mds.mds_vfsmnt->mnt_devname); + LASSERT(obd->u.obt.obt_vfsmnt->mnt_devname); *eof = 1; - return snprintf(page, count, "%s\n",obd->u.mds.mds_vfsmnt->mnt_devname); + return snprintf(page, count, "%s\n",obd->u.obt.obt_vfsmnt->mnt_devname); } static int lprocfs_mds_rd_evictostnids(char *page, char **start, off_t off, diff --git a/lustre/mds/mds_lov.c b/lustre/mds/mds_lov.c index 2947394..8ea0686 100644 --- a/lustre/mds/mds_lov.c +++ b/lustre/mds/mds_lov.c @@ -612,7 +612,7 @@ static int mds_lov_update_desc(struct obd_device *obd, int idx, LASSERT(obd->obd_upcall.onu_upcall != NULL); rc = obd->obd_upcall.onu_upcall(obd, NULL, ev, obd->obd_upcall.onu_owner, - &mds->mds_mount_count); + &mds->mds_obt.obt_mount_count); } out: OBD_FREE(ld, sizeof(*ld)); diff --git a/lustre/mdt/mdt_handler.c b/lustre/mdt/mdt_handler.c index a6f1a60..b4c747a 100644 --- a/lustre/mdt/mdt_handler.c +++ b/lustre/mdt/mdt_handler.c @@ -5036,7 +5036,7 @@ static int mdt_obd_connect(const struct lu_env *env, LASSERT(mti != NULL); mti->mti_exp = lexp; memcpy(lcd->lcd_uuid, cluuid, sizeof lcd->lcd_uuid); - lexp->exp_mdt_data.med_lcd = lcd; + lexp->exp_target_data.ted_lcd = lcd; rc = mdt_client_new(env, mdt); if (rc == 0) mdt_export_stats_init(obd, lexp, localdata); @@ -5264,7 +5264,7 @@ static int mdt_upcall(const struct lu_env *env, struct md_device *md, m->mdt_max_mdsize, m->mdt_max_cookiesize); mdt_allow_cli(m, CONFIG_SYNC); if (data) - (*(__u64 *)data) = m->mdt_mount_count; + (*(__u64 *)data) = m->mdt_lut.lut_mount_count; break; case MD_NO_TRANS: mti = lu_context_key_get(&env->le_ctx, &mdt_thread_key); diff --git a/lustre/mdt/mdt_internal.h b/lustre/mdt/mdt_internal.h index eb09101..5b3f836 100644 --- a/lustre/mdt/mdt_internal.h +++ b/lustre/mdt/mdt_internal.h @@ -75,7 +75,7 @@ /* check if request's xid is equal to last one or not*/ static inline int req_xid_is_last(struct ptlrpc_request *req) { - struct lsd_client_data *lcd = req->rq_export->exp_mdt_data.med_lcd; + struct lsd_client_data *lcd = req->rq_export->exp_target_data.ted_lcd; return (req->rq_xid == lcd->lcd_last_xid || req->rq_xid == lcd->lcd_last_close_xid); } @@ -171,14 +171,6 @@ struct mdt_device { int mdt_sec_level; }; -#define mdt_transno_lock mdt_lut.lut_translock -#define mdt_last_transno mdt_lut.lut_last_transno -#define mdt_last_rcvd mdt_lut.lut_last_rcvd -#define mdt_mount_count mdt_lut.lut_mount_count -#define mdt_lsd mdt_lut.lut_lsd -#define mdt_client_bitmap_lock mdt_lut.lut_client_bitmap_lock -#define mdt_client_bitmap mdt_lut.lut_client_bitmap - #define MDT_SERVICE_WATCHDOG_FACTOR (2) #define MDT_ROCOMPAT_SUPP (OBD_ROCOMPAT_LOVOBJID) #define MDT_INCOMPAT_SUPP (OBD_INCOMPAT_MDT | OBD_INCOMPAT_COMMON_LR | \ @@ -721,7 +713,7 @@ static inline int mdt_check_resent(struct mdt_thread_info *info, RETURN(1); } DEBUG_REQ(D_HA, req, "no reply for RESENT req (have "LPD64")", - req->rq_export->exp_mdt_data.med_lcd->lcd_last_xid); + req->rq_export->exp_target_data.ted_lcd->lcd_last_xid); } RETURN(0); } diff --git a/lustre/mdt/mdt_open.c b/lustre/mdt/mdt_open.c index af84bba..269d3c2 100644 --- a/lustre/mdt/mdt_open.c +++ b/lustre/mdt/mdt_open.c @@ -231,7 +231,7 @@ static int mdt_som_attr_set(struct mdt_thread_info *info, ma->ma_som->msd_size = la->la_valid & LA_SIZE ? la->la_size : 0; ma->ma_som->msd_blocks = la->la_valid & LA_BLOCKS ? la->la_blocks : 0; - ma->ma_som->msd_mountid = mdt->mdt_mount_count; + ma->ma_som->msd_mountid = mdt->mdt_lut.lut_mount_count; ma->ma_attr.la_valid &= LA_ATIME | LA_MTIME | LA_CTIME; } else { ma->ma_som->msd_ioepoch = IOEPOCH_INVAL; @@ -557,15 +557,15 @@ static void mdt_empty_transno(struct mdt_thread_info* info) return; } - cfs_spin_lock(&mdt->mdt_transno_lock); + cfs_spin_lock(&mdt->mdt_lut.lut_translock); if (info->mti_transno == 0) { - info->mti_transno = ++ mdt->mdt_last_transno; + info->mti_transno = ++ mdt->mdt_lut.lut_last_transno; } else { /* should be replay */ - if (info->mti_transno > mdt->mdt_last_transno) - mdt->mdt_last_transno = info->mti_transno; + if (info->mti_transno > mdt->mdt_lut.lut_last_transno) + mdt->mdt_lut.lut_last_transno = info->mti_transno; } - cfs_spin_unlock(&mdt->mdt_transno_lock); + cfs_spin_unlock(&mdt->mdt_lut.lut_translock); CDEBUG(D_INODE, "transno = "LPU64", last_committed = "LPU64"\n", info->mti_transno, @@ -883,8 +883,8 @@ void mdt_reconstruct_open(struct mdt_thread_info *info, struct mdt_device *mdt = info->mti_mdt; struct req_capsule *pill = info->mti_pill; struct ptlrpc_request *req = mdt_info_req(info); - struct mdt_export_data *med = &req->rq_export->exp_mdt_data; - struct lsd_client_data *lcd = med->med_lcd; + struct tg_export_data *ted = &req->rq_export->exp_target_data; + struct lsd_client_data *lcd = ted->ted_lcd; struct md_attr *ma = &info->mti_attr; struct mdt_reint_record *rr = &info->mti_rr; __u32 flags = info->mti_spec.sp_cr_flags; @@ -908,7 +908,7 @@ void mdt_reconstruct_open(struct mdt_thread_info *info, ma->ma_valid = 0; - mdt_req_from_lcd(req, med->med_lcd); + mdt_req_from_lcd(req, lcd); mdt_set_disposition(info, ldlm_rep, lcd->lcd_last_data); CERROR("This is reconstruct open: disp="LPX64", result=%d\n", diff --git a/lustre/mdt/mdt_recovery.c b/lustre/mdt/mdt_recovery.c index 4a9440a..bce0088 100644 --- a/lustre/mdt/mdt_recovery.c +++ b/lustre/mdt/mdt_recovery.c @@ -142,15 +142,15 @@ static inline int mdt_last_rcvd_header_read(const struct lu_env *env, mti = lu_context_key_get(&env->le_ctx, &mdt_thread_key); mti->mti_off = 0; - rc = dt_record_read(env, mdt->mdt_last_rcvd, + rc = dt_record_read(env, mdt->mdt_lut.lut_last_rcvd, mdt_buf(env, &mti->mti_lsd, sizeof(mti->mti_lsd)), &mti->mti_off); if (rc == 0) - lsd_le_to_cpu(&mti->mti_lsd, &mdt->mdt_lsd); + lsd_le_to_cpu(&mti->mti_lsd, &mdt->mdt_lut.lut_lsd); CDEBUG(D_INFO, "read last_rcvd header rc = %d, uuid = %s, " - "last_transno = "LPU64"\n", rc, mdt->mdt_lsd.lsd_uuid, - mdt->mdt_lsd.lsd_last_transno); + "last_transno = "LPU64"\n", rc, mdt->mdt_lut.lut_lsd.lsd_uuid, + mdt->mdt_lut.lut_lsd.lsd_last_transno); return rc; } @@ -165,16 +165,16 @@ static int mdt_last_rcvd_header_write(const struct lu_env *env, mti = lu_context_key_get(&env->le_ctx, &mdt_thread_key); mti->mti_off = 0; - lsd_cpu_to_le(&mdt->mdt_lsd, &mti->mti_lsd); + lsd_cpu_to_le(&mdt->mdt_lut.lut_lsd, &mti->mti_lsd); - rc = dt_record_write(env, mdt->mdt_last_rcvd, + rc = dt_record_write(env, mdt->mdt_lut.lut_last_rcvd, mdt_buf_const(env, &mti->mti_lsd, sizeof(mti->mti_lsd)), &mti->mti_off, th); CDEBUG(D_INFO, "write last_rcvd header rc = %d, uuid = %s, " - "last_transno = "LPU64"\n", rc, mdt->mdt_lsd.lsd_uuid, - mdt->mdt_lsd.lsd_last_transno); + "last_transno = "LPU64"\n", rc, mdt->mdt_lut.lut_lsd.lsd_uuid, + mdt->mdt_lut.lut_lsd.lsd_last_transno); RETURN(rc); } @@ -189,7 +189,7 @@ static int mdt_last_rcvd_read(const struct lu_env *env, struct mdt_device *mdt, mti = lu_context_key_get(&env->le_ctx, &mdt_thread_key); tmp = &mti->mti_lcd; - rc = dt_record_read(env, mdt->mdt_last_rcvd, + rc = dt_record_read(env, mdt->mdt_lut.lut_last_rcvd, mdt_buf(env, tmp, sizeof(*tmp)), off); if (rc == 0) { check_lcd(mdt2obd_dev(mdt)->obd_name, index, tmp); @@ -222,7 +222,7 @@ static int mdt_last_rcvd_write(const struct lu_env *env, lcd_cpu_to_le(lcd, tmp); - rc = dt_record_write(env, mdt->mdt_last_rcvd, + rc = dt_record_write(env, mdt->mdt_lut.lut_last_rcvd, mdt_buf_const(env, tmp, sizeof(*tmp)), off, th); CDEBUG(D_INFO, "write lcd @%d rc = %d, uuid = %s, last_transno = "LPU64 @@ -240,7 +240,7 @@ static int mdt_clients_data_init(const struct lu_env *env, struct mdt_device *mdt, unsigned long last_size) { - struct lr_server_data *lsd = &mdt->mdt_lsd; + struct lr_server_data *lsd = &mdt->mdt_lut.lut_lsd; struct lsd_client_data *lcd = NULL; struct obd_device *obd = mdt2obd_dev(mdt); loff_t off; @@ -304,7 +304,7 @@ static int mdt_clients_data_init(const struct lu_env *env, mti = lu_context_key_get(&env->le_ctx, &mdt_thread_key); LASSERT(mti != NULL); mti->mti_exp = exp; - exp->exp_mdt_data.med_lcd = lcd; + exp->exp_target_data.ted_lcd = lcd; rc = mdt_client_add(env, mdt, cl_idx); /* can't fail existing */ LASSERTF(rc == 0, "rc = %d\n", rc); @@ -322,10 +322,10 @@ static int mdt_clients_data_init(const struct lu_env *env, CDEBUG(D_OTHER, "client at idx %d has last_transno="LPU64"\n", cl_idx, last_transno); /* protect __u64 value update */ - cfs_spin_lock(&mdt->mdt_transno_lock); - mdt->mdt_last_transno = max(last_transno, - mdt->mdt_last_transno); - cfs_spin_unlock(&mdt->mdt_transno_lock); + cfs_spin_lock(&mdt->mdt_lut.lut_translock); + mdt->mdt_lut.lut_last_transno = max(last_transno, + mdt->mdt_lut.lut_last_transno); + cfs_spin_unlock(&mdt->mdt_lut.lut_translock); } err_client: @@ -338,7 +338,7 @@ static int mdt_server_data_init(const struct lu_env *env, struct mdt_device *mdt, struct lustre_sb_info *lsi) { - struct lr_server_data *lsd = &mdt->mdt_lsd; + struct lr_server_data *lsd = &mdt->mdt_lut.lut_lsd; struct lsd_client_data *lcd = NULL; struct obd_device *obd = mdt2obd_dev(mdt); struct mdt_thread_info *mti; @@ -360,8 +360,8 @@ static int mdt_server_data_init(const struct lu_env *env, LASSERT(mti != NULL); la = &mti->mti_attr.ma_attr; - obj = mdt->mdt_last_rcvd; - rc = obj->do_ops->do_attr_get(env, mdt->mdt_last_rcvd, la, BYPASS_CAPA); + obj = mdt->mdt_lut.lut_last_rcvd; + rc = obj->do_ops->do_attr_get(env, obj, la, BYPASS_CAPA); if (rc) RETURN(rc); @@ -433,13 +433,13 @@ static int mdt_server_data_init(const struct lu_env *env, lsd->lsd_feature_incompat |= OBD_INCOMPAT_FID; - cfs_spin_lock(&mdt->mdt_transno_lock); - mdt->mdt_last_transno = lsd->lsd_last_transno; - cfs_spin_unlock(&mdt->mdt_transno_lock); + cfs_spin_lock(&mdt->mdt_lut.lut_translock); + mdt->mdt_lut.lut_last_transno = lsd->lsd_last_transno; + cfs_spin_unlock(&mdt->mdt_lut.lut_translock); CDEBUG(D_INODE, "========BEGIN DUMPING LAST_RCVD========\n"); CDEBUG(D_INODE, "%s: server last_transno: "LPU64"\n", - obd->obd_name, mdt->mdt_last_transno); + obd->obd_name, mdt->mdt_lut.lut_last_transno); CDEBUG(D_INODE, "%s: server mount_count: "LPU64"\n", obd->obd_name, mount_count + 1); CDEBUG(D_INODE, "%s: server data size: %u\n", @@ -466,14 +466,14 @@ static int mdt_server_data_init(const struct lu_env *env, if (rc) GOTO(err_client, rc); - cfs_spin_lock(&mdt->mdt_transno_lock); + cfs_spin_lock(&mdt->mdt_lut.lut_translock); /* obd_last_committed is used for compatibility * with other lustre recovery code */ - obd->obd_last_committed = mdt->mdt_last_transno; - cfs_spin_unlock(&mdt->mdt_transno_lock); + obd->obd_last_committed = mdt->mdt_lut.lut_last_transno; + cfs_spin_unlock(&mdt->mdt_lut.lut_translock); - mdt->mdt_mount_count = mount_count + 1; - lsd->lsd_mount_count = mdt->mdt_mount_count; + mdt->mdt_lut.lut_mount_count = mount_count + 1; + lsd->lsd_mount_count = mdt->mdt_lut.lut_mount_count; /* save it, so mount count and last_transno is current */ rc = mdt_server_data_update(env, mdt); @@ -503,11 +503,11 @@ static int mdt_server_data_update(const struct lu_env *env, RETURN(PTR_ERR(th)); CDEBUG(D_SUPER, "MDS mount_count is "LPU64", last_transno is "LPU64"\n", - mdt->mdt_mount_count, mdt->mdt_last_transno); + mdt->mdt_lut.lut_mount_count, mdt->mdt_lut.lut_last_transno); - cfs_spin_lock(&mdt->mdt_transno_lock); - mdt->mdt_lsd.lsd_last_transno = mdt->mdt_last_transno; - cfs_spin_unlock(&mdt->mdt_transno_lock); + cfs_spin_lock(&mdt->mdt_lut.lut_translock); + mdt->mdt_lut.lut_lsd.lsd_last_transno = mdt->mdt_lut.lut_last_transno; + cfs_spin_unlock(&mdt->mdt_lut.lut_translock); rc = mdt_last_rcvd_header_write(env, mdt, th); mdt_trans_stop(env, mdt, th); @@ -517,11 +517,10 @@ static int mdt_server_data_update(const struct lu_env *env, int mdt_client_new(const struct lu_env *env, struct mdt_device *mdt) { - unsigned long *bitmap = mdt->mdt_client_bitmap; + unsigned long *bitmap = mdt->mdt_lut.lut_client_bitmap; struct mdt_thread_info *mti; - struct mdt_export_data *med; - struct lsd_client_data *lcd; - struct lr_server_data *lsd = &mdt->mdt_lsd; + struct tg_export_data *ted; + struct lr_server_data *lsd = &mdt->mdt_lut.lut_lsd; struct obd_device *obd = mdt2obd_dev(mdt); struct thandle *th; loff_t off; @@ -532,40 +531,39 @@ int mdt_client_new(const struct lu_env *env, struct mdt_device *mdt) mti = lu_context_key_get(&env->le_ctx, &mdt_thread_key); LASSERT(mti != NULL); - med = &mti->mti_exp->exp_mdt_data; - lcd = med->med_lcd; + ted = &mti->mti_exp->exp_target_data; LASSERT(bitmap != NULL); - if (!strcmp(med->med_lcd->lcd_uuid, obd->obd_uuid.uuid)) + if (!strcmp(ted->ted_lcd->lcd_uuid, obd->obd_uuid.uuid)) RETURN(0); /* the bitmap operations can handle cl_idx > sizeof(long) * 8, so * there's no need for extra complication here */ - cfs_spin_lock(&mdt->mdt_client_bitmap_lock); + cfs_spin_lock(&mdt->mdt_lut.lut_client_bitmap_lock); cl_idx = cfs_find_first_zero_bit(bitmap, LR_MAX_CLIENTS); if (cl_idx >= LR_MAX_CLIENTS || OBD_FAIL_CHECK(OBD_FAIL_MDS_CLIENT_ADD)) { CERROR("no room for %u clients - fix LR_MAX_CLIENTS\n", cl_idx); - cfs_spin_unlock(&mdt->mdt_client_bitmap_lock); + cfs_spin_unlock(&mdt->mdt_lut.lut_client_bitmap_lock); RETURN(-EOVERFLOW); } cfs_set_bit(cl_idx, bitmap); - cfs_spin_unlock(&mdt->mdt_client_bitmap_lock); + cfs_spin_unlock(&mdt->mdt_lut.lut_client_bitmap_lock); CDEBUG(D_INFO, "client at idx %d with UUID '%s' added\n", - cl_idx, med->med_lcd->lcd_uuid); + cl_idx, ted->ted_lcd->lcd_uuid); - med->med_lr_idx = cl_idx; - med->med_lr_off = lsd->lsd_client_start + + ted->ted_lr_idx = cl_idx; + ted->ted_lr_off = lsd->lsd_client_start + (cl_idx * lsd->lsd_client_size); - cfs_init_mutex(&med->med_lcd_lock); + cfs_init_mutex(&ted->ted_lcd_lock); - LASSERTF(med->med_lr_off > 0, "med_lr_off = %llu\n", med->med_lr_off); + LASSERTF(ted->ted_lr_off > 0, "ted_lr_off = %llu\n", ted->ted_lr_off); /* Write new client data. */ - off = med->med_lr_off; + off = ted->ted_lr_off; if (OBD_FAIL_CHECK(OBD_FAIL_TGT_CLIENT_ADD)) RETURN(-ENOSPC); @@ -587,9 +585,9 @@ int mdt_client_new(const struct lu_env *env, struct mdt_device *mdt) mti->mti_exp->exp_need_sync = 1; cfs_spin_unlock(&mti->mti_exp->exp_lock); - rc = mdt_last_rcvd_write(env, mdt, lcd, &off, th); + rc = mdt_last_rcvd_write(env, mdt, ted->ted_lcd, &off, th); CDEBUG(D_INFO, "wrote client lcd at idx %u off %llu (len %u)\n", - cl_idx, med->med_lr_off, (int)sizeof(*lcd)); + cl_idx, ted->ted_lr_off, (int)sizeof(*(ted->ted_lcd))); mdt_trans_stop(env, mdt, th); RETURN(rc); @@ -607,41 +605,41 @@ int mdt_client_add(const struct lu_env *env, struct mdt_device *mdt, int cl_idx) { struct mdt_thread_info *mti; - struct mdt_export_data *med; - unsigned long *bitmap = mdt->mdt_client_bitmap; + struct tg_export_data *ted; + unsigned long *bitmap = mdt->mdt_lut.lut_client_bitmap; struct obd_device *obd = mdt2obd_dev(mdt); - struct lr_server_data *lsd = &mdt->mdt_lsd; + struct lr_server_data *lsd = &mdt->mdt_lut.lut_lsd; int rc = 0; ENTRY; mti = lu_context_key_get(&env->le_ctx, &mdt_thread_key); LASSERT(mti != NULL); - med = &mti->mti_exp->exp_mdt_data; + ted = &mti->mti_exp->exp_target_data; LASSERT(bitmap != NULL); LASSERTF(cl_idx >= 0, "%d\n", cl_idx); - if (!strcmp(med->med_lcd->lcd_uuid, obd->obd_uuid.uuid)) + if (!strcmp(ted->ted_lcd->lcd_uuid, obd->obd_uuid.uuid)) RETURN(0); - cfs_spin_lock(&mdt->mdt_client_bitmap_lock); + cfs_spin_lock(&mdt->mdt_lut.lut_client_bitmap_lock); if (cfs_test_and_set_bit(cl_idx, bitmap)) { CERROR("MDS client %d: bit already set in bitmap!!\n", cl_idx); LBUG(); } - cfs_spin_unlock(&mdt->mdt_client_bitmap_lock); + cfs_spin_unlock(&mdt->mdt_lut.lut_client_bitmap_lock); CDEBUG(D_INFO, "client at idx %d with UUID '%s' added\n", - cl_idx, med->med_lcd->lcd_uuid); + cl_idx, ted->ted_lcd->lcd_uuid); - med->med_lr_idx = cl_idx; - med->med_lr_off = lsd->lsd_client_start + + ted->ted_lr_idx = cl_idx; + ted->ted_lr_off = lsd->lsd_client_start + (cl_idx * lsd->lsd_client_size); - cfs_init_mutex(&med->med_lcd_lock); + cfs_init_mutex(&ted->ted_lcd_lock); - LASSERTF(med->med_lr_off > 0, "med_lr_off = %llu\n", med->med_lr_off); + LASSERTF(ted->ted_lr_off > 0, "ted_lr_off = %llu\n", ted->ted_lr_off); RETURN(rc); } @@ -649,8 +647,7 @@ int mdt_client_add(const struct lu_env *env, int mdt_client_del(const struct lu_env *env, struct mdt_device *mdt) { struct mdt_thread_info *mti; - struct mdt_export_data *med; - struct lsd_client_data *lcd; + struct tg_export_data *ted; struct obd_device *obd = mdt2obd_dev(mdt); struct obd_export *exp; struct thandle *th; @@ -662,27 +659,26 @@ int mdt_client_del(const struct lu_env *env, struct mdt_device *mdt) LASSERT(mti != NULL); exp = mti->mti_exp; - med = &exp->exp_mdt_data; - lcd = med->med_lcd; - if (!lcd) + ted = &exp->exp_target_data; + if (!ted->ted_lcd) RETURN(0); /* XXX: If lcd_uuid were a real obd_uuid, I could use obd_uuid_equals */ - if (!strcmp(lcd->lcd_uuid, obd->obd_uuid.uuid)) + if (!strcmp(ted->ted_lcd->lcd_uuid, obd->obd_uuid.uuid)) GOTO(free, 0); CDEBUG(D_INFO, "freeing client at idx %u, offset %lld\n", - med->med_lr_idx, med->med_lr_off); + ted->ted_lr_idx, ted->ted_lr_off); - off = med->med_lr_off; + off = ted->ted_lr_off; /* - * Don't clear med_lr_idx here as it is likely also unset. At worst we + * Don't clear ted_lr_idx here as it is likely also unset. At worst we * leak a client slot that will be cleaned on the next recovery. */ if (off <= 0) { CERROR("client idx %d has offset %lld\n", - med->med_lr_idx, off); + ted->ted_lr_idx, off); GOTO(free, rc = -EINVAL); } @@ -690,9 +686,9 @@ int mdt_client_del(const struct lu_env *env, struct mdt_device *mdt) * Clear the bit _after_ zeroing out the client so we don't race with * mdt_client_add and zero out new clients. */ - if (!cfs_test_bit(med->med_lr_idx, mdt->mdt_client_bitmap)) { + if (!cfs_test_bit(ted->ted_lr_idx, mdt->mdt_lut.lut_client_bitmap)) { CERROR("MDT client %u: bit already clear in bitmap!!\n", - med->med_lr_idx); + ted->ted_lr_idx); LBUG(); } @@ -706,14 +702,14 @@ int mdt_client_del(const struct lu_env *env, struct mdt_device *mdt) if (IS_ERR(th)) GOTO(free, rc = PTR_ERR(th)); - cfs_mutex_down(&med->med_lcd_lock); - memset(lcd->lcd_uuid, 0, sizeof lcd->lcd_uuid); - rc = mdt_last_rcvd_write(env, mdt, lcd, &off, th); - cfs_mutex_up(&med->med_lcd_lock); + cfs_mutex_down(&ted->ted_lcd_lock); + memset(ted->ted_lcd->lcd_uuid, 0, sizeof ted->ted_lcd->lcd_uuid); + rc = mdt_last_rcvd_write(env, mdt, ted->ted_lcd, &off, th); + cfs_mutex_up(&ted->ted_lcd_lock); mdt_trans_stop(env, mdt, th); CDEBUG(rc == 0 ? D_INFO : D_ERROR, "Zeroing out client idx %u in " - "%s, rc %d\n", med->med_lr_idx, LAST_RCVD, rc); + "%s, rc %d\n", ted->ted_lr_idx, LAST_RCVD, rc); RETURN(0); free: return 0; @@ -727,7 +723,7 @@ static int mdt_last_rcvd_update(struct mdt_thread_info *mti, { struct mdt_device *mdt = mti->mti_mdt; struct ptlrpc_request *req = mdt_info_req(mti); - struct mdt_export_data *med; + struct tg_export_data *ted; struct lsd_client_data *lcd; loff_t off; int err; @@ -737,22 +733,22 @@ static int mdt_last_rcvd_update(struct mdt_thread_info *mti, LASSERT(req); LASSERT(req->rq_export); LASSERT(mdt); - med = &req->rq_export->exp_mdt_data; - LASSERT(med); + ted = &req->rq_export->exp_target_data; + LASSERT(ted); - cfs_mutex_down(&med->med_lcd_lock); - lcd = med->med_lcd; + cfs_mutex_down(&ted->ted_lcd_lock); + lcd = ted->ted_lcd; /* if the export has already been disconnected, we have no last_rcvd slot, * update server data with latest transno then */ if (lcd == NULL) { - cfs_mutex_up(&med->med_lcd_lock); + cfs_mutex_up(&ted->ted_lcd_lock); CWARN("commit transaction for disconnected client %s: rc %d\n", req->rq_export->exp_client_uuid.uuid, rc); err = mdt_last_rcvd_header_write(mti->mti_env, mdt, th); RETURN(err); } - off = med->med_lr_off; + off = ted->ted_lr_off; LASSERT(ergo(mti->mti_transno == 0, rc != 0)); if (lustre_msg_get_opc(req->rq_reqmsg) == MDS_CLOSE || lustre_msg_get_opc(req->rq_reqmsg) == MDS_DONE_WRITING) { @@ -780,12 +776,12 @@ static int mdt_last_rcvd_update(struct mdt_thread_info *mti, } if (off <= 0) { - CERROR("client idx %d has offset %lld\n", med->med_lr_idx, off); + CERROR("client idx %d has offset %lld\n", ted->ted_lr_idx, off); err = -EINVAL; } else { err = mdt_last_rcvd_write(mti->mti_env, mdt, lcd, &off, th); } - cfs_mutex_up(&med->med_lcd_lock); + cfs_mutex_up(&ted->ted_lcd_lock); RETURN(err); } @@ -842,20 +838,20 @@ static int mdt_txn_stop_cb(const struct lu_env *env, } mti->mti_has_trans = 1; - cfs_spin_lock(&mdt->mdt_transno_lock); + cfs_spin_lock(&mdt->mdt_lut.lut_translock); if (txn->th_result != 0) { if (mti->mti_transno != 0) { CERROR("Replay transno "LPU64" failed: rc %i\n", mti->mti_transno, txn->th_result); } } else if (mti->mti_transno == 0) { - mti->mti_transno = ++ mdt->mdt_last_transno; + mti->mti_transno = ++ mdt->mdt_lut.lut_last_transno; } else { /* should be replay */ - if (mti->mti_transno > mdt->mdt_last_transno) - mdt->mdt_last_transno = mti->mti_transno; + if (mti->mti_transno > mdt->mdt_lut.lut_last_transno) + mdt->mdt_lut.lut_last_transno = mti->mti_transno; } - cfs_spin_unlock(&mdt->mdt_transno_lock); + cfs_spin_unlock(&mdt->mdt_lut.lut_translock); /* sometimes the reply message has not been successfully packed */ LASSERT(req != NULL && req->rq_repmsg != NULL); @@ -1051,9 +1047,9 @@ void mdt_reconstruct_generic(struct mdt_thread_info *mti, struct mdt_lock_handle *lhc) { struct ptlrpc_request *req = mdt_info_req(mti); - struct mdt_export_data *med = &req->rq_export->exp_mdt_data; + struct tg_export_data *ted = &req->rq_export->exp_target_data; - return mdt_req_from_lcd(req, med->med_lcd); + return mdt_req_from_lcd(req, ted->ted_lcd); } static void mdt_reconstruct_create(struct mdt_thread_info *mti, @@ -1061,13 +1057,13 @@ static void mdt_reconstruct_create(struct mdt_thread_info *mti, { struct ptlrpc_request *req = mdt_info_req(mti); struct obd_export *exp = req->rq_export; - struct mdt_export_data *med = &exp->exp_mdt_data; + struct tg_export_data *ted = &exp->exp_target_data; struct mdt_device *mdt = mti->mti_mdt; struct mdt_object *child; struct mdt_body *body; int rc; - mdt_req_from_lcd(req, med->med_lcd); + mdt_req_from_lcd(req, ted->ted_lcd); if (req->rq_status) return; @@ -1109,7 +1105,7 @@ static void mdt_reconstruct_setattr(struct mdt_thread_info *mti, struct mdt_object *obj; struct mdt_body *body; - mdt_req_from_lcd(req, med->med_lcd); + mdt_req_from_lcd(req, med->med_ted.ted_lcd); if (req->rq_status) return; diff --git a/lustre/obdfilter/filter.c b/lustre/obdfilter/filter.c index 327e189..e3f13b7 100644 --- a/lustre/obdfilter/filter.c +++ b/lustre/obdfilter/filter.c @@ -120,9 +120,9 @@ int filter_version_get_check(struct obd_export *exp, int filter_finish_transno(struct obd_export *exp, struct inode *inode, struct obd_trans_info *oti, int rc, int force_sync) { - struct filter_obd *filter = &exp->exp_obd->u.filter; - struct filter_export_data *fed = &exp->exp_filter_data; - struct lr_server_data *fsd = class_server_data(exp->exp_obd); + struct obd_device_target *obt = &exp->exp_obd->u.obt; + struct tg_export_data *ted = &exp->exp_target_data; + struct lr_server_data *lsd = class_server_data(exp->exp_obd); struct lsd_client_data *lcd; __u64 last_rcvd; loff_t off; @@ -135,12 +135,12 @@ int filter_finish_transno(struct obd_export *exp, struct inode *inode, if (!exp->exp_obd->obd_replayable || oti == NULL) RETURN(rc); - cfs_mutex_down(&fed->fed_lcd_lock); - lcd = fed->fed_lcd; + cfs_mutex_down(&ted->ted_lcd_lock); + lcd = ted->ted_lcd; /* if the export has already been disconnected, we have no last_rcvd slot, * update server data with latest transno then */ if (lcd == NULL) { - cfs_mutex_up(&fed->fed_lcd_lock); + cfs_mutex_up(&ted->ted_lcd_lock); CWARN("commit transaction for disconnected client %s: rc %d\n", exp->exp_client_uuid.uuid, rc); err = filter_update_server_data(exp->exp_obd); @@ -148,14 +148,14 @@ int filter_finish_transno(struct obd_export *exp, struct inode *inode, } /* we don't allocate new transnos for replayed requests */ - cfs_spin_lock(&filter->fo_translock); + cfs_spin_lock(&obt->obt_lut->lut_translock); if (oti->oti_transno == 0) { - last_rcvd = le64_to_cpu(fsd->lsd_last_transno) + 1; - fsd->lsd_last_transno = cpu_to_le64(last_rcvd); + last_rcvd = le64_to_cpu(lsd->lsd_last_transno) + 1; + lsd->lsd_last_transno = cpu_to_le64(last_rcvd); } else { last_rcvd = oti->oti_transno; - if (last_rcvd > le64_to_cpu(fsd->lsd_last_transno)) - fsd->lsd_last_transno = cpu_to_le64(last_rcvd); + if (last_rcvd > le64_to_cpu(lsd->lsd_last_transno)) + lsd->lsd_last_transno = cpu_to_le64(last_rcvd); } oti->oti_transno = last_rcvd; @@ -163,15 +163,15 @@ int filter_finish_transno(struct obd_export *exp, struct inode *inode, lcd->lcd_last_transno = cpu_to_le64(last_rcvd); lcd->lcd_pre_versions[0] = cpu_to_le64(oti->oti_pre_version); lcd->lcd_last_xid = cpu_to_le64(oti->oti_xid); - cfs_spin_unlock(&filter->fo_translock); + cfs_spin_unlock(&obt->obt_lut->lut_translock); if (inode) fsfilt_set_version(exp->exp_obd, inode, last_rcvd); - off = fed->fed_lr_off; + off = ted->ted_lr_off; if (off <= 0) { CERROR("%s: client idx %d is %lld\n", exp->exp_obd->obd_name, - fed->fed_lr_idx, fed->fed_lr_off); + ted->ted_lr_idx, ted->ted_lr_off); err = -EINVAL; } else { class_export_cb_get(exp); /* released when the cb is called */ @@ -182,7 +182,7 @@ int filter_finish_transno(struct obd_export *exp, struct inode *inode, filter_commit_cb, exp); - err = fsfilt_write_record(exp->exp_obd, filter->fo_rcvd_filp, + err = fsfilt_write_record(exp->exp_obd, obt->obt_rcvd_filp, lcd, sizeof(*lcd), &off, force_sync | exp->exp_need_sync); if (force_sync) @@ -195,8 +195,8 @@ int filter_finish_transno(struct obd_export *exp, struct inode *inode, } CDEBUG(log_pri, "wrote trans "LPU64" for client %s at #%d: err = %d\n", - last_rcvd, lcd->lcd_uuid, fed->fed_lr_idx, err); - cfs_mutex_up(&fed->fed_lcd_lock); + last_rcvd, lcd->lcd_uuid, ted->ted_lr_idx, err); + cfs_mutex_up(&ted->ted_lcd_lock); RETURN(rc); } @@ -309,10 +309,10 @@ static int filter_export_stats_init(struct obd_device *obd, static int filter_client_add(struct obd_device *obd, struct obd_export *exp, int cl_idx) { - struct filter_obd *filter = &obd->u.filter; - struct filter_export_data *fed = &exp->exp_filter_data; - struct lr_server_data *fsd = class_server_data(obd); - unsigned long *bitmap = filter->fo_last_rcvd_slots; + struct obd_device_target *obt = &obd->u.obt; + struct tg_export_data *ted = &exp->exp_target_data; + struct lr_server_data *lsd = class_server_data(obd); + unsigned long *bitmap = obt->obt_lut->lut_client_bitmap; int new_client = (cl_idx == -1); ENTRY; @@ -321,7 +321,7 @@ static int filter_client_add(struct obd_device *obd, struct obd_export *exp, LASSERTF(cl_idx > -2, "%d\n", cl_idx); /* Self-export */ - if (strcmp(fed->fed_lcd->lcd_uuid, obd->obd_uuid.uuid) == 0) + if (strcmp(ted->ted_lcd->lcd_uuid, obd->obd_uuid.uuid) == 0) RETURN(0); /* the bitmap operations can handle cl_idx > sizeof(long) * 8, so @@ -348,23 +348,23 @@ static int filter_client_add(struct obd_device *obd, struct obd_export *exp, } } - fed->fed_lr_idx = cl_idx; - fed->fed_lr_off = le32_to_cpu(fsd->lsd_client_start) + - cl_idx * le16_to_cpu(fsd->lsd_client_size); - cfs_init_mutex(&fed->fed_lcd_lock); - LASSERTF(fed->fed_lr_off > 0, "fed_lr_off = %llu\n", fed->fed_lr_off); + ted->ted_lr_idx = cl_idx; + ted->ted_lr_off = le32_to_cpu(lsd->lsd_client_start) + + cl_idx * le16_to_cpu(lsd->lsd_client_size); + cfs_init_mutex(&ted->ted_lcd_lock); + LASSERTF(ted->ted_lr_off > 0, "ted_lr_off = %llu\n", ted->ted_lr_off); CDEBUG(D_INFO, "client at index %d (%llu) with UUID '%s' added\n", - fed->fed_lr_idx, fed->fed_lr_off, fed->fed_lcd->lcd_uuid); + ted->ted_lr_idx, ted->ted_lr_off, ted->ted_lcd->lcd_uuid); if (new_client) { struct lvfs_run_ctxt saved; - loff_t off = fed->fed_lr_off; + loff_t off = ted->ted_lr_off; int rc; void *handle; CDEBUG(D_INFO, "writing client lcd at idx %u (%llu) (len %u)\n", - fed->fed_lr_idx,off,(unsigned int)sizeof(*fed->fed_lcd)); + ted->ted_lr_idx,off,(unsigned int)sizeof(*ted->ted_lcd)); if (OBD_FAIL_CHECK(OBD_FAIL_TGT_CLIENT_ADD)) RETURN(-ENOSPC); @@ -372,13 +372,13 @@ static int filter_client_add(struct obd_device *obd, struct obd_export *exp, push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); /* Transaction needed to fix bug 1403 */ handle = fsfilt_start(obd, - filter->fo_rcvd_filp->f_dentry->d_inode, + obt->obt_rcvd_filp->f_dentry->d_inode, FSFILT_OP_SETATTR, NULL); if (IS_ERR(handle)) { rc = PTR_ERR(handle); CERROR("unable to start transaction: rc %d\n", rc); } else { - fed->fed_lcd->lcd_last_epoch = fsd->lsd_start_epoch; + ted->ted_lcd->lcd_last_epoch = lsd->lsd_start_epoch; exp->exp_last_request_time = cfs_time_current_sec(); rc = fsfilt_add_journal_cb(obd, 0, handle, target_client_add_cb, @@ -388,19 +388,19 @@ static int filter_client_add(struct obd_device *obd, struct obd_export *exp, exp->exp_need_sync = 1; cfs_spin_unlock(&exp->exp_lock); } - rc = fsfilt_write_record(obd, filter->fo_rcvd_filp, - fed->fed_lcd, - sizeof(*fed->fed_lcd), + rc = fsfilt_write_record(obd, obt->obt_rcvd_filp, + ted->ted_lcd, + sizeof(*ted->ted_lcd), &off, rc /* sync if no cb */); fsfilt_commit(obd, - filter->fo_rcvd_filp->f_dentry->d_inode, + obt->obt_rcvd_filp->f_dentry->d_inode, handle, 0); } pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); if (rc) { CERROR("error writing %s client idx %u: rc %d\n", - LAST_RCVD, fed->fed_lr_idx, rc); + LAST_RCVD, ted->ted_lr_idx, rc); RETURN(rc); } } @@ -409,62 +409,60 @@ static int filter_client_add(struct obd_device *obd, struct obd_export *exp, static int filter_client_del(struct obd_export *exp) { - struct filter_export_data *fed = &exp->exp_filter_data; - struct filter_obd *filter = &exp->exp_obd->u.filter; - struct obd_device *obd = exp->exp_obd; + struct tg_export_data *ted = &exp->exp_target_data; + struct obd_device_target *obt = &exp->exp_obd->u.obt; struct lvfs_run_ctxt saved; - struct lsd_client_data *lcd = fed->fed_lcd; int rc; loff_t off; ENTRY; - if (lcd == NULL) + if (ted->ted_lcd == NULL) RETURN(0); /* XXX if lcd_uuid were a real obd_uuid, I could use obd_uuid_equals */ - if (strcmp(lcd->lcd_uuid, obd->obd_uuid.uuid ) == 0) + if (strcmp(ted->ted_lcd->lcd_uuid, exp->exp_obd->obd_uuid.uuid ) == 0) GOTO(free, 0); - LASSERT(filter->fo_last_rcvd_slots != NULL); + LASSERT(obt->obt_lut->lut_client_bitmap != NULL); - off = fed->fed_lr_off; + off = ted->ted_lr_off; CDEBUG(D_INFO, "freeing client at idx %u, offset %lld with UUID '%s'\n", - fed->fed_lr_idx, fed->fed_lr_off, lcd->lcd_uuid); + ted->ted_lr_idx, ted->ted_lr_off, ted->ted_lcd->lcd_uuid); - /* Don't clear fed_lr_idx here as it is likely also unset. At worst + /* Don't clear ted_lr_idx here as it is likely also unset. At worst * we leak a client slot that will be cleaned on the next recovery. */ if (off <= 0) { CERROR("%s: client idx %d has med_off %lld\n", - obd->obd_name, fed->fed_lr_idx, off); + exp->exp_obd->obd_name, ted->ted_lr_idx, off); GOTO(free, rc = -EINVAL); } /* Clear the bit _after_ zeroing out the client so we don't race with filter_client_add and zero out new clients.*/ - if (!cfs_test_bit(fed->fed_lr_idx, filter->fo_last_rcvd_slots)) { + if (!cfs_test_bit(ted->ted_lr_idx, obt->obt_lut->lut_client_bitmap)) { CERROR("FILTER client %u: bit already clear in bitmap!!\n", - fed->fed_lr_idx); + ted->ted_lr_idx); LBUG(); } - push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); + push_ctxt(&saved, &exp->exp_obd->obd_lvfs_ctxt, NULL); /* Make sure the server's last_transno is up to date. * This should be done before zeroing client slot so last_transno will * be in server data or in client data in case of failure */ - filter_update_server_data(obd); - - cfs_mutex_down(&fed->fed_lcd_lock); - memset(fed->fed_lcd->lcd_uuid, 0, sizeof fed->fed_lcd->lcd_uuid); - rc = fsfilt_write_record(obd, filter->fo_rcvd_filp, - fed->fed_lcd, - sizeof(*fed->fed_lcd), &off, 0); - cfs_mutex_up(&fed->fed_lcd_lock); - pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); + filter_update_server_data(exp->exp_obd); + + cfs_mutex_down(&ted->ted_lcd_lock); + memset(ted->ted_lcd->lcd_uuid, 0, sizeof ted->ted_lcd->lcd_uuid); + rc = fsfilt_write_record(exp->exp_obd, obt->obt_rcvd_filp, + ted->ted_lcd, + sizeof(*ted->ted_lcd), &off, 0); + cfs_mutex_up(&ted->ted_lcd_lock); + pop_ctxt(&saved, &exp->exp_obd->obd_lvfs_ctxt, NULL); CDEBUG(rc == 0 ? D_INFO : D_ERROR, "zero out client %s at idx %u/%llu in %s, rc %d\n", - lcd->lcd_uuid, fed->fed_lr_idx, fed->fed_lr_off, + ted->ted_lcd->lcd_uuid, ted->ted_lr_idx, ted->ted_lr_off, LAST_RCVD, rc); EXIT; free: @@ -655,10 +653,10 @@ static int filter_init_export(struct obd_export *exp) return ldlm_init_export(exp); } -static int filter_free_server_data(struct filter_obd *filter) +static int filter_free_server_data(struct obd_device_target *obt) { - lut_fini(NULL, filter->fo_obt.obt_lut); - OBD_FREE_PTR(filter->fo_obt.obt_lut); + lut_fini(NULL, obt->obt_lut); + OBD_FREE_PTR(obt->obt_lut); return 0; } @@ -666,18 +664,18 @@ static int filter_free_server_data(struct filter_obd *filter) int filter_update_server_data(struct obd_device *obd) { struct file *filp = obd->u.obt.obt_rcvd_filp; - struct lr_server_data *fsd = class_server_data(obd); + struct lr_server_data *lsd = class_server_data(obd); loff_t off = 0; int rc; ENTRY; - CDEBUG(D_INODE, "server uuid : %s\n", fsd->lsd_uuid); + CDEBUG(D_INODE, "server uuid : %s\n", lsd->lsd_uuid); CDEBUG(D_INODE, "server last_rcvd : "LPU64"\n", - le64_to_cpu(fsd->lsd_last_transno)); + le64_to_cpu(lsd->lsd_last_transno)); CDEBUG(D_INODE, "server last_mount: "LPU64"\n", - le64_to_cpu(fsd->lsd_mount_count)); + le64_to_cpu(lsd->lsd_mount_count)); - rc = fsfilt_write_record(obd, filp, fsd, sizeof(*fsd), &off, 0); + rc = fsfilt_write_record(obd, filp, lsd, sizeof(*lsd), &off, 0); if (rc) CERROR("error writing lr_server_data: rc = %d\n", rc); @@ -715,7 +713,7 @@ extern int ost_handle(struct ptlrpc_request *req); static int filter_init_server_data(struct obd_device *obd, struct file * filp) { struct filter_obd *filter = &obd->u.filter; - struct lr_server_data *fsd; + struct lr_server_data *lsd; struct lsd_client_data *lcd = NULL; struct inode *inode = filp->f_dentry->d_inode; unsigned long last_rcvd_size = i_size_read(inode); @@ -728,7 +726,7 @@ static int filter_init_server_data(struct obd_device *obd, struct file * filp) /* ensure padding in the struct is the correct size */ CLASSERT (offsetof(struct lr_server_data, lsd_padding) + - sizeof(fsd->lsd_padding) == LR_SERVER_SIZE); + sizeof(lsd->lsd_padding) == LR_SERVER_SIZE); CLASSERT (offsetof(struct lsd_client_data, lcd_padding) + sizeof(lcd->lcd_padding) == LR_CLIENT_SIZE); @@ -738,92 +736,92 @@ static int filter_init_server_data(struct obd_device *obd, struct file * filp) RETURN(-ENOMEM); rc = lut_init(NULL, lut, obd, NULL); if (rc) - GOTO(err_fsd, rc); - fsd = class_server_data(obd); + GOTO(err_lut, rc); + lsd = class_server_data(obd); if (last_rcvd_size == 0) { LCONSOLE_WARN("%s: new disk, initializing\n", obd->obd_name); - memcpy(fsd->lsd_uuid, obd->obd_uuid.uuid,sizeof(fsd->lsd_uuid)); - fsd->lsd_last_transno = 0; - mount_count = fsd->lsd_mount_count = 0; - fsd->lsd_server_size = cpu_to_le32(LR_SERVER_SIZE); - fsd->lsd_client_start = cpu_to_le32(LR_CLIENT_START); - fsd->lsd_client_size = cpu_to_le16(LR_CLIENT_SIZE); - fsd->lsd_subdir_count = cpu_to_le16(FILTER_SUBDIR_COUNT); + memcpy(lsd->lsd_uuid, obd->obd_uuid.uuid,sizeof(lsd->lsd_uuid)); + lsd->lsd_last_transno = 0; + mount_count = lsd->lsd_mount_count = 0; + lsd->lsd_server_size = cpu_to_le32(LR_SERVER_SIZE); + lsd->lsd_client_start = cpu_to_le32(LR_CLIENT_START); + lsd->lsd_client_size = cpu_to_le16(LR_CLIENT_SIZE); + lsd->lsd_subdir_count = cpu_to_le16(FILTER_SUBDIR_COUNT); filter->fo_subdir_count = FILTER_SUBDIR_COUNT; /* OBD_COMPAT_OST is set in filter_connect_internal when the * MDS first connects and assigns the OST index number. */ - fsd->lsd_feature_incompat = cpu_to_le32(OBD_INCOMPAT_COMMON_LR| + lsd->lsd_feature_incompat = cpu_to_le32(OBD_INCOMPAT_COMMON_LR| OBD_INCOMPAT_OST); } else { - rc = fsfilt_read_record(obd, filp, fsd, sizeof(*fsd), &off); + rc = fsfilt_read_record(obd, filp, lsd, sizeof(*lsd), &off); if (rc) { CDEBUG(D_INODE,"OBD filter: error reading %s: rc %d\n", LAST_RCVD, rc); - GOTO(err_fsd, rc); + GOTO(err_lut, rc); } - if (strcmp(fsd->lsd_uuid, obd->obd_uuid.uuid) != 0) { + if (strcmp(lsd->lsd_uuid, obd->obd_uuid.uuid) != 0) { LCONSOLE_ERROR_MSG(0x134, "Trying to start OBD %s " "using the wrong disk %s. Were the " "/dev/ assignments rearranged?\n", - obd->obd_uuid.uuid, fsd->lsd_uuid); - GOTO(err_fsd, rc = -EINVAL); + obd->obd_uuid.uuid, lsd->lsd_uuid); + GOTO(err_lut, rc = -EINVAL); } - mount_count = le64_to_cpu(fsd->lsd_mount_count); - filter->fo_subdir_count = le16_to_cpu(fsd->lsd_subdir_count); + mount_count = le64_to_cpu(lsd->lsd_mount_count); + filter->fo_subdir_count = le16_to_cpu(lsd->lsd_subdir_count); /* COMPAT_146 */ /* Assume old last_rcvd format unless I_C_LR is set */ - if (!(fsd->lsd_feature_incompat & + if (!(lsd->lsd_feature_incompat & cpu_to_le32(OBD_INCOMPAT_COMMON_LR))) - fsd->lsd_last_transno = fsd->lsd_compat14; + lsd->lsd_last_transno = lsd->lsd_compat14; /* end COMPAT_146 */ /* OBD_COMPAT_OST is set in filter_connect_internal when the * MDS first connects and assigns the OST index number. */ - fsd->lsd_feature_incompat |= cpu_to_le32(OBD_INCOMPAT_COMMON_LR| + lsd->lsd_feature_incompat |= cpu_to_le32(OBD_INCOMPAT_COMMON_LR| OBD_INCOMPAT_OST); } - if (fsd->lsd_feature_incompat & ~cpu_to_le32(FILTER_INCOMPAT_SUPP)) { + if (lsd->lsd_feature_incompat & ~cpu_to_le32(FILTER_INCOMPAT_SUPP)) { CERROR("%s: unsupported incompat filesystem feature(s) %x\n", - obd->obd_name, le32_to_cpu(fsd->lsd_feature_incompat) & + obd->obd_name, le32_to_cpu(lsd->lsd_feature_incompat) & ~FILTER_INCOMPAT_SUPP); - GOTO(err_fsd, rc = -EINVAL); + GOTO(err_lut, rc = -EINVAL); } - if (fsd->lsd_feature_rocompat & ~cpu_to_le32(FILTER_ROCOMPAT_SUPP)) { + if (lsd->lsd_feature_rocompat & ~cpu_to_le32(FILTER_ROCOMPAT_SUPP)) { CERROR("%s: unsupported read-only filesystem feature(s) %x\n", - obd->obd_name, le32_to_cpu(fsd->lsd_feature_rocompat) & + obd->obd_name, le32_to_cpu(lsd->lsd_feature_rocompat) & ~FILTER_ROCOMPAT_SUPP); /* Do something like remount filesystem read-only */ - GOTO(err_fsd, rc = -EINVAL); + GOTO(err_lut, rc = -EINVAL); } - start_epoch = le32_to_cpu(fsd->lsd_start_epoch); + start_epoch = le32_to_cpu(lsd->lsd_start_epoch); CDEBUG(D_INODE, "%s: server start_epoch : %#x\n", obd->obd_name, start_epoch); CDEBUG(D_INODE, "%s: server last_transno : "LPX64"\n", - obd->obd_name, le64_to_cpu(fsd->lsd_last_transno)); + obd->obd_name, le64_to_cpu(lsd->lsd_last_transno)); CDEBUG(D_INODE, "%s: server mount_count: "LPU64"\n", obd->obd_name, mount_count + 1); CDEBUG(D_INODE, "%s: server data size: %u\n", - obd->obd_name, le32_to_cpu(fsd->lsd_server_size)); + obd->obd_name, le32_to_cpu(lsd->lsd_server_size)); CDEBUG(D_INODE, "%s: per-client data start: %u\n", - obd->obd_name, le32_to_cpu(fsd->lsd_client_start)); + obd->obd_name, le32_to_cpu(lsd->lsd_client_start)); CDEBUG(D_INODE, "%s: per-client data size: %u\n", - obd->obd_name, le32_to_cpu(fsd->lsd_client_size)); + obd->obd_name, le32_to_cpu(lsd->lsd_client_size)); CDEBUG(D_INODE, "%s: server subdir_count: %u\n", - obd->obd_name, le16_to_cpu(fsd->lsd_subdir_count)); + obd->obd_name, le16_to_cpu(lsd->lsd_subdir_count)); CDEBUG(D_INODE, "%s: last_rcvd clients: %lu\n", obd->obd_name, - last_rcvd_size <= le32_to_cpu(fsd->lsd_client_start) ? 0 : - (last_rcvd_size - le32_to_cpu(fsd->lsd_client_start)) / - le16_to_cpu(fsd->lsd_client_size)); + last_rcvd_size <= le32_to_cpu(lsd->lsd_client_start) ? 0 : + (last_rcvd_size - le32_to_cpu(lsd->lsd_client_start)) / + le16_to_cpu(lsd->lsd_client_size)); if (!obd->obd_replayable) { CWARN("%s: recovery support OFF\n", obd->obd_name); GOTO(out, rc = 0); } - for (cl_idx = 0, off = le32_to_cpu(fsd->lsd_client_start); + for (cl_idx = 0, off = le32_to_cpu(lsd->lsd_client_start); off < last_rcvd_size; cl_idx++) { __u64 last_rcvd; struct obd_export *exp; @@ -837,9 +835,9 @@ static int filter_init_server_data(struct obd_device *obd, struct file * filp) /* Don't assume off is incremented properly by * fsfilt_read_record(), in case sizeof(*lcd) - * isn't the same as fsd->lsd_client_size. */ - off = le32_to_cpu(fsd->lsd_client_start) + - cl_idx * le16_to_cpu(fsd->lsd_client_size); + * isn't the same as lsd->lsd_client_size. */ + off = le32_to_cpu(lsd->lsd_client_start) + + cl_idx * le16_to_cpu(lsd->lsd_client_size); rc = fsfilt_read_record(obd, filp, lcd, sizeof(*lcd), &off); if (rc) { CERROR("error reading FILT %s idx %d off %llu: rc %d\n", @@ -864,7 +862,7 @@ static int filter_init_server_data(struct obd_device *obd, struct file * filp) CDEBUG(D_HA, "RCVRNG CLIENT uuid: %s idx: %d lr: "LPU64 " srv lr: "LPU64"\n", lcd->lcd_uuid, cl_idx, - last_rcvd, le64_to_cpu(fsd->lsd_last_transno)); + last_rcvd, le64_to_cpu(lsd->lsd_last_transno)); if (IS_ERR(exp)) { if (PTR_ERR(exp) == -EALREADY) { /* export already exists, zero out this one */ @@ -876,7 +874,7 @@ static int filter_init_server_data(struct obd_device *obd, struct file * filp) } } else { fed = &exp->exp_filter_data; - fed->fed_lcd = lcd; + fed->fed_ted.ted_lcd = lcd; fed->fed_group = 0; /* will be assigned at connect */ filter_export_stats_init(obd, exp, NULL); rc = filter_client_add(obd, exp, cl_idx); @@ -900,17 +898,17 @@ static int filter_init_server_data(struct obd_device *obd, struct file * filp) CDEBUG(D_OTHER, "client at idx %d has last_rcvd = "LPU64"\n", cl_idx, last_rcvd); - if (last_rcvd > le64_to_cpu(fsd->lsd_last_transno)) - fsd->lsd_last_transno = cpu_to_le64(last_rcvd); + if (last_rcvd > le64_to_cpu(lsd->lsd_last_transno)) + lsd->lsd_last_transno = cpu_to_le64(last_rcvd); } if (lcd) OBD_FREE_PTR(lcd); - obd->obd_last_committed = le64_to_cpu(fsd->lsd_last_transno); + obd->obd_last_committed = le64_to_cpu(lsd->lsd_last_transno); out: - filter->fo_mount_count = mount_count + 1; - fsd->lsd_mount_count = cpu_to_le64(filter->fo_mount_count); + lut->lut_mount_count = mount_count + 1; + lsd->lsd_mount_count = cpu_to_le64(lut->lut_mount_count); /* save it, so mount count and last_transno is current */ rc = filter_update_server_data(obd); @@ -921,8 +919,8 @@ out: err_client: class_disconnect_exports(obd); -err_fsd: - filter_free_server_data(filter); +err_lut: + filter_free_server_data(&obd->u.obt); RETURN(rc); } @@ -1054,8 +1052,8 @@ static int filter_read_group_internal(struct obd_device *obd, int group, RETURN(PTR_ERR(dentry)); } } else { - dentry = simple_mkdir(filter->fo_dentry_O, filter->fo_vfsmnt, - name, 0700, 1); + dentry = simple_mkdir(filter->fo_dentry_O, + obd->u.obt.obt_vfsmnt, name, 0700, 1); if (IS_ERR(dentry)) { CERROR("cannot lookup/create O/%s: rc = %ld\n", name, PTR_ERR(dentry)); @@ -1090,7 +1088,7 @@ static int filter_read_group_internal(struct obd_device *obd, int group, snprintf(dir, sizeof(dir), "d%u", i); tmp_subdirs->dentry[i] = simple_mkdir(dentry, - filter->fo_vfsmnt, + obd->u.obt.obt_vfsmnt, dir, 0700, 1); if (IS_ERR(tmp_subdirs->dentry[i])) { rc = PTR_ERR(tmp_subdirs->dentry[i]); @@ -1214,7 +1212,7 @@ static int filter_prep_groups(struct obd_device *obd) loff_t off = 0; ENTRY; - O_dentry = simple_mkdir(current->fs->pwd, filter->fo_vfsmnt, + O_dentry = simple_mkdir(current->fs->pwd, obd->u.obt.obt_vfsmnt, "O", 0700, 1); CDEBUG(D_INODE, "got/created O: %p\n", O_dentry); if (IS_ERR(O_dentry)) { @@ -1286,7 +1284,7 @@ static int filter_prep(struct obd_device *obd) LAST_RCVD, rc); GOTO(out, rc); } - filter->fo_rcvd_filp = file; + obd->u.obt.obt_rcvd_filp = file; if (!S_ISREG(file->f_dentry->d_inode->i_mode)) { CERROR("%s is not a regular file!: mode = %o\n", LAST_RCVD, file->f_dentry->d_inode->i_mode); @@ -1341,11 +1339,11 @@ err_health_check: filter->fo_obt.obt_health_check_filp = NULL; err_server_data: target_recovery_fini(obd); - filter_free_server_data(filter); + filter_free_server_data(&obd->u.obt); err_filp: - if (filp_close(filter->fo_rcvd_filp, 0)) + if (filp_close(obd->u.obt.obt_rcvd_filp, 0)) CERROR("can't close %s after error\n", LAST_RCVD); - filter->fo_rcvd_filp = NULL; + obd->u.obt.obt_rcvd_filp = NULL; goto out; } @@ -1373,8 +1371,8 @@ static void filter_post(struct obd_device *obd) i, rc); } - rc = filp_close(filter->fo_rcvd_filp, 0); - filter->fo_rcvd_filp = NULL; + rc = filp_close(obd->u.obt.obt_rcvd_filp, 0); + obd->u.obt.obt_rcvd_filp = NULL; if (rc) CERROR("error closing %s: rc = %d\n", LAST_RCVD, rc); @@ -1384,7 +1382,7 @@ static void filter_post(struct obd_device *obd) CERROR("error closing %s: rc = %d\n", HEALTH_CHECK, rc); filter_cleanup_groups(obd); - filter_free_server_data(filter); + filter_free_server_data(&obd->u.obt); pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); filter_free_capa_keys(filter); @@ -1612,7 +1610,6 @@ static int filter_destroy_internal(struct obd_device *obd, obd_id objid, struct dentry *dchild) { struct inode *inode = dchild->d_inode; - struct filter_obd *filter = &obd->u.filter; int rc; if (inode->i_nlink != 1 || atomic_read(&inode->i_count) != 1) { @@ -1622,7 +1619,7 @@ static int filter_destroy_internal(struct obd_device *obd, obd_id objid, atomic_read(&inode->i_count)); } - rc = filter_vfs_unlink(dparent->d_inode, dchild, filter->fo_vfsmnt); + rc = filter_vfs_unlink(dparent->d_inode, dchild, obd->u.obt.obt_vfsmnt); if (rc) CERROR("error unlinking objid %.*s: rc %d\n", dchild->d_name.len, dchild->d_name.name, rc); @@ -2035,7 +2032,7 @@ int filter_common_setup(struct obd_device *obd, struct lustre_cfg* lcfg, } } - filter->fo_vfsmnt = mnt; + obd->u.obt.obt_vfsmnt = mnt; obd->u.obt.obt_sb = mnt->mnt_sb; filter->fo_fstype = mnt->mnt_sb->s_type->name; CDEBUG(D_SUPER, "%s: mnt = %p\n", filter->fo_fstype, mnt); @@ -2623,7 +2620,7 @@ static int filter_cleanup(struct obd_device *obd) LL_DQUOT_OFF(obd->u.obt.obt_sb); shrink_dcache_sb(obd->u.obt.obt_sb); - server_put_mount(obd->obd_name, filter->fo_vfsmnt); + server_put_mount(obd->obd_name, obd->u.obt.obt_vfsmnt); obd->u.obt.obt_sb = NULL; fsfilt_put_ops(obd->obd_fsops); @@ -2709,9 +2706,9 @@ static int filter_connect_internal(struct obd_export *exp, data->ocd_index); RETURN(-EBADF); } - /* FIXME: Do the same with the MDS UUID and fsd_peeruuid. + /* FIXME: Do the same with the MDS UUID and lsd_peeruuid. * FIXME: We don't strictly need the COMPAT flag for that, - * FIXME: as fsd_peeruuid[0] will tell us if that is set. + * FIXME: as lsd_peeruuid[0] will tell us if that is set. * FIXME: We needed it for the index, as index 0 is valid. */ } @@ -2778,7 +2775,7 @@ static int filter_connect(const struct lu_env *env, struct lvfs_run_ctxt saved; struct lustre_handle conn = { 0 }; struct obd_export *lexp; - struct filter_export_data *fed; + struct tg_export_data *ted; struct lsd_client_data *lcd = NULL; __u32 group; int rc; @@ -2793,7 +2790,7 @@ static int filter_connect(const struct lu_env *env, lexp = class_conn2export(&conn); LASSERT(lexp != NULL); - fed = &lexp->exp_filter_data; + ted = &lexp->exp_target_data; rc = filter_connect_internal(lexp, data, 0); if (rc) @@ -2808,7 +2805,7 @@ static int filter_connect(const struct lu_env *env, } memcpy(lcd->lcd_uuid, cluuid, sizeof(lcd->lcd_uuid)); - fed->fed_lcd = lcd; + ted->ted_lcd = lcd; rc = filter_client_add(obd, lexp, -1); if (rc) GOTO(cleanup, rc); @@ -3803,7 +3800,7 @@ static int filter_precreate(struct obd_device *obd, struct obdo *oa, if (rc == 0 && osfs->os_bavail < (osfs->os_blocks >> 10)) { CDEBUG(D_RPCTRACE,"%s: not enough space for create " LPU64"\n", obd->obd_name, osfs->os_bavail << - filter->fo_vfsmnt->mnt_sb->s_blocksize_bits); + obd->u.obt.obt_vfsmnt->mnt_sb->s_blocksize_bits); *num = 0; rc = -ENOSPC; } @@ -4255,7 +4252,7 @@ static int filter_sync(struct obd_export *exp, struct obdo *oa, void *capa) { struct lvfs_run_ctxt saved; - struct filter_obd *filter; + struct obd_device_target *obt; struct dentry *dentry; int rc, rc2; ENTRY; @@ -4269,11 +4266,11 @@ static int filter_sync(struct obd_export *exp, struct obdo *oa, if (rc) RETURN(rc); - filter = &exp->exp_obd->u.filter; + obt = &exp->exp_obd->u.obt; /* An objid of zero is taken to mean "sync whole filesystem" */ if (!oa || !(oa->o_valid & OBD_MD_FLID)) { - rc = fsfilt_sync(exp->exp_obd, filter->fo_obt.obt_sb); + rc = fsfilt_sync(exp->exp_obd, obt->obt_sb); /* Flush any remaining cancel messages out to the target */ filter_sync_llogs(exp->exp_obd, exp); RETURN(rc); @@ -4290,7 +4287,7 @@ static int filter_sync(struct obd_export *exp, struct obdo *oa, rc = filemap_fdatawrite(dentry->d_inode->i_mapping); if (rc == 0) { /* just any file to grab fsync method - "file" arg unused */ - struct file *file = filter->fo_rcvd_filp; + struct file *file = obt->obt_rcvd_filp; if (file->f_op && file->f_op->fsync) rc = file->f_op->fsync(NULL, dentry, 1); diff --git a/lustre/obdfilter/lproc_obdfilter.c b/lustre/obdfilter/lproc_obdfilter.c index 76e0edc..e39ae9b 100644 --- a/lustre/obdfilter/lproc_obdfilter.c +++ b/lustre/obdfilter/lproc_obdfilter.c @@ -88,10 +88,10 @@ static int lprocfs_filter_rd_mntdev(char *page, char **start, off_t off, struct obd_device *obd = (struct obd_device *)data; LASSERT(obd != NULL); - LASSERT(obd->u.filter.fo_vfsmnt->mnt_devname); + LASSERT(obd->u.obt.obt_vfsmnt->mnt_devname); *eof = 1; return snprintf(page, count, "%s\n", - obd->u.filter.fo_vfsmnt->mnt_devname); + obd->u.obt.obt_vfsmnt->mnt_devname); } static int lprocfs_filter_rd_last_id(char *page, char **start, off_t off, diff --git a/lustre/ptlrpc/target.c b/lustre/ptlrpc/target.c index 2b2d522..94c6e3b 100644 --- a/lustre/ptlrpc/target.c +++ b/lustre/ptlrpc/target.c @@ -47,17 +47,17 @@ */ static int obt_client_data_update(struct obd_export *exp) { - struct lu_export_data *led = &exp->exp_target_data; + struct tg_export_data *ted = &exp->exp_target_data; struct obd_device_target *obt = &exp->exp_obd->u.obt; struct lu_target *lut = class_exp2tgt(exp); - loff_t off = led->led_lr_off; + loff_t off = ted->ted_lr_off; int rc = 0; rc = fsfilt_write_record(exp->exp_obd, obt->obt_rcvd_filp, - led->led_lcd, sizeof(*led->led_lcd), &off, 0); + ted->ted_lcd, sizeof(*ted->ted_lcd), &off, 0); CDEBUG(D_INFO, "update client idx %u last_epoch %#x (%#x)\n", - led->led_lr_idx, le32_to_cpu(led->led_lcd->lcd_last_epoch), + ted->ted_lr_idx, le32_to_cpu(ted->ted_lcd->lcd_last_epoch), le32_to_cpu(lut->lut_lsd.lsd_start_epoch)); return rc; @@ -93,7 +93,7 @@ int obt_server_data_update(struct lu_target *lut, int force_sync) */ void obt_client_epoch_update(struct obd_export *exp) { - struct lsd_client_data *lcd = exp->exp_target_data.led_lcd; + struct lsd_client_data *lcd = exp->exp_target_data.ted_lcd; struct lu_target *lut = class_exp2tgt(exp); /** VBR: set client last_epoch to current epoch */ @@ -175,16 +175,16 @@ static int lut_last_rcvd_write(const struct lu_env *env, struct lu_target *lut, */ void lut_client_free(struct obd_export *exp) { - struct lu_export_data *led = &exp->exp_target_data; + struct tg_export_data *ted = &exp->exp_target_data; struct lu_target *lut = class_exp2tgt(exp); - OBD_FREE_PTR(led->led_lcd); - led->led_lcd = NULL; + OBD_FREE_PTR(ted->ted_lcd); + ted->ted_lcd = NULL; /* Clear bit when lcd is freed */ spin_lock(&lut->lut_client_bitmap_lock); - if (!test_and_clear_bit(led->led_lr_idx, lut->lut_client_bitmap)) { + if (!test_and_clear_bit(ted->ted_lr_idx, lut->lut_client_bitmap)) { CERROR("%s: client %u bit already clear in bitmap\n", - exp->exp_obd->obd_name, led->led_lr_idx); + exp->exp_obd->obd_name, ted->ted_lr_idx); LBUG(); } spin_unlock(&lut->lut_client_bitmap_lock); @@ -196,17 +196,17 @@ EXPORT_SYMBOL(lut_client_free); */ int lut_client_data_update(const struct lu_env *env, struct obd_export *exp) { - struct lu_export_data *led = &exp->exp_target_data; + struct tg_export_data *ted = &exp->exp_target_data; struct lu_target *lut = class_exp2tgt(exp); struct lsd_client_data tmp_lcd; - loff_t tmp_off = led->led_lr_off; + loff_t tmp_off = ted->ted_lr_off; struct lu_buf tmp_buf = { .lb_buf = &tmp_lcd, .lb_len = sizeof(tmp_lcd) }; int rc = 0; - lcd_cpu_to_le(led->led_lcd, &tmp_lcd); + lcd_cpu_to_le(ted->ted_lcd, &tmp_lcd); LASSERT(lut->lut_last_rcvd); rc = lut_last_rcvd_write(env, lut, &tmp_buf, &tmp_off, 0); @@ -245,7 +245,7 @@ static int lut_server_data_update(const struct lu_env *env, void lut_client_epoch_update(const struct lu_env *env, struct obd_export *exp) { - struct lsd_client_data *lcd = exp->exp_target_data.led_lcd; + struct lsd_client_data *lcd = exp->exp_target_data.ted_lcd; struct lu_target *lut = class_exp2tgt(exp); LASSERT(lut->lut_bottom);