X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fofd%2Fofd_dev.c;h=843abca369bcf40976ae12fd2260151c7ec74ea1;hb=3cce65712d94cffe8f1626545845b95b88aef672;hp=17ce15f5c64fa0ef3dd98bee0a44410c86b30baf;hpb=a8dcf372f430c308d3e96fb506563068d0a80c2d;p=fs%2Flustre-release.git diff --git a/lustre/ofd/ofd_dev.c b/lustre/ofd/ofd_dev.c index 17ce15f..843abca 100644 --- a/lustre/ofd/ofd_dev.c +++ b/lustre/ofd/ofd_dev.c @@ -23,7 +23,7 @@ * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2012, 2016, Intel Corporation. + * Copyright (c) 2012, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -82,7 +82,6 @@ /* Slab for OFD object allocation */ static struct kmem_cache *ofd_object_kmem; - static struct lu_kmem_descr ofd_caches[] = { { .ckd_cache = &ofd_object_kmem, @@ -245,9 +244,14 @@ static void ofd_stack_fini(const struct lu_env *env, struct ofd_device *m, top->ld_ops->ldo_process_config(env, top, lcfg); OBD_FREE(lcfg, lustre_cfg_len(lcfg->lcfg_bufcount, lcfg->lcfg_buflens)); + if (m->ofd_los != NULL) { + local_oid_storage_fini(env, m->ofd_los); + m->ofd_los = NULL; + } + 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_ERROR, NULL); + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_OTHER, NULL); lu_site_print(env, top->ld_site, &msgdata, lu_cdebug_printer); } @@ -257,6 +261,30 @@ static void ofd_stack_fini(const struct lu_env *env, struct ofd_device *m, EXIT; } +static void ofd_stack_pre_fini(const struct lu_env *env, struct ofd_device *m, + struct lu_device *top) +{ + struct lustre_cfg_bufs bufs; + struct lustre_cfg *lcfg; + ENTRY; + + LASSERT(top); + + lustre_cfg_bufs_reset(&bufs, ofd_name(m)); + lustre_cfg_bufs_set_string(&bufs, 1, NULL); + OBD_ALLOC(lcfg, lustre_cfg_len(bufs.lcfg_bufcount, bufs.lcfg_buflen)); + if (!lcfg) { + CERROR("%s: failed to trigger LCFG_PRE_CLEANUP\n", ofd_name(m)); + } else { + lustre_cfg_init(lcfg, LCFG_PRE_CLEANUP, &bufs); + top->ld_ops->ldo_process_config(env, top, lcfg); + OBD_FREE(lcfg, lustre_cfg_len(lcfg->lcfg_bufcount, + lcfg->lcfg_buflens)); + } + + EXIT; +} + /* For interoperability, see mdt_interop_param[]. */ static struct cfg_interop_param ofd_interop_param[] = { { "ost.quota_type", NULL }, @@ -291,13 +319,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; } } @@ -330,11 +352,11 @@ static int ofd_process_config(const struct lu_env *env, struct lu_device *d, switch (cfg->lcfg_command) { case LCFG_PARAM: { - struct obd_device *obd = ofd_obd(m); /* For interoperability */ - struct cfg_interop_param *ptr = NULL; - struct lustre_cfg *old_cfg = NULL; - char *param = NULL; + struct cfg_interop_param *ptr = NULL; + struct lustre_cfg *old_cfg = NULL; + char *param = NULL; + ssize_t count; param = lustre_cfg_string(cfg, 1); if (param == NULL) { @@ -368,14 +390,16 @@ static int ofd_process_config(const struct lu_env *env, struct lu_device *d, break; } - rc = class_process_proc_param(PARAM_OST, obd->obd_vars, cfg, - d->ld_obd); - if (rc > 0 || rc == -ENOSYS) { - CDEBUG(D_CONFIG, "pass param %s down the stack.\n", - param); - /* we don't understand; pass it on */ - rc = next->ld_ops->ldo_process_config(env, next, cfg); + count = class_modify_config(cfg, PARAM_OST, + &d->ld_obd->obd_kset.kobj); + if (count > 0) { + rc = 0; + break; } + CDEBUG(D_CONFIG, "pass param %s down the stack.\n", + param); + /* we don't understand; pass it on */ + rc = next->ld_ops->ldo_process_config(env, next, cfg); break; } case LCFG_SPTLRPC_CONF: { @@ -609,6 +633,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); + OBD_FAIL_TIMEOUT_ORSET(OBD_FAIL_OST_PREPARE_DELAY, OBD_FAIL_ONCE, + (OBD_TIMEOUT_DEFAULT + 1) / 4); LASSERT(obd->obd_no_conn); spin_lock(&obd->obd_dev_lock); obd->obd_no_conn = 0; @@ -670,75 +696,7 @@ static struct lu_device_operations ofd_lu_ops = { .ldo_prepare = ofd_prepare, }; -LPROC_SEQ_FOPS(lprocfs_nid_stats_clear); - -/** - * Initialize all needed procfs entries for OFD device. - * - * \param[in] ofd OFD device - * - * \retval 0 if successful - * \retval negative value on error - */ -static int ofd_procfs_init(struct ofd_device *ofd) -{ - struct obd_device *obd = ofd_obd(ofd); - struct proc_dir_entry *entry; - int rc = 0; - - ENTRY; - - /* lprocfs must be setup before the ofd so state can be safely added - * to /proc incrementally as the ofd is setup */ - obd->obd_vars = lprocfs_ofd_obd_vars; - rc = lprocfs_obd_setup(obd, false); - if (rc) { - CERROR("%s: lprocfs_obd_setup failed: %d.\n", - obd->obd_name, rc); - RETURN(rc); - } - - rc = lprocfs_alloc_obd_stats(obd, LPROC_OFD_STATS_LAST); - if (rc) { - CERROR("%s: lprocfs_alloc_obd_stats failed: %d.\n", - obd->obd_name, rc); - GOTO(obd_cleanup, rc); - } - - obd->obd_uses_nid_stats = 1; - - entry = lprocfs_register("exports", obd->obd_proc_entry, NULL, NULL); - if (IS_ERR(entry)) { - rc = PTR_ERR(entry); - CERROR("%s: error %d setting up lprocfs for %s\n", - obd->obd_name, rc, "exports"); - GOTO(obd_cleanup, rc); - } - obd->obd_proc_exports_entry = entry; - - entry = lprocfs_add_simple(obd->obd_proc_exports_entry, "clear", - obd, &lprocfs_nid_stats_clear_fops); - if (IS_ERR(entry)) { - rc = PTR_ERR(entry); - CERROR("%s: add proc entry 'clear' failed: %d.\n", - obd->obd_name, rc); - GOTO(obd_cleanup, rc); - } - - ofd_stats_counter_init(obd->obd_stats); - - rc = lprocfs_job_stats_init(obd, LPROC_OFD_STATS_LAST, - ofd_stats_counter_init); - if (rc) - GOTO(obd_cleanup, rc); - RETURN(0); -obd_cleanup: - lprocfs_obd_cleanup(obd); - lprocfs_free_obd_stats(obd); - - return rc; -} - +#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 14, 53, 0) /** * Expose OSD statistics to OFD layer. * @@ -752,8 +710,31 @@ obd_cleanup: */ 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; + struct obd_device *obd = ofd_obd(ofd); + struct obd_device *osd_obd = ofd->ofd_osd_exp->exp_obd; + struct kobj_type *osd_type; + int i; + + osd_type = get_ktype(&ofd->ofd_osd->dd_kobj); + for (i = 0; osd_type->default_attrs[i]; i++) { + if (strcmp(osd_type->default_attrs[i]->name, + "read_cache_enable") == 0) { + ofd->ofd_read_cache_enable = + osd_type->default_attrs[i]; + } + + if (strcmp(osd_type->default_attrs[i]->name, + "readcache_max_filesize") == 0) { + ofd->ofd_read_cache_max_filesize = + osd_type->default_attrs[i]; + } + + if (strcmp(osd_type->default_attrs[i]->name, + "writethrough_cache_enable") == 0) { + ofd->ofd_write_cache_enable = + osd_type->default_attrs[i]; + } + } if (obd->obd_proc_entry == NULL) return; @@ -761,21 +742,8 @@ static void ofd_procfs_add_brw_stats_symlink(struct ofd_device *ofd) 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. @@ -786,6 +754,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); @@ -825,18 +794,19 @@ int ofd_fid_fini(const struct lu_env *env, struct ofd_device *ofd) */ int ofd_fid_init(const struct lu_env *env, struct ofd_device *ofd) { - struct seq_server_site *ss = &ofd->ofd_seq_site; - struct lu_device *lu = &ofd->ofd_dt_dev.dd_lu_dev; - char *obd_name = ofd_name(ofd); - char *name = NULL; - int rc = 0; + struct seq_server_site *ss = &ofd->ofd_seq_site; + struct lu_device *lu = &ofd->ofd_dt_dev.dd_lu_dev; + char *obd_name = ofd_name(ofd); + char *name = NULL; + int len = strlen(obd_name) + 7; + int rc = 0; ss = &ofd->ofd_seq_site; lu->ld_site->ld_seq_site = ss; ss->ss_lu = lu->ld_site; ss->ss_node_id = ofd->ofd_lut.lut_lsd.lsd_osd_index; - OBD_ALLOC(name, sizeof(obd_name) * 2 + 10); + OBD_ALLOC(name, len); if (name == NULL) return -ENOMEM; @@ -847,7 +817,7 @@ int ofd_fid_init(const struct lu_env *env, struct ofd_device *ofd) rc = seq_server_init(env, ss->ss_server_seq, ofd->ofd_osd, obd_name, LUSTRE_SEQ_SERVER, ss); if (rc) { - CERROR("%s : seq server init error %d\n", obd_name, rc); + CERROR("%s: seq server init error: rc = %d\n", obd_name, rc); GOTO(out_server, rc); } ss->ss_server_seq->lss_space.lsr_index = ss->ss_node_id; @@ -856,15 +826,11 @@ int ofd_fid_init(const struct lu_env *env, struct ofd_device *ofd) if (ss->ss_client_seq == NULL) GOTO(out_server, rc = -ENOMEM); - /* - * It always printed as "%p", so that the name is unique in the kernel, - * even if the filesystem is mounted twice. So sizeof(.) * 2 is enough. - */ - snprintf(name, sizeof(obd_name) * 2 + 7, "%p-super", obd_name); + 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 %d\n", obd_name, rc); + CERROR("%s: seq client init error: rc = %d\n", obd_name, rc); GOTO(out_client, rc); } @@ -881,7 +847,7 @@ out_server: ss->ss_server_seq = NULL; } out_name: - OBD_FREE(name, sizeof(obd_name) * 2 + 10); + OBD_FREE(name, len); return rc; } @@ -993,48 +959,25 @@ int ofd_fiemap_get(const struct lu_env *env, struct ofd_device *ofd, return rc; } -struct locked_region { - struct list_head list; - struct lustre_handle lh; -}; -/** - * Lock single extent and save lock handle in the list. - * - * This is supplemental function for lock_zero_regions(). It allocates - * new locked_region structure and locks it with extent lock, then adds - * it to the list of all such regions. - * - * \param[in] ns LDLM namespace - * \param[in] res_id resource ID - * \param[in] begin start of region - * \param[in] end end of region - * \param[in] locked list head of regions list - * - * \retval 0 if successful locking - * \retval negative value on error - */ -static int lock_region(struct ldlm_namespace *ns, struct ldlm_res_id *res_id, - unsigned long long begin, unsigned long long end, - struct list_head *locked) +static int ofd_lock_unlock_region(const struct lu_env *env, + struct ldlm_namespace *ns, + struct ldlm_res_id *res_id, + unsigned long long begin, + unsigned long long end) { - struct locked_region *region = NULL; __u64 flags = 0; int rc; + struct lustre_handle lh = { 0 }; LASSERT(begin <= end); - OBD_ALLOC_PTR(region); - if (region == NULL) - return -ENOMEM; - rc = tgt_extent_lock(ns, res_id, begin, end, ®ion->lh, - LCK_PR, &flags); + rc = tgt_extent_lock(env, ns, res_id, begin, end, &lh, LCK_PR, &flags); if (rc != 0) return rc; - CDEBUG(D_OTHER, "ost lock [%llu,%llu], lh=%p\n", begin, end, - ®ion->lh); - list_add(®ion->list, locked); + CDEBUG(D_OTHER, "ost lock [%llu,%llu], lh=%p\n", begin, end, &lh); + tgt_extent_unlock(&lh, LCK_PR); return 0; } @@ -1057,10 +1000,10 @@ static int lock_region(struct ldlm_namespace *ns, struct ldlm_res_id *res_id, * \retval 0 if successful * \retval negative value on error */ -static int lock_zero_regions(struct ldlm_namespace *ns, +static int lock_zero_regions(const struct lu_env *env, + struct ldlm_namespace *ns, struct ldlm_res_id *res_id, - struct fiemap *fiemap, - struct list_head *locked) + struct fiemap *fiemap) { __u64 begin = fiemap->fm_start; unsigned int i; @@ -1074,8 +1017,8 @@ static int lock_zero_regions(struct ldlm_namespace *ns, if (fiemap_start[i].fe_logical > begin) { CDEBUG(D_OTHER, "ost lock [%llu,%llu]\n", begin, fiemap_start[i].fe_logical); - rc = lock_region(ns, res_id, begin, - fiemap_start[i].fe_logical, locked); + rc = ofd_lock_unlock_region(env, ns, res_id, begin, + fiemap_start[i].fe_logical); if (rc) RETURN(rc); } @@ -1086,34 +1029,13 @@ static int lock_zero_regions(struct ldlm_namespace *ns, if (begin < (fiemap->fm_start + fiemap->fm_length)) { CDEBUG(D_OTHER, "ost lock [%llu,%llu]\n", begin, fiemap->fm_start + fiemap->fm_length); - rc = lock_region(ns, res_id, begin, - fiemap->fm_start + fiemap->fm_length, locked); + rc = ofd_lock_unlock_region(env, ns, res_id, begin, + fiemap->fm_start + fiemap->fm_length); } RETURN(rc); } -/** - * Unlock all previously locked sparse areas for given resource. - * - * This function goes through list of locked regions, unlocking and freeing - * them one-by-one. - * - * \param[in] ns LDLM namespace - * \param[in] locked list head of regions list - */ -static void -unlock_zero_regions(struct ldlm_namespace *ns, struct list_head *locked) -{ - struct locked_region *entry, *temp; - - list_for_each_entry_safe(entry, temp, locked, list) { - CDEBUG(D_OTHER, "ost unlock lh=%p\n", &entry->lh); - tgt_extent_unlock(&entry->lh, LCK_PR); - list_del(&entry->list); - OBD_FREE_PTR(entry); - } -} /** * OFD request handler for OST_GET_INFO RPC. @@ -1207,19 +1129,12 @@ static int ofd_get_info_hdl(struct tgt_session_info *tsi) * flushed back from client, then call fiemap again. */ if (fm_key->lfik_oa.o_valid & OBD_MD_FLFLAGS && fm_key->lfik_oa.o_flags & OBD_FL_SRVLOCK) { - struct list_head locked; - - INIT_LIST_HEAD(&locked); ost_fid_build_resid(fid, &fti->fti_resid); - rc = lock_zero_regions(ofd->ofd_namespace, - &fti->fti_resid, fiemap, - &locked); - if (rc == 0 && !list_empty(&locked)) { + rc = lock_zero_regions(tsi->tsi_env, ofd->ofd_namespace, + &fti->fti_resid, fiemap); + if (rc == 0) rc = ofd_fiemap_get(tsi->tsi_env, ofd, fid, fiemap); - unlock_zero_regions(ofd->ofd_namespace, - &locked); - } } } else if (KEY_IS(KEY_LAST_FID)) { struct ofd_device *ofd = ofd_exp(exp); @@ -1307,7 +1222,8 @@ static int ofd_getattr_hdl(struct tgt_session_info *tsi) if (unlikely(tsi->tsi_ost_body->oa.o_flags & OBD_FL_FLUSH)) lock_mode = LCK_PW; - rc = tgt_extent_lock(tsi->tsi_tgt->lut_obd->obd_namespace, + rc = tgt_extent_lock(tsi->tsi_env, + tsi->tsi_tgt->lut_obd->obd_namespace, &tsi->tsi_resid, 0, OBD_OBJECT_EOF, &lh, lock_mode, &flags); if (rc != 0) @@ -1332,6 +1248,16 @@ static int ofd_getattr_hdl(struct tgt_session_info *tsi) repbody->oa.o_valid |= OBD_MD_FLDATAVERSION; repbody->oa.o_data_version = curr_version; } + + if (fo->ofo_ff.ff_layout_version > 0) { + repbody->oa.o_valid |= OBD_MD_LAYOUT_VERSION; + repbody->oa.o_layout_version = + fo->ofo_ff.ff_layout_version + fo->ofo_ff.ff_range; + + CDEBUG(D_INODE, DFID": get layout version: %u\n", + PFID(&tsi->tsi_fid), + repbody->oa.o_layout_version); + } } ofd_object_put(tsi->tsi_env, fo); @@ -1367,7 +1293,6 @@ static int ofd_setattr_hdl(struct tgt_session_info *tsi) struct ost_body *repbody; struct ldlm_resource *res; struct ofd_object *fo; - struct filter_fid *ff = NULL; int rc = 0; ENTRY; @@ -1407,13 +1332,8 @@ static int ofd_setattr_hdl(struct tgt_session_info *tsi) la_from_obdo(&fti->fti_attr, &body->oa, body->oa.o_valid); fti->fti_attr.la_valid &= ~LA_TYPE; - if (body->oa.o_valid & OBD_MD_FLFID) { - ff = &fti->fti_mds_fid; - ofd_prepare_fidea(ff, &body->oa); - } - /* setting objects attributes (including owner/group) */ - rc = ofd_attr_set(tsi->tsi_env, fo, &fti->fti_attr, ff); + rc = ofd_attr_set(tsi->tsi_env, fo, &fti->fti_attr, &body->oa); if (rc != 0) GOTO(out_put, rc); @@ -1622,8 +1542,9 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) oseq->os_destroys_in_progress = 1; mutex_lock(&oseq->os_create_lock); if (!oseq->os_destroys_in_progress) { - CERROR("%s:[%llu] destroys_in_progress already" - " cleared\n", ofd_name(ofd), seq); + CDEBUG(D_HA, + "%s:[%llu] destroys_in_progress already cleared\n", + ofd_name(ofd), seq); rc = ostid_set_id(&rep_oa->o_oi, ofd_seq_last_oid(oseq)); GOTO(out, rc); @@ -1698,10 +1619,11 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) } } if (diff > 0) { - cfs_time_t enough_time = cfs_time_shift(DISK_TIMEOUT); - u64 next_id; - int created = 0; - int count; + time64_t enough_time = ktime_get_seconds() + DISK_TIMEOUT; + u64 next_id; + int created = 0; + int count; + int rc2; if (!(oa->o_valid & OBD_MD_FLFLAGS) || !(oa->o_flags & OBD_FL_DELORPHAN)) { @@ -1749,7 +1671,7 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) count, seq, next_id); if (!(lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY) - && cfs_time_after(jiffies, enough_time)) { + && ktime_get_seconds() > enough_time) { CDEBUG(D_HA, "%s: Slow creates, %d/%lld objects" " created at a rate of %d/s\n", ofd_name(ofd), created, diff + created, @@ -1789,11 +1711,14 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) granted = 0; } - rc = ostid_set_id(&rep_oa->o_oi, ofd_seq_last_oid(oseq)); + rc2 = ostid_set_id(&rep_oa->o_oi, ofd_seq_last_oid(oseq)); + rc = rc ? : rc2; } EXIT; ofd_counter_incr(exp, LPROC_OFD_STATS_CREATE, tsi->tsi_jobid, 1); + if (unlikely(!oseq->os_last_id_synced)) + oseq->os_last_id_synced = 1; out: mutex_unlock(&oseq->os_create_lock); out_nolock: @@ -1922,10 +1847,12 @@ static int ofd_statfs_hdl(struct tgt_session_info *tsi) ENTRY; + OBD_FAIL_TIMEOUT(OBD_FAIL_OST_STATFS_DELAY, 10); + osfs = req_capsule_server_get(tsi->tsi_pill, &RMF_OBD_STATFS); rc = ofd_statfs(tsi->tsi_env, tsi->tsi_exp, osfs, - cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), 0); + ktime_get_seconds() - OBD_STATFS_CACHE_SECONDS, 0); if (rc != 0) CERROR("%s: statfs failed: rc = %d\n", tgt_name(tsi->tsi_tgt), rc); @@ -2017,7 +1944,6 @@ static int ofd_punch_hdl(struct tgt_session_info *tsi) struct ldlm_namespace *ns = tsi->tsi_tgt->lut_obd->obd_namespace; struct ldlm_resource *res; struct ofd_object *fo; - struct filter_fid *ff = NULL; __u64 flags = 0; struct lustre_handle lh = { 0, }; int rc; @@ -2058,8 +1984,8 @@ static int ofd_punch_hdl(struct tgt_session_info *tsi) oa->o_flags & OBD_FL_SRVLOCK; if (srvlock) { - rc = tgt_extent_lock(ns, &tsi->tsi_resid, start, end, &lh, - LCK_PW, &flags); + rc = tgt_extent_lock(tsi->tsi_env, ns, &tsi->tsi_resid, start, + end, &lh, LCK_PW, &flags); if (rc != 0) RETURN(rc); } @@ -2078,13 +2004,8 @@ static int ofd_punch_hdl(struct tgt_session_info *tsi) info->fti_attr.la_size = start; info->fti_attr.la_valid |= LA_SIZE; - if (oa->o_valid & OBD_MD_FLFID) { - ff = &info->fti_mds_fid; - ofd_prepare_fidea(ff, oa); - } - rc = ofd_object_punch(tsi->tsi_env, fo, start, end, &info->fti_attr, - ff, (struct obdo *)oa); + (struct obdo *)oa); if (rc) GOTO(out_put, rc); @@ -2105,7 +2026,12 @@ out: res = ldlm_resource_get(ns, NULL, &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; + repbody->oa.o_valid |= OBD_MD_FLBLOCKS; + repbody->oa.o_blocks = res_lvb->lvb_blocks; ldlm_resource_putref(res); } } @@ -2269,7 +2195,7 @@ static int ofd_ladvise_hdl(struct tgt_session_info *tsi) ioo.ioo_oid = body->oa.o_oi; ioo.ioo_bufcnt = 1; - rc = tgt_extent_lock(exp->exp_obd->obd_namespace, + rc = tgt_extent_lock(env, exp->exp_obd->obd_namespace, &tsi->tsi_resid, start, end - 1, &lockh, LCK_PR, &flags); if (rc != 0) @@ -2364,16 +2290,16 @@ static int ofd_quotactl(struct tgt_session_info *tsi) * * \retval amount of time to extend the timeout with */ -static inline int prolong_timeout(struct ptlrpc_request *req) +static inline time64_t prolong_timeout(struct ptlrpc_request *req) { struct ptlrpc_service_part *svcpt = req->rq_rqbd->rqbd_svcpt; - time_t req_timeout; + 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(time_t, at_est2timeout(at_get(&svcpt->scp_at_estimate)), + return max_t(time64_t, at_est2timeout(at_get(&svcpt->scp_at_estimate)), req_timeout); } @@ -2430,10 +2356,14 @@ static void ofd_prolong_extent_locks(struct tgt_session_info *tsi, LASSERT(lock->l_export == data->lpa_export); ldlm_lock_prolong_one(lock, data); LDLM_LOCK_PUT(lock); - RETURN_EXIT; + if (data->lpa_locks_cnt > 0) + RETURN_EXIT; + /* The lock was destroyed probably lets try + * resource tree. */ + } else { + lock->l_last_used = ktime_get(); + LDLM_LOCK_PUT(lock); } - lock->l_last_used = cfs_time_current(); - LDLM_LOCK_PUT(lock); } } @@ -2781,26 +2711,25 @@ 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(HAS_REPLY, OST_QUOTACTL, ofd_quotactl), +TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_LADVISE, ofd_ladvise_hdl), }; static struct tgt_opc_slice ofd_common_slice[] = { @@ -2902,7 +2831,6 @@ 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; - struct obd_statfs *osfs; struct lu_fid fid; struct nm_config_file *nodemap_config; struct obd_device_target *obt; @@ -2923,29 +2851,13 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, 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; - spin_lock_init(&m->ofd_flags_lock); m->ofd_raid_degraded = 0; - m->ofd_syncjournal = 0; + m->ofd_checksum_t10pi_enforce = 0; + m->ofd_sync_journal = 0; ofd_slc_set(m); - tgd->tgd_grant_compat_disable = 0; m->ofd_soft_sync_limit = OFD_SOFT_SYNC_LIMIT_DEFAULT; - /* statfs data */ - spin_lock_init(&tgd->tgd_osfs_lock); - tgd->tgd_osfs_age = cfs_time_shift_64(-1000); - tgd->tgd_osfs_unstable = 0; - tgd->tgd_statfs_inflight = 0; - tgd->tgd_osfs_inflight = 0; - - /* grant data */ - spin_lock_init(&tgd->tgd_grant_lock); - tgd->tgd_tot_dirty = 0; - tgd->tgd_tot_granted = 0; - tgd->tgd_tot_pending = 0; - m->ofd_seq_count = 0; init_waitqueue_head(&m->ofd_inconsistency_thread.t_ctl_waitq); INIT_LIST_HEAD(&m->ofd_inconsistency_list); @@ -2959,12 +2871,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_procfs_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; @@ -2981,15 +2887,18 @@ 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); 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); @@ -3008,41 +2917,29 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, ptlrpc_init_client(LDLM_CB_REQUEST_PORTAL, LDLM_CB_REPLY_PORTAL, "filter_ldlm_cb_client", &obd->obd_ldlm_client); - dt_conf_get(env, m->ofd_osd, &m->ofd_lut.lut_dt_conf); - rc = tgt_init(env, &m->ofd_lut, obd, m->ofd_osd, ofd_common_slice, OBD_FAIL_OST_ALL_REQUEST_NET, OBD_FAIL_OST_ALL_REPLY_NET); if (rc) GOTO(err_free_ns, rc); - /* populate cached statfs data */ - osfs = &ofd_info(env)->fti_u.osfs; - rc = tgt_statfs_internal(env, &m->ofd_lut, osfs, 0, NULL); - if (rc != 0) { - CERROR("%s: can't get statfs data, rc %d\n", obd->obd_name, rc); + rc = ofd_tunables_init(m); + if (rc) GOTO(err_fini_lut, rc); - } - if (!is_power_of_2(osfs->os_bsize)) { - CERROR("%s: blocksize (%d) is not a power of 2\n", - obd->obd_name, osfs->os_bsize); - GOTO(err_fini_lut, rc = -EPROTO); - } - tgd->tgd_blockbits = fls(osfs->os_bsize) - 1; - if (DT_DEF_BRW_SIZE < (1U << tgd->tgd_blockbits)) - m->ofd_brw_size = 1U << tgd->tgd_blockbits; - else - m->ofd_brw_size = DT_DEF_BRW_SIZE; + tgd->tgd_reserved_pcnt = 0; - m->ofd_cksum_types_supported = cksum_types_supported_server(); + 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 (osfs->os_bsize * osfs->os_blocks < OFD_PRECREATE_SMALL_FS) + if (tgd->tgd_osfs.os_bsize * tgd->tgd_osfs.os_blocks < + OFD_PRECREATE_SMALL_FS) m->ofd_precreate_batch = OFD_PRECREATE_BATCH_SMALL; 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; @@ -3078,6 +2975,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: @@ -3085,8 +2984,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; } @@ -3108,6 +3005,7 @@ static void ofd_fini(const struct lu_env *env, struct ofd_device *m) stop.ls_status = LS_PAUSED; stop.ls_flags = 0; lfsck_stop(env, m->ofd_osd, &stop); + ofd_stack_pre_fini(env, m, &m->ofd_dt_dev.dd_lu_dev); target_recovery_fini(obd); if (m->ofd_namespace != NULL) ldlm_namespace_free_prior(m->ofd_namespace, NULL, @@ -3116,6 +3014,7 @@ 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); @@ -3123,18 +3022,13 @@ static void ofd_fini(const struct lu_env *env, struct ofd_device *m) nm_config_file_deregister_tgt(env, obd->u.obt.obt_nodemap_config_file); obd->u.obt.obt_nodemap_config_file = NULL; - if (m->ofd_los != NULL) { - local_oid_storage_fini(env, m->ofd_los); - m->ofd_los = NULL; - } - if (m->ofd_namespace != NULL) { ldlm_namespace_free_post(m->ofd_namespace); d->ld_obd->obd_namespace = m->ofd_namespace = 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; @@ -3253,20 +3147,6 @@ static int __init ofd_init(void) 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_dlm_init(); - if (rc) { - lu_kmem_fini(ofd_caches); - ofd_fmd_exit(); - return rc; - } - rc = class_register_type(&ofd_obd_ops, NULL, true, NULL, LUSTRE_OST_NAME, &ofd_device_type); return rc; @@ -3280,8 +3160,6 @@ static int __init ofd_init(void) */ static void __exit ofd_exit(void) { - ofd_fmd_exit(); - ofd_dlm_exit(); lu_kmem_fini(ofd_caches); class_unregister_type(LUSTRE_OST_NAME); }