* 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.
*/
/*
/* OBD Device Declarations */
extern struct obd_device *obd_devs[MAX_OBD_DEVICES];
-extern spinlock_t obd_dev_lock;
+extern cfs_spinlock_t obd_dev_lock;
/* OBD Operations Declarations */
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);
struct lu_device_type;
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 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, const char *nid);
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,
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, int locks);
/*obdecho*/
#ifdef LPROCFS
/* 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 */
/* list of active configuration logs */
struct config_llog_data {
- char *cld_logname;
- struct ldlm_res_id cld_resid;
+ char *cld_logname;
+ struct ldlm_res_id cld_resid;
struct config_llog_instance cld_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 */
- cld_lostlock:1; /* lock not requeued */
+ 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;
+ 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;
+ cfs_list_t lp_list;
char *lp_profile;
char *lp_dt;
char *lp_md;
void class_del_profile(const char *prof);
void class_del_profiles(void);
+#if LUSTRE_TRACKS_LOCK_EXP_REFS
+
+void __class_export_add_lock_ref(struct obd_export *, struct ldlm_lock *);
+void __class_export_del_lock_ref(struct obd_export *, struct ldlm_lock *);
+extern void (*class_export_dump_hook)(struct obd_export *);
+
+#else
+
+#define __class_export_add_lock_ref(exp, lock) do {} while(0)
+#define __class_export_del_lock_ref(exp, lock) do {} while(0)
+
+#endif
+
#define class_export_rpc_get(exp) \
({ \
- atomic_inc(&(exp)->exp_rpc_count); \
+ cfs_atomic_inc(&(exp)->exp_rpc_count); \
CDEBUG(D_INFO, "RPC GETting export %p : new rpc_count %d\n", \
- (exp), atomic_read(&(exp)->exp_rpc_count)); \
+ (exp), cfs_atomic_read(&(exp)->exp_rpc_count)); \
class_export_get(exp); \
})
#define class_export_rpc_put(exp) \
({ \
- atomic_dec(&(exp)->exp_rpc_count); \
+ LASSERT(cfs_atomic_read(&exp->exp_rpc_count) > 0); \
+ cfs_atomic_dec(&(exp)->exp_rpc_count); \
CDEBUG(D_INFO, "RPC PUTting export %p : new rpc_count %d\n", \
- (exp), atomic_read(&(exp)->exp_rpc_count)); \
+ (exp), cfs_atomic_read(&(exp)->exp_rpc_count)); \
+ class_export_put(exp); \
+})
+
+#define class_export_lock_get(exp, lock) \
+({ \
+ cfs_atomic_inc(&(exp)->exp_locks_count); \
+ __class_export_add_lock_ref(exp, lock); \
+ CDEBUG(D_INFO, "lock GETting export %p : new locks_count %d\n", \
+ (exp), cfs_atomic_read(&(exp)->exp_locks_count)); \
+ class_export_get(exp); \
+})
+
+#define class_export_lock_put(exp, lock) \
+({ \
+ LASSERT(cfs_atomic_read(&exp->exp_locks_count) > 0); \
+ 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", \
+ (exp), cfs_atomic_read(&(exp)->exp_locks_count)); \
+ class_export_put(exp); \
+})
+
+#define class_export_cb_get(exp) \
+({ \
+ cfs_atomic_inc(&(exp)->exp_cb_count); \
+ CDEBUG(D_INFO, "callback GETting export %p : new cb_count %d\n",\
+ (exp), cfs_atomic_read(&(exp)->exp_cb_count)); \
+ class_export_get(exp); \
+})
+
+#define class_export_cb_put(exp) \
+({ \
+ LASSERT(cfs_atomic_read(&exp->exp_cb_count) > 0); \
+ 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)); \
class_export_put(exp); \
})
struct obd_uuid *cluuid);
int class_disconnect(struct obd_export *exp);
void class_fail_export(struct obd_export *exp);
+int class_connected_export(struct obd_export *exp);
void class_disconnect_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);
+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);
+}
+
+static inline struct lu_target *class_exp2tgt(struct obd_export *exp)
+{
+ LASSERT(exp->exp_obd);
+ return exp->exp_obd->u.obt.obt_lut;
+}
+
+static inline struct lr_server_data *class_server_data(struct obd_device *obd)
+{
+ LASSERT(obd->u.obt.obt_lut);
+ return &obd->u.obt.obt_lut->lut_lsd;
+}
void obdo_cpy_md(struct obdo *dst, struct obdo *src, obd_flag valid);
void obdo_to_ioobj(struct obdo *oa, struct obd_ioobj *ioobj);
#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)) { \
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)) {
} else
rc = PTR_ERR(d);
}
+ lu_context_exit(&session_ctx);
+ lu_context_fini(&session_ctx);
+
} else {
OBD_CHECK_DT_OP(obd, setup, -EOPNOTSUPP);
OBD_COUNTER_INCREMENT(obd, setup);
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) {
rc = OBP(obd, process_config)(obd, datalen, data);
}
OBD_COUNTER_INCREMENT(obd, process_config);
+ obd->obd_process_conf = 0;
RETURN(rc);
}
return rc;
}
-static inline int obd_checkmd(struct obd_export *exp,
- struct obd_export *md_exp,
- struct lov_stripe_md *mem_tgt)
+static inline int obd_precreate(struct obd_export *exp)
{
int rc;
ENTRY;
- EXP_CHECK_DT_OP(exp, checkmd);
- EXP_COUNTER_INCREMENT(exp, checkmd);
+ EXP_CHECK_DT_OP(exp, precreate);
+ OBD_COUNTER_INCREMENT(exp->exp_obd, precreate);
- rc = OBP(exp->exp_obd, checkmd)(exp, md_exp, mem_tgt);
+ rc = OBP(exp->exp_obd, precreate)(exp);
RETURN(rc);
}
-static inline int obd_precreate(struct obd_export *exp)
+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, precreate);
- OBD_COUNTER_INCREMENT(exp->exp_obd, precreate);
+ EXP_CHECK_DT_OP(exp, create_async);
+ EXP_COUNTER_INCREMENT(exp, create_async);
- rc = OBP(exp->exp_obd, precreate)(exp);
+ rc = OBP(exp->exp_obd, create_async)(exp, oinfo, ea, oti);
RETURN(rc);
}
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_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);
}
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 lustre_handle *conn,struct obd_device *obd,
+ struct obd_export **exp,struct obd_device *obd,
struct obd_uuid *cluuid,
struct obd_connect_data *d,
void *localdata)
OBD_CHECK_DT_OP(obd, connect, -EOPNOTSUPP);
OBD_COUNTER_INCREMENT(obd, connect);
- rc = OBP(obd, connect)(env, conn, obd, cluuid, d, localdata);
+ 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 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;
return 0;
}
-#ifndef time_before
-#define time_before(t1, t2) ((long)t2 - (long)t1 > 0)
-#endif
-
/* @max_age is the oldest time in jiffies 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. */
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);
+ cfs_spin_lock(&obd->obd_osfs_lock);
memcpy(oinfo->oi_osfs, &obd->obd_osfs, sizeof(*oinfo->oi_osfs));
- spin_unlock(&obd->obd_osfs_lock);
+ cfs_spin_unlock(&obd->obd_osfs_lock);
oinfo->oi_flags |= OBD_STATFS_FROM_CACHE;
if (oinfo->oi_cb_up)
oinfo->oi_cb_up(oinfo, 0);
if (cfs_time_before_64(obd->obd_osfs_age, max_age)) {
rc = OBP(obd, statfs)(obd, osfs, max_age, flags);
if (rc == 0) {
- spin_lock(&obd->obd_osfs_lock);
+ cfs_spin_lock(&obd->obd_osfs_lock);
memcpy(&obd->obd_osfs, osfs, sizeof(obd->obd_osfs));
obd->obd_osfs_age = cfs_time_current_64();
- spin_unlock(&obd->obd_osfs_lock);
+ cfs_spin_unlock(&obd->obd_osfs_lock);
}
} else {
CDEBUG(D_SUPER,"%s: use %p cache blocks "LPU64"/"LPU64
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);
+ cfs_spin_lock(&obd->obd_osfs_lock);
memcpy(osfs, &obd->obd_osfs, sizeof(*osfs));
- spin_unlock(&obd->obd_osfs_lock);
+ cfs_spin_unlock(&obd->obd_osfs_lock);
}
RETURN(rc);
}
RETURN(rc);
}
+static inline int obd_sync_fs(struct obd_device *obd, struct obd_info *oinfo,
+ int wait)
+{
+ int rc;
+ ENTRY;
+
+ OBD_CHECK_DT_OP(obd, sync_fs, -EOPNOTSUPP);
+ OBD_COUNTER_INCREMENT(obd, sync);
+
+ rc = OBP(obd, sync_fs)(obd, oinfo, wait);
+
+ RETURN(rc);
+}
+
static inline int obd_punch_rqset(struct obd_export *exp,
struct obd_info *oinfo,
struct obd_trans_info *oti)
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;
*/
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;
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);
}
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,
+ struct ptlrpc_request_set *set)
+{
+#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)
+ cfs_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, set);
+
+#if defined(LPROCFS) && defined(HAVE_QUOTA_SUPPORT)
+ if (qctxt) {
+ cfs_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);
}
{
ENTRY;
OBD_CHECK_DEV(obd);
- if (obd->obd_observer && observer)
+ cfs_down_write(&obd->obd_observer_link_sem);
+ if (obd->obd_observer && observer) {
+ cfs_up_write(&obd->obd_observer_link_sem);
RETURN(-EALREADY);
+ }
obd->obd_observer = observer;
+ cfs_up_write(&obd->obd_observer_link_sem);
+ RETURN(0);
+}
+
+static inline int obd_pin_observer(struct obd_device *obd,
+ struct obd_device **observer)
+{
+ ENTRY;
+ cfs_down_read(&obd->obd_observer_link_sem);
+ if (!obd->obd_observer) {
+ *observer = NULL;
+ cfs_up_read(&obd->obd_observer_link_sem);
+ RETURN(-ENOENT);
+ }
+ *observer = obd->obd_observer;
+ RETURN(0);
+}
+
+static inline int obd_unpin_observer(struct obd_device *obd)
+{
+ ENTRY;
+ cfs_up_read(&obd->obd_observer_link_sem);
RETURN(0);
}
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,
+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, fid, oc, valid,
- ea_size, request);
+ rc = MDP(exp->exp_obd, getattr)(exp, op_data, request);
RETURN(rc);
}
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_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 md_op_data *op_data,
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);
+ rc = MDP(exp->exp_obd, getattr_name)(exp, op_data, request);
RETURN(rc);
}
}
static inline int md_set_lock_data(struct obd_export *exp,
- __u64 *lockh, void *data)
+ __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));
+ 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)
+ ldlm_mode_t mode,
+ ldlm_cancel_flags_t flags,
+ void *opaque)
{
int rc;
ENTRY;
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)
static inline int md_revalidate_lock(struct obd_export *exp,
struct lookup_intent *it,
- struct lu_fid *fid)
+ struct lu_fid *fid, __u32 *bits)
{
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);
+ rc = MDP(exp->exp_obd, revalidate_lock)(exp, it, fid, bits);
RETURN(rc);
}
#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 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 */