X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fobdfilter%2Ffilter.c;h=422db94f179872e7d70fc717c5ad35794f839d4a;hp=9dfef42feaa8b60b0f5aeadf371f6f350c1f6bc1;hb=11c2c0ec77125041e9c8143a80e7e51aede653ea;hpb=65701b4a30efdb695776bcf690a2b3cabc928da1 diff --git a/lustre/obdfilter/filter.c b/lustre/obdfilter/filter.c index 9dfef42..422db94 100644 --- a/lustre/obdfilter/filter.c +++ b/lustre/obdfilter/filter.c @@ -1,6 +1,4 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: - * +/* * GPL HEADER START * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. @@ -53,9 +51,6 @@ #define DEBUG_SUBSYSTEM S_FILTER -#ifndef AUTOCONF_INCLUDED -#include -#endif #include #include #include @@ -137,12 +132,12 @@ int filter_finish_transno(struct obd_export *exp, struct inode *inode, if (!exp->exp_obd->obd_replayable || oti == NULL) RETURN(rc); - cfs_mutex_down(&ted->ted_lcd_lock); + cfs_mutex_lock(&ted->ted_lcd_lock); lcd = ted->ted_lcd; /* if the export has already been disconnected, we have no last_rcvd slot, * update server data with latest transno then */ if (lcd == NULL) { - cfs_mutex_up(&ted->ted_lcd_lock); + cfs_mutex_unlock(&ted->ted_lcd_lock); CWARN("commit transaction for disconnected client %s: rc %d\n", exp->exp_client_uuid.uuid, rc); err = filter_update_server_data(exp->exp_obd); @@ -167,7 +162,7 @@ int filter_finish_transno(struct obd_export *exp, struct inode *inode, exp->exp_vbr_failed = 1; cfs_spin_unlock(&exp->exp_lock); cfs_spin_unlock(&obt->obt_lut->lut_translock); - cfs_mutex_up(&ted->ted_lcd_lock); + cfs_mutex_unlock(&ted->ted_lcd_lock); RETURN(-EOVERFLOW); } } @@ -209,7 +204,7 @@ int filter_finish_transno(struct obd_export *exp, struct inode *inode, CDEBUG(log_pri, "wrote trans "LPU64" for client %s at #%d: err = %d\n", last_rcvd, lcd->lcd_uuid, ted->ted_lr_idx, err); - cfs_mutex_up(&ted->ted_lcd_lock); + cfs_mutex_unlock(&ted->ted_lcd_lock); RETURN(rc); } @@ -354,7 +349,7 @@ static int filter_client_add(struct obd_device *obd, struct obd_export *exp, ted->ted_lr_idx = cl_idx; ted->ted_lr_off = le32_to_cpu(lsd->lsd_client_start) + cl_idx * le16_to_cpu(lsd->lsd_client_size); - cfs_init_mutex(&ted->ted_lcd_lock); + cfs_mutex_init(&ted->ted_lcd_lock); LASSERTF(ted->ted_lr_off > 0, "ted_lr_off = %llu\n", ted->ted_lr_off); CDEBUG(D_INFO, "client at index %d (%llu) with UUID '%s' added\n", @@ -455,12 +450,12 @@ static int filter_client_del(struct obd_export *exp) * be in server data or in client data in case of failure */ filter_update_server_data(exp->exp_obd); - cfs_mutex_down(&ted->ted_lcd_lock); + cfs_mutex_lock(&ted->ted_lcd_lock); memset(ted->ted_lcd->lcd_uuid, 0, sizeof ted->ted_lcd->lcd_uuid); rc = fsfilt_write_record(exp->exp_obd, obt->obt_rcvd_filp, ted->ted_lcd, sizeof(*ted->ted_lcd), &off, 0); - cfs_mutex_up(&ted->ted_lcd_lock); + cfs_mutex_unlock(&ted->ted_lcd_lock); pop_ctxt(&saved, &exp->exp_obd->obd_lvfs_ctxt, NULL); CDEBUG(rc == 0 ? D_INFO : D_ERROR, @@ -1198,14 +1193,14 @@ static int filter_read_groups(struct obd_device *obd, int last_group, struct filter_obd *filter = &obd->u.filter; int old_count, group, rc = 0; - cfs_down(&filter->fo_init_lock); + cfs_mutex_lock(&filter->fo_init_lock); old_count = filter->fo_group_count; for (group = old_count; group <= last_group; group++) { rc = filter_read_group_internal(obd, group, create); if (rc != 0) break; } - cfs_up(&filter->fo_init_lock); + cfs_mutex_unlock(&filter->fo_init_lock); return rc; } @@ -1777,7 +1772,7 @@ static int filter_intent_policy(struct ldlm_namespace *ns, * therefore, that res->lr_lvb_data cannot increase beyond the * end of already granted lock. As a result, it is safe to * check against "stale" reply_lvb->lvb_size value without - * res->lr_lvb_sem. + * res->lr_lvb_mutex. */ arg.size = reply_lvb->lvb_size; arg.victim = &l; @@ -1850,15 +1845,16 @@ static int filter_intent_policy(struct ldlm_namespace *ns, * at the OST layer there are only (potentially) multiple obd_device of type * unknown at the time of OST thread creation. * - * Instead array of iobuf's is attached to struct filter_obd (->fo_iobuf_pool - * field). This array has size OST_MAX_THREADS, so that each OST thread uses - * it's very own iobuf. + * We create a cfs_hash for struct filter_obd (->fo_iobuf_hash field) on + * initializing, each OST thread will create it's own iobuf on the first + * access and insert it into ->fo_iobuf_hash with thread ID as key, + * so the iobuf can be found again by thread ID. * * Functions below * - * filter_kiobuf_pool_init() + * filter_iobuf_pool_init() * - * filter_kiobuf_pool_done() + * filter_iobuf_pool_done() * * filter_iobuf_get() * @@ -1871,21 +1867,13 @@ static int filter_intent_policy(struct ldlm_namespace *ns, */ static void filter_iobuf_pool_done(struct filter_obd *filter) { - struct filter_iobuf **pool; - int i; + ENTRY; - ENTRY; - - pool = filter->fo_iobuf_pool; - if (pool != NULL) { - for (i = 0; i < filter->fo_iobuf_count; ++ i) { - if (pool[i] != NULL) - filter_free_iobuf(pool[i]); - } - OBD_FREE(pool, filter->fo_iobuf_count * sizeof pool[0]); - filter->fo_iobuf_pool = NULL; - } - EXIT; + if (filter->fo_iobuf_hash != NULL) { + cfs_hash_putref(filter->fo_iobuf_hash); + filter->fo_iobuf_hash = NULL; + } + EXIT; } static int filter_adapt_sptlrpc_conf(struct obd_device *obd, int initial) @@ -1912,50 +1900,126 @@ static int filter_adapt_sptlrpc_conf(struct obd_device *obd, int initial) return 0; } -/* - * pre-allocate pool of iobuf's to be used by filter_{prep,commit}rw_write(). - */ -static int filter_iobuf_pool_init(struct filter_obd *filter) +static unsigned +filter_iobuf_hop_hash(cfs_hash_t *hs, const void *key, unsigned mask) { - void **pool; + __u64 val = *((__u64 *)key); - ENTRY; + return cfs_hash_long(val, hs->hs_cur_bits); +} +static void * +filter_iobuf_hop_key(cfs_hlist_node_t *hnode) +{ + struct filter_iobuf *pool; - OBD_ALLOC_GFP(filter->fo_iobuf_pool, OSS_THREADS_MAX * sizeof(*pool), - GFP_KERNEL); - if (filter->fo_iobuf_pool == NULL) - RETURN(-ENOMEM); + pool = cfs_hlist_entry(hnode, struct filter_iobuf, dr_hlist); + return &pool->dr_hkey; +} - filter->fo_iobuf_count = OSS_THREADS_MAX; +static int +filter_iobuf_hop_keycmp(const void *key, cfs_hlist_node_t *hnode) +{ + struct filter_iobuf *pool; - RETURN(0); + pool = cfs_hlist_entry(hnode, struct filter_iobuf, dr_hlist); + return pool->dr_hkey == *((__u64 *)key); } -/* Return iobuf allocated for @thread_id. We don't know in advance how - * many threads there will be so we allocate a large empty array and only - * fill in those slots that are actually in use. - * If we haven't allocated a pool entry for this thread before, do so now. */ -void *filter_iobuf_get(struct filter_obd *filter, struct obd_trans_info *oti) +static void * +filter_iobuf_hop_object(cfs_hlist_node_t *hnode) { - int thread_id = (oti && oti->oti_thread) ? - oti->oti_thread->t_id : -1; - struct filter_iobuf *pool = NULL; - struct filter_iobuf **pool_place = NULL; + return cfs_hlist_entry(hnode, struct filter_iobuf, dr_hlist); +} - if (thread_id >= 0) { - LASSERT(thread_id < filter->fo_iobuf_count); - pool = *(pool_place = &filter->fo_iobuf_pool[thread_id]); - } +static void +filter_iobuf_hop_get(cfs_hash_t *hs, cfs_hlist_node_t *hnode) +{ + /* dummy, required by cfs_hash */ +} - if (unlikely(pool == NULL)) { - pool = filter_alloc_iobuf(filter, OBD_BRW_WRITE, - PTLRPC_MAX_BRW_PAGES); - if (pool_place != NULL) - *pool_place = pool; - } +static void +filter_iobuf_hop_put_locked(cfs_hash_t *hs, cfs_hlist_node_t *hnode) +{ + /* dummy, required by cfs_hash */ +} - return pool; +static void +filter_iobuf_hop_exit(cfs_hash_t *hs, cfs_hlist_node_t *hnode) +{ + struct filter_iobuf *pool; + + pool = cfs_hlist_entry(hnode, struct filter_iobuf, dr_hlist); + filter_free_iobuf(pool); +} + +static struct cfs_hash_ops filter_iobuf_hops = { + .hs_hash = filter_iobuf_hop_hash, + .hs_key = filter_iobuf_hop_key, + .hs_keycmp = filter_iobuf_hop_keycmp, + .hs_object = filter_iobuf_hop_object, + .hs_get = filter_iobuf_hop_get, + .hs_put_locked = filter_iobuf_hop_put_locked, + .hs_exit = filter_iobuf_hop_exit +}; + +#define FILTER_IOBUF_HASH_BITS 9 +#define FILTER_IOBUF_HBKT_BITS 4 + +/* + * pre-allocate pool of iobuf's to be used by filter_{prep,commit}rw_write(). + */ +static int filter_iobuf_pool_init(struct filter_obd *filter) +{ + filter->fo_iobuf_hash = cfs_hash_create("filter_iobuf", + FILTER_IOBUF_HASH_BITS, + FILTER_IOBUF_HASH_BITS, + FILTER_IOBUF_HBKT_BITS, 0, + CFS_HASH_MIN_THETA, + CFS_HASH_MAX_THETA, + &filter_iobuf_hops, + CFS_HASH_RW_BKTLOCK | + CFS_HASH_NO_ITEMREF); + + return filter->fo_iobuf_hash != NULL ? 0 : -ENOMEM; +} + +/* Return iobuf allocated for @thread_id. + * If we haven't allocated a pool entry for this thread before, do so now and + * insert it into fo_iobuf_hash, otherwise we can find it from fo_iobuf_hash */ +void *filter_iobuf_get(struct filter_obd *filter, struct obd_trans_info *oti) +{ + struct filter_iobuf *pool = NULL; + __u64 key = 0; + int thread_id; + int rc; + + thread_id = (oti && oti->oti_thread) ? oti->oti_thread->t_id : -1; + if (thread_id >= 0) { + struct ptlrpc_service_part *svcpt; + + svcpt = oti->oti_thread->t_svcpt; + LASSERT(svcpt != NULL); + + key = (__u64)(svcpt->scp_cpt) << 32 | thread_id; + pool = cfs_hash_lookup(filter->fo_iobuf_hash, &key); + if (pool != NULL) + return pool; + } + + pool = filter_alloc_iobuf(filter, OBD_BRW_WRITE, PTLRPC_MAX_BRW_PAGES); + if (pool == NULL) + return NULL; + + if (thread_id >= 0) { + pool->dr_hkey = key; + rc = cfs_hash_add_unique(filter->fo_iobuf_hash, + &key, &pool->dr_hlist); + /* ptlrpc service thould guarantee thread ID is unique */ + LASSERT(rc != -EALREADY); + } + + return pool; } /* mount the file system (secretly). lustre_cfg parameters are: @@ -1969,6 +2033,7 @@ int filter_common_setup(struct obd_device *obd, struct lustre_cfg* lcfg, { struct filter_obd *filter = &obd->u.filter; struct vfsmount *mnt; + struct file_system_type *type; struct lustre_mount_info *lmi; struct obd_uuid uuid; __u8 *uuid_ptr; @@ -1993,9 +2058,14 @@ int filter_common_setup(struct obd_device *obd, struct lustre_cfg* lcfg, } else { /* old path - used by lctl */ CERROR("Using old MDS mount method\n"); - mnt = ll_kern_mount(lustre_cfg_string(lcfg, 2), - MS_NOATIME|MS_NODIRATIME, - lustre_cfg_string(lcfg, 1), option); + type = get_fs_type(lustre_cfg_string(lcfg, 2)); + if (!type) { + CERROR("get_fs_type failed\n"); + RETURN(-ENODEV); + } + mnt = vfs_kern_mount(type, MS_NOATIME|MS_NODIRATIME, + lustre_cfg_string(lcfg, 1), option); + cfs_module_put(type->owner); if (IS_ERR(mnt)) { rc = PTR_ERR(mnt); LCONSOLE_ERROR_MSG(0x135, "Can't mount disk %s (%d)\n", @@ -2038,7 +2108,9 @@ int filter_common_setup(struct obd_device *obd, struct lustre_cfg* lcfg, filter->fo_fstype = mnt->mnt_sb->s_type->name; CDEBUG(D_SUPER, "%s: mnt = %p\n", filter->fo_fstype, mnt); - fsfilt_setup(obd, obd->u.obt.obt_sb); + rc = fsfilt_setup(obd, obd->u.obt.obt_sb); + if (rc) + GOTO(err_ops, rc); OBD_SET_CTXT_MAGIC(&obd->obd_lvfs_ctxt); obd->obd_lvfs_ctxt.pwdmnt = mnt; @@ -2046,15 +2118,15 @@ int filter_common_setup(struct obd_device *obd, struct lustre_cfg* lcfg, obd->obd_lvfs_ctxt.fs = get_ds(); obd->obd_lvfs_ctxt.cb_ops = filter_lvfs_ops; - cfs_init_mutex(&filter->fo_init_lock); + cfs_mutex_init(&filter->fo_init_lock); filter->fo_committed_group = 0; filter->fo_destroys_in_progress = 0; for (i = 0; i < 32; i++) - cfs_sema_init(&filter->fo_create_locks[i], 1); + cfs_mutex_init(&filter->fo_create_locks[i]); cfs_spin_lock_init(&filter->fo_objidlock); CFS_INIT_LIST_HEAD(&filter->fo_export_list); - cfs_sema_init(&filter->fo_alloc_lock, 1); + cfs_mutex_init(&filter->fo_alloc_lock); init_brw_stats(&filter->fo_filter_stats); cfs_spin_lock_init(&filter->fo_flags_lock); filter->fo_read_cache = 1; /* enable read-only cache by default */ @@ -2218,10 +2290,15 @@ static int filter_setup(struct obd_device *obd, struct lustre_cfg* lcfg) GOTO(free_obd_stats, rc); } + rc = lprocfs_job_stats_init(obd, LPROC_FILTER_STATS_LAST, + filter_stats_counter_init); + if (rc) + GOTO(remove_entry_clear, rc); + /* 2.6.9 selinux wants a full option page for do_kern_mount (bug6471) */ OBD_PAGE_ALLOC(page, CFS_ALLOC_STD); if (!page) - GOTO(remove_entry_clear, rc = -ENOMEM); + GOTO(job_stats_fini, rc = -ENOMEM); addr = (unsigned long)cfs_page_address(page); clear_page((void *)addr); memcpy((void *)addr, lustre_cfg_buf(lcfg, 4), @@ -2231,11 +2308,13 @@ static int filter_setup(struct obd_device *obd, struct lustre_cfg* lcfg) if (rc) { CERROR("%s: filter_common_setup failed: %d.\n", obd->obd_name, rc); - GOTO(remove_entry_clear, rc); + GOTO(job_stats_fini, rc); } RETURN(0); +job_stats_fini: + lprocfs_job_stats_fini(obd); remove_entry_clear: lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry); free_obd_stats: @@ -2395,28 +2474,28 @@ static int filter_llog_finish(struct obd_device *obd, int count) * We actually do sync in disconnect time, but disconnect * may not come being marked rq_no_resend = 1. */ - llog_sync(ctxt, NULL); + llog_sync(ctxt, NULL, OBD_LLOG_FL_EXIT); /* * Balance class_import_get() in llog_receptor_accept(). * This is safe to do, as llog is already synchronized * and its import may go. */ - cfs_mutex_down(&ctxt->loc_sem); + cfs_mutex_lock(&ctxt->loc_mutex); if (ctxt->loc_imp) { class_import_put(ctxt->loc_imp); ctxt->loc_imp = NULL; } - cfs_mutex_up(&ctxt->loc_sem); + + if (filter->fo_lcm) { + llog_recov_thread_fini(filter->fo_lcm, obd->obd_force); + filter->fo_lcm = NULL; + } + + cfs_mutex_unlock(&ctxt->loc_mutex); llog_ctxt_put(ctxt); } - if (filter->fo_lcm) { - cfs_mutex_down(&ctxt->loc_sem); - llog_recov_thread_fini(filter->fo_lcm, obd->obd_force); - filter->fo_lcm = NULL; - cfs_mutex_up(&ctxt->loc_sem); - } RETURN(filter_olg_fini(&obd->obd_olg)); } @@ -2542,9 +2621,9 @@ static int filter_llog_connect(struct obd_export *exp, LASSERTF(ctxt != NULL, "ctxt is not null, ctxt idx %d \n", body->lgdc_ctxt_idx); - CWARN("%s: Recovery from log "LPX64"/"LPX64":%x\n", - obd->obd_name, body->lgdc_logid.lgl_oid, - body->lgdc_logid.lgl_oseq, body->lgdc_logid.lgl_ogen); + CDEBUG(D_HA, "%s: Recovery from log "LPX64"/"LPX64":%x\n", + obd->obd_name, body->lgdc_logid.lgl_oid, + body->lgdc_logid.lgl_oseq, body->lgdc_logid.lgl_ogen); cfs_spin_lock(&obd->u.filter.fo_flags_lock); obd->u.filter.fo_mds_ost_sync = 1; @@ -2612,6 +2691,7 @@ static int filter_precleanup(struct obd_device *obd, obd_zombie_barrier(); rc = filter_llog_preclean(obd); + lprocfs_job_stats_fini(obd); lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry); lprocfs_free_per_client_stats(obd); lprocfs_obd_cleanup(obd); @@ -2687,8 +2767,8 @@ static int filter_connect_internal(struct obd_export *exp, /* Kindly make sure the SKIP_ORPHAN flag is from MDS. */ if (data->ocd_connect_flags & OBD_CONNECT_MDS) - CWARN("%s: Received MDS connection for group %u\n", - exp->exp_obd->obd_name, data->ocd_group); + CDEBUG(D_HA, "%s: Received MDS connection for group %u\n", + exp->exp_obd->obd_name, data->ocd_group); else if (data->ocd_connect_flags & OBD_CONNECT_SKIP_ORPHAN) RETURN(-EPROTO); @@ -2763,11 +2843,9 @@ static int filter_connect_internal(struct obd_export *exp, /* The client set in ocd_cksum_types the checksum types it * supports. We have to mask off the algorithms that we don't * support */ - data->ocd_cksum_types &= cksum_types_supported(); + data->ocd_cksum_types &= cksum_types_supported_server(); - /* 1.6.4- only support CRC32 and didn't set ocd_cksum_types */ - if (unlikely(data->ocd_cksum_types == 0)) - data->ocd_cksum_types = OBD_CKSUM_CRC32; + /* 1.6.4 clients are not supported any more */ CDEBUG(D_RPCTRACE, "%s: cli %s supports cksum type %x, return " "%x\n", exp->exp_obd->obd_name, @@ -3052,7 +3130,7 @@ static void filter_sync_llogs(struct obd_device *obd, struct obd_export *dexp) ctxt = llog_group_get_ctxt(olg_min, LLOG_MDS_OST_REPL_CTXT); if (ctxt) { - err = llog_sync(ctxt, olg_min->olg_exp); + err = llog_sync(ctxt, olg_min->olg_exp, 0); llog_ctxt_put(ctxt); if (err) { CERROR("error flushing logs to MDS: " @@ -3108,7 +3186,7 @@ static void filter_revimp_update(struct obd_export *exp) EXIT; } -static int filter_ping(struct obd_export *exp) +static int filter_ping(const struct lu_env *env, struct obd_export *exp) { filter_fmd_expire(exp); return 0; @@ -3154,10 +3232,12 @@ struct dentry *__filter_oa2dentry(struct obd_device *obd, struct ost_id *ostid, return dchild; } -static int filter_getattr(struct obd_export *exp, struct obd_info *oinfo) +static int filter_getattr(const struct lu_env *env, struct obd_export *exp, + struct obd_info *oinfo) { struct dentry *dentry = NULL; struct obd_device *obd; + __u64 curr_version; int rc = 0; ENTRY; @@ -3178,7 +3258,14 @@ static int filter_getattr(struct obd_export *exp, struct obd_info *oinfo) /* Limit the valid bits in the return data to what we actually use */ oinfo->oi_oa->o_valid = OBD_MD_FLID; - obdo_from_inode(oinfo->oi_oa, dentry->d_inode, NULL, FILTER_VALID_FLAGS); + obdo_from_inode(oinfo->oi_oa, dentry->d_inode, FILTER_VALID_FLAGS); + + /* Store inode version in reply */ + curr_version = fsfilt_get_version(exp->exp_obd, dentry->d_inode); + if ((__s64)curr_version != -EOPNOTSUPP) { + oinfo->oi_oa->o_valid |= OBD_MD_FLDATAVERSION; + oinfo->oi_oa->o_data_version = curr_version; + } f_dput(dentry); RETURN(rc); @@ -3403,8 +3490,8 @@ out_unlock: } /* this is called from filter_truncate() until we have filter_punch() */ -int filter_setattr(struct obd_export *exp, struct obd_info *oinfo, - struct obd_trans_info *oti) +int filter_setattr(const struct lu_env *env, struct obd_export *exp, + struct obd_info *oinfo, struct obd_trans_info *oti) { struct obdo *oa = oinfo->oi_oa; struct lustre_capa *capa = oinfo_capa(oinfo); @@ -3495,9 +3582,11 @@ int filter_setattr(struct obd_export *exp, struct obd_info *oinfo, oa->o_valid = OBD_MD_FLID; /* Quota release need uid/gid info */ - obdo_from_inode(oa, dentry->d_inode, NULL, + obdo_from_inode(oa, dentry->d_inode, FILTER_VALID_FLAGS | OBD_MD_FLUID | OBD_MD_FLGID); + filter_counter_incr(exp, LPROC_FILTER_STATS_SETATTR, + oti ? oti->oti_jobid : NULL, 1); EXIT; out_unlock: f_dput(dentry); @@ -3571,7 +3660,7 @@ static int filter_destroy_precreated(struct obd_export *exp, struct obdo *oa, int skip_orphan; ENTRY; - LASSERT(down_trylock(&filter->fo_create_locks[oa->o_seq]) != 0); + LASSERT_MUTEX_LOCKED(&filter->fo_create_locks[oa->o_seq]); memset(&doa, 0, sizeof(doa)); @@ -3595,7 +3684,7 @@ static int filter_destroy_precreated(struct obd_export *exp, struct obdo *oa, for (id = last; id > oa->o_id; id--) { doa.o_id = id; - rc = filter_destroy(exp, &doa, NULL, NULL, NULL, NULL); + rc = filter_destroy(NULL, exp, &doa, NULL, NULL, NULL, NULL); if (rc && rc != -ENOENT) /* this is pretty fatal... */ CEMERG("error destroying precreate objid "LPU64": %d\n", id, rc); @@ -3653,18 +3742,18 @@ static int filter_handle_precreate(struct obd_export *exp, struct obdo *oa, } /* This causes inflight precreates to abort and drop lock */ cfs_set_bit(group, &filter->fo_destroys_in_progress); - cfs_down(&filter->fo_create_locks[group]); + cfs_mutex_lock(&filter->fo_create_locks[group]); if (!cfs_test_bit(group, &filter->fo_destroys_in_progress)) { CERROR("%s:["LPU64"] destroys_in_progress already cleared\n", exp->exp_obd->obd_name, group); - cfs_up(&filter->fo_create_locks[group]); + cfs_mutex_unlock(&filter->fo_create_locks[group]); RETURN(0); } diff = oa->o_id - last; CDEBUG(D_HA, "filter_last_id() = "LPU64" -> diff = %d\n", last, diff); - if (-diff > OST_MAX_PRECREATE) { + if (-diff > (OST_MAX_PRECREATE * 3) / 2) { CERROR("%s: ignoring bogus orphan destroy request: " "obdid "LPU64" last_id "LPU64"\n", obd->obd_name, oa->o_id, last); @@ -3682,7 +3771,7 @@ static int filter_handle_precreate(struct obd_export *exp, struct obdo *oa, cfs_clear_bit(group, &filter->fo_destroys_in_progress); } } else { - cfs_down(&filter->fo_create_locks[group]); + cfs_mutex_lock(&filter->fo_create_locks[group]); if (oti->oti_conn_cnt < exp->exp_conn_cnt) { CERROR("%s: dropping old precreate request\n", obd->obd_name); @@ -3711,13 +3800,14 @@ static int filter_handle_precreate(struct obd_export *exp, struct obdo *oa, /* else diff == 0 */ GOTO(out, rc = 0); out: - cfs_up(&filter->fo_create_locks[group]); + cfs_mutex_unlock(&filter->fo_create_locks[group]); return rc; } -static int filter_statfs(struct obd_device *obd, struct obd_statfs *osfs, - __u64 max_age, __u32 flags) +static int filter_statfs(const struct lu_env *env, struct obd_export *exp, + struct obd_statfs *osfs, __u64 max_age, __u32 flags) { + struct obd_device *obd = class_exp2obd(exp); struct filter_obd *filter = &obd->u.filter; int blockbits = obd->u.obt.obt_sb->s_blocksize_bits; struct lr_server_data *lsd = class_server_data(obd); @@ -3830,7 +3920,7 @@ static int filter_precreate(struct obd_device *obd, struct obdo *oa, filter = &obd->u.filter; - LASSERT(down_trylock(&filter->fo_create_locks[group]) != 0); + LASSERT_MUTEX_LOCKED(&filter->fo_create_locks[group]); OBD_FAIL_TIMEOUT(OBD_FAIL_TGT_DELAY_PRECREATE, obd_timeout / 2); @@ -3841,7 +3931,7 @@ static int filter_precreate(struct obd_device *obd, struct obdo *oa, OBD_ALLOC(osfs, sizeof(*osfs)); if (osfs == NULL) RETURN(-ENOMEM); - rc = filter_statfs(obd, osfs, + rc = filter_statfs(NULL, obd->obd_self_export, osfs, cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), 0); if (rc == 0 && osfs->os_bavail < (osfs->os_blocks >> 10)) { @@ -4043,8 +4133,9 @@ set_last_id: RETURN(rc); } -int filter_create(struct obd_export *exp, struct obdo *oa, - struct lov_stripe_md **ea, struct obd_trans_info *oti) +int filter_create(const struct lu_env *env, struct obd_export *exp, + struct obdo *oa, struct lov_stripe_md **ea, + struct obd_trans_info *oti) { struct obd_device *obd = exp->exp_obd; struct filter_export_data *fed; @@ -4100,9 +4191,9 @@ int filter_create(struct obd_export *exp, struct obdo *oa, rc = -EINVAL; } else { diff = 1; - cfs_down(&filter->fo_create_locks[oa->o_seq]); + cfs_mutex_lock(&filter->fo_create_locks[oa->o_seq]); rc = filter_precreate(obd, oa, oa->o_seq, &diff); - cfs_up(&filter->fo_create_locks[oa->o_seq]); + cfs_mutex_unlock(&filter->fo_create_locks[oa->o_seq]); } } else { rc = filter_handle_precreate(exp, oa, oa->o_seq, oti); @@ -4123,9 +4214,10 @@ int filter_create(struct obd_export *exp, struct obdo *oa, RETURN(rc); } -int filter_destroy(struct obd_export *exp, struct obdo *oa, - struct lov_stripe_md *md, struct obd_trans_info *oti, - struct obd_export *md_exp, void *capa) +int filter_destroy(const struct lu_env *env, struct obd_export *exp, + struct obdo *oa, struct lov_stripe_md *md, + struct obd_trans_info *oti, struct obd_export *md_exp, + void *capa) { unsigned int qcids[MAXQUOTAS] = {0, 0}; struct obd_device *obd; @@ -4258,7 +4350,7 @@ int filter_destroy(struct obd_export *exp, struct obdo *oa, cleanup_phase = 4; /* fsfilt_commit */ /* Quota release need uid/gid of inode */ - obdo_from_inode(oa, dchild->d_inode, NULL, OBD_MD_FLUID|OBD_MD_FLGID); + obdo_from_inode(oa, dchild->d_inode, OBD_MD_FLUID | OBD_MD_FLGID); filter_fmd_drop(exp, oa->o_id, oa->o_seq); @@ -4319,8 +4411,8 @@ cleanup: } /* NB start and end are used for punch, but not truncate */ -static int filter_truncate(struct obd_export *exp, struct obd_info *oinfo, - struct obd_trans_info *oti, +static int filter_truncate(const struct lu_env *env, struct obd_export *exp, + struct obd_info *oinfo, struct obd_trans_info *oti, struct ptlrpc_request_set *rqset) { int rc; @@ -4337,12 +4429,12 @@ static int filter_truncate(struct obd_export *exp, struct obd_info *oinfo, oinfo->oi_policy.l_extent.start); oinfo->oi_oa->o_size = oinfo->oi_policy.l_extent.start; - rc = filter_setattr(exp, oinfo, oti); + rc = filter_setattr(env, exp, oinfo, oti); RETURN(rc); } -static int filter_sync(struct obd_export *exp, struct obd_info *oinfo, - obd_off start, obd_off end, +static int filter_sync(const struct lu_env *env, struct obd_export *exp, + struct obd_info *oinfo, obd_off start, obd_off end, struct ptlrpc_request_set *set) { struct lvfs_run_ctxt saved; @@ -4390,17 +4482,17 @@ static int filter_sync(struct obd_export *exp, struct obd_info *oinfo, UNLOCK_INODE_MUTEX(dentry->d_inode); oinfo->oi_oa->o_valid = OBD_MD_FLID; - obdo_from_inode(oinfo->oi_oa, dentry->d_inode, NULL, - FILTER_VALID_FLAGS); + obdo_from_inode(oinfo->oi_oa, dentry->d_inode, FILTER_VALID_FLAGS); pop_ctxt(&saved, &exp->exp_obd->obd_lvfs_ctxt, NULL); + filter_counter_incr(exp, LPROC_FILTER_STATS_SYNC, oinfo->oi_jobid, 1); f_dput(dentry); RETURN(rc); } -static int filter_get_info(struct obd_export *exp, __u32 keylen, - void *key, __u32 *vallen, void *val, +static int filter_get_info(const struct lu_env *env, struct obd_export *exp, + __u32 keylen, void *key, __u32 *vallen, void *val, struct lov_stripe_md *lsm) { struct obd_device *obd; @@ -4556,7 +4648,8 @@ out: RETURN(rc); } -static int filter_set_info_async(struct obd_export *exp, __u32 keylen, +static int filter_set_info_async(const struct lu_env *env, + struct obd_export *exp, __u32 keylen, void *key, __u32 vallen, void *val, struct ptlrpc_request_set *set) { @@ -4632,8 +4725,8 @@ int filter_iocontrol(unsigned int cmd, struct obd_export *exp, CDEBUG(D_HA, "syncing ost %s\n", obd->obd_name); rc = fsfilt_sync(obd, obd->u.obt.obt_sb); - lvfs_set_rdonly(obd, obd->u.obt.obt_sb); - RETURN(0); + rc = lvfs_set_rdonly(obd, obd->u.obt.obt_sb); + RETURN(rc); } case OBD_IOC_CATLOGLIST: { @@ -4665,7 +4758,7 @@ int filter_iocontrol(unsigned int cmd, struct obd_export *exp, RETURN(0); } -static int filter_health_check(struct obd_device *obd) +static int filter_health_check(const struct lu_env *env, struct obd_device *obd) { #ifdef USE_HEALTH_CHECK_WRITE struct filter_obd *filter = &obd->u.filter; @@ -4754,7 +4847,6 @@ static struct obd_ops filter_obd_ops = { .o_create = filter_create, .o_setattr = filter_setattr, .o_destroy = filter_destroy, - .o_brw = filter_brw, .o_punch = filter_truncate, .o_sync = filter_sync, .o_preprw = filter_preprw,