From: Mikhail Pershin Date: Mon, 15 Oct 2012 13:23:00 +0000 (+0400) Subject: LU-2145 target: use tgt_ prefix for target function X-Git-Tag: 2.3.54~20 X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=commitdiff_plain;h=5bea38b1bf8136ea4b286388ce83f2660a425493 LU-2145 target: use tgt_ prefix for target function There are several prefixes used: target_, lut_, tg_. Start to use tgt_ prefix as single one. Signed-off-by: Mikhail Pershin Change-Id: I4e1f38b81a5311d56472162b8a1114a2aa252874 Reviewed-on: http://review.whamcloud.com/4273 Tested-by: Hudson Tested-by: Maloo Reviewed-by: Andreas Dilger Reviewed-by: Alex Zhuravlev --- diff --git a/lustre/include/lu_target.h b/lustre/include/lu_target.h index 1b41913..bc5b327 100644 --- a/lustre/include/lu_target.h +++ b/lustre/include/lu_target.h @@ -59,33 +59,33 @@ struct lu_target { unsigned long *lut_client_bitmap; }; -typedef void (*lut_cb_t)(struct lu_target *lut, __u64 transno, +typedef void (*tgt_cb_t)(struct lu_target *lut, __u64 transno, void *data, int err); -struct lut_commit_cb { - lut_cb_t lut_cb_func; - void *lut_cb_data; +struct tgt_commit_cb { + tgt_cb_t tgt_cb_func; + void *tgt_cb_data; }; -void lut_boot_epoch_update(struct lu_target *lut); -int lut_last_commit_cb_add(struct thandle *th, struct lu_target *lut, +void tgt_boot_epoch_update(struct lu_target *lut); +int tgt_last_commit_cb_add(struct thandle *th, struct lu_target *lut, struct obd_export *exp, __u64 transno); -int lut_new_client_cb_add(struct thandle *th, struct obd_export *exp); +int tgt_new_client_cb_add(struct thandle *th, struct obd_export *exp); int tgt_init(const struct lu_env *env, struct lu_target *lut, struct obd_device *obd, struct dt_device *dt); void tgt_fini(const struct lu_env *env, struct lu_target *lut); -int lut_client_alloc(struct obd_export *exp); -void lut_client_free(struct obd_export *exp); -int lut_client_del(const struct lu_env *env, struct obd_export *exp); -int lut_client_add(const struct lu_env *env, struct obd_export *exp, int); -int lut_client_new(const struct lu_env *env, struct obd_export *exp); -int lut_client_data_read(const struct lu_env *env, struct lu_target *tg, +int tgt_client_alloc(struct obd_export *exp); +void tgt_client_free(struct obd_export *exp); +int tgt_client_del(const struct lu_env *env, struct obd_export *exp); +int tgt_client_add(const struct lu_env *env, struct obd_export *exp, int); +int tgt_client_new(const struct lu_env *env, struct obd_export *exp); +int tgt_client_data_read(const struct lu_env *env, struct lu_target *tg, struct lsd_client_data *lcd, loff_t *off, int index); -int lut_client_data_write(const struct lu_env *env, struct lu_target *tg, +int tgt_client_data_write(const struct lu_env *env, struct lu_target *tg, struct lsd_client_data *lcd, loff_t *off, struct thandle *th); -int lut_server_data_read(const struct lu_env *env, struct lu_target *tg); -int lut_server_data_write(const struct lu_env *env, struct lu_target *tg, +int tgt_server_data_read(const struct lu_env *env, struct lu_target *tg); +int tgt_server_data_write(const struct lu_env *env, struct lu_target *tg, struct thandle *th); -int lut_server_data_update(const struct lu_env *env, struct lu_target *tg, int sync); -int lut_truncate_last_rcvd(const struct lu_env *env, struct lu_target *tg, loff_t off); +int tgt_server_data_update(const struct lu_env *env, struct lu_target *tg, int sync); +int tgt_truncate_last_rcvd(const struct lu_env *env, struct lu_target *tg, loff_t off); #endif /* __LUSTRE_LU_TARGET_H */ diff --git a/lustre/ldlm/ldlm_lib.c b/lustre/ldlm/ldlm_lib.c index f0123e0..9313687 100644 --- a/lustre/ldlm/ldlm_lib.c +++ b/lustre/ldlm/ldlm_lib.c @@ -2075,7 +2075,7 @@ static int target_recovery_thread(void *arg) */ CDEBUG(D_INFO, "3: final stage - process recovery completion pings\n"); /** Update server last boot epoch */ - lut_boot_epoch_update(lut); + tgt_boot_epoch_update(lut); /* We drop recoverying flag to forward all new requests * to regular mds_handle() since now */ cfs_spin_lock(&obd->obd_dev_lock); @@ -2176,7 +2176,7 @@ void target_recovery_init(struct lu_target *lut, svc_handler_t handler) struct obd_device *obd = lut->lut_obd; if (obd->obd_max_recoverable_clients == 0) { /** Update server last boot epoch */ - lut_boot_epoch_update(lut); + tgt_boot_epoch_update(lut); return; } diff --git a/lustre/mdt/mdt_handler.c b/lustre/mdt/mdt_handler.c index 95bfdf9..e1b23e3 100644 --- a/lustre/mdt/mdt_handler.c +++ b/lustre/mdt/mdt_handler.c @@ -5753,7 +5753,7 @@ static int mdt_obd_connect(const struct lu_env *env, LASSERT(lcd); info->mti_exp = lexp; memcpy(lcd->lcd_uuid, cluuid, sizeof lcd->lcd_uuid); - rc = lut_client_new(env, lexp); + rc = tgt_client_new(env, lexp); if (rc == 0) mdt_export_stats_init(obd, lexp, localdata); } @@ -5855,7 +5855,7 @@ static int mdt_export_cleanup(struct obd_export *exp) /* cleanup client slot early */ /* Do not erase record for recoverable client. */ if (!(exp->exp_flags & OBD_OPT_FAILOVER) || exp->exp_failed) - lut_client_del(&env, exp); + tgt_client_del(&env, exp); lu_env_fini(&env); RETURN(rc); @@ -5898,7 +5898,7 @@ static int mdt_init_export(struct obd_export *exp) &exp->exp_client_uuid))) RETURN(0); - rc = lut_client_alloc(exp); + rc = tgt_client_alloc(exp); if (rc) GOTO(err, rc); @@ -5909,7 +5909,7 @@ static int mdt_init_export(struct obd_export *exp) RETURN(rc); err_free: - lut_client_free(exp); + tgt_client_free(exp); err: CERROR("%s: Failed to initialize export: rc = %d\n", exp->exp_obd->obd_name, rc); @@ -5931,7 +5931,7 @@ static int mdt_destroy_export(struct obd_export *exp) RETURN(0); ldlm_destroy_export(exp); - lut_client_free(exp); + tgt_client_free(exp); LASSERT(cfs_list_empty(&exp->exp_outstanding_replies)); LASSERT(cfs_list_empty(&exp->exp_mdt_data.med_open_head)); diff --git a/lustre/mdt/mdt_recovery.c b/lustre/mdt/mdt_recovery.c index 6c07c5f..98bae6f 100644 --- a/lustre/mdt/mdt_recovery.c +++ b/lustre/mdt/mdt_recovery.c @@ -106,7 +106,7 @@ static int mdt_clients_data_init(const struct lu_env *env, off = lsd->lsd_client_start + cl_idx * lsd->lsd_client_size; - rc = lut_client_data_read(env, &mdt->mdt_lut, lcd, &off, cl_idx); + rc = tgt_client_data_read(env, &mdt->mdt_lut, lcd, &off, cl_idx); if (rc) { CERROR("error reading MDS %s idx %d, off %llu: rc %d\n", LAST_RCVD, cl_idx, off, rc); @@ -146,7 +146,7 @@ static int mdt_clients_data_init(const struct lu_env *env, mti->mti_exp = exp; /* copy on-disk lcd to the export */ *exp->exp_target_data.ted_lcd = *lcd; - rc = lut_client_add(env, exp, cl_idx); + rc = tgt_client_add(env, exp, cl_idx); /* can't fail existing */ LASSERTF(rc == 0, "rc = %d\n", rc); /* VBR: set export last committed version */ @@ -221,7 +221,7 @@ static int mdt_server_data_init(const struct lu_env *env, OBD_INCOMPAT_MULTI_OI; } else { LCONSOLE_WARN("%s: used disk, loading\n", obd->obd_name); - rc = lut_server_data_read(env, &mdt->mdt_lut); + rc = tgt_server_data_read(env, &mdt->mdt_lut); if (rc) { CERROR("error reading MDS %s: rc %d\n", LAST_RCVD, rc); GOTO(out, rc); @@ -258,7 +258,7 @@ static int mdt_server_data_init(const struct lu_env *env, LCONSOLE_WARN("Mounting %s at first time on 1.8 FS, " "remove all clients for interop needs\n", obd->obd_name); - rc = lut_truncate_last_rcvd(env, &mdt->mdt_lut, + rc = tgt_truncate_last_rcvd(env, &mdt->mdt_lut, lsd->lsd_client_start); if (rc) GOTO(out, rc); @@ -317,7 +317,7 @@ static int mdt_server_data_init(const struct lu_env *env, lsd->lsd_mount_count = obd->u.obt.obt_mount_count; /* save it, so mount count and last_transno is current */ - rc = lut_server_data_update(env, &mdt->mdt_lut, 0); + rc = tgt_server_data_update(env, &mdt->mdt_lut, 0); if (rc) GOTO(err_client, rc); @@ -358,7 +358,7 @@ static int mdt_last_rcvd_update(struct mdt_thread_info *mti, cfs_mutex_unlock(&ted->ted_lcd_lock); CWARN("commit transaction for disconnected client %s: rc %d\n", req->rq_export->exp_client_uuid.uuid, rc); - err = lut_server_data_write(mti->mti_env, &mdt->mdt_lut, th); + err = tgt_server_data_write(mti->mti_env, &mdt->mdt_lut, th); RETURN(err); } @@ -440,14 +440,14 @@ static int mdt_last_rcvd_update(struct mdt_thread_info *mti, cfs_spin_unlock(&tg->lut_translock); if (update) - err = lut_server_data_write(mti->mti_env, tg, th); + err = tgt_server_data_write(mti->mti_env, tg, th); } else if (off <= 0) { CERROR("%s: client idx %d has offset %lld\n", mdt2obd_dev(mdt)->obd_name, ted->ted_lr_idx, off); cfs_mutex_unlock(&ted->ted_lcd_lock); err = -EINVAL; } else { - err = lut_client_data_write(mti->mti_env, &mdt->mdt_lut, lcd, + err = tgt_client_data_write(mti->mti_env, &mdt->mdt_lut, lcd, &off, th); cfs_mutex_unlock(&ted->ted_lcd_lock); } @@ -543,7 +543,7 @@ static int mdt_txn_stop_cb(const struct lu_env *env, req->rq_transno = mti->mti_transno; lustre_msg_set_transno(req->rq_repmsg, mti->mti_transno); /* if can't add callback, do sync write */ - txn->th_sync |= !!lut_last_commit_cb_add(txn, &mdt->mdt_lut, + txn->th_sync |= !!tgt_last_commit_cb_add(txn, &mdt->mdt_lut, mti->mti_exp, mti->mti_transno); return mdt_last_rcvd_update(mti, txn); diff --git a/lustre/ofd/ofd_fs.c b/lustre/ofd/ofd_fs.c index ee01de2..45c46cc 100644 --- a/lustre/ofd/ofd_fs.c +++ b/lustre/ofd/ofd_fs.c @@ -299,7 +299,7 @@ int ofd_clients_data_init(const struct lu_env *env, struct ofd_device *ofd, * fsfilt_read_record(), in case sizeof(*lcd) * isn't the same as fsd->lsd_client_size. */ off = lsd->lsd_client_start + cl_idx * lsd->lsd_client_size; - rc = lut_client_data_read(env, &ofd->ofd_lut, lcd, &off, cl_idx); + rc = tgt_client_data_read(env, &ofd->ofd_lut, lcd, &off, cl_idx); if (rc) { CERROR("error reading FILT %s idx %d off %llu: rc %d\n", LAST_RCVD, cl_idx, off, rc); @@ -336,7 +336,7 @@ int ofd_clients_data_init(const struct lu_env *env, struct ofd_device *ofd, fed = &exp->exp_filter_data; *fed->fed_ted.ted_lcd = *lcd; - rc = lut_client_add(env, exp, cl_idx); + rc = tgt_client_add(env, exp, cl_idx); LASSERTF(rc == 0, "rc = %d\n", rc); /* can't fail existing */ /* VBR: set export last committed version */ exp->exp_last_committed = last_rcvd; @@ -394,7 +394,7 @@ int ofd_server_data_init(const struct lu_env *env, struct ofd_device *ofd) lsd->lsd_subdir_count = FILTER_SUBDIR_COUNT; lsd->lsd_feature_incompat = OBD_INCOMPAT_OST; } else { - rc = lut_server_data_read(env, &ofd->ofd_lut); + rc = tgt_server_data_read(env, &ofd->ofd_lut); if (rc) { CDEBUG(D_INODE,"OBD ofd: error reading %s: rc %d\n", LAST_RCVD, rc); @@ -457,7 +457,7 @@ int ofd_server_data_init(const struct lu_env *env, struct ofd_device *ofd) cfs_spin_unlock(&ofd->ofd_lut.lut_translock); /* save it, so mount count and last_transno is current */ - rc = lut_server_data_update(env, &ofd->ofd_lut, 0); + rc = tgt_server_data_update(env, &ofd->ofd_lut, 0); if (rc) GOTO(err_fsd, rc); diff --git a/lustre/ofd/ofd_obd.c b/lustre/ofd/ofd_obd.c index 2a05f1d..e024671 100644 --- a/lustre/ofd/ofd_obd.c +++ b/lustre/ofd/ofd_obd.c @@ -177,7 +177,7 @@ static int ofd_parse_connect_data(const struct lu_env *env, lsd->lsd_feature_compat |= OBD_COMPAT_OST; /* sync is not needed here as lut_client_add will * set exp_need_sync flag */ - lut_server_data_update(env, &ofd->ofd_lut, 0); + tgt_server_data_update(env, &ofd->ofd_lut, 0); } else if (index != data->ocd_index) { LCONSOLE_ERROR_MSG(0x136, "Connection from %s to index" " %u doesn't match actual OST index" @@ -307,7 +307,7 @@ static int ofd_obd_connect(const struct lu_env *env, struct obd_export **_exp, memcpy(ted->ted_lcd->lcd_uuid, cluuid, sizeof(ted->ted_lcd->lcd_uuid)); - rc = lut_client_new(env, exp); + rc = tgt_client_new(env, exp); if (rc != 0) GOTO(out, rc); ofd_export_stats_init(ofd, exp, localdata); @@ -355,7 +355,7 @@ static int ofd_obd_disconnect(struct obd_export *exp) /* Do not erase record for recoverable client. */ if (exp->exp_obd->obd_replayable && (!exp->exp_obd->obd_fail || exp->exp_failed)) - lut_client_del(&env, exp); + tgt_client_del(&env, exp); lu_env_fini(&env); class_export_put(exp); @@ -377,7 +377,7 @@ static int ofd_init_export(struct obd_export *exp) &exp->exp_client_uuid))) return 0; - rc = lut_client_alloc(exp); + rc = tgt_client_alloc(exp); if (rc == 0) ldlm_init_export(exp); if (rc) @@ -402,7 +402,7 @@ static int ofd_destroy_export(struct obd_export *exp) return 0; ldlm_destroy_export(exp); - lut_client_free(exp); + tgt_client_free(exp); ofd_fmd_cleanup(exp); diff --git a/lustre/ofd/ofd_trans.c b/lustre/ofd/ofd_trans.c index cd238f3..bcd8c7a 100644 --- a/lustre/ofd/ofd_trans.c +++ b/lustre/ofd/ofd_trans.c @@ -133,7 +133,7 @@ static int ofd_last_rcvd_update(struct ofd_thread_info *info, if (lcd == NULL) { CWARN("commit transaction for disconnected client %s: rc %d\n", info->fti_exp->exp_client_uuid.uuid, rc); - err = lut_server_data_write(info->fti_env, &ofd->ofd_lut, th); + err = tgt_server_data_write(info->fti_env, &ofd->ofd_lut, th); RETURN(err); } /* ofd connect may cause transaction before export has last_rcvd @@ -157,7 +157,7 @@ static int ofd_last_rcvd_update(struct ofd_thread_info *info, ofd->ofd_lut.lut_lsd.lsd_last_transno = ofd->ofd_lut.lut_last_transno; cfs_spin_unlock(&ofd->ofd_lut.lut_translock); - lut_server_data_write(info->fti_env, &ofd->ofd_lut, th); + tgt_server_data_write(info->fti_env, &ofd->ofd_lut, th); } *transno_p = info->fti_transno; @@ -179,10 +179,10 @@ static int ofd_last_rcvd_update(struct ofd_thread_info *info, } cfs_spin_unlock(&tg->lut_translock); if (update) - err = lut_server_data_write(info->fti_env, tg, th); + err = tgt_server_data_write(info->fti_env, tg, th); } else { LASSERT(fed->fed_ted.ted_lr_off > 0); - err = lut_client_data_write(info->fti_env, &ofd->ofd_lut, lcd, + err = tgt_client_data_write(info->fti_env, &ofd->ofd_lut, lcd, &off, th); } @@ -244,7 +244,7 @@ int ofd_txn_stop_cb(const struct lu_env *env, struct thandle *txn, info->fti_transno, ofd_obd(ofd)->obd_last_committed); /* if can't add callback, do sync write */ - txn->th_sync = !!lut_last_commit_cb_add(txn, &ofd->ofd_lut, + txn->th_sync = !!tgt_last_commit_cb_add(txn, &ofd->ofd_lut, info->fti_exp, info->fti_transno); diff --git a/lustre/target/tgt_lastrcvd.c b/lustre/target/tgt_lastrcvd.c index 03014a1..d9021f0 100644 --- a/lustre/target/tgt_lastrcvd.c +++ b/lustre/target/tgt_lastrcvd.c @@ -61,71 +61,72 @@ static inline struct lu_buf *tti_buf_lcd(struct tgt_thread_info *tti) /** * Allocate in-memory data for client slot related to export. */ -int lut_client_alloc(struct obd_export *exp) +int tgt_client_alloc(struct obd_export *exp) { - LASSERT(exp != exp->exp_obd->obd_self_export); - - OBD_ALLOC_PTR(exp->exp_target_data.ted_lcd); - if (exp->exp_target_data.ted_lcd == NULL) - RETURN(-ENOMEM); - /* Mark that slot is not yet valid, 0 doesn't work here */ - exp->exp_target_data.ted_lr_idx = -1; - RETURN(0); + ENTRY; + LASSERT(exp != exp->exp_obd->obd_self_export); + + OBD_ALLOC_PTR(exp->exp_target_data.ted_lcd); + if (exp->exp_target_data.ted_lcd == NULL) + RETURN(-ENOMEM); + /* Mark that slot is not yet valid, 0 doesn't work here */ + exp->exp_target_data.ted_lr_idx = -1; + RETURN(0); } -EXPORT_SYMBOL(lut_client_alloc); +EXPORT_SYMBOL(tgt_client_alloc); /** * Free in-memory data for client slot related to export. */ -void lut_client_free(struct obd_export *exp) +void tgt_client_free(struct obd_export *exp) { - struct tg_export_data *ted = &exp->exp_target_data; - struct lu_target *lut = class_exp2tgt(exp); + struct tg_export_data *ted = &exp->exp_target_data; + struct lu_target *lut = class_exp2tgt(exp); - LASSERT(exp != exp->exp_obd->obd_self_export); + LASSERT(exp != exp->exp_obd->obd_self_export); - OBD_FREE_PTR(ted->ted_lcd); - ted->ted_lcd = NULL; + OBD_FREE_PTR(ted->ted_lcd); + ted->ted_lcd = NULL; - /* Slot may be not yet assigned */ - if (ted->ted_lr_idx < 0) - return; - /* Clear bit when lcd is freed */ + /* Slot may be not yet assigned */ + if (ted->ted_lr_idx < 0) + return; + /* Clear bit when lcd is freed */ LASSERT(lut->lut_client_bitmap); - if (!cfs_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, ted->ted_lr_idx); - LBUG(); - } + if (!cfs_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, ted->ted_lr_idx); + LBUG(); + } } -EXPORT_SYMBOL(lut_client_free); +EXPORT_SYMBOL(tgt_client_free); -int lut_client_data_read(const struct lu_env *env, struct lu_target *tg, +int tgt_client_data_read(const struct lu_env *env, struct lu_target *tgt, struct lsd_client_data *lcd, loff_t *off, int index) { - struct tgt_thread_info *tti = tgt_th_info(env); - int rc; + struct tgt_thread_info *tti = tgt_th_info(env); + int rc; tti_buf_lcd(tti); - rc = dt_record_read(env, tg->lut_last_rcvd, &tti->tti_buf, off); + rc = dt_record_read(env, tgt->lut_last_rcvd, &tti->tti_buf, off); if (rc == 0) { - check_lcd(tg->lut_obd->obd_name, index, &tti->tti_lcd); + check_lcd(tgt->lut_obd->obd_name, index, &tti->tti_lcd); lcd_le_to_cpu(&tti->tti_lcd, lcd); } CDEBUG(D_INFO, "%s: read lcd @%lld uuid = %s, last_transno = "LPU64 ", last_xid = "LPU64", last_result = %u, last_data = %u, " "last_close_transno = "LPU64", last_close_xid = "LPU64", " - "last_close_result = %u, rc = %d\n", tg->lut_obd->obd_name, + "last_close_result = %u, rc = %d\n", tgt->lut_obd->obd_name, *off, lcd->lcd_uuid, lcd->lcd_last_transno, lcd->lcd_last_xid, lcd->lcd_last_result, lcd->lcd_last_data, lcd->lcd_last_close_transno, lcd->lcd_last_close_xid, lcd->lcd_last_close_result, rc); return rc; } -EXPORT_SYMBOL(lut_client_data_read); +EXPORT_SYMBOL(tgt_client_data_read); -int lut_client_data_write(const struct lu_env *env, struct lu_target *tg, +int tgt_client_data_write(const struct lu_env *env, struct lu_target *tgt, struct lsd_client_data *lcd, loff_t *off, struct thandle *th) { @@ -134,34 +135,34 @@ int lut_client_data_write(const struct lu_env *env, struct lu_target *tg, lcd_cpu_to_le(lcd, &tti->tti_lcd); tti_buf_lcd(tti); - return dt_record_write(env, tg->lut_last_rcvd, &tti->tti_buf, off, th); + return dt_record_write(env, tgt->lut_last_rcvd, &tti->tti_buf, off, th); } -EXPORT_SYMBOL(lut_client_data_write); +EXPORT_SYMBOL(tgt_client_data_write); /** * Update client data in last_rcvd */ -int lut_client_data_update(const struct lu_env *env, struct obd_export *exp) +int tgt_client_data_update(const struct lu_env *env, struct obd_export *exp) { - struct tg_export_data *ted = &exp->exp_target_data; - struct lu_target *tg = class_exp2tgt(exp); - struct tgt_thread_info *tti = tgt_th_info(env); - struct thandle *th; - int rc = 0; + struct tg_export_data *ted = &exp->exp_target_data; + struct lu_target *tgt = class_exp2tgt(exp); + struct tgt_thread_info *tti = tgt_th_info(env); + struct thandle *th; + int rc = 0; ENTRY; - th = dt_trans_create(env, tg->lut_bottom); + th = dt_trans_create(env, tgt->lut_bottom); if (IS_ERR(th)) RETURN(PTR_ERR(th)); - rc = dt_declare_record_write(env, tg->lut_last_rcvd, + rc = dt_declare_record_write(env, tgt->lut_last_rcvd, sizeof(struct lsd_client_data), ted->ted_lr_off, th); if (rc) GOTO(out, rc); - rc = dt_trans_start_local(env, tg->lut_bottom, th); + rc = dt_trans_start_local(env, tgt->lut_bottom, th); if (rc) GOTO(out, rc); /* @@ -170,7 +171,7 @@ int lut_client_data_update(const struct lu_env *env, struct obd_export *exp) * transaction so that many connecting clients will not bring * server down with lots of sync writes. */ - rc = lut_new_client_cb_add(th, exp); + rc = tgt_new_client_cb_add(th, exp); if (rc) { /* can't add callback, do sync now */ th->th_sync = 1; @@ -181,110 +182,112 @@ int lut_client_data_update(const struct lu_env *env, struct obd_export *exp) } tti->tti_off = ted->ted_lr_off; - rc = lut_client_data_write(env, tg, ted->ted_lcd, &tti->tti_off, th); + rc = tgt_client_data_write(env, tgt, ted->ted_lcd, &tti->tti_off, th); EXIT; out: - dt_trans_stop(env, tg->lut_bottom, th); + dt_trans_stop(env, tgt->lut_bottom, th); CDEBUG(D_INFO, "%s: update last_rcvd client data for UUID = %s, " - "last_transno = "LPU64": rc = %d\n", tg->lut_obd->obd_name, - tg->lut_lsd.lsd_uuid, tg->lut_lsd.lsd_last_transno, rc); + "last_transno = "LPU64": rc = %d\n", tgt->lut_obd->obd_name, + tgt->lut_lsd.lsd_uuid, tgt->lut_lsd.lsd_last_transno, rc); return rc; } -int lut_server_data_read(const struct lu_env *env, struct lu_target *tg) +int tgt_server_data_read(const struct lu_env *env, struct lu_target *tgt) { - struct tgt_thread_info *tti = tgt_th_info(env); - int rc; + struct tgt_thread_info *tti = tgt_th_info(env); + int rc; tti->tti_off = 0; tti_buf_lsd(tti); - rc = dt_record_read(env, tg->lut_last_rcvd, &tti->tti_buf, &tti->tti_off); + rc = dt_record_read(env, tgt->lut_last_rcvd, &tti->tti_buf, + &tti->tti_off); if (rc == 0) - lsd_le_to_cpu(&tti->tti_lsd, &tg->lut_lsd); + lsd_le_to_cpu(&tti->tti_lsd, &tgt->lut_lsd); CDEBUG(D_INFO, "%s: read last_rcvd server data for UUID = %s, " - "last_transno = "LPU64": rc = %d\n", tg->lut_obd->obd_name, - tg->lut_lsd.lsd_uuid, tg->lut_lsd.lsd_last_transno, rc); + "last_transno = "LPU64": rc = %d\n", tgt->lut_obd->obd_name, + tgt->lut_lsd.lsd_uuid, tgt->lut_lsd.lsd_last_transno, rc); return rc; } -EXPORT_SYMBOL(lut_server_data_read); +EXPORT_SYMBOL(tgt_server_data_read); -int lut_server_data_write(const struct lu_env *env, struct lu_target *tg, +int tgt_server_data_write(const struct lu_env *env, struct lu_target *tgt, struct thandle *th) { - struct tgt_thread_info *tti = tgt_th_info(env); - int rc; + struct tgt_thread_info *tti = tgt_th_info(env); + int rc; + ENTRY; tti->tti_off = 0; tti_buf_lsd(tti); - lsd_cpu_to_le(&tg->lut_lsd, &tti->tti_lsd); + lsd_cpu_to_le(&tgt->lut_lsd, &tti->tti_lsd); - rc = dt_record_write(env, tg->lut_last_rcvd, &tti->tti_buf, + rc = dt_record_write(env, tgt->lut_last_rcvd, &tti->tti_buf, &tti->tti_off, th); CDEBUG(D_INFO, "%s: write last_rcvd server data for UUID = %s, " - "last_transno = "LPU64": rc = %d\n", tg->lut_obd->obd_name, - tg->lut_lsd.lsd_uuid, tg->lut_lsd.lsd_last_transno, rc); + "last_transno = "LPU64": rc = %d\n", tgt->lut_obd->obd_name, + tgt->lut_lsd.lsd_uuid, tgt->lut_lsd.lsd_last_transno, rc); RETURN(rc); } -EXPORT_SYMBOL(lut_server_data_write); +EXPORT_SYMBOL(tgt_server_data_write); /** * Update server data in last_rcvd */ -int lut_server_data_update(const struct lu_env *env, struct lu_target *tg, +int tgt_server_data_update(const struct lu_env *env, struct lu_target *tgt, int sync) { - struct tgt_thread_info *tti = tgt_th_info(env); - struct thandle *th; - int rc = 0; + struct tgt_thread_info *tti = tgt_th_info(env); + struct thandle *th; + int rc = 0; ENTRY; CDEBUG(D_SUPER, "%s: mount_count is "LPU64", last_transno is "LPU64"\n", - tg->lut_lsd.lsd_uuid, tg->lut_obd->u.obt.obt_mount_count, - tg->lut_last_transno); + tgt->lut_lsd.lsd_uuid, tgt->lut_obd->u.obt.obt_mount_count, + tgt->lut_last_transno); /* Always save latest transno to keep it fresh */ - cfs_spin_lock(&tg->lut_translock); - tg->lut_lsd.lsd_last_transno = tg->lut_last_transno; - cfs_spin_unlock(&tg->lut_translock); + cfs_spin_lock(&tgt->lut_translock); + tgt->lut_lsd.lsd_last_transno = tgt->lut_last_transno; + cfs_spin_unlock(&tgt->lut_translock); - th = dt_trans_create(env, tg->lut_bottom); + th = dt_trans_create(env, tgt->lut_bottom); if (IS_ERR(th)) RETURN(PTR_ERR(th)); th->th_sync = sync; - rc = dt_declare_record_write(env, tg->lut_last_rcvd, + rc = dt_declare_record_write(env, tgt->lut_last_rcvd, sizeof(struct lr_server_data), tti->tti_off, th); if (rc) GOTO(out, rc); - rc = dt_trans_start(env, tg->lut_bottom, th); + rc = dt_trans_start(env, tgt->lut_bottom, th); if (rc) GOTO(out, rc); - rc = lut_server_data_write(env, tg, th); + rc = tgt_server_data_write(env, tgt, th); out: - dt_trans_stop(env, tg->lut_bottom, th); + dt_trans_stop(env, tgt->lut_bottom, th); CDEBUG(D_INFO, "%s: update last_rcvd server data for UUID = %s, " - "last_transno = "LPU64": rc = %d\n", tg->lut_obd->obd_name, - tg->lut_lsd.lsd_uuid, tg->lut_lsd.lsd_last_transno, rc); + "last_transno = "LPU64": rc = %d\n", tgt->lut_obd->obd_name, + tgt->lut_lsd.lsd_uuid, tgt->lut_lsd.lsd_last_transno, rc); RETURN(rc); } -EXPORT_SYMBOL(lut_server_data_update); +EXPORT_SYMBOL(tgt_server_data_update); -int lut_truncate_last_rcvd(const struct lu_env *env, struct lu_target *tg, +int tgt_truncate_last_rcvd(const struct lu_env *env, struct lu_target *tgt, loff_t size) { - struct dt_object *dt = tg->lut_last_rcvd; + struct dt_object *dt = tgt->lut_last_rcvd; struct thandle *th; struct lu_attr attr; int rc; @@ -294,7 +297,7 @@ int lut_truncate_last_rcvd(const struct lu_env *env, struct lu_target *tg, attr.la_size = size; attr.la_valid = LA_SIZE; - th = dt_trans_create(env, tg->lut_bottom); + th = dt_trans_create(env, tgt->lut_bottom); if (IS_ERR(th)) RETURN(PTR_ERR(th)); rc = dt_declare_punch(env, dt, size, OBD_OBJECT_EOF, th); @@ -303,7 +306,7 @@ int lut_truncate_last_rcvd(const struct lu_env *env, struct lu_target *tg, rc = dt_declare_attr_set(env, dt, &attr, th); if (rc) GOTO(cleanup, rc); - rc = dt_trans_start_local(env, tg->lut_bottom, th); + rc = dt_trans_start_local(env, tgt->lut_bottom, th); if (rc) GOTO(cleanup, rc); @@ -312,137 +315,138 @@ int lut_truncate_last_rcvd(const struct lu_env *env, struct lu_target *tg, rc = dt_attr_set(env, dt, &attr, th, BYPASS_CAPA); cleanup: - dt_trans_stop(env, tg->lut_bottom, th); + dt_trans_stop(env, tgt->lut_bottom, th); RETURN(rc); } -EXPORT_SYMBOL(lut_truncate_last_rcvd); +EXPORT_SYMBOL(tgt_truncate_last_rcvd); -void lut_client_epoch_update(const struct lu_env *env, struct obd_export *exp) +void tgt_client_epoch_update(const struct lu_env *env, struct obd_export *exp) { - struct lsd_client_data *lcd = exp->exp_target_data.ted_lcd; - struct lu_target *lut = class_exp2tgt(exp); - - LASSERT(lut->lut_bottom); - /** VBR: set client last_epoch to current epoch */ - if (lcd->lcd_last_epoch >= lut->lut_lsd.lsd_start_epoch) - return; - lcd->lcd_last_epoch = lut->lut_lsd.lsd_start_epoch; - lut_client_data_update(env, exp); + struct lsd_client_data *lcd = exp->exp_target_data.ted_lcd; + struct lu_target *tgt = class_exp2tgt(exp); + + LASSERT(tgt->lut_bottom); + /** VBR: set client last_epoch to current epoch */ + if (lcd->lcd_last_epoch >= tgt->lut_lsd.lsd_start_epoch) + return; + lcd->lcd_last_epoch = tgt->lut_lsd.lsd_start_epoch; + tgt_client_data_update(env, exp); } /** * Update boot epoch when recovery ends */ -void lut_boot_epoch_update(struct lu_target *lut) +void tgt_boot_epoch_update(struct lu_target *tgt) { - struct lu_env env; - struct ptlrpc_request *req; - __u32 start_epoch; - cfs_list_t client_list; - int rc; + struct lu_env env; + struct ptlrpc_request *req; + __u32 start_epoch; + cfs_list_t client_list; + int rc; - if (lut->lut_obd->obd_stopping) - return; + if (tgt->lut_obd->obd_stopping) + return; rc = lu_env_init(&env, LCT_DT_THREAD); - if (rc) { - CERROR("Can't initialize environment rc=%d\n", rc); - return; - } - - cfs_spin_lock(&lut->lut_translock); - start_epoch = lr_epoch(lut->lut_last_transno) + 1; - lut->lut_last_transno = (__u64)start_epoch << LR_EPOCH_BITS; - lut->lut_lsd.lsd_start_epoch = start_epoch; - cfs_spin_unlock(&lut->lut_translock); - - CFS_INIT_LIST_HEAD(&client_list); - /** - * The recovery is not yet finished and final queue can still be updated - * with resend requests. Move final list to separate one for processing - */ - cfs_spin_lock(&lut->lut_obd->obd_recovery_task_lock); - cfs_list_splice_init(&lut->lut_obd->obd_final_req_queue, &client_list); - cfs_spin_unlock(&lut->lut_obd->obd_recovery_task_lock); - - /** - * go through list of exports participated in recovery and - * set new epoch for them - */ - cfs_list_for_each_entry(req, &client_list, rq_list) { - LASSERT(!req->rq_export->exp_delayed); - if (!req->rq_export->exp_vbr_failed) - lut_client_epoch_update(&env, req->rq_export); - } - /** return list back at once */ - cfs_spin_lock(&lut->lut_obd->obd_recovery_task_lock); - cfs_list_splice_init(&client_list, &lut->lut_obd->obd_final_req_queue); - cfs_spin_unlock(&lut->lut_obd->obd_recovery_task_lock); - /** update server epoch */ - lut_server_data_update(&env, lut, 1); - lu_env_fini(&env); + if (rc) { + CERROR("%s: can't initialize environment: rc = %d\n", + tgt->lut_obd->obd_name, rc); + return; + } + + cfs_spin_lock(&tgt->lut_translock); + start_epoch = lr_epoch(tgt->lut_last_transno) + 1; + tgt->lut_last_transno = (__u64)start_epoch << LR_EPOCH_BITS; + tgt->lut_lsd.lsd_start_epoch = start_epoch; + cfs_spin_unlock(&tgt->lut_translock); + + CFS_INIT_LIST_HEAD(&client_list); + /** + * The recovery is not yet finished and final queue can still be updated + * with resend requests. Move final list to separate one for processing + */ + cfs_spin_lock(&tgt->lut_obd->obd_recovery_task_lock); + cfs_list_splice_init(&tgt->lut_obd->obd_final_req_queue, &client_list); + cfs_spin_unlock(&tgt->lut_obd->obd_recovery_task_lock); + + /** + * go through list of exports participated in recovery and + * set new epoch for them + */ + cfs_list_for_each_entry(req, &client_list, rq_list) { + LASSERT(!req->rq_export->exp_delayed); + if (!req->rq_export->exp_vbr_failed) + tgt_client_epoch_update(&env, req->rq_export); + } + /** return list back at once */ + cfs_spin_lock(&tgt->lut_obd->obd_recovery_task_lock); + cfs_list_splice_init(&client_list, &tgt->lut_obd->obd_final_req_queue); + cfs_spin_unlock(&tgt->lut_obd->obd_recovery_task_lock); + /** update server epoch */ + tgt_server_data_update(&env, tgt, 1); + lu_env_fini(&env); } -EXPORT_SYMBOL(lut_boot_epoch_update); +EXPORT_SYMBOL(tgt_boot_epoch_update); /** * commit callback, need to update last_commited value */ -struct lut_last_committed_callback { - struct dt_txn_commit_cb llcc_cb; - struct lu_target *llcc_lut; - struct obd_export *llcc_exp; - __u64 llcc_transno; +struct tgt_last_committed_callback { + struct dt_txn_commit_cb llcc_cb; + struct lu_target *llcc_tgt; + struct obd_export *llcc_exp; + __u64 llcc_transno; }; -void lut_cb_last_committed(struct lu_env *env, struct thandle *th, - struct dt_txn_commit_cb *cb, int err) +void tgt_cb_last_committed(struct lu_env *env, struct thandle *th, + struct dt_txn_commit_cb *cb, int err) { - struct lut_last_committed_callback *ccb; - - ccb = container_of0(cb, struct lut_last_committed_callback, llcc_cb); - - LASSERT(ccb->llcc_lut != NULL); - LASSERT(ccb->llcc_exp->exp_obd == ccb->llcc_lut->lut_obd); - - cfs_spin_lock(&ccb->llcc_lut->lut_translock); - if (ccb->llcc_transno > ccb->llcc_lut->lut_obd->obd_last_committed) - ccb->llcc_lut->lut_obd->obd_last_committed = ccb->llcc_transno; - - LASSERT(ccb->llcc_exp); - if (ccb->llcc_transno > ccb->llcc_exp->exp_last_committed) { - ccb->llcc_exp->exp_last_committed = ccb->llcc_transno; - cfs_spin_unlock(&ccb->llcc_lut->lut_translock); - ptlrpc_commit_replies(ccb->llcc_exp); - } else { - cfs_spin_unlock(&ccb->llcc_lut->lut_translock); - } - class_export_cb_put(ccb->llcc_exp); - if (ccb->llcc_transno) - CDEBUG(D_HA, "%s: transno "LPD64" is committed\n", - ccb->llcc_lut->lut_obd->obd_name, ccb->llcc_transno); - OBD_FREE_PTR(ccb); + struct tgt_last_committed_callback *ccb; + + ccb = container_of0(cb, struct tgt_last_committed_callback, llcc_cb); + + LASSERT(ccb->llcc_tgt != NULL); + LASSERT(ccb->llcc_exp->exp_obd == ccb->llcc_tgt->lut_obd); + + cfs_spin_lock(&ccb->llcc_tgt->lut_translock); + if (ccb->llcc_transno > ccb->llcc_tgt->lut_obd->obd_last_committed) + ccb->llcc_tgt->lut_obd->obd_last_committed = ccb->llcc_transno; + + LASSERT(ccb->llcc_exp); + if (ccb->llcc_transno > ccb->llcc_exp->exp_last_committed) { + ccb->llcc_exp->exp_last_committed = ccb->llcc_transno; + cfs_spin_unlock(&ccb->llcc_tgt->lut_translock); + ptlrpc_commit_replies(ccb->llcc_exp); + } else { + cfs_spin_unlock(&ccb->llcc_tgt->lut_translock); + } + class_export_cb_put(ccb->llcc_exp); + if (ccb->llcc_transno) + CDEBUG(D_HA, "%s: transno "LPD64" is committed\n", + ccb->llcc_tgt->lut_obd->obd_name, ccb->llcc_transno); + OBD_FREE_PTR(ccb); } -int lut_last_commit_cb_add(struct thandle *th, struct lu_target *lut, - struct obd_export *exp, __u64 transno) +int tgt_last_commit_cb_add(struct thandle *th, struct lu_target *tgt, + struct obd_export *exp, __u64 transno) { - struct lut_last_committed_callback *ccb; - struct dt_txn_commit_cb *dcb; - int rc; + struct tgt_last_committed_callback *ccb; + struct dt_txn_commit_cb *dcb; + int rc; OBD_ALLOC_PTR(ccb); if (ccb == NULL) return -ENOMEM; - ccb->llcc_lut = lut; - ccb->llcc_exp = class_export_cb_get(exp); + ccb->llcc_tgt = tgt; + ccb->llcc_exp = class_export_cb_get(exp); ccb->llcc_transno = transno; - dcb = &ccb->llcc_cb; - dcb->dcb_func = lut_cb_last_committed; + dcb = &ccb->llcc_cb; + dcb->dcb_func = tgt_cb_last_committed; CFS_INIT_LIST_HEAD(&dcb->dcb_linkage); - strncpy(dcb->dcb_name, "lut_cb_last_committed", MAX_COMMIT_CB_STR_LEN); + strncpy(dcb->dcb_name, "tgt_cb_last_committed", MAX_COMMIT_CB_STR_LEN); dcb->dcb_name[MAX_COMMIT_CB_STR_LEN - 1] = '\0'; rc = dt_trans_cb_add(th, dcb); @@ -457,50 +461,50 @@ int lut_last_commit_cb_add(struct thandle *th, struct lu_target *lut, return rc; } -EXPORT_SYMBOL(lut_last_commit_cb_add); +EXPORT_SYMBOL(tgt_last_commit_cb_add); -struct lut_new_client_callback { - struct dt_txn_commit_cb lncc_cb; - struct obd_export *lncc_exp; +struct tgt_new_client_callback { + struct dt_txn_commit_cb lncc_cb; + struct obd_export *lncc_exp; }; -void lut_cb_new_client(struct lu_env *env, struct thandle *th, - struct dt_txn_commit_cb *cb, int err) +void tgt_cb_new_client(struct lu_env *env, struct thandle *th, + struct dt_txn_commit_cb *cb, int err) { - struct lut_new_client_callback *ccb; + struct tgt_new_client_callback *ccb; - ccb = container_of0(cb, struct lut_new_client_callback, lncc_cb); + ccb = container_of0(cb, struct tgt_new_client_callback, lncc_cb); - LASSERT(ccb->lncc_exp->exp_obd); + LASSERT(ccb->lncc_exp->exp_obd); - CDEBUG(D_RPCTRACE, "%s: committing for initial connect of %s\n", - ccb->lncc_exp->exp_obd->obd_name, - ccb->lncc_exp->exp_client_uuid.uuid); + CDEBUG(D_RPCTRACE, "%s: committing for initial connect of %s\n", + ccb->lncc_exp->exp_obd->obd_name, + ccb->lncc_exp->exp_client_uuid.uuid); - cfs_spin_lock(&ccb->lncc_exp->exp_lock); - ccb->lncc_exp->exp_need_sync = 0; - cfs_spin_unlock(&ccb->lncc_exp->exp_lock); - class_export_cb_put(ccb->lncc_exp); + cfs_spin_lock(&ccb->lncc_exp->exp_lock); + ccb->lncc_exp->exp_need_sync = 0; + cfs_spin_unlock(&ccb->lncc_exp->exp_lock); + class_export_cb_put(ccb->lncc_exp); - OBD_FREE_PTR(ccb); + OBD_FREE_PTR(ccb); } -int lut_new_client_cb_add(struct thandle *th, struct obd_export *exp) +int tgt_new_client_cb_add(struct thandle *th, struct obd_export *exp) { - struct lut_new_client_callback *ccb; - struct dt_txn_commit_cb *dcb; - int rc; + struct tgt_new_client_callback *ccb; + struct dt_txn_commit_cb *dcb; + int rc; OBD_ALLOC_PTR(ccb); if (ccb == NULL) return -ENOMEM; - ccb->lncc_exp = class_export_cb_get(exp); + ccb->lncc_exp = class_export_cb_get(exp); - dcb = &ccb->lncc_cb; - dcb->dcb_func = lut_cb_new_client; + dcb = &ccb->lncc_cb; + dcb->dcb_func = tgt_cb_new_client; CFS_INIT_LIST_HEAD(&dcb->dcb_linkage); - strncpy(dcb->dcb_name, "lut_cb_new_client", MAX_COMMIT_CB_STR_LEN); + strncpy(dcb->dcb_name, "tgt_cb_new_client", MAX_COMMIT_CB_STR_LEN); dcb->dcb_name[MAX_COMMIT_CB_STR_LEN - 1] = '\0'; rc = dt_trans_cb_add(th, dcb); @@ -517,16 +521,16 @@ int lut_new_client_cb_add(struct thandle *th, struct obd_export *exp) * We use a bitmap to locate a free space in the last_rcvd file and initialize * tg_export_data. */ -int lut_client_new(const struct lu_env *env, struct obd_export *exp) +int tgt_client_new(const struct lu_env *env, struct obd_export *exp) { - struct tg_export_data *ted = &exp->exp_target_data; - struct lu_target *tg = class_exp2tgt(exp); - int rc = 0, idx; + struct tg_export_data *ted = &exp->exp_target_data; + struct lu_target *tgt = class_exp2tgt(exp); + int rc = 0, idx; ENTRY; - LASSERT(tg->lut_client_bitmap != NULL); - if (!strcmp(ted->ted_lcd->lcd_uuid, tg->lut_obd->obd_uuid.uuid)) + LASSERT(tgt->lut_client_bitmap != NULL); + if (!strcmp(ted->ted_lcd->lcd_uuid, tgt->lut_obd->obd_uuid.uuid)) RETURN(0); cfs_mutex_init(&ted->ted_lcd_lock); @@ -537,44 +541,44 @@ int lut_client_new(const struct lu_env *env, struct obd_export *exp) /* the bitmap operations can handle cl_idx > sizeof(long) * 8, so * there's no need for extra complication here */ - idx = cfs_find_first_zero_bit(tg->lut_client_bitmap, LR_MAX_CLIENTS); + idx = cfs_find_first_zero_bit(tgt->lut_client_bitmap, LR_MAX_CLIENTS); repeat: if (idx >= LR_MAX_CLIENTS || OBD_FAIL_CHECK(OBD_FAIL_MDS_CLIENT_ADD)) { CERROR("%s: no room for %u clients - fix LR_MAX_CLIENTS\n", - tg->lut_obd->obd_name, idx); + tgt->lut_obd->obd_name, idx); RETURN(-EOVERFLOW); } - if (cfs_test_and_set_bit(idx, tg->lut_client_bitmap)) { - idx = cfs_find_next_zero_bit(tg->lut_client_bitmap, + if (cfs_test_and_set_bit(idx, tgt->lut_client_bitmap)) { + idx = cfs_find_next_zero_bit(tgt->lut_client_bitmap, LR_MAX_CLIENTS, idx); goto repeat; } CDEBUG(D_INFO, "%s: client at idx %d with UUID '%s' added\n", - tg->lut_obd->obd_name, idx, ted->ted_lcd->lcd_uuid); + tgt->lut_obd->obd_name, idx, ted->ted_lcd->lcd_uuid); ted->ted_lr_idx = idx; - ted->ted_lr_off = tg->lut_lsd.lsd_client_start + - idx * tg->lut_lsd.lsd_client_size; + ted->ted_lr_off = tgt->lut_lsd.lsd_client_start + + idx * tgt->lut_lsd.lsd_client_size; LASSERTF(ted->ted_lr_off > 0, "ted_lr_off = %llu\n", ted->ted_lr_off); CDEBUG(D_INFO, "%s: new client at index %d (%llu) with UUID '%s'\n", - tg->lut_obd->obd_name, ted->ted_lr_idx, ted->ted_lr_off, + tgt->lut_obd->obd_name, ted->ted_lr_idx, ted->ted_lr_off, ted->ted_lcd->lcd_uuid); if (OBD_FAIL_CHECK(OBD_FAIL_TGT_CLIENT_ADD)) RETURN(-ENOSPC); - rc = lut_client_data_update(env, exp); + rc = tgt_client_data_update(env, exp); if (rc) CERROR("%s: Failed to write client lcd at idx %d, rc %d\n", - tg->lut_obd->obd_name, idx, rc); + tgt->lut_obd->obd_name, idx, rc); RETURN(rc); } -EXPORT_SYMBOL(lut_client_new); +EXPORT_SYMBOL(tgt_client_new); /* Add client data to the MDS. We use a bitmap to locate a free space * in the last_rcvd file if cl_off is -1 (i.e. a new client). @@ -584,32 +588,32 @@ EXPORT_SYMBOL(lut_client_new); * It should not be possible to fail adding an existing client - otherwise * mdt_init_server_data() callsite needs to be fixed. */ -int lut_client_add(const struct lu_env *env, struct obd_export *exp, int idx) +int tgt_client_add(const struct lu_env *env, struct obd_export *exp, int idx) { - struct tg_export_data *ted = &exp->exp_target_data; - struct lu_target *tg = class_exp2tgt(exp); + struct tg_export_data *ted = &exp->exp_target_data; + struct lu_target *tgt = class_exp2tgt(exp); ENTRY; - LASSERT(tg->lut_client_bitmap != NULL); + LASSERT(tgt->lut_client_bitmap != NULL); LASSERTF(idx >= 0, "%d\n", idx); - if (!strcmp(ted->ted_lcd->lcd_uuid, tg->lut_obd->obd_uuid.uuid) || + if (!strcmp(ted->ted_lcd->lcd_uuid, tgt->lut_obd->obd_uuid.uuid) || (exp->exp_connect_flags & OBD_CONNECT_LIGHTWEIGHT) != 0) RETURN(0); - if (cfs_test_and_set_bit(idx, tg->lut_client_bitmap)) { + if (cfs_test_and_set_bit(idx, tgt->lut_client_bitmap)) { CERROR("%s: client %d: bit already set in bitmap!!\n", - tg->lut_obd->obd_name, idx); + tgt->lut_obd->obd_name, idx); LBUG(); } CDEBUG(D_INFO, "%s: client at idx %d with UUID '%s' added\n", - tg->lut_obd->obd_name, idx, ted->ted_lcd->lcd_uuid); + tgt->lut_obd->obd_name, idx, ted->ted_lcd->lcd_uuid); ted->ted_lr_idx = idx; - ted->ted_lr_off = tg->lut_lsd.lsd_client_start + - idx * tg->lut_lsd.lsd_client_size; + ted->ted_lr_off = tgt->lut_lsd.lsd_client_start + + idx * tgt->lut_lsd.lsd_client_size; cfs_mutex_init(&ted->ted_lcd_lock); @@ -617,13 +621,13 @@ int lut_client_add(const struct lu_env *env, struct obd_export *exp, int idx) RETURN(0); } -EXPORT_SYMBOL(lut_client_add); +EXPORT_SYMBOL(tgt_client_add); -int lut_client_del(const struct lu_env *env, struct obd_export *exp) +int tgt_client_del(const struct lu_env *env, struct obd_export *exp) { - struct tg_export_data *ted = &exp->exp_target_data; - struct lu_target *tg = class_exp2tgt(exp); - int rc; + struct tg_export_data *ted = &exp->exp_target_data; + struct lu_target *tgt = class_exp2tgt(exp); + int rc; ENTRY; @@ -631,19 +635,19 @@ int lut_client_del(const struct lu_env *env, struct obd_export *exp) /* XXX if lcd_uuid were a real obd_uuid, I could use obd_uuid_equals */ if (!strcmp((char *)ted->ted_lcd->lcd_uuid, - (char *)tg->lut_obd->obd_uuid.uuid) || + (char *)tgt->lut_obd->obd_uuid.uuid) || (exp->exp_connect_flags & OBD_CONNECT_LIGHTWEIGHT) != 0) RETURN(0); CDEBUG(D_INFO, "%s: del client at idx %u, off %lld, UUID '%s'\n", - tg->lut_obd->obd_name, ted->ted_lr_idx, ted->ted_lr_off, + tgt->lut_obd->obd_name, ted->ted_lr_idx, ted->ted_lr_off, ted->ted_lcd->lcd_uuid); /* 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(ted->ted_lr_idx, tg->lut_client_bitmap)) { + if (!cfs_test_bit(ted->ted_lr_idx, tgt->lut_client_bitmap)) { CERROR("%s: client %u: bit already clear in bitmap!!\n", - tg->lut_obd->obd_name, ted->ted_lr_idx); + tgt->lut_obd->obd_name, ted->ted_lr_idx); LBUG(); } @@ -654,23 +658,23 @@ int lut_client_del(const struct lu_env *env, struct obd_export *exp) /* 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 */ - rc = lut_server_data_update(env, tg, 0); + rc = tgt_server_data_update(env, tgt, 0); if (rc != 0) { CERROR("%s: failed to update server data, skip client %s " - "zeroing, rc %d\n", tg->lut_obd->obd_name, + "zeroing, rc %d\n", tgt->lut_obd->obd_name, ted->ted_lcd->lcd_uuid, rc); RETURN(rc); } cfs_mutex_lock(&ted->ted_lcd_lock); memset(ted->ted_lcd->lcd_uuid, 0, sizeof ted->ted_lcd->lcd_uuid); - rc = lut_client_data_update(env, exp); + rc = tgt_client_data_update(env, exp); cfs_mutex_unlock(&ted->ted_lcd_lock); CDEBUG(rc == 0 ? D_INFO : D_ERROR, "%s: zeroing out client %s at idx %u (%llu), rc %d\n", - tg->lut_obd->obd_name, ted->ted_lcd->lcd_uuid, + tgt->lut_obd->obd_name, ted->ted_lcd->lcd_uuid, ted->ted_lr_idx, ted->ted_lr_off, rc); RETURN(rc); } -EXPORT_SYMBOL(lut_client_del); +EXPORT_SYMBOL(tgt_client_del);