X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fofd%2Fofd_dev.c;h=8b2a720506dcd620aac8f6ee6ebe33402397a31e;hp=a246be642af0c146f9f1f5894b45fc2bd65d1f44;hb=HEAD;hpb=cd294a12553a0f24096c98c2dc59f4b0ec4a5c14 diff --git a/lustre/ofd/ofd_dev.c b/lustre/ofd/ofd_dev.c index a246be6..00cd1bb 100644 --- a/lustre/ofd/ofd_dev.c +++ b/lustre/ofd/ofd_dev.c @@ -27,7 +27,6 @@ */ /* * This file is part of Lustre, http://www.lustre.org/ - * Lustre is a trademark of Sun Microsystems, Inc. * * lustre/ofd/ofd_dev.c * @@ -77,12 +76,12 @@ #include #include #include +#include #include "ofd_internal.h" /* Slab for OFD object allocation */ static struct kmem_cache *ofd_object_kmem; - static struct lu_kmem_descr ofd_caches[] = { { .ckd_cache = &ofd_object_kmem, @@ -162,7 +161,8 @@ out: * \retval negative value on error */ static int ofd_stack_init(const struct lu_env *env, - struct ofd_device *m, struct lustre_cfg *cfg) + struct ofd_device *m, struct lustre_cfg *cfg, + unsigned long *lmd_flags) { const char *dev = lustre_cfg_string(cfg, 0); struct lu_device *d; @@ -181,8 +181,13 @@ static int ofd_stack_init(const struct lu_env *env, } lmd = s2lsi(lmi->lmi_sb)->lsi_lmd; - if (lmd != NULL && lmd->lmd_flags & LMD_FLG_SKIP_LFSCK) - m->ofd_skip_lfsck = 1; + if (lmd) { + if (test_bit(LMD_FLG_SKIP_LFSCK, lmd->lmd_flags)) + m->ofd_skip_lfsck = 1; + if (test_bit(LMD_FLG_NO_CREATE, lmd->lmd_flags)) + m->ofd_lut.lut_no_create = 1; + bitmap_copy(lmd_flags, lmd->lmd_flags, LMD_FLG_NUM_FLAGS); + } /* find bottom osd */ OBD_ALLOC(osdname, MTI_NAME_MAXLEN); @@ -198,6 +203,8 @@ static int ofd_stack_init(const struct lu_env *env, d = m->ofd_osd_exp->exp_obd->obd_lu_dev; LASSERT(d); m->ofd_osd = lu2dt_dev(d); + if (m->ofd_osd->dd_rdonly) + ofd_obd(m)->obd_read_only = 1; snprintf(info->fti_u.name, sizeof(info->fti_u.name), "%s-osd", lustre_cfg_string(cfg, 0)); @@ -251,11 +258,8 @@ static void ofd_stack_fini(const struct lu_env *env, struct ofd_device *m, } lu_site_purge(env, top->ld_site, ~0); - if (!cfs_hash_is_empty(top->ld_site->ls_obj_hash)) { - LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_OTHER, NULL); - lu_site_print(env, top->ld_site, &msgdata, lu_cdebug_printer); - } - + lu_site_print(env, top->ld_site, &top->ld_site->ls_obj_hash.nelems, + D_OTHER, lu_cdebug_printer); LASSERT(m->ofd_osd_exp); obd_disconnect(m->ofd_osd_exp); @@ -320,13 +324,7 @@ static bool match_symlink_param(char *param) sval = strchr(param, '='); if (sval != NULL) { paramlen = sval - param; - if (strncmp(param, "writethrough_cache_enable", - paramlen) == 0 || - strncmp(param, "readcache_max_filesize", - paramlen) == 0 || - strncmp(param, "read_cache_enable", - paramlen) == 0 || - strncmp(param, "brw_stats", paramlen) == 0) + if (strncmp(param, "brw_stats", paramlen) == 0) return true; } } @@ -456,6 +454,14 @@ static int ofd_object_init(const struct lu_env *env, struct lu_object *o, RETURN(rc); } +static void ofd_object_free_rcu(struct rcu_head *head) +{ + struct ofd_object *of = container_of(head, struct ofd_object, + ofo_header.loh_rcu); + + kmem_cache_free(ofd_object_kmem, of); +} + /** * Implementation of lu_object_operations::loo_object_free. * @@ -477,7 +483,8 @@ static void ofd_object_free(const struct lu_env *env, struct lu_object *o) lu_object_fini(o); lu_object_header_fini(h); - OBD_SLAB_FREE_PTR(of, ofd_object_kmem); + OBD_FREE_PRE(of, sizeof(*of), "slab-freed"); + call_rcu(&of->ofo_header.loh_rcu, ofd_object_free_rcu); EXIT; } @@ -501,7 +508,7 @@ static int ofd_object_print(const struct lu_env *env, void *cookie, return (*p)(env, cookie, LUSTRE_OST_NAME"-object@%p", o); } -static struct lu_object_operations ofd_obj_ops = { +static const struct lu_object_operations ofd_obj_ops = { .loo_object_init = ofd_object_init, .loo_object_free = ofd_object_free, .loo_object_print = ofd_object_print @@ -640,6 +647,8 @@ static int ofd_prepare(const struct lu_env *env, struct lu_device *pdev, LASSERTF(rc == 0, "register namespace failed: rc = %d\n", rc); target_recovery_init(&ofd->ofd_lut, tgt_request_handle); + CFS_FAIL_TIMEOUT_ORSET(OBD_FAIL_OST_PREPARE_DELAY, CFS_FAIL_ONCE, + (OBD_TIMEOUT_DEFAULT + 1) / 4); LASSERT(obd->obd_no_conn); spin_lock(&obd->obd_dev_lock); obd->obd_no_conn = 0; @@ -694,53 +703,13 @@ static int ofd_recovery_complete(const struct lu_env *env, /** * lu_device_operations matrix for OFD device. */ -static struct lu_device_operations ofd_lu_ops = { +static const struct lu_device_operations ofd_lu_ops = { .ldo_object_alloc = ofd_object_alloc, .ldo_process_config = ofd_process_config, .ldo_recovery_complete = ofd_recovery_complete, .ldo_prepare = ofd_prepare, }; -#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 14, 53, 0) -/** - * Expose OSD statistics to OFD layer. - * - * The osd interfaces to the backend file system exposes useful data - * such as brw_stats and read or write cache states. This same data - * needs to be exposed into the obdfilter (ofd) layer to maintain - * backwards compatibility. This function creates the symlinks in the - * proc layer to enable this. - * - * \param[in] ofd OFD device - */ -static void ofd_procfs_add_brw_stats_symlink(struct ofd_device *ofd) -{ - struct obd_device *obd = ofd_obd(ofd); - struct obd_device *osd_obd = ofd->ofd_osd_exp->exp_obd; - - if (obd->obd_proc_entry == NULL) - return; - - lprocfs_add_symlink("brw_stats", obd->obd_proc_entry, - "../../%s/%s/brw_stats", - osd_obd->obd_type->typ_name, obd->obd_name); - - lprocfs_add_symlink("read_cache_enable", obd->obd_proc_entry, - "../../%s/%s/read_cache_enable", - osd_obd->obd_type->typ_name, obd->obd_name); - - lprocfs_add_symlink("readcache_max_filesize", - obd->obd_proc_entry, - "../../%s/%s/readcache_max_filesize", - osd_obd->obd_type->typ_name, obd->obd_name); - - lprocfs_add_symlink("writethrough_cache_enable", - obd->obd_proc_entry, - "../../%s/%s/writethrough_cache_enable", - osd_obd->obd_type->typ_name, obd->obd_name); -} -#endif - /** * Cleanup all procfs entries in OFD. * @@ -750,6 +719,7 @@ static void ofd_procfs_fini(struct ofd_device *ofd) { struct obd_device *obd = ofd_obd(ofd); + tgt_tunables_fini(&ofd->ofd_lut); lprocfs_free_per_client_stats(obd); lprocfs_obd_cleanup(obd); lprocfs_free_obd_stats(obd); @@ -822,17 +792,12 @@ int ofd_fid_init(const struct lu_env *env, struct ofd_device *ofd) GOTO(out_server, rc = -ENOMEM); snprintf(name, len, "%s-super", obd_name); - rc = seq_client_init(ss->ss_client_seq, NULL, LUSTRE_SEQ_DATA, - name, NULL); - if (rc) { - CERROR("%s: seq client init error: rc = %d\n", obd_name, rc); - GOTO(out_client, rc); - } + seq_client_init(ss->ss_client_seq, NULL, LUSTRE_SEQ_DATA, + name, NULL); rc = seq_server_set_cli(env, ss->ss_server_seq, ss->ss_client_seq); if (rc) { -out_client: seq_client_fini(ss->ss_client_seq); OBD_FREE_PTR(ss->ss_client_seq); ss->ss_client_seq = NULL; @@ -864,6 +829,7 @@ static int ofd_set_info_hdl(struct tgt_session_info *tsi) void *key, *val = NULL; int keylen, vallen, rc = 0; bool is_grant_shrink; + ktime_t kstart = ktime_get(); ENTRY; @@ -896,6 +862,19 @@ static int ofd_set_info_hdl(struct tgt_session_info *tsi) if (is_grant_shrink) { body = req_capsule_client_get(tsi->tsi_pill, &RMF_OST_BODY); + /* + * Because we already sync grant info with client when + * reconnect, grant info will be cleared for resent + * req, otherwise, outdated grant count in the rpc + * would de-sync grant counters + */ + if (lustre_msg_get_flags(req->rq_reqmsg) & + (MSG_RESENT | MSG_REPLAY)) { + DEBUG_REQ(D_CACHE, req, + "clear resent/replay req grant info"); + body->oa.o_valid &= ~OBD_MD_FLGRANT; + } + repbody = req_capsule_server_get(tsi->tsi_pill, &RMF_OST_BODY); *repbody = *body; @@ -912,7 +891,7 @@ static int ofd_set_info_hdl(struct tgt_session_info *tsi) rc = -EOPNOTSUPP; } ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_SET_INFO, - tsi->tsi_jobid, 1); + tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart)); RETURN(rc); } @@ -972,7 +951,7 @@ static int ofd_lock_unlock_region(const struct lu_env *env, return rc; CDEBUG(D_OTHER, "ost lock [%llu,%llu], lh=%p\n", begin, end, &lh); - tgt_extent_unlock(&lh, LCK_PR); + tgt_data_unlock(&lh, LCK_PR); return 0; } @@ -1058,6 +1037,7 @@ static int ofd_get_info_hdl(struct tgt_session_info *tsi) void *key; int keylen; int replylen, rc = 0; + ktime_t kstart = ktime_get(); ENTRY; @@ -1155,12 +1135,12 @@ static int ofd_get_info_hdl(struct tgt_session_info *tsi) oseq = ofd_seq_load(tsi->tsi_env, ofd, ostid_seq(&fti->fti_ostid)); if (IS_ERR(oseq)) - RETURN(PTR_ERR(oseq)); + RETURN(-EFAULT); rc = ostid_to_fid(fid, &oseq->os_oi, ofd->ofd_lut.lut_lsd.lsd_osd_index); if (rc != 0) - GOTO(out_put, rc); + GOTO(out_put, rc = -EFAULT); CDEBUG(D_HA, "%s: LAST FID is "DFID"\n", ofd_name(ofd), PFID(fid)); @@ -1172,7 +1152,7 @@ out_put: rc = -EOPNOTSUPP; } ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_GET_INFO, - tsi->tsi_jobid, 1); + tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart)); RETURN(rc); } @@ -1197,6 +1177,7 @@ static int ofd_getattr_hdl(struct tgt_session_info *tsi) struct ofd_object *fo; __u64 flags = 0; enum ldlm_mode lock_mode = LCK_PR; + ktime_t kstart = ktime_get(); bool srvlock; int rc; ENTRY; @@ -1258,10 +1239,10 @@ static int ofd_getattr_hdl(struct tgt_session_info *tsi) ofd_object_put(tsi->tsi_env, fo); out: if (srvlock) - tgt_extent_unlock(&lh, lock_mode); + tgt_data_unlock(&lh, lock_mode); ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_GETATTR, - tsi->tsi_jobid, 1); + tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart)); repbody->oa.o_valid |= OBD_MD_FLFLAGS; repbody->oa.o_flags = OBD_FL_FLUSH; @@ -1288,6 +1269,7 @@ static int ofd_setattr_hdl(struct tgt_session_info *tsi) struct ost_body *repbody; struct ldlm_resource *res; struct ofd_object *fo; + ktime_t kstart = ktime_get(); int rc = 0; ENTRY; @@ -1336,7 +1318,7 @@ static int ofd_setattr_hdl(struct tgt_session_info *tsi) OFD_VALID_FLAGS | LA_UID | LA_GID | LA_PROJID); ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_SETATTR, - tsi->tsi_jobid, 1); + tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart)); EXIT; out_put: ofd_object_put(tsi->tsi_env, fo); @@ -1347,10 +1329,10 @@ out: * otherwise concurrent destroy can make the object unavailable * for 2nd lu_object_find() waiting for the first reference * to go... deadlock! */ - res = ldlm_resource_get(ofd->ofd_namespace, NULL, - &tsi->tsi_resid, LDLM_EXTENT, 0); + res = ldlm_resource_get(ofd->ofd_namespace, &tsi->tsi_resid, + LDLM_EXTENT, 0); if (!IS_ERR(res)) { - ldlm_res_lvbo_update(tsi->tsi_env, res, NULL, 0); + ldlm_res_lvbo_update(res, NULL, 0); ldlm_resource_putref(res); } } @@ -1385,6 +1367,8 @@ static int ofd_orphans_destroy(const struct lu_env *env, u64 oid; int skip_orphan; int rc = 0; + char *target_start; + int target_len; ENTRY; @@ -1402,11 +1386,13 @@ static int ofd_orphans_destroy(const struct lu_env *env, LASSERT(exp != NULL); skip_orphan = !!(exp_connect_flags(exp) & OBD_CONNECT_SKIP_ORPHAN); - if (OBD_FAIL_CHECK(OBD_FAIL_OST_NODESTROY)) + if (CFS_FAIL_CHECK(OBD_FAIL_OST_NODESTROY)) goto done; - LCONSOLE(D_INFO, "%s: deleting orphan objects from "DOSTID - " to "DOSTID"\n", ofd_name(ofd), seq, end_id + 1, seq, last); + deuuidify(exp->exp_client_uuid.uuid, NULL, &target_start, &target_len); + LCONSOLE(D_INFO, "%s: new connection from %.*s (cleaning up unused objects from "DOSTID" to "DOSTID")\n", + ofd_name(ofd), target_len, target_start, seq, end_id + 1, seq, + last); while (oid > end_id) { rc = fid_set_id(fid, oid); @@ -1464,25 +1450,31 @@ out_put: */ static int ofd_create_hdl(struct tgt_session_info *tsi) { - struct ptlrpc_request *req = tgt_ses_req(tsi); - struct ost_body *repbody; - const struct obdo *oa = &tsi->tsi_ost_body->oa; - struct obdo *rep_oa; - struct obd_export *exp = tsi->tsi_exp; - struct ofd_device *ofd = ofd_exp(exp); - u64 seq = ostid_seq(&oa->o_oi); - u64 oid = ostid_id(&oa->o_oi); - struct ofd_seq *oseq; + struct ptlrpc_request *req = tgt_ses_req(tsi); + struct ost_body *repbody; + const struct obdo *oa = &tsi->tsi_ost_body->oa; + struct obdo *rep_oa; + struct obd_export *exp = tsi->tsi_exp; + struct ofd_device *ofd = ofd_exp(exp); + struct seq_server_site *ss = &ofd->ofd_seq_site; + __u64 seq_width = ss->ss_client_seq->lcs_width; + u64 seq = ostid_seq(&oa->o_oi); + u64 oid = ostid_id(&oa->o_oi); + struct ofd_seq *oseq; + int sync_trans = 0; + long granted = 0; + ktime_t kstart = ktime_get(); s64 diff; int rc = 0; - int sync_trans = 0; - long granted = 0; ENTRY; - if (OBD_FAIL_CHECK(OBD_FAIL_OST_EROFS)) + if (CFS_FAIL_CHECK(OBD_FAIL_OST_EROFS)) RETURN(-EROFS); + if (ofd->ofd_lut.lut_no_create) + return -EPERM; + repbody = req_capsule_server_get(tsi->tsi_pill, &RMF_OST_BODY); if (repbody == NULL) RETURN(-ENOMEM); @@ -1496,6 +1488,8 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) rep_oa = &repbody->oa; rep_oa->o_oi = oa->o_oi; + rep_oa->o_valid |= OBD_MD_FLSIZE; + rep_oa->o_size = seq_width; LASSERT(oa->o_valid & OBD_MD_FLGROUP); @@ -1526,12 +1520,13 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) (oa->o_flags & OBD_FL_DELORPHAN)) { exp->exp_filter_data.fed_lastid_gen = ofd->ofd_lastid_gen; + CFS_FAIL_TIMEOUT(OBD_FAIL_OST_DELORPHAN_DELAY, cfs_fail_val); /* destroy orphans */ if (lustre_msg_get_conn_cnt(tgt_ses_req(tsi)->rq_reqmsg) < exp->exp_conn_cnt) { CERROR("%s: dropping old orphan cleanup request\n", ofd_name(ofd)); - GOTO(out_nolock, rc = 0); + GOTO(out_nolock, rc = -ESTALE); } /* This causes inflight precreates to abort and drop lock */ oseq->os_destroys_in_progress = 1; @@ -1579,7 +1574,7 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) exp->exp_conn_cnt) { CERROR("%s: dropping old precreate request\n", ofd_name(ofd)); - GOTO(out, rc = 0); + GOTO(out, rc = -ESTALE); } /* only precreate if seq is 0, IDIF or normal and also o_id * must be specfied */ @@ -1589,20 +1584,11 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) } else { diff = oid - ofd_seq_last_oid(oseq); /* Do sync create if the seq is about to used up */ - if (fid_seq_is_idif(seq) || fid_seq_is_mdt0(seq)) { - if (unlikely(oid >= IDIF_MAX_OID - 1)) - sync_trans = 1; - } else if (fid_seq_is_norm(seq)) { - if (unlikely(oid >= - LUSTRE_DATA_SEQ_MAX_WIDTH - 1)) - sync_trans = 1; - } else { - CERROR("%s : invalid o_seq "DOSTID"\n", - ofd_name(ofd), POSTID(&oa->o_oi)); - GOTO(out, rc = -EINVAL); - } + sync_trans = ofd_seq_is_exhausted(ofd, oa); + if (sync_trans < 0) + GOTO(out, rc = sync_trans); - if (diff < 0) { + if (diff <= -OST_MAX_PRECREATE) { /* LU-5648 */ CERROR("%s: invalid precreate request for " DOSTID", last_id %llu. " @@ -1610,16 +1596,44 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) ofd_name(ofd), POSTID(&oa->o_oi), ofd_seq_last_oid(oseq)); GOTO(out, rc = -EINVAL); + } else if (diff < 0) { + LCONSOLE(D_INFO, + "%s: MDS LAST_ID "DFID" (%llu) is %lld behind OST LAST_ID "DFID" (%llu), trust the OST\n", + ofd_name(ofd), PFID(&oa->o_oi.oi_fid), + oid, -diff, PFID(&oseq->os_oi.oi_fid), + ofd_seq_last_oid(oseq)); + /* Let MDS know that we are so far ahead. */ + rc = ostid_set_id(&rep_oa->o_oi, + ofd_seq_last_oid(oseq) + 1); } } } if (diff > 0) { time64_t enough_time = ktime_get_seconds() + DISK_TIMEOUT; + bool trans_local; u64 next_id; int created = 0; int count; int rc2; + /* This can happen if a new OST is formatted and installed + * in place of an old one at the same index. Instead of + * precreating potentially millions of deleted old objects + * (possibly filling the OST), only precreate the last batch. + * LFSCK will eventually clean up any orphans. LU-14 */ + if (diff > 5 * OST_MAX_PRECREATE) { + /* Message below is checked in conf-sanity test_122b */ + LCONSOLE_WARN("%s: precreate FID "DOSTID" is over %lld higher than LAST_ID "DOSTID", only precreating the last %llu objects. OST replaced or reformatted?\n", + ofd_name(ofd), POSTID(&oa->o_oi), diff, + POSTID(&oseq->os_oi), + min(seq_width, (__u64)OST_MAX_PRECREATE)); + /* From last created */ + diff = min(seq_width, (__u64)OST_MAX_PRECREATE); + ofd_seq_last_oid_set(oseq, ostid_id(&oa->o_oi) - diff); + /* no sync_trans when recreating last batch */ + sync_trans = 0; + } + if (!(oa->o_valid & OBD_MD_FLFLAGS) || !(oa->o_flags & OBD_FL_DELORPHAN)) { /* don't enforce grant during orphan recovery */ @@ -1636,27 +1650,7 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) } } - /* This can happen if a new OST is formatted and installed - * in place of an old one at the same index. Instead of - * precreating potentially millions of deleted old objects - * (possibly filling the OST), only precreate the last batch. - * LFSCK will eventually clean up any orphans. LU-14 */ - if (diff > 5 * OST_MAX_PRECREATE) { - diff = OST_MAX_PRECREATE / 2; - LCONSOLE_WARN("%s: Too many FIDs to precreate " - "OST replaced or reformatted: " - "LFSCK will clean up", - ofd_name(ofd)); - - CDEBUG(D_HA, "%s: precreate FID "DOSTID" is over " - "%u larger than the LAST_ID "DOSTID", only " - "precreating the last %lld objects.\n", - ofd_name(ofd), POSTID(&oa->o_oi), - 5 * OST_MAX_PRECREATE, - POSTID(&oseq->os_oi), diff); - ofd_seq_last_oid_set(oseq, ostid_id(&oa->o_oi) - diff); - } - + trans_local = !exp_connect_replay_create(req->rq_export); while (diff > 0) { next_id = ofd_seq_last_oid(oseq) + 1; count = ofd_precreate_batch(ofd, (int)diff); @@ -1675,7 +1669,8 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) } rc = ofd_precreate_objects(tsi->tsi_env, ofd, next_id, - oseq, count, sync_trans); + oseq, count, sync_trans, + trans_local); if (rc > 0) { created += rc; diff -= rc; @@ -1711,22 +1706,14 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) } EXIT; ofd_counter_incr(exp, LPROC_OFD_STATS_CREATE, - tsi->tsi_jobid, 1); + tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart)); + if (unlikely(!oseq->os_last_id_synced)) + oseq->os_last_id_synced = 1; out: mutex_unlock(&oseq->os_create_lock); out_nolock: - if (rc == 0) { -#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 8, 53, 0) - struct ofd_thread_info *info = ofd_info(tsi->tsi_env); - struct lu_fid *fid = &info->fti_fid; - - /* For compatible purpose, it needs to convert back to - * OST ID before put it on wire. */ - *fid = rep_oa->o_oi.oi_fid; - fid_to_ostid(fid, &rep_oa->o_oi); -#endif + if (rc == 0) rep_oa->o_valid |= OBD_MD_FLID | OBD_MD_FLGROUP; - } ofd_seq_put(tsi->tsi_env, oseq); out_sem: @@ -1752,13 +1739,14 @@ static int ofd_destroy_hdl(struct tgt_session_info *tsi) struct ofd_device *ofd = ofd_exp(tsi->tsi_exp); struct ofd_thread_info *fti = tsi2ofd_info(tsi); struct lu_fid *fid = &fti->fti_fid; + ktime_t kstart = ktime_get(); u64 oid; u32 count; int rc = 0; ENTRY; - if (OBD_FAIL_CHECK(OBD_FAIL_OST_EROFS)) + if (CFS_FAIL_CHECK(OBD_FAIL_OST_EROFS)) RETURN(-EROFS); /* This is old case for clients before Lustre 2.4 */ @@ -1813,7 +1801,7 @@ static int ofd_destroy_hdl(struct tgt_session_info *tsi) } ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_DESTROY, - tsi->tsi_jobid, 1); + tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart)); GOTO(out, rc); @@ -1835,12 +1823,13 @@ out: */ static int ofd_statfs_hdl(struct tgt_session_info *tsi) { + ktime_t kstart = ktime_get(); struct obd_statfs *osfs; int rc; ENTRY; - OBD_FAIL_TIMEOUT(OBD_FAIL_OST_STATFS_DELAY, 10); + CFS_FAIL_TIMEOUT(OBD_FAIL_OST_STATFS_DELAY, 10); osfs = req_capsule_server_get(tsi->tsi_pill, &RMF_OBD_STATFS); @@ -1850,11 +1839,11 @@ static int ofd_statfs_hdl(struct tgt_session_info *tsi) CERROR("%s: statfs failed: rc = %d\n", tgt_name(tsi->tsi_tgt), rc); - if (OBD_FAIL_CHECK(OBD_FAIL_OST_STATFS_EINPROGRESS)) + if (CFS_FAIL_CHECK(OBD_FAIL_OST_STATFS_EINPROGRESS)) rc = -EINPROGRESS; ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_STATFS, - tsi->tsi_jobid, 1); + tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart)); RETURN(rc); } @@ -1877,6 +1866,7 @@ static int ofd_sync_hdl(struct tgt_session_info *tsi) struct ofd_thread_info *fti = tsi2ofd_info(tsi); struct ofd_device *ofd = ofd_exp(tsi->tsi_exp); struct ofd_object *fo = NULL; + ktime_t kstart = ktime_get(); int rc = 0; ENTRY; @@ -1897,7 +1887,7 @@ static int ofd_sync_hdl(struct tgt_session_info *tsi) GOTO(put, rc); ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_SYNC, - tsi->tsi_jobid, 1); + tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart)); if (fo == NULL) RETURN(0); @@ -1919,6 +1909,156 @@ put: } /** + * OFD request handler for OST_FALLOCATE RPC. + * + * This is part of request processing. Validate request fields, + * preallocate the given OFD object and pack reply. + * + * \param[in] tsi target session environment for this request + * + * \retval 0 if successful + * \retval negative value on error + */ +static int ofd_fallocate_hdl(struct tgt_session_info *tsi) +{ + struct obdo *oa = &tsi->tsi_ost_body->oa; + struct ost_body *repbody; + struct ofd_thread_info *info = tsi2ofd_info(tsi); + struct ldlm_namespace *ns = tsi->tsi_tgt->lut_obd->obd_namespace; + struct ldlm_resource *res; + struct ofd_object *fo; + __u64 flags = 0; + __u64 valid; + struct lustre_handle lh = { 0, }; + int rc, mode; + __u64 start, end; + bool srvlock; + ktime_t kstart = ktime_get(); + + repbody = req_capsule_server_get(tsi->tsi_pill, &RMF_OST_BODY); + if (repbody == NULL) + RETURN(err_serious(-ENOMEM)); + + /* + * fallocate() start and end are passed in o_size and o_blocks + * on the wire. Clients 2.15.0 and newer should always set + * the OBD_MD_FLSIZE and OBD_MD_FLBLOCKS valid flags, but some + * older client (exp_old_falloc is true) versions did not. + * We permit older clients to not set these flags, checking their + * version by proxy using the lack of OBD_CONNECT_TRUNCLOCK to + * imply 2.14.0 and older. + * + * Return -EOPNOTSUPP to also work with older clients not + * supporting newer server modes. + */ + if ((oa->o_valid & (OBD_MD_FLSIZE | OBD_MD_FLBLOCKS)) != + (OBD_MD_FLSIZE | OBD_MD_FLBLOCKS) +#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 21, 53, 0) + && !tsi->tsi_exp->exp_old_falloc +#endif + ) + RETURN(-EOPNOTSUPP); + + start = oa->o_size; + end = oa->o_blocks; + CDEBUG(D_INFO, "%s: start: %llu end: %llu\n", tgt_name(tsi->tsi_tgt), + start, end); + +#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 21, 53, 0) + /* For inter-op case with older clients (where exp_old_falloc is true) + * fallocate() start and end are passed in as 0 (For interior case + * where end offset less than file size) This is fixed later. + * For such cases we return -EOPNOTSUPP + */ + if (tsi->tsi_exp->exp_old_falloc && start >= end) + RETURN(-EOPNOTSUPP); +#endif + /* client should already limit len >= 0 */ + if (start >= end) + RETURN(-EINVAL); + + mode = oa->o_falloc_mode; + /* + * mode == 0 (which is standard prealloc) and PUNCH is supported + * Rest of mode options are not supported yet. + */ + if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE)) + RETURN(-EOPNOTSUPP); + + /* PUNCH_HOLE mode should always be accompanied with KEEP_SIZE flag + * Check that and add the missing flag for such invalid call with + * warning. + */ + if (mode & FALLOC_FL_PUNCH_HOLE && !(mode & FALLOC_FL_KEEP_SIZE)) { + CWARN("%s: PUNCH mode misses KEEP_SIZE flag, setting it\n", + tsi->tsi_tgt->lut_obd->obd_name); + mode |= FALLOC_FL_KEEP_SIZE; + } + + repbody->oa.o_oi = oa->o_oi; + repbody->oa.o_valid = OBD_MD_FLID; + + srvlock = oa->o_valid & OBD_MD_FLFLAGS && + oa->o_flags & OBD_FL_SRVLOCK; + + if (srvlock) { + rc = tgt_extent_lock(tsi->tsi_env, ns, &tsi->tsi_resid, + start, end, &lh, LCK_PW, &flags); + if (rc != 0) + RETURN(rc); + } + + fo = ofd_object_find_exists(tsi->tsi_env, ofd_exp(tsi->tsi_exp), + &tsi->tsi_fid); + if (IS_ERR(fo)) + GOTO(out, rc = PTR_ERR(fo)); + + valid = OBD_MD_FLUID | OBD_MD_FLGID | OBD_MD_FLPROJID | + OBD_MD_FLATIME | OBD_MD_FLMTIME | OBD_MD_FLCTIME; + la_from_obdo(&info->fti_attr, oa, valid); + + rc = ofd_object_fallocate(tsi->tsi_env, fo, start, end, mode, + &info->fti_attr, oa); + if (rc) + GOTO(out_put, rc); + + rc = ofd_attr_get(tsi->tsi_env, fo, &info->fti_attr); + if (rc == 0) + obdo_from_la(&repbody->oa, &info->fti_attr, OFD_VALID_FLAGS); + else + rc = 0; + + ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_PREALLOC, + tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart)); + + EXIT; +out_put: + ofd_object_put(tsi->tsi_env, fo); +out: + if (srvlock) + tgt_data_unlock(&lh, LCK_PW); + if (rc == 0) { + res = ldlm_resource_get(ns, &tsi->tsi_resid, LDLM_EXTENT, 0); + if (!IS_ERR(res)) { + struct ost_lvb *res_lvb; + + ldlm_res_lvbo_update(res, NULL, 0); + res_lvb = res->lr_lvb_data; + /* Blocks */ + repbody->oa.o_valid |= OBD_MD_FLBLOCKS; + repbody->oa.o_blocks = res_lvb->lvb_blocks; + /* Size */ + repbody->oa.o_valid |= OBD_MD_FLSIZE; + repbody->oa.o_size = res_lvb->lvb_size; + + ldlm_resource_putref(res); + } + } + + RETURN(rc); +} + +/** * OFD request handler for OST_PUNCH RPC. * * This is part of request processing. Validate request fields, @@ -1939,16 +2079,14 @@ static int ofd_punch_hdl(struct tgt_session_info *tsi) struct ofd_object *fo; __u64 flags = 0; struct lustre_handle lh = { 0, }; - int rc; __u64 start, end; bool srvlock; + ktime_t kstart = ktime_get(); + int rc; ENTRY; - OBD_FAIL_TIMEOUT(OBD_FAIL_OST_PAUSE_PUNCH, cfs_fail_val); - - /* check that we do support OBD_CONNECT_TRUNCLOCK. */ - CLASSERT(OST_CONNECT_SUPPORTED & OBD_CONNECT_TRUNCLOCK); + CFS_FAIL_TIMEOUT(OBD_FAIL_OST_PAUSE_PUNCH, cfs_fail_val); if ((oa->o_valid & (OBD_MD_FLSIZE | OBD_MD_FLBLOCKS)) != (OBD_MD_FLSIZE | OBD_MD_FLBLOCKS)) @@ -2003,25 +2141,24 @@ static int ofd_punch_hdl(struct tgt_session_info *tsi) GOTO(out_put, rc); ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_PUNCH, - tsi->tsi_jobid, 1); + tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart)); EXIT; out_put: ofd_object_put(tsi->tsi_env, fo); out: if (srvlock) - tgt_extent_unlock(&lh, LCK_PW); + tgt_data_unlock(&lh, LCK_PW); if (rc == 0) { /* we do not call this before to avoid lu_object_find() in * ->lvbo_update() holding another reference on the object. * otherwise concurrent destroy can make the object unavailable * for 2nd lu_object_find() waiting for the first reference * to go... deadlock! */ - res = ldlm_resource_get(ns, NULL, &tsi->tsi_resid, - LDLM_EXTENT, 0); + res = ldlm_resource_get(ns, &tsi->tsi_resid, LDLM_EXTENT, 0); if (!IS_ERR(res)) { struct ost_lvb *res_lvb; - ldlm_res_lvbo_update(tsi->tsi_env, res, NULL, 0); + ldlm_res_lvbo_update(res, NULL, 0); res_lvb = res->lr_lvb_data; repbody->oa.o_valid |= OBD_MD_FLBLOCKS; repbody->oa.o_blocks = res_lvb->lvb_blocks; @@ -2068,7 +2205,8 @@ static int ofd_ladvise_prefetch(const struct lu_env *env, PTLRPC_MAX_BRW_PAGES; rnb.rnb_offset = start_index << PAGE_SHIFT; rnb.rnb_len = nr_local << PAGE_SHIFT; - rc = dt_bufs_get(env, ofd_object_child(fo), &rnb, lnb, dbt); + rc = dt_bufs_get(env, ofd_object_child(fo), &rnb, lnb, + PTLRPC_MAX_BRW_PAGES, dbt); if (unlikely(rc < 0)) break; nr_local = rc; @@ -2197,7 +2335,7 @@ static int ofd_ladvise_hdl(struct tgt_session_info *tsi) req->rq_status = ofd_ladvise_prefetch(env, fo, tbc->local, start, end, dbt); - tgt_extent_unlock(&lockh, LCK_PR); + tgt_data_unlock(&lockh, LCK_PR); break; case LU_LADVISE_DONTNEED: rc = dt_ladvise(env, dob, ladvise->lla_start, @@ -2228,21 +2366,39 @@ static int ofd_quotactl(struct tgt_session_info *tsi) { struct obd_quotactl *oqctl, *repoqc; struct lu_nodemap *nodemap; + ktime_t kstart = ktime_get(); + char *buffer = NULL; int id; int rc; - ENTRY; oqctl = req_capsule_client_get(tsi->tsi_pill, &RMF_OBD_QUOTACTL); if (oqctl == NULL) RETURN(err_serious(-EPROTO)); + if (oqctl->qc_cmd == LUSTRE_Q_ITEROQUOTA) + req_capsule_set_size(tsi->tsi_pill, &RMF_OBD_QUOTA_ITER, + RCL_SERVER, LQUOTA_ITER_BUFLEN); + else + req_capsule_set_size(tsi->tsi_pill, &RMF_OBD_QUOTA_ITER, + RCL_SERVER, 0); + + rc = req_capsule_server_pack(tsi->tsi_pill); + if (rc) + RETURN(err_serious(rc)); + repoqc = req_capsule_server_get(tsi->tsi_pill, &RMF_OBD_QUOTACTL); if (repoqc == NULL) RETURN(err_serious(-ENOMEM)); - *repoqc = *oqctl; + if (oqctl->qc_cmd == LUSTRE_Q_ITEROQUOTA) { + buffer = req_capsule_server_get(tsi->tsi_pill, + &RMF_OBD_QUOTA_ITER); + if (buffer == NULL) + RETURN(err_serious(-ENOMEM)); + } + nodemap = nodemap_get_from_exp(tsi->tsi_exp); if (IS_ERR(nodemap)) RETURN(PTR_ERR(nodemap)); @@ -2256,16 +2412,21 @@ static int ofd_quotactl(struct tgt_session_info *tsi) id = nodemap_map_id(nodemap, NODEMAP_GID, NODEMAP_CLIENT_TO_FS, repoqc->qc_id); + else if (oqctl->qc_type == PRJQUOTA) + id = nodemap_map_id(nodemap, NODEMAP_PROJID, + NODEMAP_CLIENT_TO_FS, + repoqc->qc_id); nodemap_putref(nodemap); if (repoqc->qc_id != id) swap(repoqc->qc_id, id); - rc = lquotactl_slv(tsi->tsi_env, tsi->tsi_tgt->lut_bottom, repoqc); + rc = lquotactl_slv(tsi->tsi_env, tsi->tsi_tgt->lut_bottom, repoqc, + buffer, buffer == NULL ? 0 : LQUOTA_ITER_BUFLEN); ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_QUOTACTL, - tsi->tsi_jobid, 1); + tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart)); if (repoqc->qc_id != id) swap(repoqc->qc_id, id); @@ -2274,29 +2435,6 @@ static int ofd_quotactl(struct tgt_session_info *tsi) } /** - * Calculate the amount of time for lock prolongation. - * - * This is helper for ofd_prolong_extent_locks() function to get - * the timeout extra time. - * - * \param[in] req current request - * - * \retval amount of time to extend the timeout with - */ -static inline time64_t prolong_timeout(struct ptlrpc_request *req) -{ - struct ptlrpc_service_part *svcpt = req->rq_rqbd->rqbd_svcpt; - time64_t req_timeout; - - if (AT_OFF) - return obd_timeout / 2; - - req_timeout = req->rq_deadline - req->rq_arrival_time.tv_sec; - return max_t(time64_t, at_est2timeout(at_get(&svcpt->scp_at_estimate)), - req_timeout); -} - -/** * Prolong lock timeout for the given extent. * * This function finds all locks related with incoming request and @@ -2327,7 +2465,7 @@ static void ofd_prolong_extent_locks(struct tgt_session_info *tsi, ENTRY; - data->lpa_timeout = prolong_timeout(tgt_ses_req(tsi)); + data->lpa_req = tgt_ses_req(tsi); data->lpa_export = tsi->tsi_exp; data->lpa_resid = tsi->tsi_resid; @@ -2472,14 +2610,14 @@ static int ofd_rw_hpreq_check(struct ptlrpc_request *req) rnb += ioo->ioo_bufcnt - 1; pa.lpa_extent.end = rnb->rnb_offset + rnb->rnb_len - 1; - DEBUG_REQ(D_RPCTRACE, req, "%s %s: refresh rw locks: "DFID - " (%llu->%llu)\n", tgt_name(tsi->tsi_tgt), - current->comm, PFID(&tsi->tsi_fid), pa.lpa_extent.start, - pa.lpa_extent.end); + DEBUG_REQ(D_RPCTRACE, req, + "%s %s: refresh rw locks for "DFID" (%llu->%llu)", + tgt_name(tsi->tsi_tgt), current->comm, PFID(&tsi->tsi_fid), + pa.lpa_extent.start, pa.lpa_extent.end); ofd_prolong_extent_locks(tsi, &pa); - CDEBUG(D_DLMTRACE, "%s: refreshed %u locks timeout for req %p.\n", + CDEBUG(D_DLMTRACE, "%s: refreshed %u locks timeout for req %p\n", tgt_name(tsi->tsi_tgt), pa.lpa_blocks_cnt, req); if (pa.lpa_blocks_cnt > 0) @@ -2704,26 +2842,27 @@ TGT_RPC_HANDLER(OST_FIRST_OPC, 0, OST_SET_INFO, ofd_set_info_hdl, &RQF_OBD_SET_INFO, LUSTRE_OST_VERSION), TGT_OST_HDL(0, OST_GET_INFO, ofd_get_info_hdl), -TGT_OST_HDL(HABEO_CORPUS| HABEO_REFERO, OST_GETATTR, ofd_getattr_hdl), -TGT_OST_HDL(HABEO_CORPUS| HABEO_REFERO | MUTABOR, +TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_GETATTR, ofd_getattr_hdl), +TGT_OST_HDL(HAS_BODY | HAS_REPLY | IS_MUTABLE, OST_SETATTR, ofd_setattr_hdl), -TGT_OST_HDL(0 | HABEO_REFERO | MUTABOR, +TGT_OST_HDL(HAS_REPLY | IS_MUTABLE, OST_CREATE, ofd_create_hdl), -TGT_OST_HDL(0 | HABEO_REFERO | MUTABOR, +TGT_OST_HDL(HAS_REPLY | IS_MUTABLE, OST_DESTROY, ofd_destroy_hdl), -TGT_OST_HDL(0 | HABEO_REFERO, OST_STATFS, ofd_statfs_hdl), -TGT_OST_HDL_HP(HABEO_CORPUS| HABEO_REFERO, - OST_BRW_READ, tgt_brw_read, +TGT_OST_HDL(HAS_REPLY, OST_STATFS, ofd_statfs_hdl), +TGT_OST_HDL_HP(HAS_BODY | HAS_REPLY, OST_BRW_READ, tgt_brw_read, ofd_hp_brw), /* don't set CORPUS flag for brw_write because -ENOENT may be valid case */ -TGT_OST_HDL_HP(HABEO_CORPUS| MUTABOR, OST_BRW_WRITE, tgt_brw_write, +TGT_OST_HDL_HP(HAS_BODY | IS_MUTABLE, OST_BRW_WRITE, tgt_brw_write, ofd_hp_brw), -TGT_OST_HDL_HP(HABEO_CORPUS| HABEO_REFERO | MUTABOR, +TGT_OST_HDL_HP(HAS_BODY | HAS_REPLY | IS_MUTABLE, OST_PUNCH, ofd_punch_hdl, ofd_hp_punch), -TGT_OST_HDL(HABEO_CORPUS| HABEO_REFERO, OST_SYNC, ofd_sync_hdl), -TGT_OST_HDL(0 | HABEO_REFERO, OST_QUOTACTL, ofd_quotactl), -TGT_OST_HDL(HABEO_CORPUS | HABEO_REFERO, OST_LADVISE, ofd_ladvise_hdl), +TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_SYNC, ofd_sync_hdl), +TGT_OST_HDL(0, OST_QUOTACTL, ofd_quotactl), +TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_LADVISE, ofd_ladvise_hdl), +TGT_OST_HDL(HAS_BODY | HAS_REPLY | IS_MUTABLE, OST_FALLOCATE, ofd_fallocate_hdl), +TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_SEEK, tgt_lseek), }; static struct tgt_opc_slice ofd_common_slice[] = { @@ -2825,6 +2964,7 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, struct ofd_thread_info *info = NULL; struct obd_device *obd; struct tg_grants_data *tgd = &m->ofd_lut.lut_tgd; + DECLARE_BITMAP(lmd_flags, LMD_FLG_NUM_FLAGS); struct lu_fid fid; struct nm_config_file *nodemap_config; struct obd_device_target *obt; @@ -2842,24 +2982,20 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, if (rc != 0) RETURN(rc); - obt = &obd->u.obt; - obt->obt_magic = OBT_MAGIC; - - m->ofd_fmd_max_num = OFD_FMD_MAX_NUM_DEFAULT; - m->ofd_fmd_max_age = OFD_FMD_MAX_AGE_DEFAULT; + obt = obd_obt_init(obd); spin_lock_init(&m->ofd_flags_lock); m->ofd_raid_degraded = 0; - m->ofd_checksum_t10pi_enforce = 0; m->ofd_sync_journal = 0; ofd_slc_set(m); m->ofd_soft_sync_limit = OFD_SOFT_SYNC_LIMIT_DEFAULT; m->ofd_seq_count = 0; - init_waitqueue_head(&m->ofd_inconsistency_thread.t_ctl_waitq); INIT_LIST_HEAD(&m->ofd_inconsistency_list); spin_lock_init(&m->ofd_inconsistency_lock); + m->ofd_access_log_mask = -1; /* Log all accesses if enabled. */ + spin_lock_init(&m->ofd_batch_lock); init_rwsem(&m->ofd_lastid_rwsem); @@ -2868,12 +3004,6 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, /* set this lu_device to obd, because error handling need it */ obd->obd_lu_dev = &m->ofd_dt_dev.dd_lu_dev; - rc = ofd_tunables_init(m); - if (rc) { - CERROR("Can't init ofd lprocfs, rc %d\n", rc); - RETURN(rc); - } - /* No connection accepted until configurations will finish */ spin_lock(&obd->obd_dev_lock); obd->obd_no_conn = 1; @@ -2890,26 +3020,28 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, info = ofd_info_init(env, NULL); if (info == NULL) - GOTO(err_fini_proc, rc = -EFAULT); + RETURN(-EFAULT); - rc = ofd_stack_init(env, m, cfg); + rc = ofd_stack_init(env, m, cfg, lmd_flags); if (rc) { - CERROR("Can't init device stack, rc %d\n", rc); - GOTO(err_fini_proc, rc); + CERROR("%s: can't init device stack, rc %d\n", + obd->obd_name, rc); + RETURN(rc); } -#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 14, 53, 0) - ofd_procfs_add_brw_stats_symlink(m); -#endif - snprintf(info->fti_u.name, sizeof(info->fti_u.name), "%s-%s", "filter"/*LUSTRE_OST_NAME*/, obd->obd_uuid.uuid); m->ofd_namespace = ldlm_namespace_new(obd, info->fti_u.name, LDLM_NAMESPACE_SERVER, LDLM_NAMESPACE_GREEDY, LDLM_NS_TYPE_OST); - if (m->ofd_namespace == NULL) - GOTO(err_fini_stack, rc = -ENOMEM); + if (IS_ERR(m->ofd_namespace)) { + rc = PTR_ERR(m->ofd_namespace); + CERROR("%s: unable to create server namespace: rc = %d\n", + obd->obd_name, rc); + m->ofd_namespace = NULL; + GOTO(err_fini_stack, rc); + } /* set obd_namespace for compatibility with old code */ obd->obd_namespace = m->ofd_namespace; ldlm_register_intent(m->ofd_namespace, ofd_intent_policy); @@ -2925,19 +3057,27 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, if (rc) GOTO(err_free_ns, rc); + if (test_bit(LMD_FLG_SKIP_LFSCK, lmd_flags)) + m->ofd_skip_lfsck = 1; + if (test_bit(LMD_FLG_LOCAL_RECOV, lmd_flags)) + m->ofd_lut.lut_local_recovery = 1; + + rc = ofd_tunables_init(m); + if (rc) + GOTO(err_fini_lut, rc); + tgd->tgd_reserved_pcnt = 0; m->ofd_brw_size = m->ofd_lut.lut_dt_conf.ddp_brw_size; - m->ofd_cksum_types_supported = - obd_cksum_types_supported_server(obd->obd_name); m->ofd_precreate_batch = OFD_PRECREATE_BATCH_DEFAULT; if (tgd->tgd_osfs.os_bsize * tgd->tgd_osfs.os_blocks < OFD_PRECREATE_SMALL_FS) m->ofd_precreate_batch = OFD_PRECREATE_BATCH_SMALL; + m->ofd_atime_diff = OFD_DEF_ATIME_DIFF; rc = ofd_fs_setup(env, m, obd); if (rc) - GOTO(err_fini_lut, rc); + GOTO(err_fini_proc, rc); fid.f_seq = FID_SEQ_LOCAL_NAME; fid.f_oid = 1; @@ -2973,6 +3113,8 @@ err_fini_los: m->ofd_los = NULL; err_fini_fs: ofd_fs_cleanup(env, m); +err_fini_proc: + ofd_procfs_fini(m); err_fini_lut: tgt_fini(env, &m->ofd_lut); err_free_ns: @@ -2980,8 +3122,6 @@ err_free_ns: obd->obd_namespace = m->ofd_namespace = NULL; err_fini_stack: ofd_stack_fini(env, m, &m->ofd_osd->dd_lu_dev); -err_fini_proc: - ofd_procfs_fini(m); return rc; } @@ -3012,20 +3152,25 @@ static void ofd_fini(const struct lu_env *env, struct ofd_device *m) obd_exports_barrier(obd); obd_zombie_barrier(); + ofd_procfs_fini(m); tgt_fini(env, &m->ofd_lut); ofd_stop_inconsistency_verification_thread(m); lfsck_degister(env, m->ofd_osd); ofd_fs_cleanup(env, m); - nm_config_file_deregister_tgt(env, obd->u.obt.obt_nodemap_config_file); - obd->u.obt.obt_nodemap_config_file = NULL; + nm_config_file_deregister_tgt(env, + obd2obt(obd)->obt_nodemap_config_file); + obd2obt(obd)->obt_nodemap_config_file = NULL; if (m->ofd_namespace != NULL) { ldlm_namespace_free_post(m->ofd_namespace); d->ld_obd->obd_namespace = m->ofd_namespace = NULL; } + ofd_access_log_delete(m->ofd_access_log); + m->ofd_access_log = NULL; + ofd_stack_fini(env, m, &m->ofd_dt_dev.dd_lu_dev); - ofd_procfs_fini(m); + LASSERT(atomic_read(&d->ld_ref) == 0); server_put_mount(obd->obd_name, true); EXIT; @@ -3109,7 +3254,7 @@ static struct lu_device *ofd_device_alloc(const struct lu_env *env, /* type constructor/destructor: ofd_type_init(), ofd_type_fini() */ LU_TYPE_INIT_FINI(ofd, &ofd_thread_key); -static struct lu_device_type_operations ofd_device_type_ops = { +static const struct lu_device_type_operations ofd_device_type_ops = { .ldto_init = ofd_type_init, .ldto_fini = ofd_type_fini, @@ -3139,20 +3284,32 @@ static struct lu_device_type ofd_device_type = { */ static int __init ofd_init(void) { - int rc; + int rc; + + rc = libcfs_setup(); + if (rc) + return rc; rc = lu_kmem_init(ofd_caches); if (rc) return rc; - rc = ofd_fmd_init(); - if (rc) { - lu_kmem_fini(ofd_caches); - return(rc); - } + rc = ofd_access_log_module_init(); + if (rc) + goto out_caches; - rc = class_register_type(&ofd_obd_ops, NULL, true, NULL, + rc = class_register_type(&ofd_obd_ops, NULL, true, LUSTRE_OST_NAME, &ofd_device_type); + if (rc) + goto out_ofd_access_log; + + return 0; + +out_ofd_access_log: + ofd_access_log_module_exit(); +out_caches: + lu_kmem_fini(ofd_caches); + return rc; } @@ -3164,9 +3321,9 @@ static int __init ofd_init(void) */ static void __exit ofd_exit(void) { - ofd_fmd_exit(); - lu_kmem_fini(ofd_caches); class_unregister_type(LUSTRE_OST_NAME); + ofd_access_log_module_exit(); + lu_kmem_fini(ofd_caches); } MODULE_AUTHOR("OpenSFS, Inc. ");