X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fofd%2Fofd_dev.c;h=7d7387a8d7a7e9738b34d306b2a89b066e303b52;hp=9900bed138dfaf19a27cbe4e185d03490137b0a6;hb=65a17be2d9e1acdec5d9aebaed007d4cb6d0ca11;hpb=77eea1985bb1655e58c8b7df00703b4f08b58ec7 diff --git a/lustre/ofd/ofd_dev.c b/lustre/ofd/ofd_dev.c index 9900bed..7d7387a 100644 --- a/lustre/ofd/ofd_dev.c +++ b/lustre/ofd/ofd_dev.c @@ -15,11 +15,7 @@ * * You should have received a copy of the GNU General Public License * version 2 along with this program; If not, see - * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf - * - * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. + * http://www.gnu.org/licenses/gpl-2.0.html * * GPL HEADER END */ @@ -27,17 +23,47 @@ * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2012, 2013, Intel Corporation. + * Copyright (c) 2012, 2014 Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ * Lustre is a trademark of Sun Microsystems, Inc. * - * lustre/ofd/ofd.c + * lustre/ofd/ofd_dev.c + * + * This file contains OSD API methods for OBD Filter Device (OFD), + * request handlers and supplemental functions to set OFD up and clean it up. * - * Author: Alex Zhuravlev - * Author: Mike Pershin - * Author: Johann Lombardi + * Author: Alex Zhuravlev + * Author: Mike Pershin + * Author: Johann Lombardi + */ +/* + * 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). + * + * TGT + * | DT and OBD APIs + * OFD + * | DT API + * OSD + * + * OFD implements the LU and OBD device APIs and is responsible for: + * + * - Handling client requests (create, destroy, bulk IO, setattr, + * get_info, set_info, statfs) for the objects belonging to the OST + * (together with TGT). + * + * - Providing grant space management which allows clients to reserve + * disk space for data writeback. OFD tracks grants on global and + * per client levels. + * + * - Handling object precreation requests from MDTs. + * + * - Operating the LDLM service that allows clients to maintain object + * data cache coherence. */ #define DEBUG_SUBSYSTEM S_FILTER @@ -49,6 +75,7 @@ #include #include #include +#include #include "ofd_internal.h" @@ -66,6 +93,20 @@ static struct lu_kmem_descr ofd_caches[] = { } }; +/** + * Connect OFD to the next device in the stack. + * + * This function is used for device stack configuration and links OFD + * device with bottom OSD device. + * + * \param[in] env execution environment + * \param[in] m OFD device + * \param[in] next name of next device in the stack + * \param[out] exp export to return + * + * \retval 0 and export in \a exp if successful + * \retval negative value on error + */ static int ofd_connect_to_next(const struct lu_env *env, struct ofd_device *m, const char *next, struct obd_export **exp) { @@ -81,7 +122,7 @@ static int ofd_connect_to_next(const struct lu_env *env, struct ofd_device *m, obd = class_name2obd(next); if (obd == NULL) { CERROR("%s: can't locate next device: %s\n", - m->ofd_dt_dev.dd_lu_dev.ld_obd->obd_name, next); + ofd_name(m), next); GOTO(out, rc = -ENOTCONN); } @@ -91,7 +132,7 @@ static int ofd_connect_to_next(const struct lu_env *env, struct ofd_device *m, rc = obd_connect(NULL, exp, obd, &obd->obd_uuid, data, NULL); if (rc) { CERROR("%s: cannot connect to next dev %s: rc = %d\n", - m->ofd_dt_dev.dd_lu_dev.ld_obd->obd_name, next, rc); + ofd_name(m), next, rc); GOTO(out, rc); } @@ -107,6 +148,18 @@ out: RETURN(rc); } +/** + * Initialize stack of devices. + * + * This function initializes OFD-OSD device stack to serve OST requests + * + * \param[in] env execution environment + * \param[in] m OFD device + * \param[in] cfg Lustre config for this server + * + * \retval 0 if successful + * \retval negative value on error + */ static int ofd_stack_init(const struct lu_env *env, struct ofd_device *m, struct lustre_cfg *cfg) { @@ -146,6 +199,19 @@ static int ofd_stack_init(const struct lu_env *env, RETURN(rc); } +/** + * Finalize the device stack OFD-OSD. + * + * This function cleans OFD-OSD device stack and + * disconnects OFD from the OSD. + * + * \param[in] env execution environment + * \param[in] m OFD device + * \param[in] top top device of stack + * + * \retval 0 if successful + * \retval negative value on error + */ static void ofd_stack_fini(const struct lu_env *env, struct ofd_device *m, struct lu_device *top) { @@ -165,10 +231,8 @@ static void ofd_stack_fini(const struct lu_env *env, struct ofd_device *m, strcat(flags, "A"); lustre_cfg_bufs_set_string(&bufs, 1, flags); lcfg = lustre_cfg_new(LCFG_CLEANUP, &bufs); - if (!lcfg) { - CERROR("Cannot alloc lcfg!\n"); + if (lcfg == NULL) RETURN_EXIT; - } LASSERT(top); top->ld_ops->ldo_process_config(env, top, lcfg); @@ -182,7 +246,6 @@ static void ofd_stack_fini(const struct lu_env *env, struct ofd_device *m, LASSERT(m->ofd_osd_exp); obd_disconnect(m->ofd_osd_exp); - m->ofd_osd = NULL; EXIT; } @@ -193,16 +256,24 @@ static struct cfg_interop_param ofd_interop_param[] = { { NULL } }; -/* Some parameters were moved from ofd to osd and only their +/** + * Check if parameters are symlinks to the OSD. + * + * Some parameters were moved from ofd to osd and only their * symlinks were kept in ofd by LU-3106. They are: * -writehthrough_cache_enable - * -readcache_max_filese + * -readcache_max_filesize * -read_cache_enable * -brw_stats - * Since they are not included by the static lprocfs var list, - * a pre-check is added for them to avoid "unknown param" error - * message confuses the customer. If they are matched in this - * check, they will be passed to the osd directly. + * + * Since they are not included by the static lprocfs var list, a pre-check + * is added for them to avoid "unknown param" errors. If they are matched + * in this check, they will be passed to the OSD directly. + * + * \param[in] param parameters to check + * + * \retval true if param is symlink to OSD param + * false otherwise */ static bool match_symlink_param(char *param) { @@ -227,7 +298,19 @@ static bool match_symlink_param(char *param) return false; } -/* used by MGS to process specific configurations */ +/** + * Process various configuration parameters. + * + * This function is used by MGS to process specific configurations and + * pass them through to the next device in server stack, i.e. the OSD. + * + * \param[in] env execution environment + * \param[in] d LU device of OFD + * \param[in] cfg parameters to process + * + * \retval 0 if successful + * \retval negative value on error + */ static int ofd_process_config(const struct lu_env *env, struct lu_device *d, struct lustre_cfg *cfg) { @@ -240,8 +323,7 @@ static int ofd_process_config(const struct lu_env *env, struct lu_device *d, switch (cfg->lcfg_command) { case LCFG_PARAM: { - struct lprocfs_static_vars lvars; - + struct obd_device *obd = ofd_obd(m); /* For interoperability */ struct cfg_interop_param *ptr = NULL; struct lustre_cfg *old_cfg = NULL; @@ -279,8 +361,7 @@ static int ofd_process_config(const struct lu_env *env, struct lu_device *d, break; } - lprocfs_ofd_init_vars(&lvars); - rc = class_process_proc_param(PARAM_OST, lvars.obd_vars, cfg, + 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", @@ -302,6 +383,18 @@ static int ofd_process_config(const struct lu_env *env, struct lu_device *d, RETURN(rc); } +/** + * Implementation of lu_object_operations::loo_object_init for OFD + * + * Allocate just the next object (OSD) in stack. + * + * \param[in] env execution environment + * \param[in] o lu_object of OFD object + * \param[in] conf additional configuration parameters, not used here + * + * \retval 0 if successful + * \retval negative value on error + */ static int ofd_object_init(const struct lu_env *env, struct lu_object *o, const struct lu_object_conf *conf) { @@ -325,6 +418,14 @@ static int ofd_object_init(const struct lu_env *env, struct lu_object *o, RETURN(rc); } +/** + * Implementation of lu_object_operations::loo_object_free. + * + * Finish OFD object lifecycle and free its memory. + * + * \param[in] env execution environment + * \param[in] o LU object of OFD object + */ static void ofd_object_free(const struct lu_env *env, struct lu_object *o) { struct ofd_object *of = ofd_obj(o); @@ -342,18 +443,45 @@ static void ofd_object_free(const struct lu_env *env, struct lu_object *o) EXIT; } +/** + * Implementation of lu_object_operations::loo_object_print. + * + * Print OFD part of compound OFD-OSD object. See lu_object_print() and + * LU_OBJECT_DEBUG() for more details about the compound object printing. + * + * \param[in] env execution environment + * \param[in] cookie opaque data passed to the printer function + * \param[in] p printer function to use + * \param[in] o LU object of OFD object + * + * \retval 0 if successful + * \retval negative value on error + */ static int ofd_object_print(const struct lu_env *env, void *cookie, lu_printer_t p, const struct lu_object *o) { return (*p)(env, cookie, LUSTRE_OST_NAME"-object@%p", o); } -struct lu_object_operations ofd_obj_ops = { +static 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 }; +/** + * Implementation of lu_device_operations::lod_object_alloc. + * + * This function allocates OFD part of compound OFD-OSD object and + * initializes its header, because OFD is the top device in stack + * + * \param[in] env execution environment + * \param[in] hdr object header, NULL for OFD + * \param[in] d lu_device + * + * \retval allocated object if successful + * \retval NULL value on failed allocation + */ static struct lu_object *ofd_object_alloc(const struct lu_env *env, const struct lu_object_header *hdr, struct lu_device *d) @@ -379,8 +507,19 @@ static struct lu_object *ofd_object_alloc(const struct lu_env *env, } } -extern int ost_handle(struct ptlrpc_request *req); - +/** + * Return the result of LFSCK run to the OFD. + * + * Notify OFD about result of LFSCK run. That may block the new object + * creation until problem is fixed by LFSCK. + * + * \param[in] env execution environment + * \param[in] data pointer to the OFD device + * \param[in] event LFSCK event type + * + * \retval 0 if successful + * \retval negative value on unknown event + */ static int ofd_lfsck_out_notify(const struct lu_env *env, void *data, enum lfsck_events event) { @@ -402,17 +541,33 @@ static int ofd_lfsck_out_notify(const struct lu_env *env, void *data, ofd->ofd_lastid_rebuilding = 0; ofd->ofd_lastid_gen++; up_write(&ofd->ofd_lastid_rwsem); + CWARN("%s: Rebuilt crashed LAST_ID files successfully.\n", + obd->obd_name); break; } default: CERROR("%s: unknown lfsck event: rc = %d\n", - ofd_obd(ofd)->obd_name, event); + ofd_name(ofd), event); return -EINVAL; } return 0; } +/** + * Implementation of lu_device_operations::ldo_prepare. + * + * This method is called after layer has been initialized and before it starts + * serving user requests. In OFD it starts lfsk check routines and initializes + * recovery. + * + * \param[in] env execution environment + * \param[in] pdev higher device in stack, NULL for OFD + * \param[in] dev lu_device of OFD device + * + * \retval 0 if successful + * \retval negative value on error + */ static int ofd_prepare(const struct lu_env *env, struct lu_device *pdev, struct lu_device *dev) { @@ -420,7 +575,6 @@ static int ofd_prepare(const struct lu_env *env, struct lu_device *pdev, struct ofd_device *ofd = ofd_dev(dev); struct obd_device *obd = ofd_obd(ofd); struct lu_device *next = &ofd->ofd_osd->dd_lu_dev; - struct lfsck_start_param lsp; int rc; ENTRY; @@ -447,15 +601,6 @@ static int ofd_prepare(const struct lu_env *env, struct lu_device *pdev, * register the namespace to such instance. */ LASSERTF(rc == 0, "register namespace failed: rc = %d\n", rc); - lsp.lsp_start = NULL; - lsp.lsp_index_valid = 0; - rc = lfsck_start(env, ofd->ofd_osd, &lsp); - if (rc != 0) { - CWARN("%s: auto trigger paused LFSCK failed: rc = %d\n", - obd->obd_name, rc); - rc = 0; - } - target_recovery_init(&ofd->ofd_lut, tgt_request_handle); LASSERT(obd->obd_no_conn); spin_lock(&obd->obd_dev_lock); @@ -468,6 +613,19 @@ static int ofd_prepare(const struct lu_env *env, struct lu_device *pdev, RETURN(rc); } +/** + * Implementation of lu_device_operations::ldo_recovery_complete. + * + * This method notifies all layers about 'recovery complete' event. That means + * device is in full state and consistent. An OFD calculates available grant + * space upon this event. + * + * \param[in] env execution environment + * \param[in] dev lu_device of OFD device + * + * \retval 0 if successful + * \retval negative value on error + */ static int ofd_recovery_complete(const struct lu_env *env, struct lu_device *dev) { @@ -477,7 +635,8 @@ static int ofd_recovery_complete(const struct lu_env *env, ENTRY; - /* Grant space for object precreation on the self export. + /* + * Grant space for object precreation on the self export. * This 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(). @@ -489,6 +648,9 @@ static int ofd_recovery_complete(const struct lu_env *env, RETURN(rc); } +/** + * lu_device_operations matrix for OFD device. + */ static struct lu_device_operations ofd_lu_ops = { .ldo_object_alloc = ofd_object_alloc, .ldo_process_config = ofd_process_config, @@ -496,19 +658,28 @@ 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 lprocfs_static_vars lvars; struct obd_device *obd = ofd_obd(ofd); - cfs_proc_dir_entry_t *entry; + 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 */ - lprocfs_ofd_init_vars(&lvars); - rc = lprocfs_obd_setup(obd, lvars.obd_vars); + 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); @@ -524,7 +695,8 @@ static int ofd_procfs_init(struct ofd_device *ofd) obd->obd_uses_nid_stats = 1; - entry = lprocfs_register("exports", obd->obd_proc_entry, NULL, NULL); + entry = lprocfs_seq_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", @@ -534,8 +706,7 @@ static int ofd_procfs_init(struct ofd_device *ofd) obd->obd_proc_exports_entry = entry; entry = lprocfs_add_simple(obd->obd_proc_exports_entry, "clear", - lprocfs_nid_stats_clear_read, - lprocfs_nid_stats_clear_write, obd, NULL); + obd, &lprocfs_nid_stats_clear_fops); if (IS_ERR(entry)) { rc = PTR_ERR(entry); CERROR("%s: add proc entry 'clear' failed: %d.\n", @@ -548,10 +719,8 @@ static int ofd_procfs_init(struct ofd_device *ofd) rc = lprocfs_job_stats_init(obd, LPROC_OFD_STATS_LAST, ofd_stats_counter_init); if (rc) - GOTO(remove_entry_clear, rc); + GOTO(obd_cleanup, rc); RETURN(0); -remove_entry_clear: - lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry); obd_cleanup: lprocfs_obd_cleanup(obd); lprocfs_free_obd_stats(obd); @@ -559,64 +728,90 @@ obd_cleanup: return rc; } +/** + * 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; - cfs_proc_dir_entry_t *osd_root = osd_obd->obd_type->typ_procroot; - cfs_proc_dir_entry_t *osd_dir; - osd_dir = lprocfs_srch(osd_root, obd->obd_name); - if (osd_dir == NULL) + if (obd->obd_proc_entry == NULL) return; - if (lprocfs_srch(osd_dir, "brw_stats") != NULL) - lprocfs_add_symlink("brw_stats", obd->obd_proc_entry, - "../../%s/%s/brw_stats", - osd_root->name, osd_dir->name); - - if (lprocfs_srch(osd_dir, "read_cache_enable") != NULL) - lprocfs_add_symlink("read_cache_enable", obd->obd_proc_entry, - "../../%s/%s/read_cache_enable", - osd_root->name, osd_dir->name); - - if (lprocfs_srch(osd_dir, "readcache_max_filesize") != NULL) - lprocfs_add_symlink("readcache_max_filesize", - obd->obd_proc_entry, - "../../%s/%s/readcache_max_filesize", - osd_root->name, osd_dir->name); - - if (lprocfs_srch(osd_dir, "writethrough_cache_enable") != NULL) - lprocfs_add_symlink("writethrough_cache_enable", - obd->obd_proc_entry, - "../../%s/%s/writethrough_cache_enable", - osd_root->name, osd_dir->name); + 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); } +/** + * Cleanup all procfs entries in OFD. + * + * \param[in] ofd OFD device + */ static void ofd_procfs_fini(struct ofd_device *ofd) { struct obd_device *obd = ofd_obd(ofd); - lprocfs_remove_proc_entry("writethrough_cache_enable", - obd->obd_proc_entry); - lprocfs_remove_proc_entry("readcache_max_filesize", - obd->obd_proc_entry); - lprocfs_remove_proc_entry("read_cache_enable", obd->obd_proc_entry); - lprocfs_remove_proc_entry("brw_stats", obd->obd_proc_entry); - lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry); lprocfs_free_per_client_stats(obd); lprocfs_obd_cleanup(obd); lprocfs_free_obd_stats(obd); lprocfs_job_stats_fini(obd); } -extern int ost_handle(struct ptlrpc_request *req); - +/** + * Stop SEQ/FID server on OFD. + * + * \param[in] env execution environment + * \param[in] ofd OFD device + * + * \retval 0 if successful + * \retval negative value on error + */ int ofd_fid_fini(const struct lu_env *env, struct ofd_device *ofd) { return seq_site_fini(env, &ofd->ofd_seq_site); } +/** + * Start SEQ/FID server on OFD. + * + * The SEQ/FID server on OFD is needed to allocate FIDs for new objects. + * It also connects to the master server to get own FID sequence (SEQ) range + * to this particular OFD. Typically that happens when the OST is first + * formatted or in the rare case that it exhausts the local sequence range. + * + * The sequence range is allocated out to the MDTs for OST object allocations, + * and not directly to the clients. + * + * \param[in] env execution environment + * \param[in] ofd OFD device + * + * \retval 0 if successful + * \retval negative value on error + */ int ofd_fid_init(const struct lu_env *env, struct ofd_device *ofd) { struct seq_server_site *ss = &ofd->ofd_seq_site; @@ -688,7 +883,17 @@ out_free: return rc; } -int ofd_set_info_hdl(struct tgt_session_info *tsi) +/** + * OFD request handler for OST_SET_INFO RPC. + * + * This is OFD-specific part of request handling + * + * \param[in] tsi target session environment for this request + * + * \retval 0 if successful + * \retval negative value on error + */ +static int ofd_set_info_hdl(struct tgt_session_info *tsi) { struct ptlrpc_request *req = tgt_ses_req(tsi); struct ost_body *body = NULL, *repbody; @@ -753,6 +958,20 @@ int ofd_set_info_hdl(struct tgt_session_info *tsi) RETURN(rc); } +/** + * Get FIEMAP (FIle Extent MAPping) for object with the given FID. + * + * This function returns a list of extents which describes how a file's + * blocks are laid out on the disk. + * + * \param[in] env execution environment + * \param[in] ofd OFD device + * \param[in] fid FID of object + * \param[in] fiemap fiemap structure to fill with data + * + * \retval 0 if \a fiemap is filled with data successfully + * \retval negative value on error + */ int ofd_fiemap_get(const struct lu_env *env, struct ofd_device *ofd, struct lu_fid *fid, struct ll_user_fiemap *fiemap) { @@ -777,13 +996,29 @@ int ofd_fiemap_get(const struct lu_env *env, struct ofd_device *ofd, } struct locked_region { - cfs_list_t list; + 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, - cfs_list_t *locked) + struct list_head *locked) { struct locked_region *region = NULL; __u64 flags = 0; @@ -801,15 +1036,33 @@ static int lock_region(struct ldlm_namespace *ns, struct ldlm_res_id *res_id, CDEBUG(D_OTHER, "ost lock [%llu,%llu], lh=%p\n", begin, end, ®ion->lh); - cfs_list_add(®ion->list, locked); + list_add(®ion->list, locked); return 0; } +/** + * Lock the sparse areas of given resource. + * + * The locking of sparse areas will cause dirty data to be flushed back from + * clients. This is used when getting the FIEMAP of an object to make sure + * there is no unaccounted cached data on clients. + * + * This function goes through \a fiemap list of extents and locks only sparse + * areas between extents. + * + * \param[in] ns LDLM namespace + * \param[in] res_id resource ID + * \param[in] fiemap file extents mapping on disk + * \param[in] locked list head of regions list + * + * \retval 0 if successful + * \retval negative value on error + */ static int lock_zero_regions(struct ldlm_namespace *ns, struct ldlm_res_id *res_id, struct ll_user_fiemap *fiemap, - cfs_list_t *locked) + struct list_head *locked) { __u64 begin = fiemap->fm_start; unsigned int i; @@ -842,19 +1095,47 @@ static int lock_zero_regions(struct ldlm_namespace *ns, RETURN(rc); } -static void unlock_zero_regions(struct ldlm_namespace *ns, cfs_list_t *locked) +/** + * 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; - cfs_list_for_each_entry_safe(entry, temp, locked, list) { + 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); - cfs_list_del(&entry->list); + list_del(&entry->list); OBD_FREE_PTR(entry); } } -int ofd_get_info_hdl(struct tgt_session_info *tsi) +/** + * OFD request handler for OST_GET_INFO RPC. + * + * This is OFD-specific part of request handling. The OFD-specific keys are: + * - KEY_LAST_ID (obsolete) + * - KEY_FIEMAP + * - KEY_LAST_FID + * + * This function reads needed data from storage and fills reply with it. + * + * Note: the KEY_LAST_ID is obsolete, replaced by KEY_LAST_FID on newer MDTs, + * and is kept for compatibility. + * + * \param[in] tsi target session environment for this request + * + * \retval 0 if successful + * \retval negative value on error + */ +static int ofd_get_info_hdl(struct tgt_session_info *tsi) { struct obd_export *exp = tsi->tsi_exp; struct ofd_device *ofd = ofd_exp(exp); @@ -875,7 +1156,7 @@ int ofd_get_info_hdl(struct tgt_session_info *tsi) RCL_CLIENT); if (KEY_IS(KEY_LAST_ID)) { - obd_id *last_id; + u64 *last_id; struct ofd_seq *oseq; req_capsule_extend(tsi->tsi_pill, &RQF_OST_GET_INFO_LAST_ID); @@ -886,7 +1167,7 @@ int ofd_get_info_hdl(struct tgt_session_info *tsi) last_id = req_capsule_server_get(tsi->tsi_pill, &RMF_OBD_ID); oseq = ofd_seq_load(tsi->tsi_env, ofd, - (obd_seq)exp->exp_filter_data.fed_group); + (u64)exp->exp_filter_data.fed_group); if (IS_ERR(oseq)) rc = -EFAULT; else @@ -927,13 +1208,14 @@ int ofd_get_info_hdl(struct tgt_session_info *tsi) * flushed back from client, then call fiemap again. */ if (fm_key->oa.o_valid & OBD_MD_FLFLAGS && fm_key->oa.o_flags & OBD_FL_SRVLOCK) { - cfs_list_t locked = CFS_LIST_HEAD_INIT(locked); + 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 && !cfs_list_empty(&locked)) { + if (rc == 0 && !list_empty(&locked)) { rc = ofd_fiemap_get(tsi->tsi_env, ofd, fid, fiemap); unlock_zero_regions(ofd->ofd_namespace, @@ -986,6 +1268,17 @@ out_put: RETURN(rc); } +/** + * OFD request handler for OST_GETATTR RPC. + * + * This is OFD-specific part of request handling. It finds the OFD object + * by its FID, gets attributes from storage and packs result to the reply. + * + * \param[in] tsi target session environment for this request + * + * \retval 0 if successful + * \retval negative value on error + */ static int ofd_getattr_hdl(struct tgt_session_info *tsi) { struct ofd_thread_info *fti = tsi2ofd_info(tsi); @@ -1057,6 +1350,17 @@ out: RETURN(rc); } +/** + * OFD request handler for OST_SETATTR RPC. + * + * This is OFD-specific part of request handling. It finds the OFD object + * by its FID, sets attributes from request and packs result to the reply. + * + * \param[in] tsi target session environment for this request + * + * \retval 0 if successful + * \retval negative value on error + */ static int ofd_setattr_hdl(struct tgt_session_info *tsi) { struct ofd_thread_info *fti = tsi2ofd_info(tsi); @@ -1133,7 +1437,7 @@ out: * to go... deadlock! */ res = ldlm_resource_get(ofd->ofd_namespace, NULL, &tsi->tsi_resid, LDLM_EXTENT, 0); - if (res != NULL) { + if (!IS_ERR(res)) { ldlm_res_lvbo_update(res, NULL, 0); ldlm_resource_putref(res); } @@ -1141,6 +1445,20 @@ out: return rc; } +/** + * Destroy OST orphans. + * + * This is part of OST_CREATE RPC handling. If there is flag OBD_FL_DELORPHAN + * set then we must destroy possible orphaned objects. + * + * \param[in] env execution environment + * \param[in] exp OBD export + * \param[in] ofd OFD device + * \param[in] oa obdo structure for reply + * + * \retval 0 if successful + * \retval negative value on error + */ static int ofd_orphans_destroy(const struct lu_env *env, struct obd_export *exp, struct ofd_device *ofd, struct obdo *oa) @@ -1149,10 +1467,10 @@ static int ofd_orphans_destroy(const struct lu_env *env, struct lu_fid *fid = &info->fti_fid; struct ost_id *oi = &oa->o_oi; struct ofd_seq *oseq; - obd_seq seq = ostid_seq(oi); - obd_id end_id = ostid_id(oi); - obd_id last; - obd_id oid; + u64 seq = ostid_seq(oi); + u64 end_id = ostid_id(oi); + u64 last; + u64 oid; int skip_orphan; int rc = 0; @@ -1172,6 +1490,9 @@ 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)) + goto done; + LCONSOLE(D_INFO, "%s: deleting orphan objects from "DOSTID " to "DOSTID"\n", ofd_name(ofd), seq, end_id + 1, seq, last); @@ -1181,9 +1502,12 @@ static int ofd_orphans_destroy(const struct lu_env *env, GOTO(out_put, rc); rc = ofd_destroy_by_fid(env, ofd, fid, 1); - if (rc != 0 && rc != -ENOENT) /* this is pretty fatal... */ - CEMERG("%s: error destroying precreated id "DFID - ": rc = %d\n", ofd_name(ofd), PFID(fid), rc); + if (rc != 0 && rc != -ENOENT && rc != -ESTALE && + likely(rc != -EREMCHG && rc != -EINPROGRESS)) + /* this is pretty fatal... */ + CEMERG("%s: error destroying precreated id " + DFID": rc = %d\n", + ofd_name(ofd), PFID(fid), rc); oid--; if (!skip_orphan) { @@ -1199,7 +1523,9 @@ static int ofd_orphans_destroy(const struct lu_env *env, CDEBUG(D_HA, "%s: after destroy: set last_id to "DOSTID"\n", ofd_name(ofd), seq, oid); +done: if (!skip_orphan) { + ofd_seq_last_oid_set(oseq, oid); rc = ofd_seq_last_oid_write(env, ofd, oseq); } else { /* don't reuse orphan object, return last used objid */ @@ -1214,15 +1540,27 @@ out_put: return rc; } +/** + * OFD request handler for OST_CREATE RPC. + * + * This is OFD-specific part of request handling. Its main purpose is to + * create new data objects on OST, but it also used to destroy orphans. + * + * \param[in] tsi target session environment for this request + * + * \retval 0 if successful + * \retval negative value on error + */ 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); - obd_seq seq = ostid_seq(&oa->o_oi); - obd_id oid = ostid_id(&oa->o_oi); + u64 seq = ostid_seq(&oa->o_oi); + u64 oid = ostid_id(&oa->o_oi); struct ofd_seq *oseq; int rc = 0, diff; int sync_trans = 0; @@ -1296,7 +1634,8 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) CDEBUG(D_HA, "ofd_last_id() = "LPU64" -> diff = %d\n", ofd_seq_last_oid(oseq), diff); if (-diff > OST_MAX_PRECREATE) { - /* FIXME: should reset precreate_next_id on MDS */ + /* Let MDS know that we are so far ahead. */ + ostid_set_id(&rep_oa->o_oi, ofd_seq_last_oid(oseq) + 1); rc = 0; } else if (diff < 0) { rc = ofd_orphans_destroy(tsi->tsi_env, exp, @@ -1309,7 +1648,8 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) } else { if (unlikely(exp->exp_filter_data.fed_lastid_gen != ofd->ofd_lastid_gen)) { - ofd_obd_disconnect(exp); + /* Keep the export ref so we can send the reply. */ + ofd_obd_disconnect(class_export_get(exp)); GOTO(out_nolock, rc = -ENOTCONN); } @@ -1340,11 +1680,21 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) ofd_name(ofd), POSTID(&oa->o_oi)); GOTO(out, rc = -EINVAL); } + + if (diff < 0) { + /* LU-5648 */ + CERROR("%s: invalid precreate request for " + DOSTID", last_id " LPU64 ". " + "Likely MDS last_id corruption\n", + ofd_name(ofd), POSTID(&oa->o_oi), + ofd_seq_last_oid(oseq)); + GOTO(out, rc = -EINVAL); + } } } if (diff > 0) { cfs_time_t enough_time = cfs_time_shift(DISK_TIMEOUT); - obd_id next_id; + u64 next_id; int created = 0; int count; @@ -1386,12 +1736,12 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) " at "LPU64"\n", ofd_name(ofd), count, seq, next_id); - if (cfs_time_after(jiffies, enough_time)) { - LCONSOLE_WARN("%s: Slow creates, %d/%d objects" - " created at a rate of %d/s\n", - ofd_name(ofd), created, - diff + created, - created / DISK_TIMEOUT); + 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" + " created at a rate of %d/s\n", + ofd_name(ofd), created, diff + created, + created / DISK_TIMEOUT); break; } @@ -1404,6 +1754,14 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) break; } } + + if (diff > 0 && + 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", + ofd_name(ofd), diff); + if (created > 0) /* some objects got created, we can return * them, even if last creation failed */ @@ -1425,9 +1783,18 @@ static int ofd_create_hdl(struct tgt_session_info *tsi) out: mutex_unlock(&oseq->os_create_lock); out_nolock: - if (rc == 0) + 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 rep_oa->o_valid |= OBD_MD_FLID | OBD_MD_FLGROUP; - + } ofd_seq_put(tsi->tsi_env, oseq); out_sem: @@ -1435,6 +1802,17 @@ out_sem: return rc; } +/** + * OFD request handler for OST_DESTROY RPC. + * + * This is OFD-specific part of request handling. It destroys data objects + * related to destroyed object on MDT. + * + * \param[in] tsi target session environment for this request + * + * \retval 0 if successful + * \retval negative value on error + */ static int ofd_destroy_hdl(struct tgt_session_info *tsi) { const struct ost_body *body = tsi->tsi_ost_body; @@ -1442,8 +1820,8 @@ 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; - obd_id oid; - obd_count count; + u64 oid; + u32 count; int rc = 0; ENTRY; @@ -1460,7 +1838,7 @@ static int ofd_destroy_hdl(struct tgt_session_info *tsi) dlm = req_capsule_client_get(tsi->tsi_pill, &RMF_DLM_REQ); if (dlm == NULL) RETURN(-EFAULT); - ldlm_request_cancel(tgt_ses_req(tsi), dlm, 0); + ldlm_request_cancel(tgt_ses_req(tsi), dlm, 0, LATF_SKIP); } *fid = body->oa.o_oi.oi_fid; @@ -1512,6 +1890,17 @@ out: return rc; } +/** + * OFD request handler for OST_STATFS RPC. + * + * This function gets statfs data from storage as part of request + * processing. + * + * \param[in] tsi target session environment for this request + * + * \retval 0 if successful + * \retval negative value on error + */ static int ofd_statfs_hdl(struct tgt_session_info *tsi) { struct obd_statfs *osfs; @@ -1536,6 +1925,17 @@ static int ofd_statfs_hdl(struct tgt_session_info *tsi) RETURN(rc); } +/** + * OFD request handler for OST_SYNC RPC. + * + * Sync object data or all filesystem data to the disk and pack the + * result in reply. + * + * \param[in] tsi target session environment for this request + * + * \retval 0 if successful + * \retval negative value on error + */ static int ofd_sync_hdl(struct tgt_session_info *tsi) { struct ost_body *body = tsi->tsi_ost_body; @@ -1557,7 +1957,8 @@ static int ofd_sync_hdl(struct tgt_session_info *tsi) } rc = tgt_sync(tsi->tsi_env, tsi->tsi_tgt, - fo != NULL ? ofd_object_child(fo) : NULL); + fo != NULL ? ofd_object_child(fo) : NULL, + repbody->oa.o_size, repbody->oa.o_blocks); if (rc) GOTO(put, rc); @@ -1583,6 +1984,17 @@ put: return rc; } +/** + * OFD request handler for OST_PUNCH RPC. + * + * This is part of request processing. Validate request fields, + * punch (truncate) 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_punch_hdl(struct tgt_session_info *tsi) { const struct obdo *oa = &tsi->tsi_ost_body->oa; @@ -1656,7 +2068,7 @@ static int ofd_punch_hdl(struct tgt_session_info *tsi) } rc = ofd_object_punch(tsi->tsi_env, fo, start, end, &info->fti_attr, - ff); + ff, (struct obdo *)oa); if (rc) GOTO(out_put, rc); @@ -1676,7 +2088,7 @@ out: * to go... deadlock! */ res = ldlm_resource_get(ns, NULL, &tsi->tsi_resid, LDLM_EXTENT, 0); - if (res != NULL) { + if (!IS_ERR(res)) { ldlm_res_lvbo_update(res, NULL, 0); ldlm_resource_putref(res); } @@ -1684,9 +2096,23 @@ out: return rc; } +/** + * OFD request handler for OST_QUOTACTL RPC. + * + * This is part of request processing to validate incoming request fields, + * get the requested data from OSD and pack reply. + * + * \param[in] tsi target session environment for this request + * + * \retval 0 if successful + * \retval negative value on error + */ 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; ENTRY; @@ -1705,34 +2131,74 @@ static int ofd_quotactl(struct tgt_session_info *tsi) RETURN(0); *repoqc = *oqctl; + + id = repoqc->qc_id; + if (oqctl->qc_type == USRQUOTA) + id = nodemap_map_id(nodemap, NODEMAP_UID, + NODEMAP_CLIENT_TO_FS, + repoqc->qc_id); + else if (oqctl->qc_type == GRPQUOTA) + id = nodemap_map_id(nodemap, NODEMAP_GID, + NODEMAP_CLIENT_TO_FS, + repoqc->qc_id); + + if (repoqc->qc_id != id) + swap(repoqc->qc_id, id); + rc = lquotactl_slv(tsi->tsi_env, tsi->tsi_tgt->lut_bottom, repoqc); ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_QUOTACTL, tsi->tsi_jobid, 1); + if (repoqc->qc_id != id) + swap(repoqc->qc_id, id); + RETURN(rc); } -/* High priority request handlers for OFD */ - -/* prolong locks for the current service time of the corresponding - * portal (= OST_IO_PORTAL) +/** + * 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 int prolong_timeout(struct ptlrpc_request *req) +static inline int prolong_timeout(struct ptlrpc_request *req, + struct ldlm_lock *lock) { struct ptlrpc_service_part *svcpt = req->rq_rqbd->rqbd_svcpt; if (AT_OFF) return obd_timeout / 2; - return max(at_est2timeout(at_get(&svcpt->scp_at_estimate)), - ldlm_timeout); + /* 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) + 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; @@ -1755,6 +2221,31 @@ static int ofd_prolong_one_lock(struct tgt_session_info *tsi, return 1; } +/** + * Prolong lock timeout for the given extent. + * + * This function finds all locks related with incoming request and + * prolongs their timeout. + * + * If a client is holding a lock for a long time while it sends + * read or write RPCs to the OST for the object under this lock, + * then we don't want the OST to evict the client. Otherwise, + * if the network or disk is very busy then the client may not + * be able to make any progress to clear out dirty pages under + * the lock and the application will fail. + * + * Every time a Bulk Read/Write (BRW) request arrives for the object + * covered by the lock, extend the timeout on that lock. The RPC should + * contain a lock handle for the lock it is using, but this + * isn't handled correctly by all client versions, and the + * 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 + * + * \retval number of prolonged locks + */ static int ofd_prolong_extent_locks(struct tgt_session_info *tsi, __u64 start, __u64 end) { @@ -1765,7 +2256,6 @@ static int ofd_prolong_extent_locks(struct tgt_session_info *tsi, .end = end }; struct ldlm_lock *lock; - int timeout = prolong_timeout(tgt_ses_req(tsi)); int lock_count = 0; ENTRY; @@ -1783,7 +2273,7 @@ static int ofd_prolong_extent_locks(struct tgt_session_info *tsi, /* bingo */ LASSERT(lock->l_export == exp); lock_count = ofd_prolong_one_lock(tsi, lock, - &extent, timeout); + &extent); LDLM_LOCK_PUT(lock); RETURN(lock_count); } @@ -1803,7 +2293,7 @@ static int ofd_prolong_extent_locks(struct tgt_session_info *tsi, &extent)) continue; - lock_count += ofd_prolong_one_lock(tsi, lock, &extent, timeout); + lock_count += ofd_prolong_one_lock(tsi, lock, &extent); } spin_unlock_bh(&exp->exp_bl_list_lock); @@ -1811,8 +2301,23 @@ static int ofd_prolong_extent_locks(struct tgt_session_info *tsi, } /** - * Returns 1 if the given PTLRPC matches the given LDLM lock, or 0 if it does - * not. + * Implementation of ptlrpc_hpreq_ops::hpreq_lock_match for OFD RW requests. + * + * Determine if \a lock and the lock from request \a req are equivalent + * by comparing their resource names, modes, and extents. + * + * It is used to give priority to read and write RPCs being done + * under this lock so that the client can drop the contended + * lock more quickly and let other clients use it. This improves + * overall performance in the case where the first client gets a + * very large lock extent that prevents other clients from + * submitting their writes. + * + * \param[in] req ptlrpc_request being processed + * \param[in] lock contended lock to match + * + * \retval 1 if lock is matched + * \retval 0 otherwise */ static int ofd_rw_hpreq_lock_match(struct ptlrpc_request *req, struct ldlm_lock *lock) @@ -1831,16 +2336,19 @@ static int ofd_rw_hpreq_lock_match(struct ptlrpc_request *req, rnb = req_capsule_client_get(&req->rq_pill, &RMF_NIOBUF_REMOTE); LASSERT(rnb != NULL); - ext.start = rnb->offset; + ext.start = rnb->rnb_offset; rnb += ioo->ioo_bufcnt - 1; - ext.end = rnb->offset + rnb->len - 1; + ext.end = rnb->rnb_offset + rnb->rnb_len - 1; LASSERT(lock->l_resource != NULL); 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; if (opc == OST_READ) + /* whereas a bulk read can be protected by either a PR or PW + * extent lock */ mode |= LCK_PR; if (!(lock->l_granted_mode & mode)) @@ -1850,14 +2358,15 @@ static int ofd_rw_hpreq_lock_match(struct ptlrpc_request *req, } /** - * High-priority queue request check for whether the given PTLRPC request - * (\a req) is blocking an LDLM lock cancel. + * 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. * - * Returns 1 if the given given PTLRPC request (\a req) is blocking an LDLM lock - * cancel, 0 if it is not, and -EFAULT if the request is malformed. + * \param[in] req the incoming request * - * Only OST_READs, OST_WRITEs and OST_PUNCHes go on the h-p RPC queue. This - * function looks only at OST_READs and OST_WRITEs. + * \retval 1 if \a req is blocking an LDLM lock cancel + * \retval 0 if it is not */ static int ofd_rw_hpreq_check(struct ptlrpc_request *req) { @@ -1872,7 +2381,6 @@ static int ofd_rw_hpreq_check(struct ptlrpc_request *req) /* Don't use tgt_ses_info() to get session info, because lock_match() * can be called while request has no processing thread yet. */ tsi = lu_context_key_get(&req->rq_session, &tgt_session_key); - LASSERT(tsi != NULL); /* * Use LASSERT below because malformed RPCs should have @@ -1883,11 +2391,11 @@ static int ofd_rw_hpreq_check(struct ptlrpc_request *req) rnb = req_capsule_client_get(&req->rq_pill, &RMF_NIOBUF_REMOTE); LASSERT(rnb != NULL); - LASSERT(!(rnb->flags & OBD_BRW_SRVLOCK)); + LASSERT(!(rnb->rnb_flags & OBD_BRW_SRVLOCK)); - start = rnb->offset; + start = rnb->rnb_offset; rnb += ioo->ioo_bufcnt - 1; - end = rnb->offset + rnb->len - 1; + end = rnb->rnb_offset + rnb->rnb_len - 1; DEBUG_REQ(D_RPCTRACE, req, "%s %s: refresh rw locks: "DFID " ("LPU64"->"LPU64")\n", @@ -1902,13 +2410,32 @@ static int ofd_rw_hpreq_check(struct ptlrpc_request *req) RETURN(lock_count > 0); } +/** + * Implementation of ptlrpc_hpreq_ops::hpreq_lock_fini for OFD RW requests. + * + * Called after the request has been handled. It refreshes lock timeout again + * so that client has more time to send lock cancel RPC. + * + * \param[in] req request which is being processed. + */ static void ofd_rw_hpreq_fini(struct ptlrpc_request *req) { ofd_rw_hpreq_check(req); } /** - * Like tgt_rw_hpreq_lock_match(), but for OST_PUNCH RPCs. + * Implementation of ptlrpc_hpreq_ops::hpreq_lock_match for OST_PUNCH request. + * + * This function checks if the given lock is the same by its resname, mode + * and extent as one taken from the request. + * It is used to give priority to punch/truncate RPCs that might lead to + * the fastest release of that lock when a lock is contended. + * + * \param[in] req ptlrpc_request being processed + * \param[in] lock contended lock to match + * + * \retval 1 if lock is matched + * \retval 0 otherwise */ static int ofd_punch_hpreq_lock_match(struct ptlrpc_request *req, struct ldlm_lock *lock) @@ -1918,8 +2445,11 @@ static int ofd_punch_hpreq_lock_match(struct ptlrpc_request *req, /* Don't use tgt_ses_info() to get session info, because lock_match() * can be called while request has no processing thread yet. */ tsi = lu_context_key_get(&req->rq_session, &tgt_session_key); - LASSERT(tsi != NULL); + /* + * Use LASSERT below because malformed RPCs should have + * been filtered out in tgt_hpreq_handler(). + */ 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) @@ -1929,7 +2459,15 @@ static int ofd_punch_hpreq_lock_match(struct ptlrpc_request *req, } /** - * Like ost_rw_hpreq_check(), but for OST_PUNCH RPCs. + * 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. + * + * \param[in] req the incoming request + * + * \retval 1 if \a req is blocking an LDLM lock cancel + * \retval 0 if it is not */ static int ofd_punch_hpreq_check(struct ptlrpc_request *req) { @@ -1961,24 +2499,40 @@ static int ofd_punch_hpreq_check(struct ptlrpc_request *req) RETURN(lock_count > 0); } +/** + * Implementation of ptlrpc_hpreq_ops::hpreq_lock_fini for OST_PUNCH request. + * + * Called after the request has been handled. It refreshes lock timeout again + * so that client has more time to send lock cancel RPC. + * + * \param[in] req request which is being processed. + */ static void ofd_punch_hpreq_fini(struct ptlrpc_request *req) { ofd_punch_hpreq_check(req); } -struct ptlrpc_hpreq_ops ofd_hpreq_rw = { +static struct ptlrpc_hpreq_ops ofd_hpreq_rw = { .hpreq_lock_match = ofd_rw_hpreq_lock_match, .hpreq_check = ofd_rw_hpreq_check, .hpreq_fini = ofd_rw_hpreq_fini }; -struct ptlrpc_hpreq_ops ofd_hpreq_punch = { +static struct ptlrpc_hpreq_ops ofd_hpreq_punch = { .hpreq_lock_match = ofd_punch_hpreq_lock_match, .hpreq_check = ofd_punch_hpreq_check, .hpreq_fini = ofd_punch_hpreq_fini }; -/** Assign high priority operations to the IO requests */ +/** + * Assign high priority operations to an IO request. + * + * Check if the incoming request is a candidate for + * high-priority processing. If it is, assign it a high + * priority operations table. + * + * \param[in] tsi target session environment for this request + */ static void ofd_hp_brw(struct tgt_session_info *tsi) { struct niobuf_remote *rnb; @@ -1993,12 +2547,21 @@ 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->flags & OBD_BRW_SRVLOCK) + if (rnb->rnb_flags & OBD_BRW_SRVLOCK) return; } tgt_ses_req(tsi)->rq_ops = &ofd_hpreq_rw; } +/** + * Assign high priority operations to an punch request. + * + * Check if the incoming request is a candidate for + * high-priority processing. If it is, assign it a high + * priority operations table. + * + * \param[in] tsi target session environment for this request + */ static void ofd_hp_punch(struct tgt_session_info *tsi) { LASSERT(tsi->tsi_ost_body != NULL); /* must exists if we are here */ @@ -2014,6 +2577,14 @@ static void ofd_hp_punch(struct tgt_session_info *tsi) #define OST_BRW_READ OST_READ #define OST_BRW_WRITE OST_WRITE +/** + * Table of OFD-specific request handlers + * + * This table contains all opcodes accepted by OFD and + * specifies handlers for them. The tgt_request_handler() + * uses such table from each target to process incoming + * requests. + */ static struct tgt_handler ofd_tgt_handlers[] = { TGT_RPC_HANDLER(OST_FIRST_OPC, 0, OST_CONNECT, tgt_connect, @@ -2063,8 +2634,8 @@ static struct tgt_opc_slice ofd_common_slice[] = { .tos_hs = tgt_dlm_handlers }, { - .tos_opc_start = UPDATE_OBJ, - .tos_opc_end = UPDATE_LAST_OPC, + .tos_opc_start = OUT_UPDATE_FIRST_OPC, + .tos_opc_end = OUT_UPDATE_LAST_OPC, .tos_hs = tgt_out_handlers }, { @@ -2082,6 +2653,58 @@ static struct tgt_opc_slice ofd_common_slice[] = { } }; +/* context key constructor/destructor: ofd_key_init(), ofd_key_fini() */ +LU_KEY_INIT_FINI(ofd, struct ofd_thread_info); + +/** + * Implementation of lu_context_key::lct_key_exit. + * + * Optional method called on lu_context_exit() for all allocated + * keys. + * It is used in OFD to sanitize context values which may be re-used + * during another request processing by the same thread. + * + * \param[in] ctx execution context + * \param[in] key context key + * \param[in] data ofd_thread_info + */ +static void ofd_key_exit(const struct lu_context *ctx, + struct lu_context_key *key, void *data) +{ + struct ofd_thread_info *info = data; + + info->fti_env = NULL; + info->fti_exp = NULL; + + info->fti_xid = 0; + info->fti_pre_version = 0; + info->fti_used = 0; + + memset(&info->fti_attr, 0, sizeof info->fti_attr); +} + +struct lu_context_key ofd_thread_key = { + .lct_tags = LCT_DT_THREAD, + .lct_init = ofd_key_init, + .lct_fini = ofd_key_fini, + .lct_exit = ofd_key_exit +}; + +/** + * Initialize OFD device according to parameters in the config log \a cfg. + * + * This is the main starting point of OFD initialization. It fills all OFD + * parameters with their initial values and calls other initializing functions + * to set up all OFD subsystems. + * + * \param[in] env execution environment + * \param[in] m OFD device + * \param[in] ldt LU device type of OFD + * \param[in] cfg configuration log + * + * \retval 0 if successful + * \retval negative value on error + */ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, struct lu_device_type *ldt, struct lustre_cfg *cfg) { @@ -2128,14 +2751,15 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, 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); + spin_lock_init(&m->ofd_inconsistency_lock); spin_lock_init(&m->ofd_batch_lock); - rwlock_init(&obd->u.filter.fo_sptlrpc_lock); - sptlrpc_rule_set_init(&obd->u.filter.fo_sptlrpc_rset); init_rwsem(&m->ofd_lastid_rwsem); obd->u.filter.fo_fl_oss_capa = 0; - CFS_INIT_LIST_HEAD(&obd->u.filter.fo_capa_keys); + INIT_LIST_HEAD(&obd->u.filter.fo_capa_keys); obd->u.filter.fo_capa_hash = init_capa_hash(); if (obd->u.filter.fo_capa_hash == NULL) RETURN(-ENOMEM); @@ -2232,7 +2856,14 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, if (rc) GOTO(err_fini_lut, rc); + rc = ofd_start_inconsistency_verification_thread(m); + if (rc != 0) + GOTO(err_fini_fs, rc); + RETURN(0); + +err_fini_fs: + ofd_fs_cleanup(env, m); err_fini_lut: tgt_fini(env, &m->ofd_lut); err_free_ns: @@ -2245,6 +2876,15 @@ err_fini_proc: return rc; } +/** + * Stop the OFD device + * + * This function stops the OFD device and all its subsystems. + * This is the end of OFD lifecycle. + * + * \param[in] env execution environment + * \param[in] m OFD device + */ static void ofd_fini(const struct lu_env *env, struct ofd_device *m) { struct obd_device *obd = ofd_obd(m); @@ -2254,12 +2894,13 @@ 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); - lfsck_degister(env, m->ofd_osd); target_recovery_fini(obd); obd_exports_barrier(obd); obd_zombie_barrier(); tgt_fini(env, &m->ofd_lut); + ofd_stop_inconsistency_verification_thread(m); + lfsck_degister(env, m->ofd_osd); ofd_fs_cleanup(env, m); ofd_free_capa_keys(m); @@ -2274,10 +2915,21 @@ static void ofd_fini(const struct lu_env *env, struct ofd_device *m) 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); + server_put_mount(obd->obd_name, true); EXIT; } +/** + * Implementation of lu_device_type_operations::ldto_device_fini. + * + * Finalize device. Dual to ofd_device_init(). It is called from + * obd_precleanup() and stops the current device. + * + * \param[in] env execution environment + * \param[in] d LU device of OFD + * + * \retval NULL + */ static struct lu_device *ofd_device_fini(const struct lu_env *env, struct lu_device *d) { @@ -2286,6 +2938,16 @@ static struct lu_device *ofd_device_fini(const struct lu_env *env, RETURN(NULL); } +/** + * Implementation of lu_device_type_operations::ldto_device_free. + * + * Free OFD device. Dual to ofd_device_alloc(). + * + * \param[in] env execution environment + * \param[in] d LU device of OFD + * + * \retval NULL + */ static struct lu_device *ofd_device_free(const struct lu_env *env, struct lu_device *d) { @@ -2296,6 +2958,19 @@ static struct lu_device *ofd_device_free(const struct lu_env *env, RETURN(NULL); } +/** + * Implementation of lu_device_type_operations::ldto_device_alloc. + * + * This function allocates the new OFD device. It is called from + * obd_setup() if OBD device had lu_device_type defined. + * + * \param[in] env execution environment + * \param[in] t lu_device_type of OFD device + * \param[in] cfg configuration log + * + * \retval pointer to the lu_device of just allocated OFD + * \retval ERR_PTR of return value on error + */ static struct lu_device *ofd_device_alloc(const struct lu_env *env, struct lu_device_type *t, struct lustre_cfg *cfg) @@ -2319,32 +2994,7 @@ static struct lu_device *ofd_device_alloc(const struct lu_env *env, return l; } -/* thread context key constructor/destructor */ -LU_KEY_INIT_FINI(ofd, struct ofd_thread_info); - -static void ofd_key_exit(const struct lu_context *ctx, - struct lu_context_key *key, void *data) -{ - struct ofd_thread_info *info = data; - - info->fti_env = NULL; - info->fti_exp = NULL; - - info->fti_xid = 0; - info->fti_pre_version = 0; - info->fti_used = 0; - - memset(&info->fti_attr, 0, sizeof info->fti_attr); -} - -struct lu_context_key ofd_thread_key = { - .lct_tags = LCT_DT_THREAD, - .lct_init = ofd_key_init, - .lct_fini = ofd_key_fini, - .lct_exit = ofd_key_exit -}; - -/* type constructor/destructor: mdt_type_init, mdt_type_fini */ +/* 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 = { @@ -2366,9 +3016,17 @@ static struct lu_device_type ofd_device_type = { .ldt_ctx_tags = LCT_DT_THREAD }; -int __init ofd_init(void) +/** + * Initialize OFD module. + * + * This function is called upon module loading. It registers OFD device type + * and prepares all in-memory structures used by all OFD devices. + * + * \retval 0 if successful + * \retval negative value on error + */ +static int __init ofd_init(void) { - struct lprocfs_static_vars lvars; int rc; rc = lu_kmem_init(ofd_caches); @@ -2381,17 +3039,18 @@ int __init ofd_init(void) return(rc); } - lprocfs_ofd_init_vars(&lvars); - - rc = class_register_type(&ofd_obd_ops, NULL, NULL, -#ifndef HAVE_ONLY_PROCFS_SEQ - lvars.module_vars, -#endif - LUSTRE_OST_NAME, &ofd_device_type); + rc = class_register_type(&ofd_obd_ops, NULL, true, NULL, + LUSTRE_OST_NAME, &ofd_device_type); return rc; } -void __exit ofd_exit(void) +/** + * Stop OFD module. + * + * This function is called upon OFD module unloading. + * It frees all related structures and unregisters OFD device type. + */ +static void __exit ofd_exit(void) { ofd_fmd_exit(); lu_kmem_fini(ofd_caches);