* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2016, Intel Corporation.
+ * Copyright (c) 2011, 2017, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#ifndef __CLASS_OBD_H
#define __CLASS_OBD_H
-
+#include <linux/kobject.h>
#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 *);
extern int class_handle_ioctl(unsigned int cmd, unsigned long arg);
-extern int lustre_get_jobid(char *jobid);
+int lustre_get_jobid(char *jobid, size_t len);
+void lustre_jobid_clear(const char *jobid);
+void jobid_cache_fini(void);
+int jobid_cache_init(void);
struct lu_device_type;
/* genops.c */
struct obd_export *class_conn2export(struct lustre_handle *);
+struct kobject *class_setup_tunables(const char *name);
int class_register_type(struct obd_ops *, struct md_ops *, bool enable_proc,
struct lprocfs_vars *module_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);
-void class_release_dev(struct obd_device *obd);
+struct obd_device *class_newdev(const char *type_name, const char *name,
+ const char *uuid);
+int class_register_device(struct obd_device *obd);
+void class_unregister_device(struct obd_device *obd);
+void class_free_dev(struct obd_device *obd);
+struct obd_device *class_dev_by_str(const char *str);
int class_name2dev(const char *name);
struct obd_device *class_name2obd(const char *name);
int class_uuid2dev(struct obd_uuid *uuid);
char *lustre_cfg_string(struct lustre_cfg *lcfg, u32 index);
struct lustre_cfg *lustre_cfg_rename(struct lustre_cfg *cfg,
const char *new_name);
+void print_lustre_cfg(struct lustre_cfg *lcfg);
int class_process_config(struct lustre_cfg *lcfg);
+ssize_t class_set_global(const char *param);
+ssize_t class_modify_config(struct lustre_cfg *lcfg, const char *prefix,
+ struct kobject *kobj);
int class_process_proc_param(char *prefix, struct lprocfs_vars *lvars,
struct lustre_cfg *lcfg, void *data);
int class_attach(struct lustre_cfg *lcfg);
struct config_llog_data {
struct ldlm_res_id cld_resid;
struct config_llog_instance cld_cfg;
- struct list_head cld_list_chain;
+ struct list_head cld_list_chain;/* on config_llog_list */
atomic_t cld_refcount;
struct config_llog_data *cld_sptlrpc;/* depended sptlrpc log */
struct config_llog_data *cld_params; /* common parameters log */
void class_export_put(struct obd_export *exp);
struct obd_export *class_new_export(struct obd_device *obddev,
struct obd_uuid *cluuid);
+struct obd_export *class_new_export_self(struct obd_device *obd,
+ struct obd_uuid *uuid);
void class_unlink_export(struct obd_export *exp);
struct obd_import *class_import_get(struct obd_import *);
void obdo_cpy_md(struct obdo *dst, const struct obdo *src, u64 valid);
void obdo_to_ioobj(const struct obdo *oa, struct obd_ioobj *ioobj);
-#define OBT(dev) (dev)->obd_type
#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
while obd is stopping */
tmp->nid_ldlm_stats);
}
-#define EXP_CHECK_MD_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) || !MDP((exp)->exp_obd, op)) { \
- CERROR("%s: obd_" #op ": dev %d no operation\n", \
- (exp)->exp_obd->obd_name, \
- (exp)->exp_obd->obd_minor); \
- RETURN(-EOPNOTSUPP); \
- } \
-} while (0)
-
-
-#define OBD_CHECK_DT_OP(obd, op, err) \
-do { \
- if (!OBT(obd) || !OBP((obd), op)) { \
- if (err) \
- CERROR("%s: no obd_" #op " operation\n", \
- obd->obd_name); \
- 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); \
- } \
- OBD_CHECK_DT_OP((exp)->exp_obd, op, -EOPNOTSUPP); \
-} while (0)
-
-#define CTXT_CHECK_OP(ctxt, op, err) \
-do { \
- if (!OBT(ctxt->loc_obd) || !CTXTP((ctxt), op)) { \
- if (err) \
- CERROR("%s: no lop_" #op "operation\n", \
- ctxt->loc_obd->obd_name); \
- RETURN(err); \
- } \
-} while (0)
+static inline int exp_check_ops(struct obd_export *exp)
+{
+ if (exp == NULL) {
+ RETURN(-ENODEV);
+ }
+ if (exp->exp_obd == NULL || !exp->exp_obd->obd_type) {
+ RETURN(-EOPNOTSUPP);
+ }
+ RETURN(0);
+}
static inline int class_devno_max(void)
{
int rc;
ENTRY;
- EXP_CHECK_DT_OP(exp, get_info);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
+ if (!exp->exp_obd->obd_type->typ_dt_ops->o_get_info) {
+ CERROR("%s: no %s operation\n",
+ (exp)->exp_obd->obd_name, __func__);
+ RETURN(-ENOTSUPP);
+ }
EXP_COUNTER_INCREMENT(exp, get_info);
rc = OBP(exp->exp_obd, get_info)(env, exp, keylen, key, vallen, val);
int rc;
ENTRY;
- EXP_CHECK_DT_OP(exp, set_info_async);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
+ if (!exp->exp_obd->obd_type->typ_dt_ops->o_set_info_async) {
+ CERROR("%s: no %s operation\n",
+ (exp)->exp_obd->obd_name, __func__);
+ RETURN(-ENOTSUPP);
+ }
EXP_COUNTER_INCREMENT(exp, set_info_async);
rc = OBP(exp->exp_obd, set_info_async)(env, exp, keylen, key, vallen,
* 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);
+ struct lu_device_type *ldt = obd->obd_type->typ_lu;
+ struct lu_device *d;
+
ENTRY;
- ldt = obd->obd_type->typ_lu;
if (ldt != NULL) {
struct lu_context session_ctx;
struct lu_env env;
lu_context_fini(&session_ctx);
} else {
- OBD_CHECK_DT_OP(obd, setup, -EOPNOTSUPP);
+ if (!obd->obd_type->typ_dt_ops->o_setup) {
+ CERROR("%s: no %s operation\n", obd->obd_name,
+ __func__);
+ RETURN(-EOPNOTSUPP);
+ }
OBD_COUNTER_INCREMENT(obd, setup);
rc = OBP(obd, setup)(obd, cfg);
}
static inline int obd_precleanup(struct obd_device *obd)
{
int rc;
- DECLARE_LU_VARS(ldt, d);
+ struct lu_device_type *ldt = obd->obd_type->typ_lu;
+ struct lu_device *d = obd->obd_lu_dev;
+
ENTRY;
- OBD_CHECK_DEV(obd);
- ldt = obd->obd_type->typ_lu;
- d = obd->obd_lu_dev;
if (ldt != NULL && d != NULL) {
struct lu_env env;
lu_env_fini(&env);
}
}
- OBD_CHECK_DT_OP(obd, precleanup, 0);
+
+ if (!obd->obd_type->typ_dt_ops->o_precleanup)
+ RETURN(0);
+
OBD_COUNTER_INCREMENT(obd, precleanup);
rc = OBP(obd, precleanup)(obd);
static inline int obd_cleanup(struct obd_device *obd)
{
int rc;
- DECLARE_LU_VARS(ldt, d);
- ENTRY;
+ struct lu_device_type *ldt = obd->obd_type->typ_lu;
+ struct lu_device *d = obd->obd_lu_dev;
- OBD_CHECK_DEV(obd);
-
- ldt = obd->obd_type->typ_lu;
- d = obd->obd_lu_dev;
+ ENTRY;
if (ldt != NULL && d != NULL) {
struct lu_env env;
obd->obd_lu_dev = NULL;
}
}
- OBD_CHECK_DT_OP(obd, cleanup, 0);
+ if (!obd->obd_type->typ_dt_ops->o_cleanup)
+ RETURN(0);
+
OBD_COUNTER_INCREMENT(obd, cleanup);
rc = OBP(obd, cleanup)(obd);
EXIT;
}
-static inline int
-obd_process_config(struct obd_device *obd, int datalen, void *data)
+static inline int obd_process_config(struct obd_device *obd, int datalen,
+ void *data)
{
int rc;
- DECLARE_LU_VARS(ldt, d);
- ENTRY;
+ struct lu_device_type *ldt = obd->obd_type->typ_lu;
+ struct lu_device *d = obd->obd_lu_dev;
- OBD_CHECK_DEV(obd);
+ ENTRY;
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;
lu_env_fini(&env);
}
} else {
- OBD_CHECK_DT_OP(obd, process_config, -EOPNOTSUPP);
+ if (!obd->obd_type->typ_dt_ops->o_process_config) {
+ CERROR("%s: no %s operation\n",
+ obd->obd_name, __func__);
+ RETURN(-EOPNOTSUPP);
+ }
rc = OBP(obd, process_config)(obd, datalen, data);
}
OBD_COUNTER_INCREMENT(obd, process_config);
int rc;
ENTRY;
- EXP_CHECK_DT_OP(exp, create);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
+ if (!exp->exp_obd->obd_type->typ_dt_ops->o_create) {
+ CERROR("%s: no %s operation\n",
+ (exp)->exp_obd->obd_name, __func__);
+ RETURN(-ENOTSUPP);
+ }
EXP_COUNTER_INCREMENT(exp, create);
rc = OBP(exp->exp_obd, create)(env, exp, obdo);
int rc;
ENTRY;
- EXP_CHECK_DT_OP(exp, destroy);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
+ if (!exp->exp_obd->obd_type->typ_dt_ops->o_destroy) {
+ CERROR("%s: no %s operation\n",
+ (exp)->exp_obd->obd_name, __func__);
+ RETURN(-ENOTSUPP);
+ }
EXP_COUNTER_INCREMENT(exp, destroy);
rc = OBP(exp->exp_obd, destroy)(env, exp, obdo);
int rc;
ENTRY;
- EXP_CHECK_DT_OP(exp, getattr);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
+ if (!exp->exp_obd->obd_type->typ_dt_ops->o_getattr) {
+ CERROR("%s: no %s operation\n",
+ (exp)->exp_obd->obd_name, __func__);
+ RETURN(-ENOTSUPP);
+ }
EXP_COUNTER_INCREMENT(exp, getattr);
rc = OBP(exp->exp_obd, getattr)(env, exp, oa);
int rc;
ENTRY;
- EXP_CHECK_DT_OP(exp, setattr);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
+ if (!exp->exp_obd->obd_type->typ_dt_ops->o_setattr) {
+ CERROR("%s: no %s operation\n",
+ (exp)->exp_obd->obd_name, __func__);
+ RETURN(-ENOTSUPP);
+ }
EXP_COUNTER_INCREMENT(exp, setattr);
rc = OBP(exp->exp_obd, setattr)(env, exp, oa);
ENTRY;
OBD_CHECK_DEV_ACTIVE(obd);
- OBD_CHECK_DT_OP(obd, add_conn, -EOPNOTSUPP);
+ if (!obd->obd_type || !obd->obd_type->typ_dt_ops->o_add_conn) {
+ CERROR("%s: no %s operation\n", obd->obd_name, __func__);
+ RETURN(-EOPNOTSUPP);
+ }
OBD_COUNTER_INCREMENT(obd, add_conn);
rc = OBP(obd, add_conn)(imp, uuid, priority);
ENTRY;
OBD_CHECK_DEV_ACTIVE(obd);
- OBD_CHECK_DT_OP(obd, del_conn, -EOPNOTSUPP);
+ if (!obd->obd_type || !obd->obd_type->typ_dt_ops->o_del_conn) {
+ CERROR("%s: no %s operation\n", obd->obd_name, __func__);
+ RETURN(-EOPNOTSUPP);
+ }
OBD_COUNTER_INCREMENT(obd, del_conn);
rc = OBP(obd, del_conn)(imp, uuid);
struct obd_uuid *uuid;
ENTRY;
- OBD_CHECK_DT_OP(exp->exp_obd, get_uuid, NULL);
+ if (!exp->exp_obd->obd_type ||
+ !exp->exp_obd->obd_type->typ_dt_ops->o_get_uuid)
+ RETURN(NULL);
+
EXP_COUNTER_INCREMENT(exp, get_uuid);
uuid = OBP(exp->exp_obd, get_uuid)(exp);
ENTRY;
OBD_CHECK_DEV_ACTIVE(obd);
- OBD_CHECK_DT_OP(obd, connect, -EOPNOTSUPP);
+ if (!obd->obd_type || !obd->obd_type->typ_dt_ops->o_connect) {
+ CERROR("%s: no %s operation\n", obd->obd_name, __func__);
+ RETURN(-EOPNOTSUPP);
+ }
OBD_COUNTER_INCREMENT(obd, connect);
rc = OBP(obd, connect)(env, exp, obd, cluuid, data, localdata);
ENTRY;
OBD_CHECK_DEV_ACTIVE(obd);
- OBD_CHECK_DT_OP(obd, reconnect, 0);
+ if (!obd->obd_type || !obd->obd_type->typ_dt_ops->o_reconnect)
+ RETURN(0);
+
OBD_COUNTER_INCREMENT(obd, reconnect);
rc = OBP(obd, reconnect)(env, exp, obd, cluuid, d, localdata);
{
int rc;
ENTRY;
-
- EXP_CHECK_DT_OP(exp, disconnect);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
+ if (!exp->exp_obd->obd_type->typ_dt_ops->o_disconnect) {
+ CERROR("%s: no %s operation\n",
+ (exp)->exp_obd->obd_name, __func__);
+ RETURN(-ENOTSUPP);
+ }
EXP_COUNTER_INCREMENT(exp, disconnect);
rc = OBP(exp->exp_obd, disconnect)(exp);
int rc;
ENTRY;
- OBD_CHECK_DT_OP(obd, fid_init, 0);
+ if (!obd->obd_type || !obd->obd_type->typ_dt_ops->o_fid_init)
+ RETURN(0);
OBD_COUNTER_INCREMENT(obd, fid_init);
rc = OBP(obd, fid_init)(obd, exp, type);
{
int rc;
ENTRY;
-
- OBD_CHECK_DT_OP(obd, fid_fini, 0);
+ if (!obd->obd_type || !obd->obd_type->typ_dt_ops->o_fid_fini)
+ RETURN(0);
OBD_COUNTER_INCREMENT(obd, fid_fini);
rc = OBP(obd, fid_fini)(obd);
{
int rc;
ENTRY;
-
- EXP_CHECK_DT_OP(exp, fid_alloc);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
+ if (!exp->exp_obd->obd_type->typ_dt_ops->o_fid_alloc) {
+ CERROR("%s: no %s operation\n",
+ (exp)->exp_obd->obd_name, __func__);
+ RETURN(-ENOTSUPP);
+ }
EXP_COUNTER_INCREMENT(exp, fid_alloc);
rc = OBP(exp->exp_obd, fid_alloc)(env, exp, fid, op_data);
int rc;
ENTRY;
- OBD_CHECK_DT_OP(exp->exp_obd, ping, 0);
+ if (!exp->exp_obd->obd_type ||
+ !exp->exp_obd->obd_type->typ_dt_ops->o_ping)
+ RETURN(0);
+
EXP_COUNTER_INCREMENT(exp, ping);
rc = OBP(exp->exp_obd, ping)(env, exp);
int rc;
ENTRY;
- OBD_CHECK_DT_OP(obd, pool_new, -EOPNOTSUPP);
+ if (!obd->obd_type || !obd->obd_type->typ_dt_ops->o_pool_new) {
+ CERROR("%s: no %s operation\n", obd->obd_name, __func__);
+ RETURN(-EOPNOTSUPP);
+ }
OBD_COUNTER_INCREMENT(obd, pool_new);
rc = OBP(obd, pool_new)(obd, poolname);
{
int rc;
ENTRY;
-
- OBD_CHECK_DT_OP(obd, pool_del, -EOPNOTSUPP);
+ if (!obd->obd_type || !obd->obd_type->typ_dt_ops->o_pool_del) {
+ CERROR("%s: no %s operation\n", obd->obd_name, __func__);
+ RETURN(-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)
+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);
+ if (!obd->obd_type || !obd->obd_type->typ_dt_ops->o_pool_add) {
+ CERROR("%s: no %s operation\n", obd->obd_name, __func__);
+ RETURN(-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)
+static inline int obd_pool_rem(struct obd_device *obd, char *poolname,
+ char *ostname)
{
- int rc;
- ENTRY;
+ int rc;
- OBD_CHECK_DT_OP(obd, pool_rem, -EOPNOTSUPP);
- OBD_COUNTER_INCREMENT(obd, pool_rem);
+ ENTRY;
+ if (!obd->obd_type || !obd->obd_type->typ_dt_ops->o_pool_rem) {
+ CERROR("%s: no %s operation\n", obd->obd_name, __func__);
+ RETURN(-EOPNOTSUPP);
+ }
+ OBD_COUNTER_INCREMENT(obd, pool_rem);
- rc = OBP(obd, pool_rem)(obd, poolname, ostname);
- RETURN(rc);
+ 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;
+ ENTRY;
+ if (obd->obd_type && 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;
+ ENTRY;
+ if (obd->obd_type && 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;
+ int rc = 0;
- ENTRY;
- if ((exp)->exp_obd != NULL && OBT((exp)->exp_obd) &&
- OBP((exp)->exp_obd, init_export))
- rc = OBP(exp->exp_obd, init_export)(exp);
- RETURN(rc);
+ ENTRY;
+ if (exp->exp_obd != NULL && exp->exp_obd->obd_type &&
+ OBP((exp)->exp_obd, init_export))
+ rc = OBP(exp->exp_obd, init_export)(exp);
+ RETURN(rc);
}
static inline int obd_destroy_export(struct obd_export *exp)
{
- ENTRY;
- if ((exp)->exp_obd != NULL && OBT((exp)->exp_obd) &&
- OBP((exp)->exp_obd, destroy_export))
- OBP(exp->exp_obd, destroy_export)(exp);
- RETURN(0);
+ ENTRY;
+ if (exp->exp_obd != NULL && exp->exp_obd->obd_type &&
+ OBP(exp->exp_obd, destroy_export))
+ OBP(exp->exp_obd, destroy_export)(exp);
+ RETURN(0);
}
-/* @max_age is the oldest time in jiffies that we accept using a cached data.
+/* @max_age is the oldest time in seconds that we accept using a cached data.
* 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. */
+ * target. Use a value of 'ktime_get_seconds() + X' to guarantee freshness.
+ */
static inline int obd_statfs_async(struct obd_export *exp,
- struct obd_info *oinfo,
- __u64 max_age,
- struct ptlrpc_request_set *rqset)
+ struct obd_info *oinfo,
+ time64_t max_age,
+ struct ptlrpc_request_set *rqset)
{
- int rc = 0;
- struct obd_device *obd;
- ENTRY;
-
- if (exp == NULL || exp->exp_obd == NULL)
- RETURN(-EINVAL);
-
- obd = exp->exp_obd;
- OBD_CHECK_DT_OP(obd, statfs, -EOPNOTSUPP);
- OBD_COUNTER_INCREMENT(obd, statfs);
-
- CDEBUG(D_SUPER, "%s: osfs %p age %llu, max_age %llu\n",
- obd->obd_name, &obd->obd_osfs, obd->obd_osfs_age, max_age);
- if (cfs_time_before_64(obd->obd_osfs_age, max_age)) {
- rc = OBP(obd, statfs_async)(exp, oinfo, max_age, rqset);
- } else {
- CDEBUG(D_SUPER, "%s: use %p cache blocks %llu/%llu objects %llu/%llu\n",
- obd->obd_name, &obd->obd_osfs,
- obd->obd_osfs.os_bavail, obd->obd_osfs.os_blocks,
- obd->obd_osfs.os_ffree, obd->obd_osfs.os_files);
- 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);
- }
- RETURN(rc);
-}
-
-static inline int obd_statfs_rqset(struct obd_export *exp,
- struct obd_statfs *osfs, __u64 max_age,
- __u32 flags)
-{
- struct ptlrpc_request_set *set = NULL;
- struct obd_info oinfo = {
- .oi_osfs = osfs,
- .oi_flags = flags,
- };
int rc = 0;
+ struct obd_device *obd;
ENTRY;
- set = ptlrpc_prep_set();
- if (set == NULL)
- RETURN(-ENOMEM);
-
- rc = obd_statfs_async(exp, &oinfo, max_age, set);
- if (rc == 0)
- rc = ptlrpc_set_wait(set);
+ if (exp == NULL || exp->exp_obd == NULL)
+ RETURN(-EINVAL);
- ptlrpc_set_destroy(set);
+ obd = exp->exp_obd;
+ if (!obd->obd_type || !obd->obd_type->typ_dt_ops->o_statfs) {
+ CERROR("%s: no %s operation\n", obd->obd_name, __func__);
+ RETURN(-EOPNOTSUPP);
+ }
+ OBD_COUNTER_INCREMENT(obd, statfs);
+ CDEBUG(D_SUPER, "%s: osfs %p age %lld, max_age %lld\n",
+ obd->obd_name, &obd->obd_osfs, obd->obd_osfs_age, max_age);
+ if (obd->obd_osfs_age < max_age) {
+ rc = OBP(obd, statfs_async)(exp, oinfo, max_age, rqset);
+ } else {
+ CDEBUG(D_SUPER,
+ "%s: use %p cache blocks %llu/%llu objects %llu/%llu\n",
+ obd->obd_name, &obd->obd_osfs,
+ obd->obd_osfs.os_bavail, obd->obd_osfs.os_blocks,
+ obd->obd_osfs.os_ffree, obd->obd_osfs.os_files);
+ 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);
+ }
RETURN(rc);
}
-/* @max_age is the oldest time in jiffies that we accept using a cached data.
+/* @max_age is the oldest time in seconds that we accept using a cached data.
* 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. */
+ * target. Use a value of 'ktime_get_seconds() + X' to guarantee freshness.
+ */
static inline int obd_statfs(const struct lu_env *env, struct obd_export *exp,
- struct obd_statfs *osfs, __u64 max_age,
+ struct obd_statfs *osfs, time64_t max_age,
__u32 flags)
{
int rc = 0;
if (obd == NULL)
RETURN(-EINVAL);
- OBD_CHECK_DT_OP(obd, statfs, -EOPNOTSUPP);
+ OBD_CHECK_DEV_ACTIVE(obd);
+
+ if (!obd->obd_type || !obd->obd_type->typ_dt_ops->o_statfs) {
+ CERROR("%s: no %s operation\n", obd->obd_name, __func__);
+ RETURN(-EOPNOTSUPP);
+ }
OBD_COUNTER_INCREMENT(obd, statfs);
- CDEBUG(D_SUPER, "osfs %llu, max_age %llu\n",
+ CDEBUG(D_SUPER, "osfs %lld, max_age %lld\n",
obd->obd_osfs_age, max_age);
- if (cfs_time_before_64(obd->obd_osfs_age, max_age)) {
+ if (obd->obd_osfs_age < max_age) {
rc = OBP(obd, statfs)(env, exp, osfs, max_age, flags);
if (rc == 0) {
spin_lock(&obd->obd_osfs_lock);
memcpy(&obd->obd_osfs, osfs, sizeof(obd->obd_osfs));
- obd->obd_osfs_age = cfs_time_current_64();
+ obd->obd_osfs_age = ktime_get_seconds();
spin_unlock(&obd->obd_osfs_lock);
}
} else {
int rc;
ENTRY;
- EXP_CHECK_DT_OP(exp, preprw);
+
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
+ if (!exp->exp_obd->obd_type->typ_dt_ops->o_preprw) {
+ CERROR("%s: no %s operation\n",
+ (exp)->exp_obd->obd_name, __func__);
+ RETURN(-ENOTSUPP);
+ }
EXP_COUNTER_INCREMENT(exp, preprw);
rc = OBP(exp->exp_obd, preprw)(env, cmd, exp, oa, objcount, obj, remote,
pages, local);
{
ENTRY;
- EXP_CHECK_DT_OP(exp, commitrw);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
+ if (!exp->exp_obd->obd_type->typ_dt_ops->o_commitrw) {
+ CERROR("%s: no %s operation\n",
+ (exp)->exp_obd->obd_name, __func__);
+ RETURN(-ENOTSUPP);
+ }
EXP_COUNTER_INCREMENT(exp, commitrw);
rc = OBP(exp->exp_obd, commitrw)(env, cmd, exp, oa, objcount, obj,
rnb, pages, local, rc);
int rc;
ENTRY;
- EXP_CHECK_DT_OP(exp, iocontrol);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
+ if (!exp->exp_obd->obd_type->typ_dt_ops->o_iocontrol) {
+ CERROR("%s: no %s operation\n",
+ (exp)->exp_obd->obd_name, __func__);
+ RETURN(-ENOTSUPP);
+ }
EXP_COUNTER_INCREMENT(exp, iocontrol);
rc = OBP(exp->exp_obd, iocontrol)(cmd, exp, len, karg, uarg);
int rc;
ENTRY;
- EXP_CHECK_DT_OP(exp, quotactl);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
+ if (!exp->exp_obd->obd_type->typ_dt_ops->o_quotactl) {
+ CERROR("%s: no %s operation\n",
+ (exp)->exp_obd->obd_name, __func__);
+ RETURN(-ENOTSUPP);
+ }
EXP_COUNTER_INCREMENT(exp, quotactl);
rc = OBP(exp->exp_obd, quotactl)(exp->exp_obd, exp, oqctl);
}
static inline int obd_health_check(const struct lu_env *env,
- struct obd_device *obd)
-{
- /* returns: 0 on healthy
- * >0 on unhealthy + reason code/flag
- * however the only suppored reason == 1 right now
- * We'll need to define some better reasons
- * or flags in the future.
- * <0 on error
- */
- int rc;
- ENTRY;
+ struct obd_device *obd)
+{
+ /* returns: 0 on healthy
+ * >0 on unhealthy + reason code/flag
+ * however the only suppored reason == 1 right now
+ * We'll need to define some better reasons
+ * or flags in the future.
+ * <0 on error
+ */
+ int rc;
- /* 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);
- }
- if (!obd->obd_set_up || obd->obd_stopping)
- RETURN(0);
- if (!OBP(obd, health_check))
- RETURN(0);
+ ENTRY;
- rc = OBP(obd, health_check)(env, obd);
- RETURN(rc);
+ /* NULL method is normal here */
+ if (obd == NULL || !obd->obd_type) {
+ CERROR("cleaned up obd\n");
+ RETURN(-EOPNOTSUPP);
+ }
+ if (!obd->obd_set_up || obd->obd_stopping)
+ RETURN(0);
+ if (!OBP(obd, health_check))
+ RETURN(0);
+
+ rc = OBP(obd, health_check)(env, obd);
+ RETURN(rc);
}
static inline int obd_register_observer(struct obd_device *obd,
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, get_root);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, get_root);
rc = MDP(exp->exp_obd, get_root)(exp, fileset, fid);
RETURN(rc);
}
-static inline int md_getattr(struct obd_export *exp, struct md_op_data *op_data,
- struct ptlrpc_request **request)
+static inline int md_getattr(struct obd_export *exp,
+ struct md_op_data *op_data,
+ 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, op_data, request);
- RETURN(rc);
+ int rc;
+
+ ENTRY;
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+ EXP_MD_COUNTER_INCREMENT(exp, getattr);
+ rc = MDP(exp->exp_obd, getattr)(exp, op_data, request);
+ RETURN(rc);
}
static inline int md_null_inode(struct obd_export *exp,
{
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, null_inode);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, null_inode);
rc = MDP(exp->exp_obd, null_inode)(exp, fid);
RETURN(rc);
{
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, close);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, close);
rc = MDP(exp->exp_obd, close)(exp, op_data, mod, request);
RETURN(rc);
{
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, create);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, create);
rc = MDP(exp->exp_obd, create)(exp, op_data, data, datalen, mode,
uid, gid, cap_effective, rdev, request);
{
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, enqueue);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, enqueue);
rc = MDP(exp->exp_obd, enqueue)(exp, einfo, policy, op_data, lockh,
extra_lock_flags);
{
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, getattr_name);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, getattr_name);
rc = MDP(exp->exp_obd, getattr_name)(exp, op_data, request);
RETURN(rc);
{
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, intent_lock);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, intent_lock);
rc = MDP(exp->exp_obd, intent_lock)(exp, op_data, it, reqp, cb_blocking,
extra_lock_flags);
{
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, link);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, link);
rc = MDP(exp->exp_obd, link)(exp, op_data, request);
RETURN(rc);
{
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, rename);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
EXP_MD_COUNTER_INCREMENT(exp, rename);
rc = MDP(exp->exp_obd, rename)(exp, op_data, old, oldlen, new,
newlen, request);
{
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, setattr);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
EXP_MD_COUNTER_INCREMENT(exp, setattr);
rc = MDP(exp->exp_obd, setattr)(exp, op_data, ea, ealen, request);
RETURN(rc);
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, fsync);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
EXP_MD_COUNTER_INCREMENT(exp, fsync);
rc = MDP(exp->exp_obd, fsync)(exp, fid, request);
RETURN(rc);
}
+/* FLR: resync mirrored files. */
+static inline int md_file_resync(struct obd_export *exp,
+ struct md_op_data *data)
+{
+ int rc;
+
+ ENTRY;
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
+ EXP_MD_COUNTER_INCREMENT(exp, file_resync);
+ rc = MDP(exp->exp_obd, file_resync)(exp, data);
+
+ RETURN(rc);
+}
+
static inline int md_read_page(struct obd_export *exp,
struct md_op_data *op_data,
struct md_callback *cb_op,
{
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, read_page);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
EXP_MD_COUNTER_INCREMENT(exp, read_page);
rc = MDP(exp->exp_obd, read_page)(exp, op_data, cb_op, hash_offset,
ppage);
{
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, unlink);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
EXP_MD_COUNTER_INCREMENT(exp, unlink);
rc = MDP(exp->exp_obd, unlink)(exp, op_data, request);
RETURN(rc);
struct obd_export *md_exp,
struct lustre_md *md)
{
+ int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, get_lustre_md);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
+
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)
{
+ int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, free_lustre_md);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, free_lustre_md);
RETURN(MDP(exp->exp_obd, free_lustre_md)(exp, md));
}
struct cl_attr *attr,
ldlm_blocking_callback cb)
{
+ int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, merge_attr);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, merge_attr);
RETURN(MDP(exp->exp_obd, merge_attr)(exp, lsm, attr, cb));
}
int output_size, int flags, __u32 suppgid,
struct ptlrpc_request **request)
{
+ int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, setxattr);
+
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, setxattr);
RETURN(MDP(exp->exp_obd, setxattr)(exp, fid, valid, name, input,
input_size, output_size, flags,
int output_size, int flags,
struct ptlrpc_request **request)
{
+ int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, getxattr);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, getxattr);
RETURN(MDP(exp->exp_obd, getxattr)(exp, fid, valid, name, input,
input_size, output_size, flags,
struct obd_client_handle *och,
struct lookup_intent *it)
{
+ int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, set_open_replay_data);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, set_open_replay_data);
RETURN(MDP(exp->exp_obd, set_open_replay_data)(exp, och, it));
}
static inline int md_clear_open_replay_data(struct obd_export *exp,
struct obd_client_handle *och)
{
+ int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, clear_open_replay_data);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, clear_open_replay_data);
RETURN(MDP(exp->exp_obd, clear_open_replay_data)(exp, och));
}
const struct lustre_handle *lockh,
void *data, __u64 *bits)
{
+ int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, set_lock_data);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, set_lock_data);
RETURN(MDP(exp->exp_obd, set_lock_data)(exp, lockh, data, bits));
}
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, cancel_unused);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, cancel_unused);
rc = MDP(exp->exp_obd, cancel_unused)(exp, fid, policy, mode,
enum ldlm_mode mode,
struct lustre_handle *lockh)
{
+ int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, lock_match);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
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, __u32 ea_size,
__u32 def_ea_size)
{
+ int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, init_ea_size);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, init_ea_size);
RETURN(MDP(exp->exp_obd, init_ea_size)(exp, ea_size, def_ea_size));
}
{
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, intent_getattr_async);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, intent_getattr_async);
rc = MDP(exp->exp_obd, intent_getattr_async)(exp, minfo);
RETURN(rc);
{
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, revalidate_lock);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, revalidate_lock);
rc = MDP(exp->exp_obd, revalidate_lock)(exp, it, fid, bits);
RETURN(rc);
{
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, get_fid_from_lsm);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, get_fid_from_lsm);
rc = MDP(exp->exp_obd, get_fid_from_lsm)(exp, lsm, name, namelen, fid);
RETURN(rc);
{
int rc;
ENTRY;
- EXP_CHECK_MD_OP(exp, unpackmd);
+ rc = exp_check_ops(exp);
+ if (rc)
+ RETURN(rc);
EXP_MD_COUNTER_INCREMENT(exp, unpackmd);
rc = MDP(exp->exp_obd, unpackmd)(exp, plsm, lmm, lmm_size);
RETURN(rc);
int lustre_unregister_fs(void);
int lustre_check_exclusion(struct super_block *sb, char *svname);
-/* sysctl.c */
-extern int obd_sysctl_init(void);
-extern void obd_sysctl_clean(void);
-
-/* uuid.c */
typedef __u8 class_uuid_t[16];
-void class_uuid_unparse(class_uuid_t in, struct obd_uuid *out);
+static inline void class_uuid_unparse(class_uuid_t uu, struct obd_uuid *out)
+{
+ snprintf(out->uuid, sizeof(out->uuid), "%02x%02x%02x%02x-%02x%02x-"
+ "%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+ uu[14], uu[15], uu[12], uu[13], uu[10], uu[11], uu[8], uu[9],
+ uu[6], uu[7], uu[4], uu[5], uu[2], uu[3], uu[0], uu[1]);
+}
/* lustre_peer.c */
int lustre_uuid_to_peer(const char *uuid, lnet_nid_t *peer_nid, int index);
int class_check_uuid(struct obd_uuid *uuid, __u64 nid);
/* class_obd.c */
-extern char obd_jobid_node[];
+extern char obd_jobid_name[];
/* prng.c */
#define ll_generate_random_uuid(uuid_out) cfs_get_random_bytes(uuid_out, sizeof(class_uuid_t))
git://git.whamcloud.com / fs / lustre-release.git / blobdiff