X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fofd%2Fofd_dev.c;h=0a2ec19a03982b6ec194059cfbd97d5c2eefa8a2;hp=b7d534887193afc6288d60faa75475c77204d296;hb=8d1e7317b3ce28a6909e139bee5ad84b787d7c7f;hpb=7b28134cbb00365f6fd6996979986408edab721e diff --git a/lustre/ofd/ofd_dev.c b/lustre/ofd/ofd_dev.c index b7d5348..0a2ec19 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, 2015, 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 + */ +/* + * 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 Documentation/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). * - * Author: Alex Zhuravlev - * Author: Mike Pershin - * Author: Johann Lombardi + * - 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 @@ -46,6 +72,10 @@ #include #include #include +#include +#include +#include +#include #include "ofd_internal.h" @@ -63,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) { @@ -78,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); } @@ -88,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); } @@ -104,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) { @@ -111,6 +167,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; @@ -122,6 +179,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) @@ -143,6 +204,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) { @@ -154,7 +228,6 @@ static void ofd_stack_fini(const struct lu_env *env, struct ofd_device *m, ENTRY; lu_site_purge(env, top->ld_site, ~0); - /* process cleanup, pass mdt obd name to get obd umount flags */ lustre_cfg_bufs_reset(&bufs, obd->obd_name); if (obd->obd_force) @@ -163,20 +236,21 @@ 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); lustre_cfg_free(lcfg); 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); + lu_site_print(env, top->ld_site, &msgdata, lu_cdebug_printer); + } LASSERT(m->ofd_osd_exp); obd_disconnect(m->ofd_osd_exp); - m->ofd_osd = NULL; EXIT; } @@ -187,7 +261,61 @@ static struct cfg_interop_param ofd_interop_param[] = { { NULL } }; -/* used by MGS to process specific configurations */ +/** + * 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_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" 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) +{ + char *sval; + int paramlen; + + if (class_match_param(param, PARAM_OST, ¶m) == 0) { + 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) + return true; + } + } + + return false; +} + +/** + * 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) { @@ -200,8 +328,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; @@ -234,12 +361,19 @@ static int ofd_process_config(const struct lu_env *env, struct lu_device *d, } } - lprocfs_ofd_init_vars(&lvars); - rc = class_process_proc_param(PARAM_OST, lvars.obd_vars, cfg, + if (match_symlink_param(param)) { + rc = next->ld_ops->ldo_process_config(env, next, cfg); + break; + } + + rc = class_process_proc_param(PARAM_OST, obd->obd_vars, cfg, d->ld_obd); - if (rc > 0 || rc == -ENOSYS) + 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); + } break; } case LCFG_SPTLRPC_CONF: { @@ -254,6 +388,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) { @@ -277,6 +423,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); @@ -294,18 +448,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) @@ -314,7 +495,7 @@ static struct lu_object *ofd_object_alloc(const struct lu_env *env, ENTRY; - OBD_SLAB_ALLOC_PTR_GFP(of, ofd_object_kmem, __GFP_IO); + OBD_SLAB_ALLOC_PTR_GFP(of, ofd_object_kmem, GFP_NOFS); if (of != NULL) { struct lu_object *o; struct lu_object_header *h; @@ -331,8 +512,67 @@ 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) +{ + struct ofd_device *ofd = data; + struct obd_device *obd = ofd_obd(ofd); + + switch (event) { + case LE_LASTID_REBUILDING: + CWARN("%s: Found crashed LAST_ID, deny creating new OST-object " + "on the device until the LAST_ID rebuilt successfully.\n", + obd->obd_name); + down_write(&ofd->ofd_lastid_rwsem); + ofd->ofd_lastid_rebuilding = 1; + up_write(&ofd->ofd_lastid_rwsem); + break; + case LE_LASTID_REBUILT: { + down_write(&ofd->ofd_lastid_rwsem); + ofd_seqs_free(env, ofd); + 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_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) { @@ -340,17 +580,10 @@ 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; - rc = lu_env_refill((struct lu_env *)env); - if (rc != 0) { - CERROR("Failure to refill session: '%d'\n", rc); - RETURN(rc); - } - info = ofd_info_init(env, NULL); if (info == NULL) RETURN(-EFAULT); @@ -360,23 +593,20 @@ static int ofd_prepare(const struct lu_env *env, struct lu_device *pdev, if (rc != 0) RETURN(rc); - rc = lfsck_register(env, ofd->ofd_osd, &ofd->ofd_dt_dev, false); + rc = lfsck_register(env, ofd->ofd_osd, ofd->ofd_osd, obd, + ofd_lfsck_out_notify, ofd, false); if (rc != 0) { CERROR("%s: failed to initialize lfsck: rc = %d\n", obd->obd_name, rc); RETURN(rc); } - lsp.lsp_start = NULL; - lsp.lsp_namespace = ofd->ofd_namespace; - 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; - } + rc = lfsck_register_namespace(env, ofd->ofd_osd, ofd->ofd_namespace); + /* The LFSCK instance is registered just now, so it must be there when + * register the namespace to such instance. */ + LASSERTF(rc == 0, "register namespace failed: rc = %d\n", rc); - target_recovery_init(&ofd->ofd_lut, ost_handle); + target_recovery_init(&ofd->ofd_lut, tgt_request_handle); LASSERT(obd->obd_no_conn); spin_lock(&obd->obd_dev_lock); obd->obd_no_conn = 0; @@ -388,27 +618,49 @@ 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) { + 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) + /* + * Grant space for object precreation on the self export. + * 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(). */ - 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_dt_conf.ddp_inodespace; + oti->fti_ocd.ocd_connect_flags = OBD_CONNECT_GRANT | + OBD_CONNECT_GRANT_PARAM; + ofd_grant_connect(env, dev->ld_obd->obd_self_export, &oti->fti_ocd, + true); rc = next->ld_ops->ldo_recovery_complete(env, next); 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, @@ -416,38 +668,41 @@ 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); RETURN(rc); } - rc = lprocfs_alloc_obd_stats(obd, LPROC_OFD_LAST); + 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); } - /* Init OFD private stats here */ - lprocfs_counter_init(obd->obd_stats, LPROC_OFD_READ_BYTES, - LPROCFS_CNTR_AVGMINMAX, "read_bytes", "bytes"); - lprocfs_counter_init(obd->obd_stats, LPROC_OFD_WRITE_BYTES, - LPROCFS_CNTR_AVGMINMAX, "write_bytes", "bytes"); - obd->obd_uses_nid_stats = 1; entry = lprocfs_register("exports", obd->obd_proc_entry, NULL, NULL); @@ -460,8 +715,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", @@ -469,13 +723,13 @@ static int ofd_procfs_init(struct ofd_device *ofd) 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(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); @@ -483,64 +737,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); + lprocfs_add_symlink("brw_stats", obd->obd_proc_entry, + "../../%s/%s/brw_stats", + osd_obd->obd_type->typ_name, obd->obd_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); + lprocfs_add_symlink("read_cache_enable", obd->obd_proc_entry, + "../../%s/%s/read_cache_enable", + osd_obd->obd_type->typ_name, obd->obd_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); + lprocfs_add_symlink("readcache_max_filesize", + obd->obd_proc_entry, + "../../%s/%s/readcache_max_filesize", + osd_obd->obd_type->typ_name, obd->obd_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("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; @@ -554,178 +834,2101 @@ int ofd_fid_init(const struct lu_env *env, struct ofd_device *ofd) ss->ss_lu = lu->ld_site; ss->ss_node_id = ofd->ofd_lut.lut_lsd.lsd_osd_index; + OBD_ALLOC(name, sizeof(obd_name) * 2 + 10); + 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(ss->ss_server_seq, ofd->ofd_osd, obd_name, - LUSTRE_SEQ_SERVER, ss, env); + 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); + 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); + /* + * It always printed as "%p", so that the name is unique in the kernel, + * even if the filesystem is mounted twice. So sizeof(.) * 2 is enough. + */ + snprintf(name, sizeof(obd_name) * 2 + 7, "%p-super", obd_name); 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); + GOTO(out_client, rc); } - OBD_FREE(name, strlen(obd_name) + 10); - name = NULL; - rc = seq_server_set_cli(ss->ss_server_seq, ss->ss_client_seq, env); + 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, sizeof(obd_name) * 2 + 10); return rc; } -static struct tgt_opc_slice ofd_common_slice[] = { - { - .tos_opc_start = UPDATE_OBJ, - .tos_opc_end = UPDATE_LAST_OPC, - .tos_hs = tgt_out_handlers - }, - { - .tos_opc_start = SEQ_FIRST_OPC, - .tos_opc_end = SEQ_LAST_OPC, - .tos_hs = seq_handlers - }, - { - .tos_hs = NULL - } -}; - -static int ofd_init0(const struct lu_env *env, struct ofd_device *m, - struct lu_device_type *ldt, struct lustre_cfg *cfg) +/** + * 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) { - const char *dev = lustre_cfg_string(cfg, 0); - struct ofd_thread_info *info = NULL; - struct obd_device *obd; - struct obd_statfs *osfs; - int rc; + struct ptlrpc_request *req = tgt_ses_req(tsi); + struct ost_body *body = NULL, *repbody; + void *key, *val = NULL; + int keylen, vallen, rc = 0; + bool is_grant_shrink; ENTRY; - obd = class_name2obd(dev); - if (obd == NULL) { - CERROR("Cannot find obd with name %s\n", dev); - RETURN(-ENODEV); + key = req_capsule_client_get(tsi->tsi_pill, &RMF_SETINFO_KEY); + if (key == NULL) { + DEBUG_REQ(D_HA, req, "no set_info key"); + RETURN(err_serious(-EFAULT)); } + keylen = req_capsule_get_size(tsi->tsi_pill, &RMF_SETINFO_KEY, + RCL_CLIENT); - rc = lu_env_refill((struct lu_env *)env); - if (rc != 0) + val = req_capsule_client_get(tsi->tsi_pill, &RMF_SETINFO_VAL); + if (val == NULL) { + DEBUG_REQ(D_HA, req, "no set_info val"); + RETURN(err_serious(-EFAULT)); + } + vallen = req_capsule_get_size(tsi->tsi_pill, &RMF_SETINFO_VAL, + RCL_CLIENT); + + is_grant_shrink = KEY_IS(KEY_GRANT_SHRINK); + if (is_grant_shrink) + /* In this case the value is actually an RMF_OST_BODY, so we + * transmutate the type of this PTLRPC */ + req_capsule_extend(tsi->tsi_pill, &RQF_OST_SET_GRANT_INFO); + + rc = req_capsule_server_pack(tsi->tsi_pill); + if (rc < 0) RETURN(rc); - obd->u.obt.obt_magic = OBT_MAGIC; + if (is_grant_shrink) { + body = req_capsule_client_get(tsi->tsi_pill, &RMF_OST_BODY); - m->ofd_fmd_max_num = OFD_FMD_MAX_NUM_DEFAULT; - m->ofd_fmd_max_age = OFD_FMD_MAX_AGE_DEFAULT; + repbody = req_capsule_server_get(tsi->tsi_pill, &RMF_OST_BODY); + *repbody = *body; - spin_lock_init(&m->ofd_flags_lock); - m->ofd_raid_degraded = 0; - m->ofd_syncjournal = 0; - ofd_slc_set(m); - m->ofd_grant_compat_disable = 0; + /** handle grant shrink, similar to a read request */ + ofd_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); + rc = -EOPNOTSUPP; + } + ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_SET_INFO, + tsi->tsi_jobid, 1); - /* 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; + RETURN(rc); +} - /* 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; +/** + * 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 fiemap *fiemap) +{ + struct ofd_object *fo; + int rc; - 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); + fo = ofd_object_find(env, ofd, fid); + if (IS_ERR(fo)) { + CERROR("%s: error finding object "DFID"\n", + ofd_name(ofd), PFID(fid)); + return PTR_ERR(fo); + } - obd->u.filter.fo_fl_oss_capa = 0; - CFS_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); + ofd_read_lock(env, fo); + if (ofd_object_exists(fo)) + rc = dt_fiemap_get(env, ofd_object_child(fo), fiemap); + else + rc = -ENOENT; + ofd_read_unlock(env, fo); + ofd_object_put(env, fo); + return rc; +} - m->ofd_dt_dev.dd_lu_dev.ld_ops = &ofd_lu_ops; - m->ofd_dt_dev.dd_lu_dev.ld_obd = obd; - /* set this lu_device to obd, because error handling need it */ - obd->obd_lu_dev = &m->ofd_dt_dev.dd_lu_dev; +struct locked_region { + struct list_head list; + struct lustre_handle lh; +}; - rc = ofd_procfs_init(m); - if (rc) { - CERROR("Can't init ofd lprocfs, rc %d\n", rc); - RETURN(rc); - } +/** + * 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) +{ + struct locked_region *region = NULL; + __u64 flags = 0; + int rc; - /* No connection accepted until configurations will finish */ - spin_lock(&obd->obd_dev_lock); - obd->obd_no_conn = 1; - spin_unlock(&obd->obd_dev_lock); - obd->obd_replayable = 1; - if (cfg->lcfg_bufcount > 4 && LUSTRE_CFG_BUFLEN(cfg, 4) > 0) { - char *str = lustre_cfg_string(cfg, 4); + LASSERT(begin <= end); + OBD_ALLOC_PTR(region); + if (region == NULL) + return -ENOMEM; - if (strchr(str, 'n')) { - CWARN("%s: recovery disabled\n", obd->obd_name); - obd->obd_replayable = 0; + rc = tgt_extent_lock(ns, res_id, begin, end, ®ion->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); + + 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 fiemap *fiemap, + struct list_head *locked) +{ + __u64 begin = fiemap->fm_start; + unsigned int i; + int rc = 0; + struct fiemap_extent *fiemap_start = fiemap->fm_extents; + + ENTRY; + + CDEBUG(D_OTHER, "extents count %u\n", fiemap->fm_mapped_extents); + for (i = 0; i < fiemap->fm_mapped_extents; i++) { + 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); + if (rc) + RETURN(rc); } - } - info = ofd_info_init(env, NULL); - if (info == NULL) - RETURN(-EFAULT); + begin = fiemap_start[i].fe_logical + fiemap_start[i].fe_length; + } - rc = ofd_stack_init(env, m, cfg); - if (rc) { - CERROR("Can't init device stack, rc %d\n", rc); - GOTO(err_fini_proc, rc); + 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); } - ofd_procfs_add_brw_stats_symlink(m); + RETURN(rc); +} - /* 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); +/** + * 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. + * + * 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); + struct ofd_thread_info *fti = tsi2ofd_info(tsi); + void *key; + int keylen; + int replylen, rc = 0; + + ENTRY; + + /* this common part for get_info rpc */ + key = req_capsule_client_get(tsi->tsi_pill, &RMF_GETINFO_KEY); + if (key == NULL) { + DEBUG_REQ(D_HA, tgt_ses_req(tsi), "no get_info key"); + RETURN(err_serious(-EPROTO)); + } + keylen = req_capsule_get_size(tsi->tsi_pill, &RMF_GETINFO_KEY, + RCL_CLIENT); + + if (KEY_IS(KEY_LAST_ID)) { + u64 *last_id; + struct ofd_seq *oseq; + + req_capsule_extend(tsi->tsi_pill, &RQF_OST_GET_INFO_LAST_ID); + rc = req_capsule_server_pack(tsi->tsi_pill); + if (rc) + RETURN(err_serious(rc)); + + last_id = req_capsule_server_get(tsi->tsi_pill, &RMF_OBD_ID); + + oseq = ofd_seq_load(tsi->tsi_env, ofd, + (u64)exp->exp_filter_data.fed_group); + if (IS_ERR(oseq)) + rc = -EFAULT; + else + *last_id = ofd_seq_last_oid(oseq); + ofd_seq_put(tsi->tsi_env, oseq); + } else if (KEY_IS(KEY_FIEMAP)) { + struct ll_fiemap_info_key *fm_key; + struct fiemap *fiemap; + struct lu_fid *fid; + + req_capsule_extend(tsi->tsi_pill, &RQF_OST_GET_INFO_FIEMAP); + + fm_key = req_capsule_client_get(tsi->tsi_pill, &RMF_FIEMAP_KEY); + rc = tgt_validate_obdo(tsi, &fm_key->lfik_oa); + if (rc) + RETURN(err_serious(rc)); + + fid = &fm_key->lfik_oa.o_oi.oi_fid; + + CDEBUG(D_INODE, "get FIEMAP of object "DFID"\n", PFID(fid)); + + replylen = fiemap_count_to_size( + fm_key->lfik_fiemap.fm_extent_count); + req_capsule_set_size(tsi->tsi_pill, &RMF_FIEMAP_VAL, + RCL_SERVER, replylen); + + rc = req_capsule_server_pack(tsi->tsi_pill); + if (rc) + RETURN(err_serious(rc)); + + fiemap = req_capsule_server_get(tsi->tsi_pill, &RMF_FIEMAP_VAL); + if (fiemap == NULL) + RETURN(-ENOMEM); + + *fiemap = fm_key->lfik_fiemap; + rc = ofd_fiemap_get(tsi->tsi_env, ofd, fid, fiemap); + + /* LU-3219: Lock the sparse areas to make sure dirty + * 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 = 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); + struct ofd_seq *oseq; + struct lu_fid *fid; + int rc; + + req_capsule_extend(tsi->tsi_pill, &RQF_OST_GET_INFO_LAST_FID); + rc = req_capsule_server_pack(tsi->tsi_pill); + if (rc) + RETURN(err_serious(rc)); + + fid = req_capsule_client_get(tsi->tsi_pill, &RMF_FID); + if (fid == NULL) + RETURN(err_serious(-EPROTO)); + + fid_le_to_cpu(&fti->fti_ostid.oi_fid, fid); + + fid = req_capsule_server_get(tsi->tsi_pill, &RMF_FID); + if (fid == NULL) + RETURN(-ENOMEM); + + oseq = ofd_seq_load(tsi->tsi_env, ofd, + ostid_seq(&fti->fti_ostid)); + if (IS_ERR(oseq)) + RETURN(PTR_ERR(oseq)); + + rc = ostid_to_fid(fid, &oseq->os_oi, + ofd->ofd_lut.lut_lsd.lsd_osd_index); + if (rc != 0) + GOTO(out_put, rc); + + CDEBUG(D_HA, "%s: LAST FID is "DFID"\n", ofd_name(ofd), + PFID(fid)); +out_put: + ofd_seq_put(tsi->tsi_env, oseq); + } else { + CERROR("%s: not supported key %s\n", tgt_name(tsi->tsi_tgt), + (char *)key); + rc = -EOPNOTSUPP; + } + ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_GET_INFO, + tsi->tsi_jobid, 1); + + 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); + struct ofd_device *ofd = ofd_exp(tsi->tsi_exp); + struct ost_body *repbody; + struct lustre_handle lh = { 0 }; + struct ofd_object *fo; + __u64 flags = 0; + enum ldlm_mode lock_mode = LCK_PR; + bool srvlock; + int rc; + ENTRY; + + LASSERT(tsi->tsi_ost_body != NULL); + + repbody = req_capsule_server_get(tsi->tsi_pill, &RMF_OST_BODY); + if (repbody == NULL) + RETURN(-ENOMEM); + + repbody->oa.o_oi = tsi->tsi_ost_body->oa.o_oi; + repbody->oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP; + + srvlock = tsi->tsi_ost_body->oa.o_valid & OBD_MD_FLFLAGS && + tsi->tsi_ost_body->oa.o_flags & OBD_FL_SRVLOCK; + + if (srvlock) { + 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, + &tsi->tsi_resid, 0, OBD_OBJECT_EOF, &lh, + lock_mode, &flags); + if (rc != 0) + RETURN(rc); + } + + fo = ofd_object_find_exists(tsi->tsi_env, ofd, &tsi->tsi_fid); + if (IS_ERR(fo)) + GOTO(out, rc = PTR_ERR(fo)); + + rc = ofd_attr_get(tsi->tsi_env, fo, &fti->fti_attr); + if (rc == 0) { + __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); + + /* Store object version in reply */ + curr_version = dt_version_get(tsi->tsi_env, + ofd_object_child(fo)); + if ((__s64)curr_version != -EOPNOTSUPP) { + repbody->oa.o_valid |= OBD_MD_FLDATAVERSION; + repbody->oa.o_data_version = curr_version; + } + } + + ofd_object_put(tsi->tsi_env, fo); +out: + if (srvlock) + tgt_extent_unlock(&lh, lock_mode); + + ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_GETATTR, + tsi->tsi_jobid, 1); + + repbody->oa.o_valid |= OBD_MD_FLFLAGS; + repbody->oa.o_flags = OBD_FL_FLUSH; + + 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); + struct ofd_device *ofd = ofd_exp(tsi->tsi_exp); + struct ost_body *body = tsi->tsi_ost_body; + struct ost_body *repbody; + struct ldlm_resource *res; + struct ofd_object *fo; + struct filter_fid *ff = NULL; + int rc = 0; + + ENTRY; + + LASSERT(body != NULL); + + repbody = req_capsule_server_get(tsi->tsi_pill, &RMF_OST_BODY); + if (repbody == NULL) + RETURN(-ENOMEM); + + repbody->oa.o_oi = body->oa.o_oi; + repbody->oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP; + + /* This would be very bad - accidentally truncating a file when + * changing the time or similar - bug 12203. */ + if (body->oa.o_valid & OBD_MD_FLSIZE && + body->oa.o_size != OBD_OBJECT_EOF) { + static char mdsinum[48]; + + if (body->oa.o_valid & OBD_MD_FLFID) + snprintf(mdsinum, sizeof(mdsinum) - 1, + "of parent "DFID, body->oa.o_parent_seq, + body->oa.o_parent_oid, 0); + else + mdsinum[0] = '\0'; + + CERROR("%s: setattr from %s is trying to truncate object "DFID + " %s\n", ofd_name(ofd), obd_export_nid2str(tsi->tsi_exp), + PFID(&tsi->tsi_fid), mdsinum); + RETURN(-EPERM); + } + + fo = ofd_object_find_exists(tsi->tsi_env, ofd, &tsi->tsi_fid); + if (IS_ERR(fo)) + GOTO(out, rc = PTR_ERR(fo)); + + 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); + 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_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_SETATTR, + tsi->tsi_jobid, 1); + EXIT; +out_put: + ofd_object_put(tsi->tsi_env, fo); +out: + if (rc == 0) { + /* we do not call this before to avoid lu_object_find() in + * ->lvbo_update() holding another reference on the object. + * otherwise concurrent destroy can make the object unavailable + * for 2nd lu_object_find() waiting for the first reference + * to go... deadlock! */ + res = ldlm_resource_get(ofd->ofd_namespace, NULL, + &tsi->tsi_resid, LDLM_EXTENT, 0); + if (!IS_ERR(res)) { + ldlm_res_lvbo_update(res, NULL, 0); + ldlm_resource_putref(res); + } + } + 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) +{ + struct ofd_thread_info *info = ofd_info(env); + struct lu_fid *fid = &info->fti_fid; + struct ost_id *oi = &oa->o_oi; + struct ofd_seq *oseq; + u64 seq = ostid_seq(oi); + u64 end_id = ostid_id(oi); + u64 last; + u64 oid; + int skip_orphan; + int rc = 0; + + ENTRY; + + oseq = ofd_seq_get(ofd, seq); + if (oseq == NULL) { + CERROR("%s: Can not find seq for "DOSTID"\n", + ofd_name(ofd), POSTID(oi)); + RETURN(-EINVAL); + } + + *fid = oi->oi_fid; + last = ofd_seq_last_oid(oseq); + oid = last; + + 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); + + while (oid > end_id) { + rc = fid_set_id(fid, oid); + if (unlikely(rc != 0)) + GOTO(out_put, rc); + + rc = ofd_destroy_by_fid(env, ofd, fid, 1); + 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) { + ofd_seq_last_oid_set(oseq, oid); + /* update last_id on disk periodically so that if we + * restart * we don't need to re-scan all of the just + * deleted objects. */ + if ((oid & 511) == 0) + ofd_seq_last_oid_write(env, ofd, oseq); + } + } + + 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 */ + ostid_set_id(oi, last); + rc = 0; + } + + GOTO(out_put, rc); + +out_put: + ofd_seq_put(env, oseq); + 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); + 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; + long granted = 0; + + ENTRY; + + if (OBD_FAIL_CHECK(OBD_FAIL_OST_EROFS)) + RETURN(-EROFS); + + repbody = req_capsule_server_get(tsi->tsi_pill, &RMF_OST_BODY); + if (repbody == NULL) + RETURN(-ENOMEM); + + down_read(&ofd->ofd_lastid_rwsem); + /* Currently, for safe, we do not distinguish which LAST_ID is broken, + * we may do that in the future. + * Return -ENOSPC until the LAST_ID rebuilt. */ + if (unlikely(ofd->ofd_lastid_rebuilding)) + GOTO(out_sem, rc = -ENOSPC); + + 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", + ofd_name(ofd), seq, PTR_ERR(oseq)); + GOTO(out_sem, rc = -EINVAL); + } + + if ((oa->o_valid & OBD_MD_FLFLAGS) && + (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 + "\n", ofd_name(ofd), POSTID(&oa->o_oi), + ofd_seq_last_oid(oseq)); + GOTO(out_nolock, rc = -EINVAL); + } + /* Do nothing here, we re-create objects during recovery + * upon write replay, see ofd_preprw_write() */ + GOTO(out_nolock, rc = 0); + } + /* former ofd_handle_precreate */ + if ((oa->o_valid & OBD_MD_FLFLAGS) && + (oa->o_flags & OBD_FL_DELORPHAN)) { + exp->exp_filter_data.fed_lastid_gen = ofd->ofd_lastid_gen; + + /* destroy orphans */ + if (lustre_msg_get_conn_cnt(tgt_ses_req(tsi)->rq_reqmsg) < + exp->exp_conn_cnt) { + CERROR("%s: dropping old orphan cleanup request\n", + ofd_name(ofd)); + GOTO(out_nolock, rc = 0); + } + /* This causes inflight precreates to abort and drop lock */ + 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); + } + diff = oid - ofd_seq_last_oid(oseq); + CDEBUG(D_HA, "ofd_last_id() = "LPU64" -> diff = %d\n", + ofd_seq_last_oid(oseq), diff); + if (-diff > OST_MAX_PRECREATE) { + /* 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, + ofd, rep_oa); + oseq->os_destroys_in_progress = 0; + } else { + /* XXX: Used by MDS for the first time! */ + oseq->os_destroys_in_progress = 0; + } + } else { + if (unlikely(exp->exp_filter_data.fed_lastid_gen != + ofd->ofd_lastid_gen)) { + /* Keep the export ref so we can send the reply. */ + ofd_obd_disconnect(class_export_get(exp)); + GOTO(out_nolock, rc = -ENOTCONN); + } + + mutex_lock(&oseq->os_create_lock); + if (lustre_msg_get_conn_cnt(tgt_ses_req(tsi)->rq_reqmsg) < + exp->exp_conn_cnt) { + CERROR("%s: dropping old precreate request\n", + ofd_name(ofd)); + GOTO(out, rc = 0); + } + /* only precreate if seq is 0, IDIF or normal and also o_id + * must be specfied */ + if ((!fid_seq_is_mdt(seq) && !fid_seq_is_norm(seq) && + !fid_seq_is_idif(seq)) || oid == 0) { + diff = 1; /* shouldn't we create this right now? */ + } else { + diff = oid - ofd_seq_last_oid(oseq); + /* Do sync create if the seq is about to used up */ + if (fid_seq_is_idif(seq) || fid_seq_is_mdt0(seq)) { + if (unlikely(oid >= IDIF_MAX_OID - 1)) + sync_trans = 1; + } else if (fid_seq_is_norm(seq)) { + if (unlikely(oid >= + LUSTRE_DATA_SEQ_MAX_WIDTH - 1)) + sync_trans = 1; + } else { + CERROR("%s : invalid o_seq "DOSTID"\n", + ofd_name(ofd), POSTID(&oa->o_oi)); + GOTO(out, rc = -EINVAL); + } + + 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); + u64 next_id; + int created = 0; + int count; + + if (!(oa->o_valid & OBD_MD_FLFLAGS) || + !(oa->o_flags & OBD_FL_DELORPHAN)) { + /* don't enforce grant during orphan recovery */ + granted = ofd_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", + ofd_name(ofd), diff, rc); + diff = 0; + } + } + + /* This can happen if a new OST is formatted and installed + * in place of an old one at the same index. Instead of + * precreating potentially millions of deleted old objects + * (possibly filling the OST), only precreate the last batch. + * LFSCK will eventually clean up any orphans. LU-14 */ + if (diff > 5 * OST_MAX_PRECREATE) { + diff = OST_MAX_PRECREATE / 2; + LCONSOLE_WARN("%s: Too many FIDs to precreate " + "OST replaced or reformatted: " + "LFSCK will clean up", + ofd_name(ofd)); + + CDEBUG(D_HA, "%s: precreate FID "DOSTID" is over " + "%u larger than the LAST_ID "DOSTID", only " + "precreating the last %u 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); + + CDEBUG(D_HA, "%s: reserve %d objects in group "LPX64 + " at "LPU64"\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" + " created at a rate of %d/s\n", + ofd_name(ofd), created, diff + created, + created / DISK_TIMEOUT); + break; + } + + rc = ofd_precreate_objects(tsi->tsi_env, ofd, next_id, + oseq, count, sync_trans); + if (rc > 0) { + created += rc; + diff -= rc; + } else if (rc < 0) { + 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 */ + rc = 0; + else + CERROR("%s: unable to precreate: rc = %d\n", + ofd_name(ofd), rc); + + if (!(oa->o_valid & OBD_MD_FLFLAGS) || + !(oa->o_flags & OBD_FL_DELORPHAN)) { + ofd_grant_commit(ofd_obd(ofd)->obd_self_export, granted, + rc); + granted = 0; + } + + ostid_set_id(&rep_oa->o_oi, ofd_seq_last_oid(oseq)); + } + EXIT; + ofd_counter_incr(exp, LPROC_OFD_STATS_CREATE, + tsi->tsi_jobid, 1); +out: + mutex_unlock(&oseq->os_create_lock); +out_nolock: + if (rc == 0) { +#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 8, 53, 0) + struct ofd_thread_info *info = ofd_info(tsi->tsi_env); + struct lu_fid *fid = &info->fti_fid; + + /* For compatible purpose, it needs to convert back to + * OST ID before put it on wire. */ + *fid = rep_oa->o_oi.oi_fid; + fid_to_ostid(fid, &rep_oa->o_oi); +#endif + rep_oa->o_valid |= OBD_MD_FLID | OBD_MD_FLGROUP; + } + ofd_seq_put(tsi->tsi_env, oseq); + +out_sem: + up_read(&ofd->ofd_lastid_rwsem); + 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; + struct ost_body *repbody; + struct ofd_device *ofd = ofd_exp(tsi->tsi_exp); + struct ofd_thread_info *fti = tsi2ofd_info(tsi); + struct lu_fid *fid = &fti->fti_fid; + u64 oid; + u32 count; + int rc = 0; + + ENTRY; + + if (OBD_FAIL_CHECK(OBD_FAIL_OST_EROFS)) + RETURN(-EROFS); + + /* This is old case for clients before Lustre 2.4 */ + /* If there's a DLM request, cancel the locks mentioned in it */ + if (req_capsule_field_present(tsi->tsi_pill, &RMF_DLM_REQ, + RCL_CLIENT)) { + struct ldlm_request *dlm; + + 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, LATF_SKIP); + } + + *fid = body->oa.o_oi.oi_fid; + oid = ostid_id(&body->oa.o_oi); + LASSERT(oid != 0); + + repbody = req_capsule_server_get(tsi->tsi_pill, &RMF_OST_BODY); + + /* check that o_misc makes sense */ + if (body->oa.o_valid & OBD_MD_FLOBJCOUNT) + count = body->oa.o_misc; + else + count = 1; /* default case - single destroy */ + + CDEBUG(D_HA, "%s: Destroy object "DOSTID" count %d\n", ofd_name(ofd), + POSTID(&body->oa.o_oi), count); + + while (count > 0) { + int lrc; + + lrc = ofd_destroy_by_fid(tsi->tsi_env, ofd, fid, 0); + if (lrc == -ENOENT) { + CDEBUG(D_INODE, + "%s: destroying non-existent object "DFID"\n", + ofd_name(ofd), PFID(fid)); + /* rewrite rc with -ENOENT only if it is 0 */ + if (rc == 0) + rc = lrc; + } else if (lrc != 0) { + CERROR("%s: error destroying object "DFID": %d\n", + ofd_name(ofd), PFID(fid), lrc); + rc = lrc; + } + + count--; + oid++; + lrc = fid_set_id(fid, oid); + if (unlikely(lrc != 0 && count > 0)) + GOTO(out, rc = lrc); + } + + ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_DESTROY, + tsi->tsi_jobid, 1); + + GOTO(out, rc); + +out: + fid_to_ostid(fid, &repbody->oa.o_oi); + 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; + int rc; + + ENTRY; + + 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); + if (rc != 0) + CERROR("%s: statfs failed: rc = %d\n", + tgt_name(tsi->tsi_tgt), rc); + + if (OBD_FAIL_CHECK(OBD_FAIL_OST_STATFS_EINPROGRESS)) + rc = -EINPROGRESS; + + ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_STATFS, + tsi->tsi_jobid, 1); + + 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; + struct ost_body *repbody; + struct ofd_thread_info *fti = tsi2ofd_info(tsi); + struct ofd_device *ofd = ofd_exp(tsi->tsi_exp); + struct ofd_object *fo = NULL; + int rc = 0; + + ENTRY; + + repbody = req_capsule_server_get(tsi->tsi_pill, &RMF_OST_BODY); + + /* if no objid is specified, it means "sync whole filesystem" */ + if (!fid_is_zero(&tsi->tsi_fid)) { + fo = ofd_object_find_exists(tsi->tsi_env, ofd, &tsi->tsi_fid); + if (IS_ERR(fo)) + RETURN(PTR_ERR(fo)); + } + + rc = tgt_sync(tsi->tsi_env, tsi->tsi_tgt, + fo != NULL ? ofd_object_child(fo) : NULL, + repbody->oa.o_size, repbody->oa.o_blocks); + if (rc) + GOTO(put, rc); + + ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_SYNC, + tsi->tsi_jobid, 1); + if (fo == NULL) + RETURN(0); + + repbody->oa.o_oi = body->oa.o_oi; + repbody->oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP; + + rc = ofd_attr_get(tsi->tsi_env, fo, &fti->fti_attr); + if (rc == 0) + obdo_from_la(&repbody->oa, &fti->fti_attr, + OFD_VALID_FLAGS); + else + /* don't return rc from getattr */ + rc = 0; + EXIT; +put: + if (fo != NULL) + ofd_object_put(tsi->tsi_env, fo); + 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; + struct ost_body *repbody; + struct ofd_thread_info *info = tsi2ofd_info(tsi); + struct ldlm_namespace *ns = tsi->tsi_tgt->lut_obd->obd_namespace; + struct ldlm_resource *res; + struct ofd_object *fo; + struct filter_fid *ff = NULL; + __u64 flags = 0; + struct lustre_handle lh = { 0, }; + int rc; + __u64 start, end; + bool srvlock; + + 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); + + if ((oa->o_valid & (OBD_MD_FLSIZE | OBD_MD_FLBLOCKS)) != + (OBD_MD_FLSIZE | OBD_MD_FLBLOCKS)) + RETURN(err_serious(-EPROTO)); + + repbody = req_capsule_server_get(tsi->tsi_pill, &RMF_OST_BODY); + if (repbody == NULL) + RETURN(err_serious(-ENOMEM)); + + /* punch start,end are passed in o_size,o_blocks throught wire */ + start = oa->o_size; + end = oa->o_blocks; + + if (end != OBD_OBJECT_EOF) /* Only truncate is supported */ + RETURN(-EPROTO); + + /* standard truncate optimization: if file body is completely + * destroyed, don't send data back to the server. */ + if (start == 0) + flags |= LDLM_FL_AST_DISCARD_DATA; + + repbody->oa.o_oi = oa->o_oi; + repbody->oa.o_valid = OBD_MD_FLID; + + srvlock = oa->o_valid & OBD_MD_FLFLAGS && + oa->o_flags & OBD_FL_SRVLOCK; + + if (srvlock) { + rc = tgt_extent_lock(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), + oa->o_valid, start, end); + + fo = ofd_object_find_exists(tsi->tsi_env, ofd_exp(tsi->tsi_exp), + &tsi->tsi_fid); + if (IS_ERR(fo)) + GOTO(out, rc = PTR_ERR(fo)); + + la_from_obdo(&info->fti_attr, oa, + OBD_MD_FLMTIME | OBD_MD_FLATIME | OBD_MD_FLCTIME); + 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); + if (rc) + GOTO(out_put, rc); + + ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_PUNCH, + tsi->tsi_jobid, 1); + EXIT; +out_put: + ofd_object_put(tsi->tsi_env, fo); +out: + if (srvlock) + tgt_extent_unlock(&lh, LCK_PW); + if (rc == 0) { + /* we do not call this before to avoid lu_object_find() in + * ->lvbo_update() holding another reference on the object. + * otherwise concurrent destroy can make the object unavailable + * for 2nd lu_object_find() waiting for the first reference + * to go... deadlock! */ + res = ldlm_resource_get(ns, NULL, &tsi->tsi_resid, + LDLM_EXTENT, 0); + if (!IS_ERR(res)) { + ldlm_res_lvbo_update(res, NULL, 0); + ldlm_resource_putref(res); + } + } + 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; + const struct lu_env *env = req->rq_svc_thread->t_env; + int rc = 0; + struct lu_ladvise *ladvise; + int num_advise; + struct ladvise_hdr *ladvise_hdr; + int i; + ENTRY; + + 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); + + for (i = 0; i < num_advise; i++, ladvise++) { + if (ladvise->lla_end <= ladvise->lla_start) { + rc = err_serious(-EPROTO); + break; + } + + /* Handle different advice types */ + switch (ladvise->lla_advice) { + default: + rc = -ENOTSUPP; + break; + } + if (rc != 0) + break; + } + + ofd_object_put(env, fo); + req->rq_status = rc; + 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; + int id; + int rc; + + ENTRY; + + oqctl = req_capsule_client_get(tsi->tsi_pill, &RMF_OBD_QUOTACTL); + if (oqctl == NULL) + RETURN(err_serious(-EPROTO)); + + repoqc = req_capsule_server_get(tsi->tsi_pill, &RMF_OBD_QUOTACTL); + if (repoqc == NULL) + RETURN(err_serious(-ENOMEM)); + + *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, + 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); + + nodemap_putref(nodemap); + + if (repoqc->qc_id != id) + swap(repoqc->qc_id, id); + + rc = lquotactl_slv(tsi->tsi_env, tsi->tsi_tgt->lut_bottom, repoqc); + + 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); +} + +/** + * 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, + struct ldlm_lock *lock) +{ + struct ptlrpc_service_part *svcpt = req->rq_rqbd->rqbd_svcpt; + + 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; +} + +/** + * 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) +{ + 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; + + if (oa->o_valid & OBD_MD_FLHANDLE) { + /* mostly a request should be covered by only one lock, try + * fast path. */ + lock = ldlm_handle2lock(&oa->o_handle); + 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)) { + /* bingo */ + LASSERT(lock->l_export == exp); + lock_count = ofd_prolong_one_lock(tsi, lock, + &extent); + 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); +} + +/** + * 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) +{ + struct niobuf_remote *rnb; + struct obd_ioobj *ioo; + enum ldlm_mode mode; + struct ldlm_extent ext; + __u32 opc = lustre_msg_get_opc(req->rq_reqmsg); + + ENTRY; + + ioo = req_capsule_client_get(&req->rq_pill, &RMF_OBD_IOOBJ); + LASSERT(ioo != NULL); + + rnb = req_capsule_client_get(&req->rq_pill, &RMF_NIOBUF_REMOTE); + LASSERT(rnb != NULL); + + ext.start = rnb->rnb_offset; + rnb += ioo->ioo_bufcnt - 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)) + RETURN(0); + + RETURN(ldlm_extent_overlap(&lock->l_policy_data.l_extent, &ext)); +} + +/** + * 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. + * + * \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_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; + + ENTRY; + + /* 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); + + /* + * Use LASSERT below because malformed RPCs should have + * been filtered out in tgt_hpreq_handler(). + */ + ioo = req_capsule_client_get(&req->rq_pill, &RMF_OBD_IOOBJ); + LASSERT(ioo != NULL); + + rnb = req_capsule_client_get(&req->rq_pill, &RMF_NIOBUF_REMOTE); + LASSERT(rnb != NULL); + LASSERT(!(rnb->rnb_flags & OBD_BRW_SRVLOCK)); + + start = rnb->rnb_offset; + rnb += ioo->ioo_bufcnt - 1; + 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); + + lock_count = ofd_prolong_extent_locks(tsi, start, end); + + CDEBUG(D_DLMTRACE, "%s: refreshed %u locks timeout for req %p.\n", + tgt_name(tsi->tsi_tgt), lock_count, 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); +} + +/** + * 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) +{ + 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. */ + tsi = lu_context_key_get(&req->rq_session, &tgt_session_key); + + /* + * 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) + RETURN(1); + + 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. + * + * \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) +{ + struct tgt_session_info *tsi; + struct obdo *oa; + int lock_count; + + ENTRY; + + /* 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); + oa = &tsi->tsi_ost_body->oa; + + LASSERT(!(oa->o_valid & OBD_MD_FLFLAGS && + oa->o_flags & OBD_FL_SRVLOCK)); + + CDEBUG(D_DLMTRACE, + "%s: refresh locks: "LPU64"/"LPU64" ("LPU64"->"LPU64")\n", + tgt_name(tsi->tsi_tgt), tsi->tsi_resid.name[0], + tsi->tsi_resid.name[1], oa->o_size, oa->o_blocks); + + lock_count = ofd_prolong_extent_locks(tsi, oa->o_size, oa->o_blocks); + + CDEBUG(D_DLMTRACE, "%s: refreshed %u locks timeout for req %p.\n", + tgt_name(tsi->tsi_tgt), lock_count, 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); +} + +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 +}; + +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 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; + struct obd_ioobj *ioo; + + ENTRY; + + ioo = req_capsule_client_get(tsi->tsi_pill, &RMF_OBD_IOOBJ); + LASSERT(ioo != NULL); /* must exist after request preprocessing */ + if (ioo->ioo_bufcnt > 0) { + rnb = req_capsule_client_get(tsi->tsi_pill, &RMF_NIOBUF_REMOTE); + LASSERT(rnb != NULL); /* must exist after request preprocessing */ + + /* no high priority if server lock is needed */ + 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 */ + /* 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) + return; + tgt_ses_req(tsi)->rq_ops = &ofd_hpreq_punch; +} + +#define OBD_FAIL_OST_READ_NET OBD_FAIL_OST_BRW_NET +#define OBD_FAIL_OST_WRITE_NET OBD_FAIL_OST_BRW_NET +#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, + &RQF_CONNECT, LUSTRE_OBD_VERSION), +TGT_RPC_HANDLER(OST_FIRST_OPC, + 0, OST_DISCONNECT, tgt_disconnect, + &RQF_OST_DISCONNECT, LUSTRE_OBD_VERSION), +TGT_RPC_HANDLER(OST_FIRST_OPC, + 0, OST_SET_INFO, ofd_set_info_hdl, + &RQF_OBD_SET_INFO, LUSTRE_OST_VERSION), +TGT_OST_HDL(0, OST_GET_INFO, ofd_get_info_hdl), +TGT_OST_HDL(HABEO_CORPUS| HABEO_REFERO, OST_GETATTR, ofd_getattr_hdl), +TGT_OST_HDL(HABEO_CORPUS| HABEO_REFERO | MUTABOR, + OST_SETATTR, ofd_setattr_hdl), +TGT_OST_HDL(0 | HABEO_REFERO | MUTABOR, + OST_CREATE, ofd_create_hdl), +TGT_OST_HDL(0 | HABEO_REFERO | MUTABOR, + OST_DESTROY, ofd_destroy_hdl), +TGT_OST_HDL(0 | HABEO_REFERO, OST_STATFS, ofd_statfs_hdl), +TGT_OST_HDL_HP(HABEO_CORPUS| HABEO_REFERO, + OST_BRW_READ, tgt_brw_read, + ofd_hp_brw), +/* don't set CORPUS flag for brw_write because -ENOENT may be valid case */ +TGT_OST_HDL_HP(HABEO_CORPUS| MUTABOR, OST_BRW_WRITE, tgt_brw_write, + ofd_hp_brw), +TGT_OST_HDL_HP(HABEO_CORPUS| HABEO_REFERO | MUTABOR, + OST_PUNCH, ofd_punch_hdl, + ofd_hp_punch), +TGT_OST_HDL(HABEO_CORPUS| HABEO_REFERO, OST_SYNC, ofd_sync_hdl), +TGT_OST_HDL(0 | HABEO_REFERO, OST_QUOTACTL, ofd_quotactl), +TGT_OST_HDL(HABEO_CORPUS | HABEO_REFERO, OST_LADVISE, ofd_ladvise_hdl), +}; + +static struct tgt_opc_slice ofd_common_slice[] = { + { + .tos_opc_start = OST_FIRST_OPC, + .tos_opc_end = OST_LAST_OPC, + .tos_hs = ofd_tgt_handlers + }, + { + .tos_opc_start = OBD_FIRST_OPC, + .tos_opc_end = OBD_LAST_OPC, + .tos_hs = tgt_obd_handlers + }, + { + .tos_opc_start = LDLM_FIRST_OPC, + .tos_opc_end = LDLM_LAST_OPC, + .tos_hs = tgt_dlm_handlers + }, + { + .tos_opc_start = OUT_UPDATE_FIRST_OPC, + .tos_opc_end = OUT_UPDATE_LAST_OPC, + .tos_hs = tgt_out_handlers + }, + { + .tos_opc_start = SEQ_FIRST_OPC, + .tos_opc_end = SEQ_LAST_OPC, + .tos_hs = seq_handlers + }, + { + .tos_opc_start = LFSCK_FIRST_OPC, + .tos_opc_end = LFSCK_LAST_OPC, + .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 + } +}; + +/* 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) +{ + const char *dev = lustre_cfg_string(cfg, 0); + struct ofd_thread_info *info = NULL; + struct obd_device *obd; + struct obd_statfs *osfs; + int rc; + + ENTRY; + + obd = class_name2obd(dev); + if (obd == NULL) { + CERROR("Cannot find obd with name %s\n", dev); + RETURN(-ENODEV); + } + + rc = lu_env_refill((struct lu_env *)env); + if (rc != 0) + RETURN(rc); + + obd->u.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; + ofd_slc_set(m); + m->ofd_grant_compat_disable = 0; + m->ofd_soft_sync_limit = OFD_SOFT_SYNC_LIMIT_DEFAULT; + m->ofd_brw_size = ONE_MB_BRW_SIZE; + + /* 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); + spin_lock_init(&m->ofd_inconsistency_lock); + + spin_lock_init(&m->ofd_batch_lock); + init_rwsem(&m->ofd_lastid_rwsem); + + m->ofd_dt_dev.dd_lu_dev.ld_ops = &ofd_lu_ops; + m->ofd_dt_dev.dd_lu_dev.ld_obd = obd; + /* set this lu_device to obd, because error handling need it */ + obd->obd_lu_dev = &m->ofd_dt_dev.dd_lu_dev; + + rc = ofd_procfs_init(m); + if (rc) { + CERROR("Can't init ofd lprocfs, rc %d\n", rc); + RETURN(rc); + } + + /* No connection accepted until configurations will finish */ + spin_lock(&obd->obd_dev_lock); + obd->obd_no_conn = 1; + spin_unlock(&obd->obd_dev_lock); + obd->obd_replayable = 1; + if (cfg->lcfg_bufcount > 4 && LUSTRE_CFG_BUFLEN(cfg, 4) > 0) { + char *str = lustre_cfg_string(cfg, 4); + + if (strchr(str, 'n')) { + CWARN("%s: recovery disabled\n", obd->obd_name); + obd->obd_replayable = 0; + } + } + + info = ofd_info_init(env, NULL); + if (info == NULL) + GOTO(err_fini_proc, rc = -EFAULT); + + rc = ofd_stack_init(env, m, cfg); + if (rc) { + CERROR("Can't init device stack, rc %d\n", rc); + GOTO(err_fini_proc, rc); + } + + 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)) { @@ -758,14 +2961,6 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, 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); @@ -776,11 +2971,20 @@ 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); + + tgt_adapt_sptlrpc_conf(&m->ofd_lut, 1); + RETURN(0); + +err_fini_fs: + ofd_fs_cleanup(env, m); err_fini_lut: tgt_fini(env, &m->ofd_lut); err_free_ns: - ldlm_namespace_free(m->ofd_namespace, 0, obd->obd_force); + ldlm_namespace_free(m->ofd_namespace, NULL, obd->obd_force); obd->obd_namespace = m->ofd_namespace = NULL; err_fini_stack: ofd_stack_fini(env, m, &m->ofd_osd->dd_lu_dev); @@ -789,36 +2993,60 @@ 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); - struct lu_device *d = &m->ofd_dt_dev.dd_lu_dev; + struct obd_device *obd = ofd_obd(m); + struct lu_device *d = &m->ofd_dt_dev.dd_lu_dev; + struct lfsck_stop stop; - lfsck_stop(env, m->ofd_osd, true); - lfsck_degister(env, m->ofd_osd); + stop.ls_status = LS_PAUSED; + stop.ls_flags = 0; + lfsck_stop(env, m->ofd_osd, &stop); target_recovery_fini(obd); + if (m->ofd_namespace != NULL) + ldlm_namespace_free_prior(m->ofd_namespace, NULL, + d->ld_obd->obd_force); + 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); - cleanup_capa_hash(obd->u.filter.fo_capa_hash); - if (m->ofd_namespace != NULL) { - ldlm_namespace_free(m->ofd_namespace, NULL, - d->ld_obd->obd_force); + ldlm_namespace_free_post(m->ofd_namespace); d->ld_obd->obd_namespace = m->ofd_namespace = NULL; } ofd_stack_fini(env, m, &m->ofd_dt_dev.dd_lu_dev); ofd_procfs_fini(m); - LASSERT(cfs_atomic_read(&d->ld_ref) == 0); - server_put_mount(obd->obd_name, NULL); + LASSERT(atomic_read(&d->ld_ref) == 0); + 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) { @@ -827,6 +3055,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) { @@ -837,6 +3075,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) @@ -860,36 +3111,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_transno = 0; - info->fti_pre_version = 0; - info->fti_obj = NULL; - info->fti_has_trans = 0; - info->fti_mult_trans = 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 = { @@ -911,9 +3133,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); @@ -926,22 +3156,27 @@ int __init ofd_init(void) return(rc); } - lprocfs_ofd_init_vars(&lvars); - - rc = class_register_type(&ofd_obd_ops, NULL, lvars.module_vars, + 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); class_unregister_type(LUSTRE_OST_NAME); } -MODULE_AUTHOR("Whamcloud, Inc. "); +MODULE_AUTHOR("OpenSFS, Inc. "); MODULE_DESCRIPTION("Lustre Object Filtering Device"); +MODULE_VERSION(LUSTRE_VERSION_STRING); MODULE_LICENSE("GPL"); module_init(ofd_init);