X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fofd%2Fofd_dev.c;h=af3379648278c8fc376ffca85ca5cbe3695cf3b8;hp=e4ddf91fccec96eb79d8aa18d2d1c61e57d9f067;hb=dc52a88cde1e7cea093b25fc9a15509fe0ac527a;hpb=930dca7253bc2531bffa15dc763db1081cdf32d8 diff --git a/lustre/ofd/ofd_dev.c b/lustre/ofd/ofd_dev.c index e4ddf91..af33796 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, 2014 Intel Corporation. + * Copyright (c) 2012, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -42,7 +42,7 @@ * The OBD Filter Device (OFD) module belongs to the Object Storage * Server stack and connects the RPC oriented Unified Target (TGT) * layer (see lustre/include/lu_target.h) to the storage oriented OSD - * layer (see lustre/doc/osd-api.txt). + * layer (see Documentation/osd-api.txt). * * TGT * | DT and OBD APIs @@ -69,13 +69,14 @@ #define DEBUG_SUBSYSTEM S_FILTER #include -#include +#include +#include #include #include -#include #include #include #include +#include #include "ofd_internal.h" @@ -167,6 +168,7 @@ static int ofd_stack_init(const struct lu_env *env, struct lu_device *d; struct ofd_thread_info *info = ofd_info(env); struct lustre_mount_info *lmi; + struct lustre_mount_data *lmd; int rc; char *osdname; @@ -178,6 +180,10 @@ static int ofd_stack_init(const struct lu_env *env, RETURN(-ENODEV); } + lmd = s2lsi(lmi->lmi_sb)->lsi_lmd; + if (lmd != NULL && lmd->lmd_flags & LMD_FLG_SKIP_LFSCK) + m->ofd_skip_lfsck = 1; + /* find bottom osd */ OBD_ALLOC(osdname, MTI_NAME_MAXLEN); if (osdname == NULL) @@ -230,17 +236,23 @@ static void ofd_stack_fini(const struct lu_env *env, struct ofd_device *m, if (obd->obd_fail) strcat(flags, "A"); lustre_cfg_bufs_set_string(&bufs, 1, flags); - lcfg = lustre_cfg_new(LCFG_CLEANUP, &bufs); - if (lcfg == NULL) + OBD_ALLOC(lcfg, lustre_cfg_len(bufs.lcfg_bufcount, bufs.lcfg_buflen)); + if (!lcfg) RETURN_EXIT; + lustre_cfg_init(lcfg, LCFG_CLEANUP, &bufs); LASSERT(top); top->ld_ops->ldo_process_config(env, top, lcfg); - lustre_cfg_free(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); } @@ -250,6 +262,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 }, @@ -284,13 +320,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; } } @@ -323,11 +353,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) { @@ -361,14 +391,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: { @@ -629,21 +661,26 @@ static int ofd_prepare(const struct lu_env *env, struct lu_device *pdev, static int ofd_recovery_complete(const struct lu_env *env, struct lu_device *dev) { + struct ofd_thread_info *oti = ofd_info(env); struct ofd_device *ofd = ofd_dev(dev); struct lu_device *next = &ofd->ofd_osd->dd_lu_dev; - int rc = 0, max_precreate; + int rc = 0; ENTRY; /* * Grant space for object precreation on the self export. - * This initial reserved space (i.e. 10MB for zfs and 280KB for ldiskfs) + * The initial reserved space (i.e. 10MB for zfs and 280KB for ldiskfs) * is enough to create 10k objects. More space is then acquired for - * precreation in ofd_grant_create(). + * precreation in tgt_grant_create(). */ - max_precreate = OST_MAX_PRECREATE * ofd->ofd_dt_conf.ddp_inodespace / 2; - ofd_grant_connect(env, dev->ld_obd->obd_self_export, max_precreate, - false); + memset(&oti->fti_ocd, 0, sizeof(oti->fti_ocd)); + oti->fti_ocd.ocd_grant = OST_MAX_PRECREATE / 2; + oti->fti_ocd.ocd_grant *= ofd->ofd_lut.lut_dt_conf.ddp_inodespace; + oti->fti_ocd.ocd_connect_flags = OBD_CONNECT_GRANT | + OBD_CONNECT_GRANT_PARAM; + tgt_grant_connect(env, dev->ld_obd->obd_self_export, &oti->fti_ocd, + true); rc = next->ld_ops->ldo_recovery_complete(env, next); RETURN(rc); } @@ -658,75 +695,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); - 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. * @@ -740,8 +709,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; @@ -749,21 +741,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. @@ -813,71 +792,60 @@ 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, len); + if (name == NULL) + return -ENOMEM; + OBD_ALLOC_PTR(ss->ss_server_seq); if (ss->ss_server_seq == NULL) - GOTO(out_free, rc = -ENOMEM); - - OBD_ALLOC(name, strlen(obd_name) + 10); - if (!name) { - OBD_FREE_PTR(ss->ss_server_seq); - ss->ss_server_seq = NULL; - GOTO(out_free, rc = -ENOMEM); - } + GOTO(out_name, rc = -ENOMEM); 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); - GOTO(out_free, 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; OBD_ALLOC_PTR(ss->ss_client_seq); if (ss->ss_client_seq == NULL) - GOTO(out_free, rc = -ENOMEM); + GOTO(out_server, rc = -ENOMEM); - snprintf(name, strlen(obd_name) + 6, "%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); - GOTO(out_free, rc); + CERROR("%s: seq client init error: rc = %d\n", obd_name, rc); + GOTO(out_client, rc); } - OBD_FREE(name, strlen(obd_name) + 10); - name = NULL; rc = seq_server_set_cli(env, ss->ss_server_seq, ss->ss_client_seq); -out_free: if (rc) { - if (ss->ss_server_seq) { - seq_server_fini(ss->ss_server_seq, env); - OBD_FREE_PTR(ss->ss_server_seq); - ss->ss_server_seq = NULL; - } - - if (ss->ss_client_seq) { - seq_client_fini(ss->ss_client_seq); - OBD_FREE_PTR(ss->ss_client_seq); - ss->ss_client_seq = NULL; - } - - if (name) { - OBD_FREE(name, strlen(obd_name) + 10); - name = NULL; - } +out_client: + seq_client_fini(ss->ss_client_seq); + OBD_FREE_PTR(ss->ss_client_seq); + ss->ss_client_seq = NULL; +out_server: + seq_server_fini(ss->ss_server_seq, env); + OBD_FREE_PTR(ss->ss_server_seq); + ss->ss_server_seq = NULL; } +out_name: + OBD_FREE(name, len); return rc; } @@ -935,14 +903,12 @@ static int ofd_set_info_hdl(struct tgt_session_info *tsi) *repbody = *body; /** handle grant shrink, similar to a read request */ - ofd_grant_prepare_read(tsi->tsi_env, tsi->tsi_exp, + tgt_grant_prepare_read(tsi->tsi_env, tsi->tsi_exp, &repbody->oa); } else if (KEY_IS(KEY_EVICT_BY_NID)) { if (vallen > 0) obd_export_evict_by_nid(tsi->tsi_exp->exp_obd, val); rc = 0; - } else if (KEY_IS(KEY_SPTLRPC_CONF)) { - rc = tgt_adapt_sptlrpc_conf(tsi->tsi_tgt, 0); } else { CERROR("%s: Unsupported key %s\n", tgt_name(tsi->tsi_tgt), (char *)key); @@ -991,48 +957,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; } @@ -1055,10 +998,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; @@ -1072,8 +1015,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); } @@ -1084,34 +1027,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. @@ -1205,19 +1127,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); @@ -1305,7 +1220,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) @@ -1321,8 +1237,7 @@ static int ofd_getattr_hdl(struct tgt_session_info *tsi) __u64 curr_version; obdo_from_la(&repbody->oa, &fti->fti_attr, - OFD_VALID_FLAGS | LA_UID | LA_GID); - tgt_drop_id(tsi->tsi_exp, &repbody->oa); + OFD_VALID_FLAGS | LA_UID | LA_GID | LA_PROJID); /* Store object version in reply */ curr_version = dt_version_get(tsi->tsi_env, @@ -1331,6 +1246,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); @@ -1366,7 +1291,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; @@ -1406,19 +1330,13 @@ 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); obdo_from_la(&repbody->oa, &fti->fti_attr, - OFD_VALID_FLAGS | LA_UID | LA_GID); - tgt_drop_id(tsi->tsi_exp, &repbody->oa); + OFD_VALID_FLAGS | LA_UID | LA_GID | LA_PROJID); ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_SETATTR, tsi->tsi_jobid, 1); @@ -1435,7 +1353,7 @@ out: res = ldlm_resource_get(ofd->ofd_namespace, NULL, &tsi->tsi_resid, LDLM_EXTENT, 0); if (!IS_ERR(res)) { - ldlm_res_lvbo_update(res, NULL, 0); + ldlm_res_lvbo_update(tsi->tsi_env, res, NULL, 0); ldlm_resource_putref(res); } } @@ -1526,8 +1444,7 @@ done: rc = ofd_seq_last_oid_write(env, ofd, oseq); } else { /* don't reuse orphan object, return last used objid */ - ostid_set_id(oi, last); - rc = 0; + rc = ostid_set_id(oi, last); } GOTO(out_put, rc); @@ -1559,8 +1476,10 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) u64 seq = ostid_seq(&oa->o_oi); u64 oid = ostid_id(&oa->o_oi); struct ofd_seq *oseq; - int rc = 0, diff; + s64 diff; + int rc = 0; int sync_trans = 0; + long granted = 0; ENTRY; @@ -1581,14 +1500,13 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) rep_oa = &repbody->oa; rep_oa->o_oi = oa->o_oi; - LASSERT(seq >= FID_SEQ_OST_MDT0); LASSERT(oa->o_valid & OBD_MD_FLGROUP); CDEBUG(D_INFO, "ofd_create("DOSTID")\n", POSTID(&oa->o_oi)); oseq = ofd_seq_load(tsi->tsi_env, ofd, seq); if (IS_ERR(oseq)) { - CERROR("%s: Can't find FID Sequence "LPX64": rc = %ld\n", + CERROR("%s: Can't find FID Sequence %#llx: rc = %ld\n", ofd_name(ofd), seq, PTR_ERR(oseq)); GOTO(out_sem, rc = -EINVAL); } @@ -1597,7 +1515,7 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) (oa->o_flags & OBD_FL_RECREATE_OBJS)) { if (!ofd_obd(ofd)->obd_recovering || oid > ofd_seq_last_oid(oseq)) { - CERROR("%s: recreate objid "DOSTID" > last id "LPU64 + CERROR("%s: recreate objid "DOSTID" > last id %llu" "\n", ofd_name(ofd), POSTID(&oa->o_oi), ofd_seq_last_oid(oseq)); GOTO(out_nolock, rc = -EINVAL); @@ -1622,18 +1540,27 @@ 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:["LPU64"] destroys_in_progress already" - " cleared\n", ofd_name(ofd), seq); - ostid_set_id(&rep_oa->o_oi, ofd_seq_last_oid(oseq)); - GOTO(out, rc = 0); + 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); } diff = oid - ofd_seq_last_oid(oseq); - CDEBUG(D_HA, "ofd_last_id() = "LPU64" -> diff = %d\n", - ofd_seq_last_oid(oseq), diff); + CDEBUG(D_HA, "ofd_last_id() = %llu -> diff = %lld\n", + ofd_seq_last_oid(oseq), diff); if (-diff > OST_MAX_PRECREATE) { + LCONSOLE(D_INFO, "%s: too large difference between MDS " + "LAST_ID "DFID" (%llu) and OST LAST_ID "DFID" " + "(%llu), trust the OST\n", + ofd_name(ofd), PFID(&oa->o_oi.oi_fid), oid, + PFID(&oseq->os_oi.oi_fid), + ofd_seq_last_oid(oseq)); + /* Let MDS know that we are so far ahead. */ - ostid_set_id(&rep_oa->o_oi, ofd_seq_last_oid(oseq) + 1); - rc = 0; + rc = ostid_set_id(&rep_oa->o_oi, + ofd_seq_last_oid(oseq) + 1); } else if (diff < 0) { rc = ofd_orphans_destroy(tsi->tsi_env, exp, ofd, rep_oa); @@ -1681,7 +1608,7 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) if (diff < 0) { /* LU-5648 */ CERROR("%s: invalid precreate request for " - DOSTID", last_id " LPU64 ". " + DOSTID", last_id %llu. " "Likely MDS last_id corruption\n", ofd_name(ofd), POSTID(&oa->o_oi), ofd_seq_last_oid(oseq)); @@ -1690,20 +1617,23 @@ 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)) { /* don't enforce grant during orphan recovery */ - rc = ofd_grant_create(tsi->tsi_env, - ofd_obd(ofd)->obd_self_export, - &diff); - if (rc) { + granted = tgt_grant_create(tsi->tsi_env, + ofd_obd(ofd)->obd_self_export, + &diff); + if (granted < 0) { + rc = granted; + granted = 0; CDEBUG(D_HA, "%s: failed to acquire grant " - "space for precreate (%d): rc = %d\n", + "space for precreate (%lld): rc = %d\n", ofd_name(ofd), diff, rc); diff = 0; } @@ -1716,26 +1646,31 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) * LFSCK will eventually clean up any orphans. LU-14 */ if (diff > 5 * OST_MAX_PRECREATE) { diff = OST_MAX_PRECREATE / 2; - LCONSOLE_WARN("%s: precreate FID "DOSTID" is over %u " - "larger than the LAST_ID "DOSTID", only " - "precreating the last %u objects.\n", - ofd_name(ofd), POSTID(&oa->o_oi), - 5 * OST_MAX_PRECREATE, - POSTID(&oseq->os_oi), diff); + 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); } while (diff > 0) { next_id = ofd_seq_last_oid(oseq) + 1; - count = ofd_precreate_batch(ofd, diff); + count = ofd_precreate_batch(ofd, (int)diff); - CDEBUG(D_HA, "%s: reserve %d objects in group "LPX64 - " at "LPU64"\n", ofd_name(ofd), + CDEBUG(D_HA, "%s: reserve %d objects in group %#llx" + " at %llu\n", ofd_name(ofd), count, seq, next_id); if (!(lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY) - && cfs_time_after(jiffies, enough_time)) { - CDEBUG(D_HA, "%s: Slow creates, %d/%d objects" + && 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, created / DISK_TIMEOUT); @@ -1756,7 +1691,7 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY) LCONSOLE_WARN("%s: can't create the same count of" " objects when replaying the request" - " (diff is %d). see LU-4621\n", + " (diff is %lld). see LU-4621\n", ofd_name(ofd), diff); if (created > 0) @@ -1768,15 +1703,20 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) ofd_name(ofd), rc); if (!(oa->o_valid & OBD_MD_FLFLAGS) || - !(oa->o_flags & OBD_FL_DELORPHAN)) - ofd_grant_commit(tsi->tsi_env, - ofd_obd(ofd)->obd_self_export, rc); + !(oa->o_flags & OBD_FL_DELORPHAN)) { + tgt_grant_commit(ofd_obd(ofd)->obd_self_export, + granted, rc); + granted = 0; + } - 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: @@ -1905,10 +1845,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); @@ -2000,7 +1942,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; @@ -2009,6 +1950,8 @@ static int ofd_punch_hdl(struct tgt_session_info *tsi) 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); @@ -2039,14 +1982,14 @@ 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); } - CDEBUG(D_INODE, "calling punch for object "DFID", valid = "LPX64 - ", start = "LPD64", end = "LPD64"\n", PFID(&tsi->tsi_fid), + CDEBUG(D_INODE, "calling punch for object "DFID", valid = %#llx" + ", start = %lld, end = %lld\n", PFID(&tsi->tsi_fid), oa->o_valid, start, end); fo = ofd_object_find_exists(tsi->tsi_env, ofd_exp(tsi->tsi_exp), @@ -2059,13 +2002,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); @@ -2086,13 +2024,200 @@ out: res = ldlm_resource_get(ns, NULL, &tsi->tsi_resid, LDLM_EXTENT, 0); if (!IS_ERR(res)) { - ldlm_res_lvbo_update(res, NULL, 0); + struct ost_lvb *res_lvb; + + ldlm_res_lvbo_update(tsi->tsi_env, 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); } } return rc; } +static int ofd_ladvise_prefetch(const struct lu_env *env, + struct ofd_object *fo, + struct niobuf_local *lnb, + __u64 start, __u64 end, enum dt_bufs_type dbt) +{ + struct ofd_thread_info *info = ofd_info(env); + pgoff_t start_index, end_index, pages; + struct niobuf_remote rnb; + unsigned long nr_local; + int rc = 0; + + if (end <= start) + RETURN(-EINVAL); + + ofd_read_lock(env, fo); + if (!ofd_object_exists(fo)) + GOTO(out_unlock, rc = -ENOENT); + + rc = ofd_attr_get(env, fo, &info->fti_attr); + if (rc) + GOTO(out_unlock, rc); + + if (end > info->fti_attr.la_size) + end = info->fti_attr.la_size; + + if (end <= start) + GOTO(out_unlock, rc); + + /* We need page aligned offset and length */ + start_index = start >> PAGE_SHIFT; + end_index = (end - 1) >> PAGE_SHIFT; + pages = end_index - start_index + 1; + while (pages > 0) { + nr_local = pages <= PTLRPC_MAX_BRW_PAGES ? pages : + 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); + if (unlikely(rc < 0)) + break; + nr_local = rc; + rc = dt_read_prep(env, ofd_object_child(fo), lnb, nr_local); + dt_bufs_put(env, ofd_object_child(fo), lnb, nr_local); + if (unlikely(rc)) + break; + start_index += nr_local; + pages -= nr_local; + } + +out_unlock: + ofd_read_unlock(env, fo); + RETURN(rc); +} + +/** + * OFD request handler for OST_LADVISE RPC. + * + * Tune cache or perfetch policies according to advices. + * + * \param[in] tsi target session environment for this request + * + * \retval 0 if successful + * \retval negative errno on error + */ +static int ofd_ladvise_hdl(struct tgt_session_info *tsi) +{ + struct ptlrpc_request *req = tgt_ses_req(tsi); + struct obd_export *exp = tsi->tsi_exp; + struct ofd_device *ofd = ofd_exp(exp); + struct ost_body *body, *repbody; + struct ofd_thread_info *info; + struct ofd_object *fo; + struct ptlrpc_thread *svc_thread = req->rq_svc_thread; + const struct lu_env *env = svc_thread->t_env; + struct tgt_thread_big_cache *tbc = svc_thread->t_data; + enum dt_bufs_type dbt = DT_BUFS_TYPE_READAHEAD; + struct lu_ladvise *ladvise; + int num_advise; + struct ladvise_hdr *ladvise_hdr; + struct obd_ioobj ioo; + struct lustre_handle lockh = { 0 }; + __u64 flags = 0; + int i; + struct dt_object *dob; + __u64 start; + __u64 end; + int rc = 0; + ENTRY; + + CFS_FAIL_TIMEOUT(OBD_FAIL_OST_LADVISE_PAUSE, cfs_fail_val); + body = tsi->tsi_ost_body; + + if ((body->oa.o_valid & OBD_MD_FLID) != OBD_MD_FLID) + RETURN(err_serious(-EPROTO)); + + ladvise_hdr = req_capsule_client_get(tsi->tsi_pill, + &RMF_OST_LADVISE_HDR); + if (ladvise_hdr == NULL) + RETURN(err_serious(-EPROTO)); + + if (ladvise_hdr->lah_magic != LADVISE_MAGIC || + ladvise_hdr->lah_count < 1) + RETURN(err_serious(-EPROTO)); + + if ((ladvise_hdr->lah_flags & (~LF_MASK)) != 0) + RETURN(err_serious(-EPROTO)); + + ladvise = req_capsule_client_get(tsi->tsi_pill, &RMF_OST_LADVISE); + if (ladvise == NULL) + RETURN(err_serious(-EPROTO)); + + num_advise = req_capsule_get_size(&req->rq_pill, + &RMF_OST_LADVISE, RCL_CLIENT) / + sizeof(*ladvise); + if (num_advise < ladvise_hdr->lah_count) + RETURN(err_serious(-EPROTO)); + + repbody = req_capsule_server_get(&req->rq_pill, &RMF_OST_BODY); + repbody->oa = body->oa; + + info = ofd_info_init(env, exp); + + rc = ostid_to_fid(&info->fti_fid, &body->oa.o_oi, + ofd->ofd_lut.lut_lsd.lsd_osd_index); + if (rc != 0) + RETURN(rc); + + fo = ofd_object_find(env, ofd, &info->fti_fid); + if (IS_ERR(fo)) { + rc = PTR_ERR(fo); + RETURN(rc); + } + LASSERT(fo != NULL); + dob = ofd_object_child(fo); + + if (ptlrpc_connection_is_local(exp->exp_connection)) + dbt |= DT_BUFS_TYPE_LOCAL; + + for (i = 0; i < num_advise; i++, ladvise++) { + start = ladvise->lla_start; + end = ladvise->lla_end; + if (end <= start) { + rc = err_serious(-EPROTO); + break; + } + + /* Handle different advice types */ + switch (ladvise->lla_advice) { + default: + rc = -ENOTSUPP; + break; + case LU_LADVISE_WILLREAD: + if (tbc == NULL) + RETURN(-ENOMEM); + + ioo.ioo_oid = body->oa.o_oi; + ioo.ioo_bufcnt = 1; + rc = tgt_extent_lock(env, exp->exp_obd->obd_namespace, + &tsi->tsi_resid, start, end - 1, + &lockh, LCK_PR, &flags); + if (rc != 0) + break; + + req->rq_status = ofd_ladvise_prefetch(env, fo, + tbc->local, + start, end, dbt); + tgt_extent_unlock(&lockh, LCK_PR); + break; + case LU_LADVISE_DONTNEED: + rc = dt_ladvise(env, dob, ladvise->lla_start, + ladvise->lla_end, LU_LADVISE_DONTNEED); + break; + } + if (rc != 0) + break; + } + + ofd_object_put(env, fo); + req->rq_status = rc; + RETURN(rc); +} + /** * OFD request handler for OST_QUOTACTL RPC. * @@ -2106,11 +2231,10 @@ out: */ static int ofd_quotactl(struct tgt_session_info *tsi) { - struct obd_quotactl *oqctl, *repoqc; - struct lu_nodemap *nodemap = - tsi->tsi_exp->exp_target_data.ted_nodemap; - int id; - int rc; + struct obd_quotactl *oqctl, *repoqc; + struct lu_nodemap *nodemap; + int id; + int rc; ENTRY; @@ -2124,6 +2248,10 @@ static int ofd_quotactl(struct tgt_session_info *tsi) *repoqc = *oqctl; + nodemap = nodemap_get_from_exp(tsi->tsi_exp); + if (IS_ERR(nodemap)) + RETURN(PTR_ERR(nodemap)); + id = repoqc->qc_id; if (oqctl->qc_type == USRQUOTA) id = nodemap_map_id(nodemap, NODEMAP_UID, @@ -2134,6 +2262,8 @@ static int ofd_quotactl(struct tgt_session_info *tsi) NODEMAP_CLIENT_TO_FS, repoqc->qc_id); + nodemap_putref(nodemap); + if (repoqc->qc_id != id) swap(repoqc->qc_id, id); @@ -2158,59 +2288,17 @@ 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, - struct ldlm_lock *lock) +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; - /* We are in the middle of the process - BL AST is sent, CANCEL - is ahead. Take half of AT + IO process time. */ - return at_est2timeout(at_get(&svcpt->scp_at_estimate)) + - (ldlm_bl_timeout(lock) >> 1); -} - -/** - * Prolong single lock timeout. - * - * This is supplemental function to the ofd_prolong_locks(). It prolongs - * a single lock. - * - * \param[in] tsi target session environment for this request - * \param[in] lock LDLM lock to prolong - * \param[in] extent related extent - * \param[in] timeout timeout value to add - * - * \retval 0 if lock is not suitable for prolongation - * \retval 1 if lock was prolonged successfully - */ -static int ofd_prolong_one_lock(struct tgt_session_info *tsi, - struct ldlm_lock *lock, - struct ldlm_extent *extent) -{ - int timeout = prolong_timeout(tgt_ses_req(tsi), lock); - - if (lock->l_flags & LDLM_FL_DESTROYED) /* lock already cancelled */ - return 0; - - /* XXX: never try to grab resource lock here because we're inside - * exp_bl_list_lock; in ldlm_lockd.c to handle waiting list we take - * res lock and then exp_bl_list_lock. */ - - if (!(lock->l_flags & LDLM_FL_AST_SENT)) - /* ignore locks not being cancelled */ - return 0; - - LDLM_DEBUG(lock, "refreshed for req x"LPU64" ext("LPU64"->"LPU64") " - "to %ds.\n", tgt_ses_req(tsi)->rq_xid, extent->start, - extent->end, timeout); - - /* OK. this is a possible lock the user holds doing I/O - * let's refresh eviction timer for it */ - ldlm_refresh_waiting_lock(lock, timeout); - return 1; + 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); } /** @@ -2233,25 +2321,26 @@ static int ofd_prolong_one_lock(struct tgt_session_info *tsi, * request may cover multiple locks. * * \param[in] tsi target session environment for this request - * \param[in] start start of extent - * \param[in] end end of extent + * \param[in] data struct of data to prolong locks * - * \retval number of prolonged locks */ -static int ofd_prolong_extent_locks(struct tgt_session_info *tsi, - __u64 start, __u64 end) +static void ofd_prolong_extent_locks(struct tgt_session_info *tsi, + struct ldlm_prolong_args *data) { - struct obd_export *exp = tsi->tsi_exp; struct obdo *oa = &tsi->tsi_ost_body->oa; - struct ldlm_extent extent = { - .start = start, - .end = end - }; struct ldlm_lock *lock; - int lock_count = 0; ENTRY; + data->lpa_timeout = prolong_timeout(tgt_ses_req(tsi)); + data->lpa_export = tsi->tsi_exp; + data->lpa_resid = tsi->tsi_resid; + + CDEBUG(D_RPCTRACE, "Prolong locks for req %p with x%llu" + " ext(%llu->%llu)\n", tgt_ses_req(tsi), + tgt_ses_req(tsi)->rq_xid, data->lpa_extent.start, + data->lpa_extent.end); + if (oa->o_valid & OBD_MD_FLHANDLE) { /* mostly a request should be covered by only one lock, try * fast path. */ @@ -2259,42 +2348,25 @@ static int ofd_prolong_extent_locks(struct tgt_session_info *tsi, if (lock != NULL) { /* Fast path to check if the lock covers the whole IO * region exclusively. */ - if (lock->l_granted_mode == LCK_PW && - ldlm_extent_contain(&lock->l_policy_data.l_extent, - &extent)) { + if (ldlm_extent_contain(&lock->l_policy_data.l_extent, + &data->lpa_extent)) { /* bingo */ - LASSERT(lock->l_export == exp); - lock_count = ofd_prolong_one_lock(tsi, lock, - &extent); + LASSERT(lock->l_export == data->lpa_export); + ldlm_lock_prolong_one(lock, data); + LDLM_LOCK_PUT(lock); + 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); - RETURN(lock_count); } - lock->l_last_used = cfs_time_current(); - LDLM_LOCK_PUT(lock); } } - spin_lock_bh(&exp->exp_bl_list_lock); - list_for_each_entry(lock, &exp->exp_bl_list, l_exp_list) { - LASSERT(lock->l_flags & LDLM_FL_AST_SENT); - LASSERT(lock->l_resource->lr_type == LDLM_EXTENT); - - /* ignore waiting locks, no more granted locks in the list */ - if (lock->l_granted_mode != lock->l_req_mode) - break; - - if (!ldlm_res_eq(&tsi->tsi_resid, &lock->l_resource->lr_name)) - continue; - - if (!ldlm_extent_overlap(&lock->l_policy_data.l_extent, - &extent)) - continue; - - lock_count += ofd_prolong_one_lock(tsi, lock, &extent); - } - spin_unlock_bh(&exp->exp_bl_list_lock); - - RETURN(lock_count); + ldlm_resource_prolong(data); + EXIT; } /** @@ -2341,8 +2413,10 @@ static int ofd_rw_hpreq_lock_match(struct ptlrpc_request *req, if (!ostid_res_name_eq(&ioo->ioo_oid, &lock->l_resource->lr_name)) RETURN(0); - /* a bulk write can only hold a reference on a PW extent lock */ - mode = LCK_PW; + /* a bulk write can only hold a reference on a PW extent lock + * or GROUP lock. + */ + mode = LCK_PW | LCK_GROUP; if (opc == OST_READ) /* whereas a bulk read can be protected by either a PR or PW * extent lock */ @@ -2358,20 +2432,22 @@ static int ofd_rw_hpreq_lock_match(struct ptlrpc_request *req, * Implementation of ptlrpc_hpreq_ops::hpreq_lock_check for OFD RW requests. * * Check for whether the given PTLRPC request (\a req) is blocking - * an LDLM lock cancel. + * an LDLM lock cancel. Also checks whether the request is covered by an LDLM + * lock. * * \param[in] req the incoming request * * \retval 1 if \a req is blocking an LDLM lock cancel * \retval 0 if it is not + * \retval -ESTALE if lock is not found */ static int ofd_rw_hpreq_check(struct ptlrpc_request *req) { struct tgt_session_info *tsi; struct obd_ioobj *ioo; struct niobuf_remote *rnb; - __u64 start, end; - int lock_count; + int opc; + struct ldlm_prolong_args pa = { 0 }; ENTRY; @@ -2383,6 +2459,9 @@ static int ofd_rw_hpreq_check(struct ptlrpc_request *req) * Use LASSERT below because malformed RPCs should have * been filtered out in tgt_hpreq_handler(). */ + opc = lustre_msg_get_opc(req->rq_reqmsg); + LASSERT(opc == OST_READ || opc == OST_WRITE); + ioo = req_capsule_client_get(&req->rq_pill, &RMF_OBD_IOOBJ); LASSERT(ioo != NULL); @@ -2390,21 +2469,28 @@ static int ofd_rw_hpreq_check(struct ptlrpc_request *req) LASSERT(rnb != NULL); LASSERT(!(rnb->rnb_flags & OBD_BRW_SRVLOCK)); - start = rnb->rnb_offset; + pa.lpa_mode = LCK_PW | LCK_GROUP; + if (opc == OST_READ) + pa.lpa_mode |= LCK_PR; + + pa.lpa_extent.start = rnb->rnb_offset; rnb += ioo->ioo_bufcnt - 1; - end = rnb->rnb_offset + rnb->rnb_len - 1; + pa.lpa_extent.end = rnb->rnb_offset + rnb->rnb_len - 1; DEBUG_REQ(D_RPCTRACE, req, "%s %s: refresh rw locks: "DFID - " ("LPU64"->"LPU64")\n", - tgt_name(tsi->tsi_tgt), current->comm, - PFID(&tsi->tsi_fid), start, end); + " (%llu->%llu)\n", tgt_name(tsi->tsi_tgt), + current->comm, PFID(&tsi->tsi_fid), pa.lpa_extent.start, + pa.lpa_extent.end); - lock_count = ofd_prolong_extent_locks(tsi, start, end); + ofd_prolong_extent_locks(tsi, &pa); CDEBUG(D_DLMTRACE, "%s: refreshed %u locks timeout for req %p.\n", - tgt_name(tsi->tsi_tgt), lock_count, req); + tgt_name(tsi->tsi_tgt), pa.lpa_blocks_cnt, req); + + if (pa.lpa_blocks_cnt > 0) + RETURN(1); - RETURN(lock_count > 0); + RETURN(pa.lpa_locks_cnt > 0 ? 0 : -ESTALE); } /** @@ -2438,6 +2524,10 @@ static int ofd_punch_hpreq_lock_match(struct ptlrpc_request *req, struct ldlm_lock *lock) { struct tgt_session_info *tsi; + struct obdo *oa; + struct ldlm_extent ext; + + ENTRY; /* Don't use tgt_ses_info() to get session info, because lock_match() * can be called while request has no processing thread yet. */ @@ -2450,27 +2540,42 @@ static int ofd_punch_hpreq_lock_match(struct ptlrpc_request *req, LASSERT(tsi->tsi_ost_body != NULL); if (tsi->tsi_ost_body->oa.o_valid & OBD_MD_FLHANDLE && tsi->tsi_ost_body->oa.o_handle.cookie == lock->l_handle.h_cookie) - return 1; + RETURN(1); - return 0; + oa = &tsi->tsi_ost_body->oa; + ext.start = oa->o_size; + ext.end = oa->o_blocks; + + LASSERT(lock->l_resource != NULL); + if (!ostid_res_name_eq(&oa->o_oi, &lock->l_resource->lr_name)) + RETURN(0); + + if (!(lock->l_granted_mode & (LCK_PW | LCK_GROUP))) + RETURN(0); + + RETURN(ldlm_extent_overlap(&lock->l_policy_data.l_extent, &ext)); } /** * Implementation of ptlrpc_hpreq_ops::hpreq_lock_check for OST_PUNCH request. * * High-priority queue request check for whether the given punch request - * (\a req) is blocking an LDLM lock cancel. + * (\a req) is blocking an LDLM lock cancel. Also checks whether the request is + * covered by an LDLM lock. + * + * * \param[in] req the incoming request * * \retval 1 if \a req is blocking an LDLM lock cancel * \retval 0 if it is not + * \retval -ESTALE if lock is not found */ static int ofd_punch_hpreq_check(struct ptlrpc_request *req) { struct tgt_session_info *tsi; struct obdo *oa; - int lock_count; + struct ldlm_prolong_args pa = { 0 }; ENTRY; @@ -2483,17 +2588,24 @@ static int ofd_punch_hpreq_check(struct ptlrpc_request *req) LASSERT(!(oa->o_valid & OBD_MD_FLFLAGS && oa->o_flags & OBD_FL_SRVLOCK)); + pa.lpa_mode = LCK_PW | LCK_GROUP; + pa.lpa_extent.start = oa->o_size; + pa.lpa_extent.end = oa->o_blocks; + CDEBUG(D_DLMTRACE, - "%s: refresh locks: "LPU64"/"LPU64" ("LPU64"->"LPU64")\n", + "%s: refresh locks: %llu/%llu (%llu->%llu)\n", tgt_name(tsi->tsi_tgt), tsi->tsi_resid.name[0], - tsi->tsi_resid.name[1], oa->o_size, oa->o_blocks); + tsi->tsi_resid.name[1], pa.lpa_extent.start, pa.lpa_extent.end); - lock_count = ofd_prolong_extent_locks(tsi, oa->o_size, oa->o_blocks); + ofd_prolong_extent_locks(tsi, &pa); CDEBUG(D_DLMTRACE, "%s: refreshed %u locks timeout for req %p.\n", - tgt_name(tsi->tsi_tgt), lock_count, req); + tgt_name(tsi->tsi_tgt), pa.lpa_blocks_cnt, req); - RETURN(lock_count > 0); + if (pa.lpa_blocks_cnt > 0) + RETURN(1); + + RETURN(pa.lpa_locks_cnt > 0 ? 0 : -ESTALE); } /** @@ -2544,7 +2656,9 @@ static void ofd_hp_brw(struct tgt_session_info *tsi) LASSERT(rnb != NULL); /* must exist after request preprocessing */ /* no high priority if server lock is needed */ - if (rnb->rnb_flags & OBD_BRW_SRVLOCK) + if (rnb->rnb_flags & OBD_BRW_SRVLOCK || + (lustre_msg_get_flags(tgt_ses_req(tsi)->rq_reqmsg) + & MSG_REPLAY)) return; } tgt_ses_req(tsi)->rq_ops = &ofd_hpreq_rw; @@ -2563,8 +2677,10 @@ static void ofd_hp_punch(struct tgt_session_info *tsi) { LASSERT(tsi->tsi_ost_body != NULL); /* must exists if we are here */ /* no high-priority if server lock is needed */ - if (tsi->tsi_ost_body->oa.o_valid & OBD_MD_FLFLAGS && - tsi->tsi_ost_body->oa.o_flags & OBD_FL_SRVLOCK) + if ((tsi->tsi_ost_body->oa.o_valid & OBD_MD_FLFLAGS && + tsi->tsi_ost_body->oa.o_flags & OBD_FL_SRVLOCK) || + tgt_conn_flags(tsi) & OBD_CONNECT_MDS || + lustre_msg_get_flags(tgt_ses_req(tsi)->rq_reqmsg) & MSG_REPLAY) return; tgt_ses_req(tsi)->rq_ops = &ofd_hpreq_punch; } @@ -2612,6 +2728,7 @@ TGT_OST_HDL_HP(HABEO_CORPUS| HABEO_REFERO | MUTABOR, 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), }; static struct tgt_opc_slice ofd_common_slice[] = { @@ -2646,6 +2763,11 @@ static struct tgt_opc_slice ofd_common_slice[] = { .tos_hs = tgt_lfsck_handlers }, { + .tos_opc_start = SEC_FIRST_OPC, + .tos_opc_end = SEC_LAST_OPC, + .tos_hs = tgt_sec_ctx_handlers + }, + { .tos_hs = NULL } }; @@ -2675,7 +2797,6 @@ static void ofd_key_exit(const struct lu_context *ctx, info->fti_xid = 0; info->fti_pre_version = 0; - info->fti_used = 0; memset(&info->fti_attr, 0, sizeof info->fti_attr); } @@ -2705,11 +2826,14 @@ struct lu_context_key ofd_thread_key = { static int ofd_init0(const struct lu_env *env, struct ofd_device *m, struct lu_device_type *ldt, struct lustre_cfg *cfg) { - const char *dev = lustre_cfg_string(cfg, 0); - struct ofd_thread_info *info = NULL; - struct obd_device *obd; - struct obd_statfs *osfs; - int rc; + const char *dev = lustre_cfg_string(cfg, 0); + struct ofd_thread_info *info = NULL; + struct obd_device *obd; + struct tg_grants_data *tgd = &m->ofd_lut.lut_tgd; + struct lu_fid fid; + struct nm_config_file *nodemap_config; + struct obd_device_target *obt; + int rc; ENTRY; @@ -2723,30 +2847,19 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, if (rc != 0) RETURN(rc); - obd->u.obt.obt_magic = OBT_MAGIC; + 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); - m->ofd_grant_compat_disable = 0; m->ofd_soft_sync_limit = OFD_SOFT_SYNC_LIMIT_DEFAULT; - /* statfs data */ - spin_lock_init(&m->ofd_osfs_lock); - m->ofd_osfs_age = cfs_time_shift_64(-1000); - m->ofd_osfs_unstable = 0; - m->ofd_statfs_inflight = 0; - m->ofd_osfs_inflight = 0; - - /* grant data */ - spin_lock_init(&m->ofd_grant_lock); - m->ofd_tot_dirty = 0; - m->ofd_tot_granted = 0; - m->ofd_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); @@ -2760,7 +2873,7 @@ 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); + rc = ofd_tunables_init(m); if (rc) { CERROR("Can't init ofd lprocfs, rc %d\n", rc); RETURN(rc); @@ -2782,7 +2895,7 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, info = ofd_info_init(env, NULL); if (info == NULL) - RETURN(-EFAULT); + GOTO(err_fini_proc, rc = -EFAULT); rc = ofd_stack_init(env, m, cfg); if (rc) { @@ -2790,25 +2903,9 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, GOTO(err_fini_proc, rc); } +#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 14, 53, 0) ofd_procfs_add_brw_stats_symlink(m); - - /* populate cached statfs data */ - osfs = &ofd_info(env)->fti_u.osfs; - rc = ofd_statfs_internal(env, m, osfs, 0, NULL); - if (rc != 0) { - CERROR("%s: can't get statfs data, rc %d\n", obd->obd_name, rc); - GOTO(err_fini_stack, rc); - } - if (!IS_PO2(osfs->os_bsize)) { - CERROR("%s: blocksize (%d) is not a power of 2\n", - obd->obd_name, osfs->os_bsize); - GOTO(err_fini_stack, rc = -EPROTO); - } - m->ofd_blockbits = fls(osfs->os_bsize) - 1; - - m->ofd_precreate_batch = OFD_PRECREATE_BATCH_DEFAULT; - if (osfs->os_bsize * osfs->os_blocks < OFD_PRECREATE_SMALL_FS) - m->ofd_precreate_batch = OFD_PRECREATE_BATCH_SMALL; +#endif snprintf(info->fti_u.name, sizeof(info->fti_u.name), "%s-%s", "filter"/*LUSTRE_OST_NAME*/, obd->obd_uuid.uuid); @@ -2827,34 +2924,58 @@ 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_dt_conf); - - /* Allow at most ddp_grant_reserved% of the available filesystem space - * to be granted to clients, so that any errors in the grant overhead - * calculations do not allow granting more space to clients than can be - * written. Assumes that in aggregate the grant overhead calculations do - * not have more than ddp_grant_reserved% estimation error in them. */ - m->ofd_grant_ratio = - ofd_grant_ratio_conv(m->ofd_dt_conf.ddp_grant_reserved); - 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); + 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; + rc = ofd_fs_setup(env, m, obd); if (rc) GOTO(err_fini_lut, rc); - rc = ofd_start_inconsistency_verification_thread(m); + fid.f_seq = FID_SEQ_LOCAL_NAME; + fid.f_oid = 1; + fid.f_ver = 0; + rc = local_oid_storage_init(env, m->ofd_osd, &fid, + &m->ofd_los); if (rc != 0) GOTO(err_fini_fs, rc); - tgt_adapt_sptlrpc_conf(&m->ofd_lut, 1); + nodemap_config = nm_config_file_register_tgt(env, m->ofd_osd, + m->ofd_los); + if (IS_ERR(nodemap_config)) { + rc = PTR_ERR(nodemap_config); + if (rc != -EROFS) + GOTO(err_fini_los, rc); + } else { + obt->obt_nodemap_config_file = nodemap_config; + } + + rc = ofd_start_inconsistency_verification_thread(m); + if (rc != 0) + GOTO(err_fini_nm, rc); + + tgt_adapt_sptlrpc_conf(&m->ofd_lut); RETURN(0); +err_fini_nm: + nm_config_file_deregister_tgt(env, obt->obt_nodemap_config_file); + obt->obt_nodemap_config_file = NULL; +err_fini_los: + local_oid_storage_fini(env, m->ofd_los); + m->ofd_los = NULL; err_fini_fs: ofd_fs_cleanup(env, m); err_fini_lut: @@ -2887,6 +3008,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, @@ -2899,6 +3021,8 @@ static void ofd_fini(const struct lu_env *env, struct ofd_device *m) 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; if (m->ofd_namespace != NULL) { ldlm_namespace_free_post(m->ofd_namespace); @@ -3050,8 +3174,9 @@ static void __exit ofd_exit(void) class_unregister_type(LUSTRE_OST_NAME); } -MODULE_AUTHOR("Intel Corporation. "); +MODULE_AUTHOR("OpenSFS, Inc. "); MODULE_DESCRIPTION("Lustre Object Filtering Device"); +MODULE_VERSION(LUSTRE_VERSION_STRING); MODULE_LICENSE("GPL"); module_init(ofd_init);