/* -*- 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 <liblustre.h>
+#endif
+
#include <obd_support.h>
#include <lustre_import.h>
#include <lustre_net.h>
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);
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);
/* 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);
struct obd_device *class_incref(struct obd_device *obd);
void class_decref(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 /* Using old-style log */
+#define CFG_F_COMPAT146 0x08 /* Allow old-style logs */
#define CFG_F_EXCLUDE 0x10 /* OST exclusion list */
/* Passed as data param to class_config_parse_llog */
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);
struct list_head cld_list_chain;
atomic_t cld_refcount;
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 */
};
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) \
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_disconnect_stale_exports(struct obd_device *,
+ int (*test_export)(struct obd_export *));
int class_manual_cleanup(struct obd_device *obd);
-/* 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
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"); \
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);
}
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)
+#ifdef __KERNEL__
+#define DECLARE_LU_VARS(ldt, d) \
+ struct lu_device_type *ldt; \
+ struct lu_device *d
+#else
+#define DECLARE_LU_VARS(ldt, d) \
+ extern void __placeholder_to_put_a_semicolon(void)
+#endif
+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);
+#ifdef __KERNEL__
+ ldt = obd->obd_type->typ_lu;
+ if (ldt != NULL) {
+ struct lu_env env;
- rc = OBP(obd, setup)(obd, datalen, data);
+ rc = lu_env_init(&env, NULL, ldt->ldt_ctx_tags);
+ if (rc == 0) {
+ 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);
+ }
+ } else
+#endif
+ {
+ 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_COUNTER_INCREMENT(obd, precleanup);
+ OBD_CHECK_DEV(obd);
+#ifdef __KERNEL__
+ ldt = obd->obd_type->typ_lu;
+ d = obd->obd_lu_dev;
+ if (ldt != NULL) {
+ LASSERT(d != NULL);
+ if (cleanup_stage == OBD_CLEANUP_EXPORTS) {
+ struct lu_env env;
+
+ rc = lu_env_init(&env, NULL, ldt->ldt_ctx_tags);
+ if (rc == 0) {
+ ldt->ldt_ops->ldto_device_fini(&env, d);
+ lu_env_fini(&env);
+ }
+ } else {
+ rc = 0;
+ }
+ } else
+#endif
+ {
+ OBD_CHECK_DT_OP(obd, precleanup, 0);
+ rc = OBP(obd, precleanup)(obd, cleanup_stage);
+ }
- rc = OBP(obd, precleanup)(obd, cleanup_stage);
+ OBD_COUNTER_INCREMENT(obd, precleanup);
RETURN(rc);
}
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);
- OBD_COUNTER_INCREMENT(obd, cleanup);
- rc = OBP(obd, cleanup)(obd);
+#ifdef __KERNEL__
+ ldt = obd->obd_type->typ_lu;
+ d = obd->obd_lu_dev;
+ if (ldt != NULL) {
+ struct lu_env env;
+ LASSERT(d != NULL);
+
+ rc = lu_env_init(&env, NULL, ldt->ldt_ctx_tags);
+ if (rc == 0) {
+ ldt->ldt_ops->ldto_device_free(&env, d);
+ lu_env_fini(&env);
+ obd->obd_lu_dev = NULL;
+ }
+ } else
+#endif
+ {
+ OBD_CHECK_DT_OP(obd, cleanup, 0);
+ rc = OBP(obd, cleanup)(obd);
+ }
+ OBD_COUNTER_INCREMENT(obd, cleanup);
RETURN(rc);
}
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);
+
+#ifdef __KERNEL__
+ 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, NULL, ldt->ldt_ctx_tags);
+ if (rc == 0) {
+ rc = d->ld_ops->ldo_process_config(&env, d, data);
+ lu_env_fini(&env);
+ }
+ } else
+#endif
+ {
+ OBD_CHECK_DT_OP(obd, process_config, -EOPNOTSUPP);
+ rc = OBP(obd, process_config)(obd, datalen, data);
+ }
OBD_COUNTER_INCREMENT(obd, process_config);
- rc = OBP(obd, process_config)(obd, datalen, data);
RETURN(rc);
}
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);
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);
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(struct obd_export *exp, struct obdo *obdo,
struct lov_stripe_md **ea,
struct obd_trans_info *oti)
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);
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);
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);
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);
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);
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();
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);
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);
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 lustre_handle *conn,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 */
+#ifdef LIBCFS_DEBUG
+ __u64 ocf = d ? d->ocd_connect_flags : 0; /* for post-condition
+ * check */
+#endif
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, conn, 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)
{
int rc;
- __u64 ocf = d ? d->ocd_connect_flags : 0; /* for post-condition check */
+#ifdef LIBCFS_DEBUG
+ __u64 ocf = d ? d->ocd_connect_flags : 0; /* for post-condition
+ * check */
+#endif
+
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);
/* check that only subset is granted */
LASSERT(ergo(d != NULL,
(d->ocd_connect_flags & ocf) == d->ocd_connect_flags));
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);
{
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);
}
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
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",
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);
}
}
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);
* 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;
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));
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);
}
int rc;
ENTRY;
- EXP_CHECK_OP(exp, punch);
+ EXP_CHECK_DT_OP(exp, punch);
EXP_COUNTER_INCREMENT(exp, punch);
set = ptlrpc_prep_set();
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);
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))) {
int rc;
ENTRY;
- EXP_CHECK_OP(exp, brw_async);
+ EXP_CHECK_DT_OP(exp, brw_async);
EXP_COUNTER_INCREMENT(exp, brw_async);
if (!(cmd & OBD_BRW_RWMASK)) {
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)
+ struct obd_trans_info *oti,
+ struct obd_capa *ocapa)
{
struct ptlrpc_request_set *set = NULL;
struct obd_info oinfo = { { { 0 } } };
oinfo.oi_oa = oa;
oinfo.oi_md = lsm;
+ oinfo.oi_capa = ocapa;
rc = obd_brw_async(cmd, exp, &oinfo, oa_bufs, pg, oti, set);
if (rc == 0) {
rc = ptlrpc_set_wait(set);
struct lov_oinfo *loi,
cfs_page_t *page, obd_off offset,
struct obd_async_page_ops *ops,
- void *data, void **res)
+ void *data, void **res, int nocache,
+ struct lustre_handle *lockh)
{
int ret;
ENTRY;
- OBD_CHECK_OP(exp->exp_obd, prep_async_page, -EOPNOTSUPP);
+ EXP_CHECK_DT_OP(exp, prep_async_page);
EXP_COUNTER_INCREMENT(exp, prep_async_page);
ret = OBP(exp->exp_obd, prep_async_page)(exp, lsm, loi, page, offset,
- ops, data, res);
+ ops, data, res, nocache,
+ lockh);
RETURN(ret);
}
+/**
+ * Checks if requested extent lock is compatible with a lock under the page.
+ *
+ * Checks if the lock under \a page is compatible with a read or write lock
+ * (specified by \a rw) for an extent [\a start , \a end].
+ *
+ * \param exp obd export (lov or osc)
+ * \param lsm striping information for the file
+ * \param res async_page placeholder
+ * \param rw OBD_BRW_READ if requested for reading,
+ * OBD_BRW_WRITE if requested for writing
+ * \param start start of the requested extent
+ * \param end end of the requested extent
+ * \param cookie transparent parameter for passing locking context
+ *
+ * \post result == 1, *cookie == context, appropriate lock is referenced or
+ *
+ * \retval 1 owned lock is reused for the request
+ * \retval 0 no lock reused for the request
+ * \retval -ENOTSUPP reget_short_lock is not exported at this layer
+ *
+ * \see obd_release_short_lock
+ */
+static inline int obd_reget_short_lock(struct obd_export *exp,
+ struct lov_stripe_md *lsm,
+ void **res, int rw,
+ obd_off start, obd_off end,
+ void **cookie)
+{
+ ENTRY;
+
+ EXP_CHECK_DT_OP(exp, reget_short_lock);
+ EXP_COUNTER_INCREMENT(exp, reget_short_lock);
+
+ RETURN(OBP(exp->exp_obd, reget_short_lock)(exp, lsm, res, rw,
+ start, end, cookie));
+}
+
+
+/**
+ * Releases a reference to a lock taken in a "fast" way.
+ *
+ * Releases a read or write (specified by \a rw) lock
+ * referenced by \a cookie.
+ *
+ * \param exp obd export (lov or osc)
+ * \param lsm striping information for the file
+ * \param end end of the locked extent
+ * \param rw OBD_BRW_READ if requested for reading,
+ * OBD_BRW_WRITE if requested for writing
+ * \param cookie transparent parameter for passing locking context
+ *
+ * \post appropriate lock is dereferenced
+ *
+ * \see obd_reget_short_lock
+ */
+static inline int obd_release_short_lock(struct obd_export *exp,
+ struct lov_stripe_md *lsm, obd_off end,
+ void *cookie, int rw)
+{
+ ENTRY;
+
+ EXP_CHECK_DT_OP(exp, release_short_lock);
+ EXP_COUNTER_INCREMENT(exp, release_short_lock);
+
+ RETURN(OBP(exp->exp_obd, release_short_lock)(exp, lsm, end,
+ cookie, rw));
+}
+
static inline int obd_queue_async_io(struct obd_export *exp,
struct lov_stripe_md *lsm,
struct lov_oinfo *loi, void *cookie,
int rc;
ENTRY;
- OBD_CHECK_OP(exp->exp_obd, queue_async_io, -EOPNOTSUPP);
+ EXP_CHECK_DT_OP(exp, queue_async_io);
EXP_COUNTER_INCREMENT(exp, queue_async_io);
LASSERT(cmd & OBD_BRW_RWMASK);
int rc;
ENTRY;
- OBD_CHECK_OP(exp->exp_obd, set_async_flags, -EOPNOTSUPP);
+ EXP_CHECK_DT_OP(exp, set_async_flags);
EXP_COUNTER_INCREMENT(exp, set_async_flags);
rc = OBP(exp->exp_obd, set_async_flags)(exp, lsm, loi, cookie,
int rc;
ENTRY;
- OBD_CHECK_OP(exp->exp_obd, queue_group_io, -EOPNOTSUPP);
+ EXP_CHECK_DT_OP(exp, queue_group_io);
EXP_COUNTER_INCREMENT(exp, queue_group_io);
LASSERT(cmd & OBD_BRW_RWMASK);
int rc;
ENTRY;
- OBD_CHECK_OP(exp->exp_obd, trigger_group_io, -EOPNOTSUPP);
+ EXP_CHECK_DT_OP(exp, trigger_group_io);
EXP_COUNTER_INCREMENT(exp, trigger_group_io);
rc = OBP(exp->exp_obd, trigger_group_io)(exp, lsm, loi, oig);
int rc;
ENTRY;
- OBD_CHECK_OP(exp->exp_obd, teardown_async_page, -EOPNOTSUPP);
+ EXP_CHECK_DT_OP(exp, teardown_async_page);
EXP_COUNTER_INCREMENT(exp, teardown_async_page);
rc = OBP(exp->exp_obd, teardown_async_page)(exp, lsm, loi, cookie);
int objcount, struct obd_ioobj *obj,
int niocount, struct niobuf_remote *remote,
struct niobuf_local *local,
- struct obd_trans_info *oti)
+ struct obd_trans_info *oti,
+ struct lustre_capa *capa)
{
int rc;
ENTRY;
- OBD_CHECK_OP(exp->exp_obd, preprw, -EOPNOTSUPP);
+ EXP_CHECK_DT_OP(exp, preprw);
EXP_COUNTER_INCREMENT(exp, preprw);
rc = OBP(exp->exp_obd, preprw)(cmd, exp, oa, objcount, obj, niocount,
- remote, local, oti);
+ remote, local, oti, capa);
RETURN(rc);
}
{
ENTRY;
- OBD_CHECK_OP(exp->exp_obd, commitrw, -EOPNOTSUPP);
+ EXP_CHECK_DT_OP(exp, commitrw);
EXP_COUNTER_INCREMENT(exp, commitrw);
rc = OBP(exp->exp_obd, commitrw)(cmd, exp, oa, objcount, obj, niocount,
int rc;
ENTRY;
- OBD_CHECK_OP(exp->exp_obd, merge_lvb, -EOPNOTSUPP);
+ EXP_CHECK_DT_OP(exp, merge_lvb);
EXP_COUNTER_INCREMENT(exp, merge_lvb);
rc = OBP(exp->exp_obd, merge_lvb)(exp, lsm, lvb, kms_only);
int rc;
ENTRY;
- OBD_CHECK_OP(exp->exp_obd, adjust_kms, -EOPNOTSUPP);
+ EXP_CHECK_DT_OP(exp, adjust_kms);
EXP_COUNTER_INCREMENT(exp, adjust_kms);
rc = OBP(exp->exp_obd, adjust_kms)(exp, lsm, size, shrink);
int rc;
ENTRY;
- EXP_CHECK_OP(exp, iocontrol);
+ EXP_CHECK_DT_OP(exp, iocontrol);
EXP_COUNTER_INCREMENT(exp, iocontrol);
rc = OBP(exp->exp_obd, iocontrol)(cmd, exp, len, karg, uarg);
static inline int obd_enqueue_rqset(struct obd_export *exp,
struct obd_info *oinfo,
- struct obd_enqueue_info *einfo)
+ struct ldlm_enqueue_info *einfo)
{
+ struct ptlrpc_request_set *set = NULL;
int rc;
ENTRY;
- EXP_CHECK_OP(exp, enqueue);
+ EXP_CHECK_DT_OP(exp, enqueue);
EXP_COUNTER_INCREMENT(exp, enqueue);
- einfo->ei_rqset = ptlrpc_prep_set();
- if (einfo->ei_rqset == NULL)
+ set = ptlrpc_prep_set();
+ if (set == NULL)
RETURN(-ENOMEM);
- rc = OBP(exp->exp_obd, enqueue)(exp, oinfo, einfo);
+ rc = OBP(exp->exp_obd, enqueue)(exp, oinfo, einfo, set);
if (rc == 0)
- rc = ptlrpc_set_wait(einfo->ei_rqset);
- ptlrpc_set_destroy(einfo->ei_rqset);
- einfo->ei_rqset = NULL;
-
+ rc = ptlrpc_set_wait(set);
+ ptlrpc_set_destroy(set);
RETURN(rc);
}
static inline int obd_enqueue(struct obd_export *exp,
struct obd_info *oinfo,
- struct obd_enqueue_info *einfo)
+ struct ldlm_enqueue_info *einfo,
+ struct ptlrpc_request_set *set)
{
int rc;
ENTRY;
- EXP_CHECK_OP(exp, enqueue);
+ EXP_CHECK_DT_OP(exp, enqueue);
EXP_COUNTER_INCREMENT(exp, enqueue);
- rc = OBP(exp->exp_obd, enqueue)(exp, oinfo, einfo);
+ rc = OBP(exp->exp_obd, enqueue)(exp, oinfo, einfo, set);
RETURN(rc);
}
int rc;
ENTRY;
- EXP_CHECK_OP(exp, match);
+ EXP_CHECK_DT_OP(exp, match);
EXP_COUNTER_INCREMENT(exp, match);
rc = OBP(exp->exp_obd, match)(exp, ea, type, policy, mode, flags, data,
int rc;
ENTRY;
- EXP_CHECK_OP(exp, change_cbdata);
+ EXP_CHECK_DT_OP(exp, change_cbdata);
EXP_COUNTER_INCREMENT(exp, change_cbdata);
rc = OBP(exp->exp_obd, change_cbdata)(exp, lsm, it, data);
int rc;
ENTRY;
- EXP_CHECK_OP(exp, cancel);
+ EXP_CHECK_DT_OP(exp, cancel);
EXP_COUNTER_INCREMENT(exp, cancel);
rc = OBP(exp->exp_obd, cancel)(exp, ea, mode, lockh);
}
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);
int rc;
ENTRY;
- EXP_CHECK_OP(exp, join_lru);
+ EXP_CHECK_DT_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);
}
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);
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);
}
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;
else
rc2 = 0;
- return rc1 ?: rc2;
- }
+ return rc1 ? rc1 : rc2;
+}
static inline int obd_quotacheck(struct obd_export *exp,
struct obd_quotactl *oqctl)
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);
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);
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);
RETURN(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);
+}
+
+/* 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, __u32 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)
+{
+ 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));
+}
+
+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_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);
/* 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.
/* 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 */
git://git.whamcloud.com / fs / lustre-release.git / blobdiff