* GPL HEADER END
*/
/*
- * Copyright 2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*/
/*
+ * Copyright (c) 2011 Whamcloud, Inc.
+ */
+/*
* This file is part of Lustre, http://www.lustre.org/
* Lustre is a trademark of Sun Microsystems, Inc.
*/
/* OBD Device Declarations */
extern struct obd_device *obd_devs[MAX_OBD_DEVICES];
-extern cfs_spinlock_t obd_dev_lock;
+extern cfs_rwlock_t obd_dev_lock;
/* OBD Operations Declarations */
extern struct obd_device *class_conn2obd(struct lustre_handle *);
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_connect_flags2str(char *page, int count, __u64 flags, char *sep);
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);
+int kuc_len(int payload_len);
+struct kuc_hdr * kuc_ptr(void *p);
+int kuc_ispayload(void *p);
+void *kuc_alloc(int payload_len, int transport, int type);
+void kuc_free(void *p, int payload_len);
+
/* obd_config.c */
int class_process_config(struct lustre_cfg *lcfg);
int class_process_proc_param(char *prefix, struct lprocfs_vars *lvars,
/* Passed as data param to class_config_parse_llog */
struct config_llog_instance {
- char * cfg_instance;
- char * cfg_obdname;
+ char *cfg_obdname;
+ void *cfg_instance;
struct super_block *cfg_sb;
struct obd_uuid cfg_uuid;
int cfg_last_idx; /* for partial llog processing */
int class_config_dump_llog(struct llog_ctxt *ctxt, char *name,
struct config_llog_instance *cfg);
+enum {
+ CONFIG_T_CONFIG = 0,
+ CONFIG_T_SPTLRPC = 1,
+ CONFIG_T_MAX = 2
+};
+
/* list of active configuration logs */
struct config_llog_data {
- char *cld_logname;
struct ldlm_res_id cld_resid;
struct config_llog_instance cld_cfg;
cfs_list_t cld_list_chain;
cfs_atomic_t cld_refcount;
struct config_llog_data *cld_sptlrpc;/* depended sptlrpc log */
struct obd_export *cld_mgcexp;
+ cfs_mutex_t cld_lock;
+ int cld_type;
unsigned int cld_stopping:1, /* we were told to stop
* watching */
- cld_lostlock:1, /* lock not requeued */
- cld_is_sptlrpc:1;
+ cld_lostlock:1; /* lock not requeued */
+ char cld_logname[0];
};
struct lustre_profile {
#define class_export_rpc_put(exp) \
({ \
- LASSERT(cfs_atomic_read(&exp->exp_rpc_count) > 0); \
+ LASSERT_ATOMIC_POS(&exp->exp_rpc_count); \
cfs_atomic_dec(&(exp)->exp_rpc_count); \
CDEBUG(D_INFO, "RPC PUTting export %p : new rpc_count %d\n", \
(exp), cfs_atomic_read(&(exp)->exp_rpc_count)); \
#define class_export_lock_put(exp, lock) \
({ \
- LASSERT(cfs_atomic_read(&exp->exp_locks_count) > 0); \
+ LASSERT_ATOMIC_POS(&exp->exp_locks_count); \
cfs_atomic_dec(&(exp)->exp_locks_count); \
__class_export_del_lock_ref(exp, lock); \
CDEBUG(D_INFO, "lock PUTting export %p : new locks_count %d\n", \
#define class_export_cb_put(exp) \
({ \
- LASSERT(cfs_atomic_read(&exp->exp_cb_count) > 0); \
+ LASSERT_ATOMIC_POS(&exp->exp_cb_count); \
cfs_atomic_dec(&(exp)->exp_cb_count); \
CDEBUG(D_INFO, "callback PUTting export %p : new cb_count %d\n",\
(exp), cfs_atomic_read(&(exp)->exp_cb_count)); \
#define EXP_MD_COUNTER_INCREMENT(exp, op)
#endif
+static inline int lprocfs_nid_ldlm_stats_init(struct nid_stat* tmp)
+{
+ /* Always add in ldlm_stats */
+ tmp->nid_ldlm_stats = lprocfs_alloc_stats(LDLM_LAST_OPC - LDLM_FIRST_OPC
+ ,LPROCFS_STATS_FLAG_NOPERCPU);
+ if (tmp->nid_ldlm_stats == NULL)
+ return -ENOMEM;
+
+ lprocfs_init_ldlm_stats(tmp->nid_ldlm_stats);
+
+ return lprocfs_register_stats(tmp->nid_proc, "ldlm_stats",
+ tmp->nid_ldlm_stats);
+}
+
#define OBD_CHECK_MD_OP(obd, op, err) \
do { \
if (!OBT(obd) || !MDP((obd), op)) { \
RETURN(rc);
}
+static inline void obd_cleanup_client_import(struct obd_device *obd)
+{
+ ENTRY;
+
+ /* If we set up but never connected, the
+ client import will not have been cleaned. */
+ cfs_down_write(&obd->u.cli.cl_sem);
+ if (obd->u.cli.cl_import) {
+ struct obd_import *imp;
+ imp = obd->u.cli.cl_import;
+ CDEBUG(D_CONFIG, "%s: client import never connected\n",
+ obd->obd_name);
+ ptlrpc_invalidate_import(imp);
+ if (imp->imp_rq_pool) {
+ ptlrpc_free_rq_pool(imp->imp_rq_pool);
+ imp->imp_rq_pool = NULL;
+ }
+ class_destroy_import(imp);
+ obd->u.cli.cl_import = NULL;
+ }
+ cfs_up_write(&obd->u.cli.cl_sem);
+
+ EXIT;
+}
+
static inline int
obd_process_config(struct obd_device *obd, int datalen, void *data)
{
RETURN(uuid);
}
+/** Create a new /a exp on device /a obd for the uuid /a cluuid
+ * @param exp New export handle
+ * @param d Connect data, supported flags are set, flags also understood
+ * by obd are returned.
+ */
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 *data,
void *localdata)
{
int rc;
- __u64 ocf = d ? d->ocd_connect_flags : 0; /* for post-condition
+ __u64 ocf = data ? data->ocd_connect_flags : 0; /* for post-condition
* check */
ENTRY;
OBD_CHECK_DT_OP(obd, connect, -EOPNOTSUPP);
OBD_COUNTER_INCREMENT(obd, connect);
- rc = OBP(obd, connect)(env, exp, obd, cluuid, d, localdata);
+ rc = OBP(obd, connect)(env, exp, obd, cluuid, data, localdata);
/* check that only subset is granted */
- LASSERT(ergo(d != NULL,
- (d->ocd_connect_flags & ocf) == d->ocd_connect_flags));
+ LASSERT(ergo(data != NULL, (data->ocd_connect_flags & ocf) ==
+ data->ocd_connect_flags));
RETURN(rc);
}
RETURN(rc);
}
-static inline int obd_sync(struct obd_export *exp, struct obdo *oa,
- struct lov_stripe_md *ea, obd_size start,
- obd_size end, void *capa)
+static inline int obd_sync_rqset(struct obd_export *exp, struct obd_info *oinfo,
+ obd_size start, obd_size end)
{
+ struct ptlrpc_request_set *set = NULL;
int rc;
ENTRY;
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, capa);
+ set = ptlrpc_prep_set();
+ if (set == NULL)
+ RETURN(-ENOMEM);
+
+ rc = OBP(exp->exp_obd, sync)(exp, oinfo, start, end, set);
+ if (rc == 0)
+ rc = ptlrpc_set_wait(set);
+ ptlrpc_set_destroy(set);
+ RETURN(rc);
+}
+
+static inline int obd_sync(struct obd_export *exp, struct obd_info *oinfo,
+ obd_size start, obd_size end,
+ struct ptlrpc_request_set *set)
+{
+ int rc;
+ ENTRY;
+
+ OBD_CHECK_DT_OP(exp->exp_obd, sync, -EOPNOTSUPP);
+ EXP_COUNTER_INCREMENT(exp, sync);
+
+ rc = OBP(exp->exp_obd, sync)(exp, oinfo, start, end, set);
RETURN(rc);
}
RETURN(rc);
}
+static inline int obd_find_cbdata(struct obd_export *exp,
+ struct lov_stripe_md *lsm,
+ ldlm_iterator_t it, void *data)
+{
+ int rc;
+ ENTRY;
+
+ EXP_CHECK_DT_OP(exp, find_cbdata);
+ EXP_COUNTER_INCREMENT(exp, find_cbdata);
+
+ rc = OBP(exp->exp_obd, find_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)
static inline int obd_cancel_unused(struct obd_export *exp,
struct lov_stripe_md *ea,
- int flags, void *opaque)
+ ldlm_cancel_flags_t flags,
+ void *opaque)
{
int rc;
ENTRY;
static inline int obd_quota_adjust_qunit(struct obd_export *exp,
struct quota_adjust_qunit *oqaq,
- struct lustre_quota_ctxt *qctxt)
+ struct lustre_quota_ctxt *qctxt,
+ struct ptlrpc_request_set *set)
{
#if defined(LPROCFS) && defined(HAVE_QUOTA_SUPPORT)
struct timeval work_start;
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);
+ rc = OBP(exp->exp_obd, quota_adjust_qunit)(exp, oqaq, qctxt, set);
#if defined(LPROCFS) && defined(HAVE_QUOTA_SUPPORT)
if (qctxt) {
RETURN(rc);
}
+static inline int md_find_cbdata(struct obd_export *exp,
+ const struct lu_fid *fid,
+ ldlm_iterator_t it, void *data)
+{
+ int rc;
+ ENTRY;
+ EXP_CHECK_MD_OP(exp, find_cbdata);
+ EXP_MD_COUNTER_INCREMENT(exp, find_cbdata);
+ rc = MDP(exp->exp_obd, find_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)
static inline int md_readpage(struct obd_export *exp, const struct lu_fid *fid,
struct obd_capa *oc, __u64 offset,
- struct page *page,
+ struct page **pages, unsigned npages,
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);
+ rc = MDP(exp->exp_obd, readpage)(exp, fid, oc, offset, pages, npages,
+ request);
RETURN(rc);
}
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)
+ ldlm_mode_t mode,
+ ldlm_cancel_flags_t flags,
+ void *opaque)
{
int rc;
ENTRY;
#define OBDO_ALLOC(ptr) \
do { \
- OBD_SLAB_ALLOC_PTR((ptr), obdo_cachep); \
+ OBD_SLAB_ALLOC_PTR_GFP((ptr), obdo_cachep, CFS_ALLOC_IO); \
} while(0)
#define OBDO_FREE(ptr) \
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);
+int class_check_uuid(struct obd_uuid *uuid, __u64 nid);
void class_init_uuidlist(void);
void class_exit_uuidlist(void);
int raw_name2idx(int hashtype, int count, const char *name, int namelen);
/* prng.c */
-void ll_generate_random_uuid(class_uuid_t uuid_out);
+#define ll_generate_random_uuid(uuid_out) cfs_get_random_bytes(uuid_out, sizeof(class_uuid_t))
#endif /* __LINUX_OBD_CLASS_H */