X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Finclude%2Fobd_class.h;h=a9e36ba1c75482755b76855a29d220b5066c7c34;hp=9802e16af3bb782289566612410eee288f9bbfcf;hb=676fff00c079ff7e91b091db76756e36bd29e572;hpb=a0c531776695cf01eb60534672092250d8f8ab0a diff --git a/lustre/include/obd_class.h b/lustre/include/obd_class.h index 9802e16..a9e36ba 100644 --- a/lustre/include/obd_class.h +++ b/lustre/include/obd_class.h @@ -1,28 +1,45 @@ /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- * vim:expandtab:shiftwidth=8:tabstop=8: * - * Copyright (C) 2001-2003 Cluster File Systems, Inc. + * GPL HEADER START * - * This file is part of Lustre, http://www.lustre.org. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * Lustre is free software; you can redistribute it and/or - * modify it under the terms of version 2 of the GNU General Public - * License as published by the Free Software Foundation. + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 only, + * as published by the Free Software Foundation. * - * Lustre is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License version 2 for more details (a copy is included + * in the LICENSE file that accompanied this code). * - * You should have received a copy of the GNU General Public License - * along with Lustre; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * 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. + * + * GPL HEADER END + */ +/* + * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Use is subject to license terms. + */ +/* + * This file is part of Lustre, http://www.lustre.org/ + * Lustre is a trademark of Sun Microsystems, Inc. */ - #ifndef __CLASS_OBD_H #define __CLASS_OBD_H +#ifndef __KERNEL__ +# include +#endif + #include #include #include @@ -49,10 +66,13 @@ extern spinlock_t obd_dev_lock; extern struct obd_device *class_conn2obd(struct lustre_handle *); extern struct obd_device *class_exp2obd(struct obd_export *); +struct lu_device_type; + /* genops.c */ struct obd_export *class_conn2export(struct lustre_handle *); -int class_register_type(struct obd_ops *ops, struct lprocfs_vars *, - const char *nm); +int class_register_type(struct obd_ops *, struct md_ops *, + struct lprocfs_vars *, const char *nm, + struct lu_device_type *ldt); int class_unregister_type(const char *nm); struct obd_device *class_newdev(const char *type_name, const char *name); @@ -66,49 +86,61 @@ void class_obd_list(void); struct obd_device * class_find_client_obd(struct obd_uuid *tgt_uuid, const char * typ_name, struct obd_uuid *grp_uuid); -struct obd_device * class_find_client_notype(struct obd_uuid *tgt_uuid, - struct obd_uuid *grp_uuid); struct obd_device * class_devices_in_group(struct obd_uuid *grp_uuid, int *next); struct obd_device * class_num2obd(int num); -int oig_init(struct obd_io_group **oig); -int oig_add_one(struct obd_io_group *oig, struct oig_callback_context *occ); -void oig_complete_one(struct obd_io_group *oig, - struct oig_callback_context *occ, int rc); -void oig_release(struct obd_io_group *oig); -int oig_wait(struct obd_io_group *oig); +int class_notify_sptlrpc_conf(const char *fsname, int namelen); char *obd_export_nid2str(struct obd_export *exp); -int obd_export_evict_by_nid(struct obd_device *obd, char *nid); -int obd_export_evict_by_uuid(struct obd_device *obd, char *uuid); +int obd_export_evict_by_nid(struct obd_device *obd, const char *nid); +int obd_export_evict_by_uuid(struct obd_device *obd, const char *uuid); + +int obd_zombie_impexp_init(void); +void obd_zombie_impexp_stop(void); +void obd_zombie_impexp_cull(void); +void obd_zombie_barrier(void); +void obd_exports_barrier(struct obd_device *obd); /* obd_config.c */ int class_process_config(struct lustre_cfg *lcfg); -int class_process_proc_param(char *prefix, struct lprocfs_vars *lvars, +int class_process_proc_param(char *prefix, struct lprocfs_vars *lvars, struct lustre_cfg *lcfg, void *data); int class_attach(struct lustre_cfg *lcfg); int class_setup(struct obd_device *obd, struct lustre_cfg *lcfg); int class_cleanup(struct obd_device *obd, struct lustre_cfg *lcfg); int class_detach(struct obd_device *obd, struct lustre_cfg *lcfg); -struct obd_device *class_incref(struct obd_device *obd); -void class_decref(struct obd_device *obd); +struct obd_device *class_incref(struct obd_device *obd, + const char *scope, const void *source); +void class_decref(struct obd_device *obd, + const char *scope, const void *source); +void dump_exports(struct obd_device *obd); + +/*obdecho*/ +#ifdef LPROCFS +extern void lprocfs_echo_init_vars(struct lprocfs_static_vars *lvars); +#else +static inline void lprocfs_echo_init_vars(struct lprocfs_static_vars *lvars) +{ + memset(lvars, 0, sizeof(*lvars)); +} +#endif #define CFG_F_START 0x01 /* Set when we start updating from a log */ #define CFG_F_MARKER 0x02 /* We are within a maker */ #define CFG_F_SKIP 0x04 /* We should ignore this cfg command */ #define CFG_F_COMPAT146 0x08 /* Allow old-style logs */ #define CFG_F_EXCLUDE 0x10 /* OST exclusion list */ -#define CFG_F_SERVER146 0x20 /* Using old server */ /* Passed as data param to class_config_parse_llog */ struct config_llog_instance { char * cfg_instance; + char * cfg_obdname; struct super_block *cfg_sb; struct obd_uuid cfg_uuid; int cfg_last_idx; /* for partial llog processing */ - int cfg_flags; + int cfg_flags; }; int class_config_parse_llog(struct llog_ctxt *ctxt, char *name, struct config_llog_instance *cfg); @@ -122,20 +154,22 @@ struct config_llog_data { struct config_llog_instance cld_cfg; struct list_head cld_list_chain; atomic_t cld_refcount; + struct config_llog_data *cld_sptlrpc;/* depended sptlrpc log */ struct obd_export *cld_mgcexp; - unsigned int cld_stopping:1; /* we were told to stop watching */ - unsigned int cld_lostlock:1; /* lock not requeued */ + unsigned int cld_stopping:1, /* we were told to stop watching */ + cld_lostlock:1, /* lock not requeued */ + cld_is_sptlrpc:1; }; struct lustre_profile { struct list_head lp_list; - char * lp_profile; - char * lp_osc; - char * lp_mdc; + char *lp_profile; + char *lp_dt; + char *lp_md; }; -struct lustre_profile *class_get_profile(char * prof); -void class_del_profile(char *prof); +struct lustre_profile *class_get_profile(const char * prof); +void class_del_profile(const char *prof); void class_del_profiles(void); #define class_export_rpc_get(exp) \ @@ -155,26 +189,8 @@ void class_del_profiles(void); }) /* genops.c */ -#define class_export_get(exp) \ -({ \ - struct obd_export *exp_ = exp; \ - atomic_inc(&exp_->exp_refcount); \ - CDEBUG(D_INFO, "GETting export %p : new refcount %d\n", exp_, \ - atomic_read(&exp_->exp_refcount)); \ - exp_; \ -}) - -#define class_export_put(exp) \ -do { \ - LASSERT((exp) != NULL); \ - CDEBUG(D_INFO, "PUTting export %p : new refcount %d\n", (exp), \ - atomic_read(&(exp)->exp_refcount) - 1); \ - LASSERT(atomic_read(&(exp)->exp_refcount) > 0); \ - LASSERT(atomic_read(&(exp)->exp_refcount) < 0x5a5a5a); \ - __class_export_put(exp); \ -} while (0) - -void __class_export_put(struct obd_export *); +struct obd_export *class_export_get(struct obd_export *exp); +void class_export_put(struct obd_export *exp); struct obd_export *class_new_export(struct obd_device *obddev, struct obd_uuid *cluuid); void class_unlink_export(struct obd_export *exp); @@ -192,16 +208,29 @@ int class_connect(struct lustre_handle *conn, struct obd_device *obd, int class_disconnect(struct obd_export *exp); void class_fail_export(struct obd_export *exp); void class_disconnect_exports(struct obd_device *obddev); -void class_disconnect_stale_exports(struct obd_device *obddev); int class_manual_cleanup(struct obd_device *obd); +void class_disconnect_stale_exports(struct obd_device *, + int (*test_export)(struct obd_export *)); +static inline enum obd_option exp_flags_from_obd(struct obd_device *obd) +{ + return ((obd->obd_fail ? OBD_OPT_FAILOVER : 0) | + (obd->obd_force ? OBD_OPT_FORCE : 0) | + (obd->obd_abort_recovery ? OBD_OPT_ABORT_RECOV : 0) | + 0); +} -/* obdo.c */ void obdo_cpy_md(struct obdo *dst, struct obdo *src, obd_flag valid); void obdo_to_ioobj(struct obdo *oa, struct obd_ioobj *ioobj); - +void obdo_from_iattr(struct obdo *oa, struct iattr *attr, + unsigned int ia_valid); +void iattr_from_obdo(struct iattr *attr, struct obdo *oa, obd_flag valid); +void md_from_obdo(struct md_op_data *op_data, struct obdo *oa, obd_flag valid); +void obdo_from_md(struct obdo *oa, struct md_op_data *op_data, + unsigned int valid); #define OBT(dev) (dev)->obd_type -#define OBP(dev, op) (dev)->obd_type->typ_ops->o_ ## op +#define OBP(dev, op) (dev)->obd_type->typ_dt_ops->o_ ## op +#define MDP(dev, op) (dev)->obd_type->typ_md_ops->m_ ## op #define CTXTP(ctxt, op) (ctxt)->loc_logops->lop_##op /* Ensure obd_setup: used for cleanup which must be called @@ -248,28 +277,57 @@ do { \ OBD_COUNTER_OFFSET(op); \ LASSERT(coffset < (export)->exp_obd->obd_stats->ls_num); \ lprocfs_counter_incr((export)->exp_obd->obd_stats, coffset); \ - if ((export)->exp_ops_stats != NULL) \ + if ((export)->exp_nid_stats != NULL && \ + (export)->exp_nid_stats->nid_stats != NULL) \ + lprocfs_counter_incr( \ + (export)->exp_nid_stats->nid_stats, coffset);\ + } + +#define MD_COUNTER_OFFSET(op) \ + ((offsetof(struct md_ops, m_ ## op) - \ + offsetof(struct md_ops, m_getstatus)) \ + / sizeof(((struct md_ops *)(0))->m_getstatus)) + +#define MD_COUNTER_INCREMENT(obdx, op) \ + if ((obd)->md_stats != NULL) { \ + unsigned int coffset; \ + coffset = (unsigned int)((obdx)->md_cntr_base) + \ + MD_COUNTER_OFFSET(op); \ + LASSERT(coffset < (obdx)->md_stats->ls_num); \ + lprocfs_counter_incr((obdx)->md_stats, coffset); \ + } + +#define EXP_MD_COUNTER_INCREMENT(export, op) \ + if ((export)->exp_obd->obd_stats != NULL) { \ + unsigned int coffset; \ + coffset = (unsigned int)((export)->exp_obd->md_cntr_base) + \ + MD_COUNTER_OFFSET(op); \ + LASSERT(coffset < (export)->exp_obd->md_stats->ls_num); \ + lprocfs_counter_incr((export)->exp_obd->md_stats, coffset); \ + if ((export)->exp_md_stats != NULL) \ lprocfs_counter_incr( \ - (export)->exp_ops_stats, coffset); \ + (export)->exp_md_stats, coffset); \ } #else #define OBD_COUNTER_OFFSET(op) #define OBD_COUNTER_INCREMENT(obd, op) -#define EXP_COUNTER_INCREMENT(exp, op); +#define EXP_COUNTER_INCREMENT(exp, op) +#define MD_COUNTER_INCREMENT(obd, op) +#define EXP_MD_COUNTER_INCREMENT(exp, op) #endif -#define OBD_CHECK_OP(obd, op, err) \ +#define OBD_CHECK_MD_OP(obd, op, err) \ do { \ - if (!OBT(obd) || !OBP((obd), op)) {\ + if (!OBT(obd) || !MDP((obd), op)) { \ if (err) \ - CERROR("obd_" #op ": dev %d no operation\n", \ - obd->obd_minor); \ + CERROR("md_" #op ": dev %s/%d no operation\n", \ + obd->obd_name, obd->obd_minor); \ RETURN(err); \ } \ } while (0) -#define EXP_CHECK_OP(exp, op) \ +#define EXP_CHECK_MD_OP(exp, op) \ do { \ if ((exp) == NULL) { \ CERROR("obd_" #op ": NULL export\n"); \ @@ -279,38 +337,68 @@ do { \ CERROR("obd_" #op ": cleaned up obd\n"); \ RETURN(-EOPNOTSUPP); \ } \ - if (!OBT((exp)->exp_obd) || !OBP((exp)->exp_obd, op)) { \ - CERROR("obd_" #op ": dev %d no operation\n", \ + if (!OBT((exp)->exp_obd) || !MDP((exp)->exp_obd, op)) { \ + CERROR("obd_" #op ": dev %s/%d no operation\n", \ + (exp)->exp_obd->obd_name, \ (exp)->exp_obd->obd_minor); \ RETURN(-EOPNOTSUPP); \ } \ } while (0) -#define CTXT_CHECK_OP(ctxt, op, err) \ + +#define OBD_CHECK_DT_OP(obd, op, err) \ do { \ - if (!OBT(ctxt->loc_obd) || !CTXTP((ctxt), op)) { \ + if (!OBT(obd) || !OBP((obd), op)) { \ if (err) \ - CERROR("lop_" #op ": dev %d no operation\n", \ - ctxt->loc_obd->obd_minor); \ + CERROR("obd_" #op ": dev %d no operation\n", \ + obd->obd_minor); \ RETURN(err); \ } \ } while (0) +#define EXP_CHECK_DT_OP(exp, op) \ +do { \ + if ((exp) == NULL) { \ + CERROR("obd_" #op ": NULL export\n"); \ + RETURN(-ENODEV); \ + } \ + if ((exp)->exp_obd == NULL || !OBT((exp)->exp_obd)) { \ + CERROR("obd_" #op ": cleaned up obd\n"); \ + RETURN(-EOPNOTSUPP); \ + } \ + if (!OBT((exp)->exp_obd) || !OBP((exp)->exp_obd, op)) { \ + CERROR("obd_" #op ": dev %d no operation\n", \ + (exp)->exp_obd->obd_minor); \ + RETURN(-EOPNOTSUPP); \ + } \ +} while (0) + +#define CTXT_CHECK_OP(ctxt, op, err) \ +do { \ + if (!OBT(ctxt->loc_obd) || !CTXTP((ctxt), op)) { \ + if (err) \ + CERROR("lop_" #op ": dev %d no operation\n", \ + ctxt->loc_obd->obd_minor); \ + RETURN(err); \ + } \ +} while (0) + static inline int class_devno_max(void) { return MAX_OBD_DEVICES; } static inline int obd_get_info(struct obd_export *exp, __u32 keylen, - void *key, __u32 *vallen, void *val) + void *key, __u32 *vallen, void *val, + struct lov_stripe_md *lsm) { int rc; ENTRY; - EXP_CHECK_OP(exp, get_info); + EXP_CHECK_DT_OP(exp, get_info); EXP_COUNTER_INCREMENT(exp, get_info); - rc = OBP(exp->exp_obd, get_info)(exp, keylen, key, vallen, val); + rc = OBP(exp->exp_obd, get_info)(exp, keylen, key, vallen, val, lsm); RETURN(rc); } @@ -321,33 +409,95 @@ static inline int obd_set_info_async(struct obd_export *exp, obd_count keylen, int rc; ENTRY; - EXP_CHECK_OP(exp, set_info_async); + EXP_CHECK_DT_OP(exp, set_info_async); EXP_COUNTER_INCREMENT(exp, set_info_async); - rc = OBP(exp->exp_obd, set_info_async)(exp, keylen, key, vallen, val, + rc = OBP(exp->exp_obd, set_info_async)(exp, keylen, key, vallen, val, set); RETURN(rc); } -static inline int obd_setup(struct obd_device *obd, int datalen, void *data) +/* + * obd-lu integration. + * + * Functionality is being moved into new lu_device-based layering, but some + * pieces of configuration process are still based on obd devices. + * + * Specifically, lu_device_type_operations::ldto_device_alloc() methods fully + * subsume ->o_setup() methods of obd devices they replace. The same for + * lu_device_operations::ldo_process_config() and ->o_process_config(). As a + * result, obd_setup() and obd_process_config() branch and call one XOR + * another. + * + * Yet neither lu_device_type_operations::ldto_device_fini() nor + * lu_device_type_operations::ldto_device_free() fully implement the + * functionality of ->o_precleanup() and ->o_cleanup() they override. Hence, + * obd_precleanup() and obd_cleanup() call both lu_device and obd operations. + */ + +#define DECLARE_LU_VARS(ldt, d) \ + struct lu_device_type *ldt; \ + struct lu_device *d + +static inline int obd_setup(struct obd_device *obd, struct lustre_cfg *cfg) { int rc; + DECLARE_LU_VARS(ldt, d); ENTRY; - OBD_CHECK_OP(obd, setup, -EOPNOTSUPP); - OBD_COUNTER_INCREMENT(obd, setup); + ldt = obd->obd_type->typ_lu; + if (ldt != NULL) { + struct lu_context session_ctx; + struct lu_env env; + lu_context_init(&session_ctx, LCT_SESSION); + session_ctx.lc_thread = NULL; + lu_context_enter(&session_ctx); + + rc = lu_env_init(&env, ldt->ldt_ctx_tags); + if (rc == 0) { + env.le_ses = &session_ctx; + d = ldt->ldt_ops->ldto_device_alloc(&env, ldt, cfg); + lu_env_fini(&env); + if (!IS_ERR(d)) { + obd->obd_lu_dev = d; + d->ld_obd = obd; + rc = 0; + } else + rc = PTR_ERR(d); + } + lu_context_exit(&session_ctx); + lu_context_fini(&session_ctx); - rc = OBP(obd, setup)(obd, datalen, data); + } else { + OBD_CHECK_DT_OP(obd, setup, -EOPNOTSUPP); + OBD_COUNTER_INCREMENT(obd, setup); + rc = OBP(obd, setup)(obd, cfg); + } RETURN(rc); } -static inline int obd_precleanup(struct obd_device *obd, +static inline int obd_precleanup(struct obd_device *obd, enum obd_cleanup_stage cleanup_stage) { int rc; + DECLARE_LU_VARS(ldt, d); ENTRY; - OBD_CHECK_OP(obd, precleanup, 0); + OBD_CHECK_DEV(obd); + ldt = obd->obd_type->typ_lu; + d = obd->obd_lu_dev; + if (ldt != NULL && d != NULL) { + if (cleanup_stage == OBD_CLEANUP_EXPORTS) { + struct lu_env env; + + rc = lu_env_init(&env, ldt->ldt_ctx_tags); + if (rc == 0) { + ldt->ldt_ops->ldto_device_fini(&env, d); + lu_env_fini(&env); + } + } + } + OBD_CHECK_DT_OP(obd, precleanup, 0); OBD_COUNTER_INCREMENT(obd, precleanup); rc = OBP(obd, precleanup)(obd, cleanup_stage); @@ -357,10 +507,24 @@ static inline int obd_precleanup(struct obd_device *obd, static inline int obd_cleanup(struct obd_device *obd) { int rc; + DECLARE_LU_VARS(ldt, d); ENTRY; OBD_CHECK_DEV(obd); - OBD_CHECK_OP(obd, cleanup, 0); + + ldt = obd->obd_type->typ_lu; + d = obd->obd_lu_dev; + if (ldt != NULL && d != NULL) { + struct lu_env env; + + rc = lu_env_init(&env, ldt->ldt_ctx_tags); + if (rc == 0) { + ldt->ldt_ops->ldto_device_free(&env, d); + lu_env_fini(&env); + obd->obd_lu_dev = NULL; + } + } + OBD_CHECK_DT_OP(obd, cleanup, 0); OBD_COUNTER_INCREMENT(obd, cleanup); rc = OBP(obd, cleanup)(obd); @@ -371,12 +535,29 @@ static inline int obd_process_config(struct obd_device *obd, int datalen, void *data) { int rc; + DECLARE_LU_VARS(ldt, d); ENTRY; - OBD_CHECK_OP(obd, process_config, -EOPNOTSUPP); + OBD_CHECK_DEV(obd); + + obd->obd_process_conf = 1; + ldt = obd->obd_type->typ_lu; + d = obd->obd_lu_dev; + if (ldt != NULL && d != NULL) { + struct lu_env env; + + rc = lu_env_init(&env, ldt->ldt_ctx_tags); + if (rc == 0) { + rc = d->ld_ops->ldo_process_config(&env, d, data); + lu_env_fini(&env); + } + } else { + OBD_CHECK_DT_OP(obd, process_config, -EOPNOTSUPP); + rc = OBP(obd, process_config)(obd, datalen, data); + } OBD_COUNTER_INCREMENT(obd, process_config); + obd->obd_process_conf = 0; - rc = OBP(obd, process_config)(obd, datalen, data); RETURN(rc); } @@ -394,7 +575,7 @@ static inline int obd_packmd(struct obd_export *exp, int rc; ENTRY; - EXP_CHECK_OP(exp, packmd); + EXP_CHECK_DT_OP(exp, packmd); EXP_COUNTER_INCREMENT(exp, packmd); rc = OBP(exp->exp_obd, packmd)(exp, disk_tgt, mem_src); @@ -439,7 +620,7 @@ static inline int obd_unpackmd(struct obd_export *exp, int rc; ENTRY; - EXP_CHECK_OP(exp, unpackmd); + EXP_CHECK_DT_OP(exp, unpackmd); EXP_COUNTER_INCREMENT(exp, unpackmd); rc = OBP(exp->exp_obd, unpackmd)(exp, mem_tgt, disk_src, disk_len); @@ -458,9 +639,13 @@ static inline int obd_alloc_memmd(struct obd_export *exp, static inline int obd_free_memmd(struct obd_export *exp, struct lov_stripe_md **mem_tgt) { + int rc; + LASSERT(mem_tgt); LASSERT(*mem_tgt); - return obd_unpackmd(exp, mem_tgt, NULL, 0); + rc = obd_unpackmd(exp, mem_tgt, NULL, 0); + *mem_tgt = NULL; + return rc; } static inline int obd_checkmd(struct obd_export *exp, @@ -470,13 +655,40 @@ static inline int obd_checkmd(struct obd_export *exp, int rc; ENTRY; - EXP_CHECK_OP(exp, checkmd); + EXP_CHECK_DT_OP(exp, checkmd); EXP_COUNTER_INCREMENT(exp, checkmd); rc = OBP(exp->exp_obd, checkmd)(exp, md_exp, mem_tgt); RETURN(rc); } +static inline int obd_precreate(struct obd_export *exp) +{ + int rc; + ENTRY; + + EXP_CHECK_DT_OP(exp, precreate); + OBD_COUNTER_INCREMENT(exp->exp_obd, precreate); + + rc = OBP(exp->exp_obd, precreate)(exp); + RETURN(rc); +} + +static inline int obd_create_async(struct obd_export *exp, + struct obd_info *oinfo, + struct lov_stripe_md **ea, + struct obd_trans_info *oti) +{ + int rc; + ENTRY; + + EXP_CHECK_DT_OP(exp, create_async); + EXP_COUNTER_INCREMENT(exp, create_async); + + rc = OBP(exp->exp_obd, create_async)(exp, oinfo, ea, oti); + RETURN(rc); +} + static inline int obd_create(struct obd_export *exp, struct obdo *obdo, struct lov_stripe_md **ea, struct obd_trans_info *oti) @@ -484,7 +696,7 @@ static inline int obd_create(struct obd_export *exp, struct obdo *obdo, int rc; ENTRY; - EXP_CHECK_OP(exp, create); + EXP_CHECK_DT_OP(exp, create); EXP_COUNTER_INCREMENT(exp, create); rc = OBP(exp->exp_obd, create)(exp, obdo, ea, oti); @@ -494,15 +706,15 @@ static inline int obd_create(struct obd_export *exp, struct obdo *obdo, static inline int obd_destroy(struct obd_export *exp, struct obdo *obdo, struct lov_stripe_md *ea, struct obd_trans_info *oti, - struct obd_export *md_exp) + struct obd_export *md_exp, void *capa) { int rc; ENTRY; - EXP_CHECK_OP(exp, destroy); + EXP_CHECK_DT_OP(exp, destroy); EXP_COUNTER_INCREMENT(exp, destroy); - rc = OBP(exp->exp_obd, destroy)(exp, obdo, ea, oti, md_exp); + rc = OBP(exp->exp_obd, destroy)(exp, obdo, ea, oti, md_exp, capa); RETURN(rc); } @@ -511,7 +723,7 @@ static inline int obd_getattr(struct obd_export *exp, struct obd_info *oinfo) int rc; ENTRY; - EXP_CHECK_OP(exp, getattr); + EXP_CHECK_DT_OP(exp, getattr); EXP_COUNTER_INCREMENT(exp, getattr); rc = OBP(exp->exp_obd, getattr)(exp, oinfo); @@ -525,7 +737,7 @@ static inline int obd_getattr_async(struct obd_export *exp, int rc; ENTRY; - EXP_CHECK_OP(exp, getattr_async); + EXP_CHECK_DT_OP(exp, getattr_async); EXP_COUNTER_INCREMENT(exp, getattr_async); rc = OBP(exp->exp_obd, getattr_async)(exp, oinfo, set); @@ -538,7 +750,7 @@ static inline int obd_setattr(struct obd_export *exp, struct obd_info *oinfo, int rc; ENTRY; - EXP_CHECK_OP(exp, setattr); + EXP_CHECK_DT_OP(exp, setattr); EXP_COUNTER_INCREMENT(exp, setattr); rc = OBP(exp->exp_obd, setattr)(exp, oinfo, oti); @@ -554,7 +766,7 @@ static inline int obd_setattr_rqset(struct obd_export *exp, int rc; ENTRY; - EXP_CHECK_OP(exp, setattr_async); + EXP_CHECK_DT_OP(exp, setattr_async); EXP_COUNTER_INCREMENT(exp, setattr_async); set = ptlrpc_prep_set(); @@ -578,7 +790,7 @@ static inline int obd_setattr_async(struct obd_export *exp, int rc; ENTRY; - EXP_CHECK_OP(exp, setattr_async); + EXP_CHECK_DT_OP(exp, setattr_async); EXP_COUNTER_INCREMENT(exp, setattr_async); rc = OBP(exp->exp_obd, setattr_async)(exp, oinfo, oti, set); @@ -593,7 +805,7 @@ static inline int obd_add_conn(struct obd_import *imp, struct obd_uuid *uuid, ENTRY; OBD_CHECK_DEV_ACTIVE(obd); - OBD_CHECK_OP(obd, add_conn, -EOPNOTSUPP); + OBD_CHECK_DT_OP(obd, add_conn, -EOPNOTSUPP); OBD_COUNTER_INCREMENT(obd, add_conn); rc = OBP(obd, add_conn)(imp, uuid, priority); @@ -607,46 +819,65 @@ static inline int obd_del_conn(struct obd_import *imp, struct obd_uuid *uuid) ENTRY; OBD_CHECK_DEV_ACTIVE(obd); - OBD_CHECK_OP(obd, del_conn, -EOPNOTSUPP); + OBD_CHECK_DT_OP(obd, del_conn, -EOPNOTSUPP); OBD_COUNTER_INCREMENT(obd, del_conn); rc = OBP(obd, del_conn)(imp, uuid); RETURN(rc); } -static inline int obd_connect(struct lustre_handle *conn,struct obd_device *obd, +static inline struct obd_uuid *obd_get_uuid(struct obd_export *exp) +{ + struct obd_uuid *uuid; + ENTRY; + + OBD_CHECK_DT_OP(exp->exp_obd, get_uuid, NULL); + EXP_COUNTER_INCREMENT(exp, get_uuid); + + uuid = OBP(exp->exp_obd, get_uuid)(exp); + RETURN(uuid); +} + +static inline int obd_connect(const struct lu_env *env, + struct obd_export **exp,struct obd_device *obd, struct obd_uuid *cluuid, - struct obd_connect_data *d) + struct obd_connect_data *d, + void *localdata) { int rc; - __u64 ocf = d ? d->ocd_connect_flags : 0; /* for post-condition check */ + __u64 ocf = d ? d->ocd_connect_flags : 0; /* for post-condition + * check */ ENTRY; OBD_CHECK_DEV_ACTIVE(obd); - OBD_CHECK_OP(obd, connect, -EOPNOTSUPP); + OBD_CHECK_DT_OP(obd, connect, -EOPNOTSUPP); OBD_COUNTER_INCREMENT(obd, connect); - rc = OBP(obd, connect)(conn, obd, cluuid, d); + rc = OBP(obd, connect)(env, exp, obd, cluuid, d, localdata); /* check that only subset is granted */ LASSERT(ergo(d != NULL, (d->ocd_connect_flags & ocf) == d->ocd_connect_flags)); RETURN(rc); } -static inline int obd_reconnect(struct obd_export *exp, +static inline int obd_reconnect(const struct lu_env *env, + struct obd_export *exp, struct obd_device *obd, struct obd_uuid *cluuid, - struct obd_connect_data *d) + struct obd_connect_data *d, + void *localdata) { int rc; - __u64 ocf = d ? d->ocd_connect_flags : 0; /* for post-condition check */ + __u64 ocf = d ? d->ocd_connect_flags : 0; /* for post-condition + * check */ + ENTRY; OBD_CHECK_DEV_ACTIVE(obd); - OBD_CHECK_OP(obd, reconnect, 0); + OBD_CHECK_DT_OP(obd, reconnect, 0); OBD_COUNTER_INCREMENT(obd, reconnect); - rc = OBP(obd, reconnect)(exp, obd, cluuid, d); + rc = OBP(obd, reconnect)(env, exp, obd, cluuid, d, localdata); /* check that only subset is granted */ LASSERT(ergo(d != NULL, (d->ocd_connect_flags & ocf) == d->ocd_connect_flags)); @@ -658,25 +889,144 @@ static inline int obd_disconnect(struct obd_export *exp) int rc; ENTRY; - EXP_CHECK_OP(exp, disconnect); + EXP_CHECK_DT_OP(exp, disconnect); EXP_COUNTER_INCREMENT(exp, disconnect); rc = OBP(exp->exp_obd, disconnect)(exp); RETURN(rc); } +static inline int obd_fid_init(struct obd_export *exp) +{ + int rc; + ENTRY; + + OBD_CHECK_DT_OP(exp->exp_obd, fid_init, 0); + EXP_COUNTER_INCREMENT(exp, fid_init); + + rc = OBP(exp->exp_obd, fid_init)(exp); + RETURN(rc); +} + +static inline int obd_fid_fini(struct obd_export *exp) +{ + int rc; + ENTRY; + + OBD_CHECK_DT_OP(exp->exp_obd, fid_fini, 0); + EXP_COUNTER_INCREMENT(exp, fid_fini); + + rc = OBP(exp->exp_obd, fid_fini)(exp); + RETURN(rc); +} + +static inline int obd_fid_alloc(struct obd_export *exp, + struct lu_fid *fid, + struct md_op_data *op_data) +{ + int rc; + ENTRY; + + EXP_CHECK_DT_OP(exp, fid_alloc); + EXP_COUNTER_INCREMENT(exp, fid_alloc); + + rc = OBP(exp->exp_obd, fid_alloc)(exp, fid, op_data); + RETURN(rc); +} + +static inline int obd_fid_delete(struct obd_export *exp, + const struct lu_fid *fid) +{ + int rc; + ENTRY; + + EXP_CHECK_DT_OP(exp, fid_delete); + EXP_COUNTER_INCREMENT(exp, fid_delete); + + rc = OBP(exp->exp_obd, fid_delete)(exp, fid); + RETURN(rc); +} + static inline int obd_ping(struct obd_export *exp) { int rc; ENTRY; - OBD_CHECK_OP(exp->exp_obd, ping, 0); + OBD_CHECK_DT_OP(exp->exp_obd, ping, 0); EXP_COUNTER_INCREMENT(exp, ping); rc = OBP(exp->exp_obd, ping)(exp); RETURN(rc); } +static inline int obd_pool_new(struct obd_device *obd, char *poolname) +{ + int rc; + ENTRY; + + OBD_CHECK_DT_OP(obd, pool_new, -EOPNOTSUPP); + OBD_COUNTER_INCREMENT(obd, pool_new); + + rc = OBP(obd, pool_new)(obd, poolname); + RETURN(rc); +} + +static inline int obd_pool_del(struct obd_device *obd, char *poolname) +{ + int rc; + ENTRY; + + OBD_CHECK_DT_OP(obd, pool_del, -EOPNOTSUPP); + OBD_COUNTER_INCREMENT(obd, pool_del); + + rc = OBP(obd, pool_del)(obd, poolname); + RETURN(rc); +} + +static inline int obd_pool_add(struct obd_device *obd, char *poolname, char *ostname) +{ + int rc; + ENTRY; + + OBD_CHECK_DT_OP(obd, pool_add, -EOPNOTSUPP); + OBD_COUNTER_INCREMENT(obd, pool_add); + + rc = OBP(obd, pool_add)(obd, poolname, ostname); + RETURN(rc); +} + +static inline int obd_pool_rem(struct obd_device *obd, char *poolname, char *ostname) +{ + int rc; + ENTRY; + + OBD_CHECK_DT_OP(obd, pool_rem, -EOPNOTSUPP); + OBD_COUNTER_INCREMENT(obd, pool_rem); + + rc = OBP(obd, pool_rem)(obd, poolname, ostname); + RETURN(rc); +} + +static inline void obd_getref(struct obd_device *obd) +{ + ENTRY; + if (OBT(obd) && OBP(obd, getref)) { + OBD_COUNTER_INCREMENT(obd, getref); + OBP(obd, getref)(obd); + } + EXIT; +} + +static inline void obd_putref(struct obd_device *obd) +{ + ENTRY; + if (OBT(obd) && OBP(obd, putref)) { + OBD_COUNTER_INCREMENT(obd, putref); + OBP(obd, putref)(obd); + } + EXIT; +} + static inline int obd_init_export(struct obd_export *exp) { int rc = 0; @@ -703,7 +1053,7 @@ static inline int obd_extent_calc(struct obd_export *exp, { int rc; ENTRY; - EXP_CHECK_OP(exp, extent_calc); + EXP_CHECK_DT_OP(exp, extent_calc); rc = OBP(exp->exp_obd, extent_calc)(exp, md, cmd, offset); RETURN(rc); } @@ -717,6 +1067,18 @@ obd_lvfs_fid2dentry(struct obd_export *exp, __u64 id_ino, __u32 gen, __u64 gr) exp->exp_obd); } +static inline int +obd_lvfs_open_llog(struct obd_export *exp, __u64 id_ino, struct dentry *dentry) +{ + LASSERT(exp->exp_obd); + CERROR("FIXME what's the story here? This needs to be an obd fn?\n"); +#if 0 + return lvfs_open_llog(&exp->exp_obd->obd_lvfs_ctxt, id_ino, + dentry, exp->exp_obd); +#endif + return 0; +} + #ifndef time_before #define time_before(t1, t2) ((long)t2 - (long)t1 > 0) #endif @@ -735,7 +1097,7 @@ static inline int obd_statfs_async(struct obd_device *obd, if (obd == NULL) RETURN(-EINVAL); - OBD_CHECK_OP(obd, statfs, -EOPNOTSUPP); + OBD_CHECK_DT_OP(obd, statfs, -EOPNOTSUPP); OBD_COUNTER_INCREMENT(obd, statfs); CDEBUG(D_SUPER, "%s: osfs %p age "LPU64", max_age "LPU64"\n", @@ -751,6 +1113,7 @@ static inline int obd_statfs_async(struct obd_device *obd, spin_lock(&obd->obd_osfs_lock); memcpy(oinfo->oi_osfs, &obd->obd_osfs, sizeof(*oinfo->oi_osfs)); spin_unlock(&obd->obd_osfs_lock); + oinfo->oi_flags |= OBD_STATFS_FROM_CACHE; if (oinfo->oi_cb_up) oinfo->oi_cb_up(oinfo, 0); } @@ -758,18 +1121,20 @@ static inline int obd_statfs_async(struct obd_device *obd, } static inline int obd_statfs_rqset(struct obd_device *obd, - struct obd_statfs *osfs, __u64 max_age) + struct obd_statfs *osfs, __u64 max_age, + __u32 flags) { struct ptlrpc_request_set *set = NULL; struct obd_info oinfo = { { { 0 } } }; int rc = 0; ENTRY; - set = ptlrpc_prep_set(); + set = ptlrpc_prep_set(); if (set == NULL) RETURN(-ENOMEM); oinfo.oi_osfs = osfs; + oinfo.oi_flags = flags; rc = obd_statfs_async(obd, &oinfo, max_age, set); if (rc == 0) rc = ptlrpc_set_wait(set); @@ -781,7 +1146,7 @@ static inline int obd_statfs_rqset(struct obd_device *obd, * If the cache is older than @max_age we will get a new value from the * target. Use a value of "cfs_time_current() + HZ" to guarantee freshness. */ static inline int obd_statfs(struct obd_device *obd, struct obd_statfs *osfs, - __u64 max_age) + __u64 max_age, __u32 flags) { int rc = 0; ENTRY; @@ -789,13 +1154,13 @@ static inline int obd_statfs(struct obd_device *obd, struct obd_statfs *osfs, if (obd == NULL) RETURN(-EINVAL); - OBD_CHECK_OP(obd, statfs, -EOPNOTSUPP); + OBD_CHECK_DT_OP(obd, statfs, -EOPNOTSUPP); OBD_COUNTER_INCREMENT(obd, statfs); CDEBUG(D_SUPER, "osfs "LPU64", max_age "LPU64"\n", obd->obd_osfs_age, max_age); if (cfs_time_before_64(obd->obd_osfs_age, max_age)) { - rc = OBP(obd, statfs)(obd, osfs, max_age); + rc = OBP(obd, statfs)(obd, osfs, max_age, flags); if (rc == 0) { spin_lock(&obd->obd_osfs_lock); memcpy(&obd->obd_osfs, osfs, sizeof(obd->obd_osfs)); @@ -817,15 +1182,15 @@ static inline int obd_statfs(struct obd_device *obd, struct obd_statfs *osfs, static inline int obd_sync(struct obd_export *exp, struct obdo *oa, struct lov_stripe_md *ea, obd_size start, - obd_size end) + obd_size end, void *capa) { int rc; ENTRY; - OBD_CHECK_OP(exp->exp_obd, sync, -EOPNOTSUPP); + OBD_CHECK_DT_OP(exp->exp_obd, sync, -EOPNOTSUPP); EXP_COUNTER_INCREMENT(exp, sync); - rc = OBP(exp->exp_obd, sync)(exp, oa, ea, start, end); + rc = OBP(exp->exp_obd, sync)(exp, oa, ea, start, end, capa); RETURN(rc); } @@ -837,7 +1202,7 @@ static inline int obd_punch_rqset(struct obd_export *exp, int rc; ENTRY; - EXP_CHECK_OP(exp, punch); + EXP_CHECK_DT_OP(exp, punch); EXP_COUNTER_INCREMENT(exp, punch); set = ptlrpc_prep_set(); @@ -858,7 +1223,7 @@ static inline int obd_punch(struct obd_export *exp, struct obd_info *oinfo, int rc; ENTRY; - EXP_CHECK_OP(exp, punch); + EXP_CHECK_DT_OP(exp, punch); EXP_COUNTER_INCREMENT(exp, punch); rc = OBP(exp->exp_obd, punch)(exp, oinfo, oti, rqset); @@ -872,7 +1237,7 @@ static inline int obd_brw(int cmd, struct obd_export *exp, int rc; ENTRY; - EXP_CHECK_OP(exp, brw); + EXP_CHECK_DT_OP(exp, brw); EXP_COUNTER_INCREMENT(exp, brw); if (!(cmd & (OBD_BRW_RWMASK | OBD_BRW_CHECK))) { @@ -885,347 +1250,171 @@ static inline int obd_brw(int cmd, struct obd_export *exp, RETURN(rc); } -static inline int obd_brw_async(int cmd, struct obd_export *exp, - struct obd_info *oinfo, obd_count oa_bufs, - struct brw_page *pg, struct obd_trans_info *oti, - struct ptlrpc_request_set *set) +static inline int obd_preprw(int cmd, struct obd_export *exp, struct obdo *oa, + int objcount, struct obd_ioobj *obj, + struct niobuf_remote *remote, int *pages, + struct niobuf_local *local, + struct obd_trans_info *oti, + struct lustre_capa *capa) { int rc; ENTRY; - EXP_CHECK_OP(exp, brw_async); - EXP_COUNTER_INCREMENT(exp, brw_async); - - if (!(cmd & OBD_BRW_RWMASK)) { - CERROR("obd_brw: cmd must be OBD_BRW_READ or OBD_BRW_WRITE\n"); - LBUG(); - } + EXP_CHECK_DT_OP(exp, preprw); + EXP_COUNTER_INCREMENT(exp, preprw); - rc = OBP(exp->exp_obd, brw_async)(cmd, exp, oinfo, oa_bufs, pg,oti,set); + rc = OBP(exp->exp_obd, preprw)(cmd, exp, oa, objcount, obj, remote, + pages, local, oti, capa); RETURN(rc); } -static inline int obd_brw_rqset(int cmd, struct obd_export *exp, - struct obdo *oa, struct lov_stripe_md *lsm, - obd_count oa_bufs, struct brw_page *pg, - struct obd_trans_info *oti) +static inline int obd_commitrw(int cmd, struct obd_export *exp, struct obdo *oa, + int objcount, struct obd_ioobj *obj, + struct niobuf_remote *rnb, int pages, + struct niobuf_local *local, + struct obd_trans_info *oti, int rc) { - struct ptlrpc_request_set *set = NULL; - struct obd_info oinfo = { { { 0 } } }; - int rc = 0; ENTRY; - set = ptlrpc_prep_set(); - if (set == NULL) - RETURN(-ENOMEM); + EXP_CHECK_DT_OP(exp, commitrw); + EXP_COUNTER_INCREMENT(exp, commitrw); - oinfo.oi_oa = oa; - oinfo.oi_md = lsm; - rc = obd_brw_async(cmd, exp, &oinfo, oa_bufs, pg, oti, set); - if (rc == 0) { - rc = ptlrpc_set_wait(set); - if (rc) - CERROR("error from callback: rc = %d\n", rc); - } else { - CDEBUG(rc == -ENOSPC ? D_INODE : D_ERROR, - "error from obd_brw_async: rc = %d\n", rc); - } - ptlrpc_set_destroy(set); + rc = OBP(exp->exp_obd, commitrw)(cmd, exp, oa, objcount, obj, + rnb, pages, local, oti, rc); RETURN(rc); } -static inline int obd_prep_async_page(struct obd_export *exp, - struct lov_stripe_md *lsm, - struct lov_oinfo *loi, - cfs_page_t *page, obd_off offset, - struct obd_async_page_ops *ops, - void *data, void **res) +static inline int obd_merge_lvb(struct obd_export *exp, + struct lov_stripe_md *lsm, + struct ost_lvb *lvb, int kms_only) { - int ret; + int rc; ENTRY; - OBD_CHECK_OP(exp->exp_obd, prep_async_page, -EOPNOTSUPP); - EXP_COUNTER_INCREMENT(exp, prep_async_page); + EXP_CHECK_DT_OP(exp, merge_lvb); + EXP_COUNTER_INCREMENT(exp, merge_lvb); - ret = OBP(exp->exp_obd, prep_async_page)(exp, lsm, loi, page, offset, - ops, data, res); - RETURN(ret); + rc = OBP(exp->exp_obd, merge_lvb)(exp, lsm, lvb, kms_only); + RETURN(rc); } -static inline int obd_queue_async_io(struct obd_export *exp, - struct lov_stripe_md *lsm, - struct lov_oinfo *loi, void *cookie, - int cmd, obd_off off, int count, - obd_flag brw_flags, obd_flag async_flags) +static inline int obd_adjust_kms(struct obd_export *exp, + struct lov_stripe_md *lsm, obd_off size, + int shrink) { int rc; ENTRY; - OBD_CHECK_OP(exp->exp_obd, queue_async_io, -EOPNOTSUPP); - EXP_COUNTER_INCREMENT(exp, queue_async_io); - LASSERT(cmd & OBD_BRW_RWMASK); + EXP_CHECK_DT_OP(exp, adjust_kms); + EXP_COUNTER_INCREMENT(exp, adjust_kms); - rc = OBP(exp->exp_obd, queue_async_io)(exp, lsm, loi, cookie, cmd, off, - count, brw_flags, async_flags); + rc = OBP(exp->exp_obd, adjust_kms)(exp, lsm, size, shrink); RETURN(rc); } -static inline int obd_set_async_flags(struct obd_export *exp, - struct lov_stripe_md *lsm, - struct lov_oinfo *loi, void *cookie, - obd_flag async_flags) +static inline int obd_iocontrol(unsigned int cmd, struct obd_export *exp, + int len, void *karg, void *uarg) { int rc; ENTRY; - OBD_CHECK_OP(exp->exp_obd, set_async_flags, -EOPNOTSUPP); - EXP_COUNTER_INCREMENT(exp, set_async_flags); + EXP_CHECK_DT_OP(exp, iocontrol); + EXP_COUNTER_INCREMENT(exp, iocontrol); - rc = OBP(exp->exp_obd, set_async_flags)(exp, lsm, loi, cookie, - async_flags); + rc = OBP(exp->exp_obd, iocontrol)(cmd, exp, len, karg, uarg); RETURN(rc); } -static inline int obd_queue_group_io(struct obd_export *exp, - struct lov_stripe_md *lsm, - struct lov_oinfo *loi, - struct obd_io_group *oig, - void *cookie, int cmd, obd_off off, - int count, obd_flag brw_flags, - obd_flag async_flags) +static inline int obd_enqueue_rqset(struct obd_export *exp, + struct obd_info *oinfo, + struct ldlm_enqueue_info *einfo) { + struct ptlrpc_request_set *set = NULL; int rc; ENTRY; - OBD_CHECK_OP(exp->exp_obd, queue_group_io, -EOPNOTSUPP); - EXP_COUNTER_INCREMENT(exp, queue_group_io); - LASSERT(cmd & OBD_BRW_RWMASK); + EXP_CHECK_DT_OP(exp, enqueue); + EXP_COUNTER_INCREMENT(exp, enqueue); + + set = ptlrpc_prep_set(); + if (set == NULL) + RETURN(-ENOMEM); - rc = OBP(exp->exp_obd, queue_group_io)(exp, lsm, loi, oig, cookie, - cmd, off, count, brw_flags, - async_flags); + rc = OBP(exp->exp_obd, enqueue)(exp, oinfo, einfo, set); + if (rc == 0) + rc = ptlrpc_set_wait(set); + ptlrpc_set_destroy(set); RETURN(rc); } -static inline int obd_trigger_group_io(struct obd_export *exp, - struct lov_stripe_md *lsm, - struct lov_oinfo *loi, - struct obd_io_group *oig) +static inline int obd_enqueue(struct obd_export *exp, + struct obd_info *oinfo, + struct ldlm_enqueue_info *einfo, + struct ptlrpc_request_set *set) { int rc; ENTRY; - OBD_CHECK_OP(exp->exp_obd, trigger_group_io, -EOPNOTSUPP); - EXP_COUNTER_INCREMENT(exp, trigger_group_io); + EXP_CHECK_DT_OP(exp, enqueue); + EXP_COUNTER_INCREMENT(exp, enqueue); - rc = OBP(exp->exp_obd, trigger_group_io)(exp, lsm, loi, oig); + rc = OBP(exp->exp_obd, enqueue)(exp, oinfo, einfo, set); RETURN(rc); } -static inline int obd_teardown_async_page(struct obd_export *exp, - struct lov_stripe_md *lsm, - struct lov_oinfo *loi, void *cookie) +static inline int obd_change_cbdata(struct obd_export *exp, + struct lov_stripe_md *lsm, + ldlm_iterator_t it, void *data) { int rc; ENTRY; - OBD_CHECK_OP(exp->exp_obd, teardown_async_page, -EOPNOTSUPP); - EXP_COUNTER_INCREMENT(exp, teardown_async_page); + EXP_CHECK_DT_OP(exp, change_cbdata); + EXP_COUNTER_INCREMENT(exp, change_cbdata); - rc = OBP(exp->exp_obd, teardown_async_page)(exp, lsm, loi, cookie); + rc = OBP(exp->exp_obd, change_cbdata)(exp, lsm, it, data); RETURN(rc); } -static inline int obd_preprw(int cmd, struct obd_export *exp, struct obdo *oa, - int objcount, struct obd_ioobj *obj, - int niocount, struct niobuf_remote *remote, - struct niobuf_local *local, - struct obd_trans_info *oti) +static inline int obd_cancel(struct obd_export *exp, + struct lov_stripe_md *ea, __u32 mode, + struct lustre_handle *lockh) { int rc; ENTRY; - OBD_CHECK_OP(exp->exp_obd, preprw, -EOPNOTSUPP); - EXP_COUNTER_INCREMENT(exp, preprw); + EXP_CHECK_DT_OP(exp, cancel); + EXP_COUNTER_INCREMENT(exp, cancel); - rc = OBP(exp->exp_obd, preprw)(cmd, exp, oa, objcount, obj, niocount, - remote, local, oti); - RETURN(rc); -} - -static inline int obd_commitrw(int cmd, struct obd_export *exp, struct obdo *oa, - int objcount, struct obd_ioobj *obj, - int niocount, struct niobuf_local *local, - struct obd_trans_info *oti, int rc) -{ - ENTRY; - - OBD_CHECK_OP(exp->exp_obd, commitrw, -EOPNOTSUPP); - EXP_COUNTER_INCREMENT(exp, commitrw); - - rc = OBP(exp->exp_obd, commitrw)(cmd, exp, oa, objcount, obj, niocount, - local, oti, rc); - RETURN(rc); -} - -static inline int obd_merge_lvb(struct obd_export *exp, - struct lov_stripe_md *lsm, - struct ost_lvb *lvb, int kms_only) -{ - int rc; - ENTRY; - - OBD_CHECK_OP(exp->exp_obd, merge_lvb, -EOPNOTSUPP); - EXP_COUNTER_INCREMENT(exp, merge_lvb); - - rc = OBP(exp->exp_obd, merge_lvb)(exp, lsm, lvb, kms_only); - RETURN(rc); -} - -static inline int obd_adjust_kms(struct obd_export *exp, - struct lov_stripe_md *lsm, obd_off size, - int shrink) -{ - int rc; - ENTRY; - - OBD_CHECK_OP(exp->exp_obd, adjust_kms, -EOPNOTSUPP); - EXP_COUNTER_INCREMENT(exp, adjust_kms); - - rc = OBP(exp->exp_obd, adjust_kms)(exp, lsm, size, shrink); - RETURN(rc); -} - -static inline int obd_iocontrol(unsigned int cmd, struct obd_export *exp, - int len, void *karg, void *uarg) -{ - int rc; - ENTRY; - - EXP_CHECK_OP(exp, iocontrol); - EXP_COUNTER_INCREMENT(exp, iocontrol); - - rc = OBP(exp->exp_obd, iocontrol)(cmd, exp, len, karg, uarg); - RETURN(rc); -} - -static inline int obd_enqueue_rqset(struct obd_export *exp, - struct obd_info *oinfo, - struct obd_enqueue_info *einfo) -{ - int rc; - ENTRY; - - EXP_CHECK_OP(exp, enqueue); - EXP_COUNTER_INCREMENT(exp, enqueue); - - einfo->ei_rqset = ptlrpc_prep_set(); - if (einfo->ei_rqset == NULL) - RETURN(-ENOMEM); - - rc = OBP(exp->exp_obd, enqueue)(exp, oinfo, einfo); - if (rc == 0) - rc = ptlrpc_set_wait(einfo->ei_rqset); - ptlrpc_set_destroy(einfo->ei_rqset); - einfo->ei_rqset = NULL; - - RETURN(rc); -} - -static inline int obd_enqueue(struct obd_export *exp, - struct obd_info *oinfo, - struct obd_enqueue_info *einfo) -{ - int rc; - ENTRY; - - EXP_CHECK_OP(exp, enqueue); - EXP_COUNTER_INCREMENT(exp, enqueue); - - rc = OBP(exp->exp_obd, enqueue)(exp, oinfo, einfo); - RETURN(rc); -} - -static inline int obd_match(struct obd_export *exp, struct lov_stripe_md *ea, - __u32 type, ldlm_policy_data_t *policy, __u32 mode, - int *flags, void *data, struct lustre_handle *lockh) -{ - int rc; - ENTRY; - - EXP_CHECK_OP(exp, match); - EXP_COUNTER_INCREMENT(exp, match); - - rc = OBP(exp->exp_obd, match)(exp, ea, type, policy, mode, flags, data, - lockh); - RETURN(rc); -} - -static inline int obd_change_cbdata(struct obd_export *exp, - struct lov_stripe_md *lsm, - ldlm_iterator_t it, void *data) -{ - int rc; - ENTRY; - - EXP_CHECK_OP(exp, change_cbdata); - EXP_COUNTER_INCREMENT(exp, change_cbdata); - - rc = OBP(exp->exp_obd, change_cbdata)(exp, lsm, it, data); - RETURN(rc); -} - -static inline int obd_cancel(struct obd_export *exp, - struct lov_stripe_md *ea, __u32 mode, - struct lustre_handle *lockh) -{ - int rc; - ENTRY; - - EXP_CHECK_OP(exp, cancel); - EXP_COUNTER_INCREMENT(exp, cancel); - - rc = OBP(exp->exp_obd, cancel)(exp, ea, mode, lockh); + rc = OBP(exp->exp_obd, cancel)(exp, ea, mode, lockh); RETURN(rc); } static inline int obd_cancel_unused(struct obd_export *exp, - struct lov_stripe_md *ea, int flags, - void *opaque) + struct lov_stripe_md *ea, + int flags, void *opaque) { int rc; ENTRY; - EXP_CHECK_OP(exp, cancel_unused); + EXP_CHECK_DT_OP(exp, cancel_unused); EXP_COUNTER_INCREMENT(exp, cancel_unused); rc = OBP(exp->exp_obd, cancel_unused)(exp, ea, flags, opaque); RETURN(rc); } -static inline int obd_join_lru(struct obd_export *exp, - struct lov_stripe_md *ea, int join) -{ - int rc; - ENTRY; - - EXP_CHECK_OP(exp, join_lru); - EXP_COUNTER_INCREMENT(exp, join_lru); - - rc = OBP(exp->exp_obd, join_lru)(exp, ea, join); - RETURN(rc); -} - -static inline int obd_pin(struct obd_export *exp, obd_id ino, __u32 gen, - int type, struct obd_client_handle *handle, int flag) +static inline int obd_pin(struct obd_export *exp, const struct lu_fid *fid, + struct obd_capa *oc, struct obd_client_handle *handle, + int flag) { int rc; ENTRY; - EXP_CHECK_OP(exp, pin); + EXP_CHECK_DT_OP(exp, pin); EXP_COUNTER_INCREMENT(exp, pin); - rc = OBP(exp->exp_obd, pin)(exp, ino, gen, type, handle, flag); + rc = OBP(exp->exp_obd, pin)(exp, fid, oc, handle, flag); RETURN(rc); } @@ -1235,7 +1424,7 @@ static inline int obd_unpin(struct obd_export *exp, int rc; ENTRY; - EXP_CHECK_OP(exp, unpin); + EXP_CHECK_DT_OP(exp, unpin); EXP_COUNTER_INCREMENT(exp, unpin); rc = OBP(exp->exp_obd, unpin)(exp, handle, flag); @@ -1260,17 +1449,33 @@ static inline void obd_import_event(struct obd_device *obd, EXIT; } +static inline int obd_llog_connect(struct obd_export *exp, + struct llogd_conn_body *body) +{ + int rc; + ENTRY; + + OBD_CHECK_DT_OP(exp->exp_obd, llog_connect, 0); + EXP_COUNTER_INCREMENT(exp, llog_connect); + + rc = OBP(exp->exp_obd, llog_connect)(exp, body); + RETURN(rc); +} + + static inline int obd_notify(struct obd_device *obd, struct obd_device *watched, - enum obd_notify_event ev, void *data) + enum obd_notify_event ev, + void *data) { + int rc; ENTRY; OBD_CHECK_DEV(obd); /* the check for async_recov is a complete hack - I'm hereby overloading the meaning to also mean "this was called from mds_postsetup". I know that my mds is able to handle notifies - by this point, and it needs to get them to execute mds_postrecov. */ + by this point, and it needs to get them to execute mds_postrecov. */ if (!obd->obd_set_up && !obd->obd_async_recov) { CDEBUG(D_HA, "obd %s not set up\n", obd->obd_name); RETURN(-EINVAL); @@ -1282,12 +1487,14 @@ static inline int obd_notify(struct obd_device *obd, } OBD_COUNTER_INCREMENT(obd, notify); - RETURN(OBP(obd, notify)(obd, watched, ev, data)); + rc = OBP(obd, notify)(obd, watched, ev, data); + RETURN(rc); } static inline int obd_notify_observer(struct obd_device *observer, struct obd_device *observed, - enum obd_notify_event ev, void *data) + enum obd_notify_event ev, + void *data) { int rc1; int rc2; @@ -1303,12 +1510,13 @@ static inline int obd_notify_observer(struct obd_device *observer, */ onu = &observer->obd_upcall; if (onu->onu_upcall != NULL) - rc2 = onu->onu_upcall(observer, observed, ev, onu->onu_owner); + rc2 = onu->onu_upcall(observer, observed, ev, + onu->onu_owner, NULL); else rc2 = 0; - return rc1 ?: rc2; - } + return rc1 ? rc1 : rc2; +} static inline int obd_quotacheck(struct obd_export *exp, struct obd_quotactl *oqctl) @@ -1316,10 +1524,10 @@ static inline int obd_quotacheck(struct obd_export *exp, int rc; ENTRY; - EXP_CHECK_OP(exp, quotacheck); + EXP_CHECK_DT_OP(exp, quotacheck); EXP_COUNTER_INCREMENT(exp, quotacheck); - rc = OBP(exp->exp_obd, quotacheck)(exp, oqctl); + rc = OBP(exp->exp_obd, quotacheck)(exp->exp_obd, exp, oqctl); RETURN(rc); } @@ -1329,10 +1537,42 @@ static inline int obd_quotactl(struct obd_export *exp, int rc; ENTRY; - EXP_CHECK_OP(exp, quotactl); + EXP_CHECK_DT_OP(exp, quotactl); EXP_COUNTER_INCREMENT(exp, quotactl); - rc = OBP(exp->exp_obd, quotactl)(exp, oqctl); + rc = OBP(exp->exp_obd, quotactl)(exp->exp_obd, exp, oqctl); + RETURN(rc); +} + +static inline int obd_quota_adjust_qunit(struct obd_export *exp, + struct quota_adjust_qunit *oqaq, + struct lustre_quota_ctxt *qctxt) +{ +#if defined(LPROCFS) && defined(HAVE_QUOTA_SUPPORT) + struct timeval work_start; + struct timeval work_end; + long timediff; +#endif + int rc; + ENTRY; + +#if defined(LPROCFS) && defined(HAVE_QUOTA_SUPPORT) + if (qctxt) + do_gettimeofday(&work_start); +#endif + EXP_CHECK_DT_OP(exp, quota_adjust_qunit); + EXP_COUNTER_INCREMENT(exp, quota_adjust_qunit); + + rc = OBP(exp->exp_obd, quota_adjust_qunit)(exp, oqaq, qctxt); + +#if defined(LPROCFS) && defined(HAVE_QUOTA_SUPPORT) + if (qctxt) { + do_gettimeofday(&work_end); + timediff = cfs_timeval_sub(&work_end, &work_start, NULL); + lprocfs_counter_add(qctxt->lqc_stats, LQUOTA_ADJUST_QUNIT, + timediff); + } +#endif RETURN(rc); } @@ -1348,7 +1588,7 @@ static inline int obd_health_check(struct obd_device *obd) int rc; ENTRY; - /* don't use EXP_CHECK_OP, because NULL method is normal here */ + /* don't use EXP_CHECK_DT_OP, because NULL method is normal here */ if (obd == NULL || !OBT(obd)) { CERROR("cleaned up obd\n"); RETURN(-EOPNOTSUPP); @@ -1373,6 +1613,453 @@ static inline int obd_register_observer(struct obd_device *obd, RETURN(0); } +#if 0 +static inline int obd_register_page_removal_cb(struct obd_export *exp, + obd_page_removal_cb_t cb, + obd_pin_extent_cb pin_cb) +{ + int rc; + ENTRY; + + OBD_CHECK_DT_OP(exp->exp_obd, register_page_removal_cb, 0); + OBD_COUNTER_INCREMENT(exp->exp_obd, register_page_removal_cb); + + rc = OBP(exp->exp_obd, register_page_removal_cb)(exp, cb, pin_cb); + RETURN(rc); +} + +static inline int obd_unregister_page_removal_cb(struct obd_export *exp, + obd_page_removal_cb_t cb) +{ + int rc; + ENTRY; + + OBD_CHECK_DT_OP(exp->exp_obd, unregister_page_removal_cb, 0); + OBD_COUNTER_INCREMENT(exp->exp_obd, unregister_page_removal_cb); + + rc = OBP(exp->exp_obd, unregister_page_removal_cb)(exp, cb); + RETURN(rc); +} + +static inline int obd_register_lock_cancel_cb(struct obd_export *exp, + obd_lock_cancel_cb cb) +{ + int rc; + ENTRY; + + OBD_CHECK_DT_OP(exp->exp_obd, register_lock_cancel_cb, 0); + OBD_COUNTER_INCREMENT(exp->exp_obd, register_lock_cancel_cb); + + rc = OBP(exp->exp_obd, register_lock_cancel_cb)(exp, cb); + RETURN(rc); +} + +static inline int obd_unregister_lock_cancel_cb(struct obd_export *exp, + obd_lock_cancel_cb cb) +{ + int rc; + ENTRY; + + OBD_CHECK_DT_OP(exp->exp_obd, unregister_lock_cancel_cb, 0); + OBD_COUNTER_INCREMENT(exp->exp_obd, unregister_lock_cancel_cb); + + rc = OBP(exp->exp_obd, unregister_lock_cancel_cb)(exp, cb); + RETURN(rc); +} +#endif + +/* metadata helpers */ +static inline int md_getstatus(struct obd_export *exp, + struct lu_fid *fid, struct obd_capa **pc) +{ + int rc; + ENTRY; + + EXP_CHECK_MD_OP(exp, getstatus); + EXP_MD_COUNTER_INCREMENT(exp, getstatus); + rc = MDP(exp->exp_obd, getstatus)(exp, fid, pc); + RETURN(rc); +} + +static inline int md_getattr(struct obd_export *exp, const struct lu_fid *fid, + struct obd_capa *oc, obd_valid valid, int ea_size, + struct ptlrpc_request **request) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, getattr); + EXP_MD_COUNTER_INCREMENT(exp, getattr); + rc = MDP(exp->exp_obd, getattr)(exp, fid, oc, valid, + ea_size, request); + RETURN(rc); +} + +static inline int md_change_cbdata(struct obd_export *exp, + const struct lu_fid *fid, + ldlm_iterator_t it, void *data) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, change_cbdata); + EXP_MD_COUNTER_INCREMENT(exp, change_cbdata); + rc = MDP(exp->exp_obd, change_cbdata)(exp, fid, it, data); + RETURN(rc); +} + +static inline int md_close(struct obd_export *exp, struct md_op_data *op_data, + struct md_open_data *mod, + struct ptlrpc_request **request) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, close); + EXP_MD_COUNTER_INCREMENT(exp, close); + rc = MDP(exp->exp_obd, close)(exp, op_data, mod, request); + RETURN(rc); +} + +static inline int md_create(struct obd_export *exp, struct md_op_data *op_data, + const void *data, int datalen, int mode, __u32 uid, + __u32 gid, cfs_cap_t cap_effective, __u64 rdev, + struct ptlrpc_request **request) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, create); + EXP_MD_COUNTER_INCREMENT(exp, create); + rc = MDP(exp->exp_obd, create)(exp, op_data, data, datalen, mode, + uid, gid, cap_effective, rdev, request); + RETURN(rc); +} + +static inline int md_done_writing(struct obd_export *exp, + struct md_op_data *op_data, + struct md_open_data *mod) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, done_writing); + EXP_MD_COUNTER_INCREMENT(exp, done_writing); + rc = MDP(exp->exp_obd, done_writing)(exp, op_data, mod); + RETURN(rc); +} + +static inline int md_enqueue(struct obd_export *exp, + struct ldlm_enqueue_info *einfo, + struct lookup_intent *it, + struct md_op_data *op_data, + struct lustre_handle *lockh, + void *lmm, int lmmsize, + struct ptlrpc_request **req, + int extra_lock_flags) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, enqueue); + EXP_MD_COUNTER_INCREMENT(exp, enqueue); + rc = MDP(exp->exp_obd, enqueue)(exp, einfo, it, op_data, lockh, + lmm, lmmsize, req, extra_lock_flags); + RETURN(rc); +} + +static inline int md_getattr_name(struct obd_export *exp, + const struct lu_fid *fid, struct obd_capa *oc, + const char *name, int namelen, + obd_valid valid, int ea_size, __u32 suppgid, + struct ptlrpc_request **request) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, getattr_name); + EXP_MD_COUNTER_INCREMENT(exp, getattr_name); + rc = MDP(exp->exp_obd, getattr_name)(exp, fid, oc, name, namelen, + valid, ea_size, suppgid, request); + RETURN(rc); +} + +static inline int md_intent_lock(struct obd_export *exp, + struct md_op_data *op_data, void *lmm, + int lmmsize, struct lookup_intent *it, + int flags, struct ptlrpc_request **reqp, + ldlm_blocking_callback cb_blocking, + int extra_lock_flags) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, intent_lock); + EXP_MD_COUNTER_INCREMENT(exp, intent_lock); + rc = MDP(exp->exp_obd, intent_lock)(exp, op_data, lmm, lmmsize, + it, flags, reqp, cb_blocking, + extra_lock_flags); + RETURN(rc); +} + +static inline int md_link(struct obd_export *exp, struct md_op_data *op_data, + struct ptlrpc_request **request) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, link); + EXP_MD_COUNTER_INCREMENT(exp, link); + rc = MDP(exp->exp_obd, link)(exp, op_data, request); + RETURN(rc); +} + +static inline int md_rename(struct obd_export *exp, struct md_op_data *op_data, + const char *old, int oldlen, const char *new, + int newlen, struct ptlrpc_request **request) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, rename); + EXP_MD_COUNTER_INCREMENT(exp, rename); + rc = MDP(exp->exp_obd, rename)(exp, op_data, old, oldlen, new, + newlen, request); + RETURN(rc); +} + +static inline int md_is_subdir(struct obd_export *exp, + const struct lu_fid *pfid, + const struct lu_fid *cfid, + struct ptlrpc_request **request) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, is_subdir); + EXP_MD_COUNTER_INCREMENT(exp, is_subdir); + rc = MDP(exp->exp_obd, is_subdir)(exp, pfid, cfid, request); + RETURN(rc); +} + +static inline int md_setattr(struct obd_export *exp, struct md_op_data *op_data, + void *ea, int ealen, void *ea2, int ea2len, + struct ptlrpc_request **request, + struct md_open_data **mod) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, setattr); + EXP_MD_COUNTER_INCREMENT(exp, setattr); + rc = MDP(exp->exp_obd, setattr)(exp, op_data, ea, ealen, + ea2, ea2len, request, mod); + RETURN(rc); +} + +static inline int md_sync(struct obd_export *exp, const struct lu_fid *fid, + struct obd_capa *oc, struct ptlrpc_request **request) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, sync); + EXP_MD_COUNTER_INCREMENT(exp, sync); + rc = MDP(exp->exp_obd, sync)(exp, fid, oc, request); + RETURN(rc); +} + +static inline int md_readpage(struct obd_export *exp, const struct lu_fid *fid, + struct obd_capa *oc, __u64 offset, + struct page *page, + struct ptlrpc_request **request) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, readpage); + EXP_MD_COUNTER_INCREMENT(exp, readpage); + rc = MDP(exp->exp_obd, readpage)(exp, fid, oc, offset, page, request); + RETURN(rc); +} + +static inline int md_unlink(struct obd_export *exp, struct md_op_data *op_data, + struct ptlrpc_request **request) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, unlink); + EXP_MD_COUNTER_INCREMENT(exp, unlink); + rc = MDP(exp->exp_obd, unlink)(exp, op_data, request); + RETURN(rc); +} + +static inline int md_get_lustre_md(struct obd_export *exp, + struct ptlrpc_request *req, + struct obd_export *dt_exp, + struct obd_export *md_exp, + struct lustre_md *md) +{ + ENTRY; + EXP_CHECK_MD_OP(exp, get_lustre_md); + EXP_MD_COUNTER_INCREMENT(exp, get_lustre_md); + RETURN(MDP(exp->exp_obd, get_lustre_md)(exp, req, dt_exp, md_exp, md)); +} + +static inline int md_free_lustre_md(struct obd_export *exp, + struct lustre_md *md) +{ + ENTRY; + EXP_CHECK_MD_OP(exp, free_lustre_md); + EXP_MD_COUNTER_INCREMENT(exp, free_lustre_md); + RETURN(MDP(exp->exp_obd, free_lustre_md)(exp, md)); +} + +static inline int md_setxattr(struct obd_export *exp, + const struct lu_fid *fid, struct obd_capa *oc, + obd_valid valid, const char *name, + const char *input, int input_size, + int output_size, int flags, __u32 suppgid, + struct ptlrpc_request **request) +{ + ENTRY; + EXP_CHECK_MD_OP(exp, setxattr); + EXP_MD_COUNTER_INCREMENT(exp, setxattr); + RETURN(MDP(exp->exp_obd, setxattr)(exp, fid, oc, valid, name, input, + input_size, output_size, flags, + suppgid, request)); +} + +static inline int md_getxattr(struct obd_export *exp, + const struct lu_fid *fid, struct obd_capa *oc, + obd_valid valid, const char *name, + const char *input, int input_size, + int output_size, int flags, + struct ptlrpc_request **request) +{ + ENTRY; + EXP_CHECK_MD_OP(exp, getxattr); + EXP_MD_COUNTER_INCREMENT(exp, getxattr); + RETURN(MDP(exp->exp_obd, getxattr)(exp, fid, oc, valid, name, input, + input_size, output_size, flags, + request)); +} + +static inline int md_set_open_replay_data(struct obd_export *exp, + struct obd_client_handle *och, + struct ptlrpc_request *open_req) +{ + ENTRY; + EXP_CHECK_MD_OP(exp, set_open_replay_data); + EXP_MD_COUNTER_INCREMENT(exp, set_open_replay_data); + RETURN(MDP(exp->exp_obd, set_open_replay_data)(exp, och, open_req)); +} + +static inline int md_clear_open_replay_data(struct obd_export *exp, + struct obd_client_handle *och) +{ + ENTRY; + EXP_CHECK_MD_OP(exp, clear_open_replay_data); + EXP_MD_COUNTER_INCREMENT(exp, clear_open_replay_data); + RETURN(MDP(exp->exp_obd, clear_open_replay_data)(exp, och)); +} + +static inline int md_set_lock_data(struct obd_export *exp, + __u64 *lockh, void *data, __u32 *bits) +{ + ENTRY; + EXP_CHECK_MD_OP(exp, set_lock_data); + EXP_MD_COUNTER_INCREMENT(exp, set_lock_data); + RETURN(MDP(exp->exp_obd, set_lock_data)(exp, lockh, data, bits)); +} + +static inline int md_cancel_unused(struct obd_export *exp, + const struct lu_fid *fid, + ldlm_policy_data_t *policy, + ldlm_mode_t mode, int flags, void *opaque) +{ + int rc; + ENTRY; + + EXP_CHECK_MD_OP(exp, cancel_unused); + EXP_MD_COUNTER_INCREMENT(exp, cancel_unused); + + rc = MDP(exp->exp_obd, cancel_unused)(exp, fid, policy, mode, + flags, opaque); + RETURN(rc); +} + +static inline ldlm_mode_t md_lock_match(struct obd_export *exp, int flags, + const struct lu_fid *fid, + ldlm_type_t type, + ldlm_policy_data_t *policy, + ldlm_mode_t mode, + struct lustre_handle *lockh) +{ + ENTRY; + EXP_CHECK_MD_OP(exp, lock_match); + EXP_MD_COUNTER_INCREMENT(exp, lock_match); + RETURN(MDP(exp->exp_obd, lock_match)(exp, flags, fid, type, + policy, mode, lockh)); +} + +static inline int md_init_ea_size(struct obd_export *exp, int easize, + int def_asize, int cookiesize) +{ + ENTRY; + EXP_CHECK_MD_OP(exp, init_ea_size); + EXP_MD_COUNTER_INCREMENT(exp, init_ea_size); + RETURN(MDP(exp->exp_obd, init_ea_size)(exp, easize, def_asize, + cookiesize)); +} + +static inline int md_get_remote_perm(struct obd_export *exp, + const struct lu_fid *fid, + struct obd_capa *oc, __u32 suppgid, + struct ptlrpc_request **request) +{ + ENTRY; + EXP_CHECK_MD_OP(exp, get_remote_perm); + EXP_MD_COUNTER_INCREMENT(exp, get_remote_perm); + RETURN(MDP(exp->exp_obd, get_remote_perm)(exp, fid, oc, suppgid, + request)); +} + +static inline int md_renew_capa(struct obd_export *exp, struct obd_capa *ocapa, + renew_capa_cb_t cb) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, renew_capa); + EXP_MD_COUNTER_INCREMENT(exp, renew_capa); + rc = MDP(exp->exp_obd, renew_capa)(exp, ocapa, cb); + RETURN(rc); +} + +static inline int md_unpack_capa(struct obd_export *exp, + struct ptlrpc_request *req, + const struct req_msg_field *field, + struct obd_capa **oc) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, unpack_capa); + EXP_MD_COUNTER_INCREMENT(exp, unpack_capa); + rc = MDP(exp->exp_obd, unpack_capa)(exp, req, field, oc); + RETURN(rc); +} + +static inline int md_intent_getattr_async(struct obd_export *exp, + struct md_enqueue_info *minfo, + struct ldlm_enqueue_info *einfo) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, intent_getattr_async); + EXP_MD_COUNTER_INCREMENT(exp, intent_getattr_async); + rc = MDP(exp->exp_obd, intent_getattr_async)(exp, minfo, einfo); + RETURN(rc); +} + +static inline int md_revalidate_lock(struct obd_export *exp, + struct lookup_intent *it, + struct lu_fid *fid) +{ + int rc; + ENTRY; + EXP_CHECK_MD_OP(exp, revalidate_lock); + EXP_MD_COUNTER_INCREMENT(exp, revalidate_lock); + rc = MDP(exp->exp_obd, revalidate_lock)(exp, it, fid); + RETURN(rc); +} + + /* OBD Metadata Support */ extern int obd_init_caches(void); @@ -1380,18 +2067,26 @@ extern void obd_cleanup_caches(void); /* support routines */ extern cfs_mem_cache_t *obdo_cachep; -static inline struct obdo *obdo_alloc(void) -{ - struct obdo *oa; - OBD_SLAB_ALLOC(oa, obdo_cachep, CFS_ALLOC_STD, sizeof(*oa)); +#define OBDO_ALLOC(ptr) \ +do { \ + OBD_SLAB_ALLOC_PTR((ptr), obdo_cachep); \ +} while(0) - return oa; +#define OBDO_FREE(ptr) \ +do { \ + OBD_SLAB_FREE_PTR((ptr), obdo_cachep); \ +} while(0) + + +static inline void obdo2fid(struct obdo *oa, struct lu_fid *fid) +{ + /* something here */ } -static inline void obdo_free(struct obdo *oa) +static inline void fid2obdo(struct lu_fid *fid, struct obdo *oa) { - OBD_SLAB_FREE(oa, obdo_cachep, sizeof(*oa)); + /* something here */ } /* I'm as embarrassed about this as you are. @@ -1406,14 +2101,20 @@ extern void obd_sysctl_clean (void); /* uuid.c */ typedef __u8 class_uuid_t[16]; -void class_generate_random_uuid(class_uuid_t uuid); void class_uuid_unparse(class_uuid_t in, struct obd_uuid *out); /* lustre_peer.c */ -int lustre_uuid_to_peer(char *uuid, lnet_nid_t *peer_nid, int index); -int class_add_uuid(char *uuid, __u64 nid); -int class_del_uuid (char *uuid); +int lustre_uuid_to_peer(const char *uuid, lnet_nid_t *peer_nid, int index); +int class_add_uuid(const char *uuid, __u64 nid); +int class_del_uuid (const char *uuid); void class_init_uuidlist(void); void class_exit_uuidlist(void); +/* mea.c */ +int mea_name2idx(struct lmv_stripe_md *mea, const char *name, int namelen); +int raw_name2idx(int hashtype, int count, const char *name, int namelen); + +/* prng.c */ +void ll_generate_random_uuid(class_uuid_t uuid_out); + #endif /* __LINUX_OBD_CLASS_H */