X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fofd%2Fofd_dev.c;h=3ffba912f90e4c6a215b4bed3f92a664958c7941;hp=302f4354c4660849ccc1421a5e80f5c4da8f7b11;hb=53d4286bc0f08f4d614c81842fbfdfb6a2f438bd;hpb=b2cb6fd1095f9c483b7bc1ebbbfdaef719aea87c diff --git a/lustre/ofd/ofd_dev.c b/lustre/ofd/ofd_dev.c index 302f435..3ffba91 100644 --- a/lustre/ofd/ofd_dev.c +++ b/lustre/ofd/ofd_dev.c @@ -27,7 +27,7 @@ * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2012, Whamcloud, Inc. + * Copyright (c) 2012, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -44,6 +44,7 @@ #include #include +#include #include "ofd_internal.h" @@ -179,6 +180,12 @@ static void ofd_stack_fini(const struct lu_env *env, struct ofd_device *m, EXIT; } +/* For interoperability, see mdt_interop_param[]. */ +static struct cfg_interop_param ofd_interop_param[] = { + { "ost.quota_type", NULL }, + { NULL } +}; + /* used by MGS to process specific configurations */ static int ofd_process_config(const struct lu_env *env, struct lu_device *d, struct lustre_cfg *cfg) @@ -194,6 +201,38 @@ static int ofd_process_config(const struct lu_env *env, struct lu_device *d, case LCFG_PARAM: { struct lprocfs_static_vars lvars; + /* For interoperability */ + struct cfg_interop_param *ptr = NULL; + struct lustre_cfg *old_cfg = NULL; + char *param = NULL; + + param = lustre_cfg_string(cfg, 1); + if (param == NULL) { + CERROR("param is empty\n"); + rc = -EINVAL; + break; + } + + ptr = class_find_old_param(param, ofd_interop_param); + if (ptr != NULL) { + if (ptr->new_param == NULL) { + rc = 0; + CWARN("For interoperability, skip this %s." + " It is obsolete.\n", ptr->old_param); + break; + } + + CWARN("Found old param %s, changed it to %s.\n", + ptr->old_param, ptr->new_param); + + old_cfg = cfg; + cfg = lustre_cfg_rename(old_cfg, ptr->new_param); + if (IS_ERR(cfg)) { + rc = PTR_ERR(cfg); + break; + } + } + lprocfs_ofd_init_vars(&lvars); rc = class_process_proc_param(PARAM_OST, lvars.obd_vars, cfg, d->ld_obd); @@ -318,6 +357,10 @@ static int ofd_prepare(const struct lu_env *env, struct lu_device *pdev, rc = next->ld_ops->ldo_prepare(env, dev, next); target_recovery_init(&ofd->ofd_lut, ost_handle); + LASSERT(obd->obd_no_conn); + spin_lock(&obd->obd_dev_lock); + obd->obd_no_conn = 0; + spin_unlock(&obd->obd_dev_lock); if (obd->obd_recovering == 0) ofd_postrecov(env, ofd); @@ -384,18 +427,12 @@ static int ofd_procfs_init(struct ofd_device *ofd) lprocfs_counter_init(obd->obd_stats, LPROC_OFD_WRITE_BYTES, LPROCFS_CNTR_AVGMINMAX, "write_bytes", "bytes"); - rc = lproc_ofd_attach_seqstat(obd); - if (rc) { - CERROR("%s: create seqstat failed: %d.\n", obd->obd_name, rc); - GOTO(free_obd_stats, rc); - } - entry = lprocfs_register("exports", obd->obd_proc_entry, NULL, NULL); if (IS_ERR(entry)) { rc = PTR_ERR(entry); CERROR("%s: error %d setting up lprocfs for %s\n", obd->obd_name, rc, "exports"); - GOTO(free_obd_stats, rc); + GOTO(obd_cleanup, rc); } obd->obd_proc_exports_entry = entry; @@ -406,7 +443,7 @@ static int ofd_procfs_init(struct ofd_device *ofd) rc = PTR_ERR(entry); CERROR("%s: add proc entry 'clear' failed: %d.\n", obd->obd_name, rc); - GOTO(free_obd_stats, rc); + GOTO(obd_cleanup, rc); } rc = lprocfs_job_stats_init(obd, LPROC_OFD_STATS_LAST, @@ -416,27 +453,122 @@ static int ofd_procfs_init(struct ofd_device *ofd) RETURN(0); remove_entry_clear: lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry); -free_obd_stats: - lprocfs_free_obd_stats(obd); obd_cleanup: lprocfs_obd_cleanup(obd); + lprocfs_free_obd_stats(obd); + return rc; } -static int ofd_procfs_fini(struct ofd_device *ofd) +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) + return; + + if (lprocfs_srch(osd_dir, "brw_stats") == NULL) + return; + + lprocfs_add_symlink("brw_stats", obd->obd_proc_entry, + "../../%s/%s/brw_stats", + osd_root->name, osd_dir->name); +} + +static void ofd_procfs_fini(struct ofd_device *ofd) { struct obd_device *obd = ofd_obd(ofd); - lprocfs_job_stats_fini(obd); + 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_free_obd_stats(obd); lprocfs_obd_cleanup(obd); - return 0; + lprocfs_free_obd_stats(obd); + lprocfs_job_stats_fini(obd); } extern int ost_handle(struct ptlrpc_request *req); +int ofd_fid_fini(const struct lu_env *env, struct ofd_device *ofd) +{ + return seq_site_fini(env, &ofd->ofd_seq_site); +} + +int ofd_fid_init(const struct lu_env *env, struct ofd_device *ofd) +{ + struct seq_server_site *ss = &ofd->ofd_seq_site; + struct lu_device *lu = &ofd->ofd_dt_dev.dd_lu_dev; + char *obd_name = ofd_name(ofd); + char *name = NULL; + int rc = 0; + + ss = &ofd->ofd_seq_site; + lu->ld_site->ld_seq_site = ss; + ss->ss_lu = lu->ld_site; + ss->ss_node_id = ofd->ofd_lut.lut_lsd.lsd_osd_index; + + OBD_ALLOC_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); + } + + rc = seq_server_init(ss->ss_server_seq, ofd->ofd_osd, obd_name, + LUSTRE_SEQ_SERVER, ss, env); + if (rc) { + CERROR("%s : seq server init error %d\n", obd_name, rc); + GOTO(out_free, 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, -ENOMEM); + + snprintf(name, strlen(obd_name) + 6, "%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); + } + OBD_FREE(name, strlen(obd_name) + 10); + name = NULL; + + rc = seq_server_set_cli(ss->ss_server_seq, ss->ss_client_seq, env); + +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; + } + } + + return rc; +} + static int ofd_init0(const struct lu_env *env, struct ofd_device *m, struct lu_device_type *ldt, struct lustre_cfg *cfg) { @@ -463,27 +595,28 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, m->ofd_fmd_max_num = OFD_FMD_MAX_NUM_DEFAULT; m->ofd_fmd_max_age = OFD_FMD_MAX_AGE_DEFAULT; - cfs_spin_lock_init(&m->ofd_flags_lock); + 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; /* statfs data */ - cfs_spin_lock_init(&m->ofd_osfs_lock); + 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 */ - cfs_spin_lock_init(&m->ofd_grant_lock); + spin_lock_init(&m->ofd_grant_lock); m->ofd_tot_dirty = 0; m->ofd_tot_granted = 0; m->ofd_tot_pending = 0; - m->ofd_max_group = 0; + m->ofd_seq_count = 0; - cfs_rwlock_init(&obd->u.filter.fo_sptlrpc_lock); + spin_lock_init(&m->ofd_batch_lock); + rwlock_init(&obd->u.filter.fo_sptlrpc_lock); sptlrpc_rule_set_init(&obd->u.filter.fo_sptlrpc_rset); obd->u.filter.fo_fl_oss_capa = 0; @@ -504,7 +637,9 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, } /* 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); @@ -525,6 +660,8 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, 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); @@ -537,9 +674,14 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, obd->obd_name, osfs->os_bsize); GOTO(err_fini_stack, rc = -EPROTO); } - m->ofd_blockbits = cfs_fls(osfs->os_bsize) - 1; + m->ofd_blockbits = fls(osfs->os_bsize) - 1; + + m->ofd_precreate_batch = OFD_PRECREATE_BATCH_DEFAULT; + if (osfs->os_bsize * osfs->os_blocks < OFD_PRECREATE_SMALL_FS) + m->ofd_precreate_batch = OFD_PRECREATE_BATCH_SMALL; - snprintf(info->fti_u.name, sizeof(info->fti_u.name), "filter-%p", m); + snprintf(info->fti_u.name, sizeof(info->fti_u.name), "%s-%s", + "filter"/*LUSTRE_OST_NAME*/, obd->obd_uuid.uuid); m->ofd_namespace = ldlm_namespace_new(obd, info->fti_u.name, LDLM_NAMESPACE_SERVER, LDLM_NAMESPACE_GREEDY, @@ -565,7 +707,7 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, m->ofd_grant_ratio = ofd_grant_ratio_conv(m->ofd_dt_conf.ddp_grant_reserved); - rc = lut_init(env, &m->ofd_lut, obd, m->ofd_osd); + rc = tgt_init(env, &m->ofd_lut, obd, m->ofd_osd); if (rc) GOTO(err_free_ns, rc); @@ -575,7 +717,7 @@ static int ofd_init0(const struct lu_env *env, struct ofd_device *m, RETURN(0); err_fini_lut: - lut_fini(env, &m->ofd_lut); + tgt_fini(env, &m->ofd_lut); err_free_ns: ldlm_namespace_free(m->ofd_namespace, 0, obd->obd_force); obd->obd_namespace = m->ofd_namespace = NULL; @@ -595,7 +737,7 @@ static void ofd_fini(const struct lu_env *env, struct ofd_device *m) obd_exports_barrier(obd); obd_zombie_barrier(); - lut_fini(env, &m->ofd_lut); + tgt_fini(env, &m->ofd_lut); ofd_fs_cleanup(env, m); ofd_free_capa_keys(m);