crypto_free_blkcipher(tfm);
return rc;
}
-EXPORT_SYMBOL(capa_decrypt_id);
void capa_cpy(void *capa, struct obd_capa *ocapa)
{
{
return cl_env_info(env)->clt_current_io != NULL;
}
-EXPORT_SYMBOL(cl_io_is_going);
/**
* cl_io invariant that holds at all times when exported cl_io_*() functions
}
EXIT;
}
-EXPORT_SYMBOL(cl_io_rw_advance);
/**
* Adds a lock to a lockset.
}
return result;
}
-EXPORT_SYMBOL(cl_io_cancel);
/**
* Main io loop.
}
RETURN(result);
}
-EXPORT_SYMBOL(cl_page_list_own);
/**
* Assumes all pages in a queue.
cl_page_list_for_each(page, plist)
cl_page_assume(env, io, page);
}
-EXPORT_SYMBOL(cl_page_list_assume);
/**
* Discards all pages in a queue.
cl_page_discard(env, io, page);
EXIT;
}
-EXPORT_SYMBOL(cl_page_list_discard);
/**
* Initialize dual page queue.
cl_page_list_assume(env, io, &queue->c2_qin);
cl_page_list_assume(env, io, &queue->c2_qout);
}
-EXPORT_SYMBOL(cl_2queue_assume);
/**
* Finalize both page lists of a 2-queue.
{
lu_object_header_fini(&h->coh_lu);
}
-EXPORT_SYMBOL(cl_object_header_fini);
/**
* Returns a cl_object with a given \a fid.
CDEBUG(D_OTHER, "%d@%p\n", cle ? cle->ce_ref : 0, cle);
return env;
}
-EXPORT_SYMBOL(cl_env_peek);
/**
* Returns lu_env: if there already is an environment associated with the
lvb->lvb_blocks = attr->cat_blocks;
EXIT;
}
-EXPORT_SYMBOL(cl_attr2lvb);
/**
* Converts struct ost_lvb to struct cl_attr.
}
RETURN(page);
}
-EXPORT_SYMBOL(cl_page_alloc);
/**
* Returns a cl_page with index \a idx at the object \a o, and associated with
(const struct lu_env *,
const struct cl_page_slice *));
}
-EXPORT_SYMBOL(cl_page_cancel);
/**
* Converts a byte offset within object \a obj into a page index.
struct obd_device *obd_devs[MAX_OBD_DEVICES];
-EXPORT_SYMBOL(obd_devs);
struct list_head obd_types;
DEFINE_RWLOCK(obd_dev_lock);
EXPORT_SYMBOL(obd_dirty_transit_pages);
char obd_jobid_var[JOBSTATS_JOBID_VAR_MAX_LEN + 1] = JOBSTATS_DISABLE;
-EXPORT_SYMBOL(obd_jobid_var);
#ifdef CONFIG_PROC_FS
struct lprocfs_stats *obd_memory = NULL;
return ret;
}
-EXPORT_SYMBOL(obd_memory_max);
__u64 obd_pages_max(void)
{
return ret;
}
-EXPORT_SYMBOL(obd_pages_max);
#endif /* CONFIG_PROC_FS */
/* liblustre doesn't call cleanup_obdclass, apparently. we carry on in this
CDEBUG(D_RPCTRACE, "nb->page: index = %ld\n",
nb->lnb_page ? page_index(nb->lnb_page) : -1);
}
-EXPORT_SYMBOL(dump_lniobuf);
#define LPDS sizeof(__u64)
int block_debug_setup(void *addr, int len, __u64 off, __u64 id)
.lct_init = dt_global_key_init,
.lct_fini = dt_global_key_fini
};
-EXPORT_SYMBOL(dt_key);
/* no lock is necessary to protect the list, because call-backs
* are added during system startup. Please refer to "struct dt_device".
}
return obj;
}
-EXPORT_SYMBOL(dt_store_resolve);
static struct dt_object *dt_reg_open(const struct lu_env *env,
struct dt_device *dt,
}
return file;
}
-EXPORT_SYMBOL(dt_store_open);
struct dt_object *dt_find_or_create(const struct lu_env *env,
struct dt_device *dt,
}
return type;
}
-EXPORT_SYMBOL(class_get_type);
void class_put_type(struct obd_type *type)
{
module_put(type->typ_dt_ops->o_owner);
spin_unlock(&type->obd_type_lock);
}
-EXPORT_SYMBOL(class_put_type);
#define CLASS_MAX_NAME 1024
return -1;
}
-EXPORT_SYMBOL(class_name2dev);
struct obd_device *class_name2obd(const char *name)
{
return -1;
}
-EXPORT_SYMBOL(class_uuid2dev);
struct obd_device *class_uuid2obd(struct obd_uuid *uuid)
{
return obd;
}
-EXPORT_SYMBOL(class_num2obd);
/**
* Get obd devices count. Device in any
}
return NULL;
}
-EXPORT_SYMBOL(class_conn2obd);
struct obd_import *class_exp2cliimp(struct obd_export *exp)
{
return NULL;
return obd->u.cli.cl_import;
}
-EXPORT_SYMBOL(class_conn2cliimp);
/* Export management functions */
static void class_export_destroy(struct obd_export *exp)
spin_unlock(&exp->exp_obd->obd_dev_lock);
class_export_put(exp);
}
-EXPORT_SYMBOL(class_unlink_export);
/* Import management functions */
static void class_import_destroy(struct obd_import *imp)
lock, exp, lock->l_exp_refs_nr);
spin_unlock(&exp->exp_locks_list_guard);
}
-EXPORT_SYMBOL(__class_export_add_lock_ref);
void __class_export_del_lock_ref(struct obd_export *exp, struct ldlm_lock *lock)
{
lock, exp, lock->l_exp_refs_nr);
spin_unlock(&exp->exp_locks_list_guard);
}
-EXPORT_SYMBOL(__class_export_del_lock_ref);
#endif
/* A connection defines an export context in which preallocation can
return exports_evicted;
}
-EXPORT_SYMBOL(obd_export_evict_by_uuid);
#if LUSTRE_TRACKS_LOCK_EXP_REFS
void (*class_export_dump_hook)(struct obd_export*) = NULL;
-EXPORT_SYMBOL(class_export_dump_hook);
#endif
static void print_export_data(struct obd_export *exp, const char *status,
print_export_data(exp, "ZOMBIE", locks);
spin_unlock(&obd_zombie_impexp_lock);
}
-EXPORT_SYMBOL(dump_exports);
void obd_exports_barrier(struct obd_device *obd)
{
err = copy_to_user(arg, data, len) ? -EFAULT : 0;
RETURN(err);
}
-EXPORT_SYMBOL(obd_ioctl_popdata);
/* opening /dev/obd */
static int obd_class_open(struct inode * inode, struct file * file)
spin_unlock(&loghandle->lgh_hdr_lock);
return rc;
}
-EXPORT_SYMBOL(llog_cancel_rec);
static int llog_read_header(const struct lu_env *env,
struct llog_handle *handle,
cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
RETURN(rc);
}
-EXPORT_SYMBOL(llog_declare_create);
int llog_create(const struct lu_env *env, struct llog_handle *handle,
struct thandle *th)
cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
RETURN(rc);
}
-EXPORT_SYMBOL(llog_create);
int llog_declare_write_rec(const struct lu_env *env,
struct llog_handle *handle,
cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
RETURN(rc);
}
-EXPORT_SYMBOL(llog_declare_write_rec);
int llog_write_rec(const struct lu_env *env, struct llog_handle *handle,
struct llog_rec_hdr *rec, struct llog_cookie *logcookies,
cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
RETURN(rc);
}
-EXPORT_SYMBOL(llog_write_rec);
int llog_add(const struct lu_env *env, struct llog_handle *lgh,
struct llog_rec_hdr *rec, struct llog_cookie *logcookies,
/* Append all records */
return llog_write(env, copy_llh, rec, LLOG_NEXT_IDX);
}
-EXPORT_SYMBOL(llog_copy_handler);
/* backup plain llog */
int llog_backup(const struct lu_env *env, struct obd_device *obd,
RETURN(rc);
}
-EXPORT_SYMBOL(llog_cat_process_or_fork);
int llog_cat_process(const struct lu_env *env, struct llog_handle *cat_llh,
llog_cb_t cb, void *data, int startcat, int startidx)
return rc;
}
-int cat_cancel_cb(const struct lu_env *env,
- struct llog_handle *cathandle,
- struct llog_rec_hdr *rec, void *data)
-{
- struct llog_logid_rec *lir = (struct llog_logid_rec *)rec;
- struct llog_handle *loghandle;
- struct llog_log_hdr *llh;
- int rc;
-
- ENTRY;
-
- if (rec->lrh_type != LLOG_LOGID_MAGIC) {
- CERROR("invalid record in catalog\n");
- RETURN(-EINVAL);
- }
-
- CDEBUG(D_HA, "processing log "DOSTID":%x at index %u of catalog "
- DOSTID"\n", POSTID(&lir->lid_id.lgl_oi), lir->lid_id.lgl_ogen,
- rec->lrh_index, POSTID(&cathandle->lgh_id.lgl_oi));
-
- rc = llog_cat_id2handle(env, cathandle, &loghandle, &lir->lid_id);
- if (rc) {
- CERROR("%s: cannot find handle for llog "DOSTID": %d\n",
- cathandle->lgh_ctxt->loc_obd->obd_name,
- POSTID(&lir->lid_id.lgl_oi), rc);
- if (rc == -ENOENT || rc == -ESTALE) {
- /* remove index from catalog */
- llog_cat_cleanup(env, cathandle, NULL, rec->lrh_index);
- }
- RETURN(rc);
- }
-
- llh = loghandle->lgh_hdr;
- if ((llh->llh_flags & LLOG_F_ZAP_WHEN_EMPTY) &&
- (llh->llh_count == 1)) {
- rc = llog_destroy(env, loghandle);
- if (rc)
- CERROR("%s: fail to destroy empty log: rc = %d\n",
- loghandle->lgh_ctxt->loc_obd->obd_name, rc);
-
- llog_cat_cleanup(env, cathandle, loghandle,
- loghandle->u.phd.phd_cookie.lgc_index);
- }
- llog_handle_put(loghandle);
-
- RETURN(rc);
-}
-EXPORT_SYMBOL(cat_cancel_cb);
-
/* helper to initialize catalog llog and process it to cancel */
int llog_cat_init_and_process(const struct lu_env *env,
struct llog_handle *llh)
/* context key: llog_thread_key */
LU_CONTEXT_KEY_DEFINE(llog, LCT_MD_THREAD | LCT_MG_THREAD | LCT_LOCAL);
LU_KEY_INIT_GENERIC(llog);
-EXPORT_SYMBOL(llog_thread_key);
int llog_info_init(void)
{
__swab64s(&log_id->lgl_oi.oi.oi_seq);
__swab32s(&log_id->lgl_ogen);
}
-EXPORT_SYMBOL(lustre_swab_llog_id);
void lustre_swab_llogd_body (struct llogd_body *d)
{
__swab32s (&fid->generation);
__swab32s (&fid->f_type);
}
-EXPORT_SYMBOL(lustre_swab_ll_fid);
void lustre_swab_lu_seq_range(struct lu_seq_range *range)
{
__swab32s(&tail->lrt_index);
}
}
-EXPORT_SYMBOL(lustre_swab_llog_rec);
static void print_llog_hdr(struct llog_log_hdr *h)
{
EXIT;
return;
}
-EXPORT_SYMBOL(lustre_swab_lustre_cfg);
/* used only for compatibility with old on-disk cfg_marker data */
struct cfg_marker32 {
EXIT;
return;
}
-EXPORT_SYMBOL(lustre_swab_cfg_marker);
cancel_count = 0;
rc = llog_cat_process(env, llh, llog_cancel_rec_cb, "foobar", 0, 0);
if (rc != -LLOG_EEMPTY) {
- CERROR("5c: process with cat_cancel_cb failed: %d\n", rc);
+ CERROR("5c: process with llog_cancel_rec_cb failed: %d\n", rc);
GOTO(out, rc);
}
plain_counter = 0;
rc = llog_cat_process(env, llh, test_8_cb, "foobar", 0, 0);
if (rc != 0) {
- CERROR("5a: process with cat_cancel_cb failed: %d\n", rc);
+ CERROR("5a: process with test_8_cb failed: %d\n", rc);
GOTO(out, rc);
}
orig_counter = plain_counter;
plain_counter = 0;
rc = llog_cat_process(env, llh, test_8_cb, "foobar", 0, 0);
if (rc != 0) {
- CERROR("8d: process with cat_cancel_cb failed: %d\n", rc);
+ CERROR("8d: process with test_8_cb failed: %d\n", rc);
GOTO(out, rc);
}
up_write(&_lprocfs_lock);
return 0;
}
-EXPORT_SYMBOL(remove_proc_subtree);
#endif /* !HAVE_REMOVE_PROC_SUBTREE */
#ifndef HAVE_PROC_REMOVE
lprocfs_stats_unlock(stats, LPROCFS_GET_NUM_CPU, &flags);
}
-EXPORT_SYMBOL(lprocfs_stats_collect);
/**
* Append a space separated list of current set flags to str.
}
return rc;
}
-EXPORT_SYMBOL(lprocfs_stats_alloc_one);
struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num,
enum lprocfs_stats_flags flags)
LPROCFS_MD_OP_INIT(num_private_stats, stats, intent_getattr_async);
LPROCFS_MD_OP_INIT(num_private_stats, stats, revalidate_lock);
}
-EXPORT_SYMBOL(lprocfs_init_mps_stats);
int lprocfs_alloc_md_stats(struct obd_device *obd,
unsigned int num_private_stats)
buffer[prtn++] ='\n';
return prtn;
}
-EXPORT_SYMBOL(lprocfs_read_frac_helper);
int lprocfs_seq_read_frac_helper(struct seq_file *m, long val, int mult)
{
return rc;
}
-EXPORT_SYMBOL(lprocfs_obd_rd_max_pages_per_rpc);
int lprocfs_obd_max_pages_per_rpc_seq_show(struct seq_file *m, void *data)
{
return 0;
}
-EXPORT_SYMBOL(lprocfs_exp_cleanup);
#define LPROCFS_OBD_OP_INIT(base, stats, op) \
do { \
}
return 1;
}
-EXPORT_SYMBOL(lu_object_invariant);
static struct lu_object *htable_lookup(struct lu_site *s,
cfs_hash_bd_t *bd,
}
}
}
-EXPORT_SYMBOL(lu_stack_fini);
enum {
/**
++key_set_version;
}
}
-EXPORT_SYMBOL(lu_context_key_quiesce);
void lu_context_key_revive(struct lu_context_key *key)
{
key->lct_tags &= ~LCT_QUIESCENT;
++key_set_version;
}
-EXPORT_SYMBOL(lu_context_key_revive);
static void keys_fini(struct lu_context *ctx)
{
{
return likely(ctx->lc_version == key_set_version) ? 0 : keys_fill(ctx);
}
-EXPORT_SYMBOL(lu_context_refill);
/**
* lu_ctx_tags/lu_ses_tags will be updated if there are new types of
}
}
}
-EXPORT_SYMBOL(lu_context_keys_dump);
/**
* Initialization of global lu_* data.
ls_stats_read(s->ls_stats, LU_SS_CACHE_DEATH_RACE),
ls_stats_read(s->ls_stats, LU_SS_LRU_PURGED));
}
-EXPORT_SYMBOL(lu_site_stats_print);
/**
* Helper function to initialize a number of kmem slab caches at once.
buf->lb_len = len;
return 0;
}
-EXPORT_SYMBOL(lu_buf_check_and_grow);
CERROR(" link: %s %p\n", link->ll_scope, link->ll_source);
}
}
-EXPORT_SYMBOL(lu_ref_print);
static int lu_ref_is_marker(const struct lu_ref *ref)
{
}
spin_unlock(&lu_ref_refs_guard);
}
-EXPORT_SYMBOL(lu_ref_print_all);
void lu_ref_init_loc(struct lu_ref *ref, const char *func, const int line)
{
list_add(&ref->lf_linkage, &lu_ref_refs);
spin_unlock(&lu_ref_refs_guard);
}
-EXPORT_SYMBOL(lu_ref_init_loc);
void lu_ref_fini(struct lu_ref *ref)
{
list_del_init(&ref->lf_linkage);
spin_unlock(&lu_ref_refs_guard);
}
-EXPORT_SYMBOL(lu_ref_fini);
static struct lu_ref_link *lu_ref_add_context(struct lu_ref *ref,
int flags,
might_sleep();
lu_ref_add_context(ref, GFP_IOFS, scope, source);
}
-EXPORT_SYMBOL(lu_ref_add);
void lu_ref_add_at(struct lu_ref *ref, struct lu_ref_link *link,
const char *scope, const void *source)
ref->lf_refs++;
spin_unlock(&ref->lf_guard);
}
-EXPORT_SYMBOL(lu_ref_add_at);
/**
* Version of lu_ref_add() to be used in non-blockable contexts.
{
lu_ref_add_context(ref, GFP_ATOMIC, scope, source);
}
-EXPORT_SYMBOL(lu_ref_add_atomic);
static inline int lu_ref_link_eq(const struct lu_ref_link *link,
const char *scope, const void *source)
spin_unlock(&ref->lf_guard);
}
}
-EXPORT_SYMBOL(lu_ref_del);
void lu_ref_set_at(struct lu_ref *ref, struct lu_ref_link *link,
const char *scope,
link->ll_source = source1;
spin_unlock(&ref->lf_guard);
}
-EXPORT_SYMBOL(lu_ref_set_at);
void lu_ref_del_at(struct lu_ref *ref, struct lu_ref_link *link,
const char *scope, const void *source)
ref->lf_refs--;
spin_unlock(&ref->lf_guard);
}
-EXPORT_SYMBOL(lu_ref_del_at);
#ifdef CONFIG_PROC_FS
}
return 0;
}
-EXPORT_SYMBOL(class_add_uuid);
/* Delete the nids for one uuid if specified, otherwise delete all */
int class_del_uuid(const char *uuid)
__swab64s(&attrs->hsm_arch_ver);
}
};
-EXPORT_SYMBOL(lustre_hsm_swab);
/*
* Swab and extract HSM attributes from on-disk xattr.
{
return class_parse_value(buf, CLASS_PARSE_NET, (void *)net, endh, 0);
}
-EXPORT_SYMBOL(class_parse_net);
/* 1 param contains key and match
* 0 param contains key and not match
}
return rc;
}
-EXPORT_SYMBOL(class_match_nid);
int class_match_net(char *buf, char *key, __u32 net)
{
}
return rc;
}
-EXPORT_SYMBOL(class_match_net);
/********************** class fns **********************/
RETURN(0);
}
-EXPORT_SYMBOL(class_cleanup);
struct obd_device *class_incref(struct obd_device *obd,
const char *scope, const void *source)
RETURN(rc);
}
-EXPORT_SYMBOL(class_add_conn);
/** Remove a failover nid location.
*/
lustre_cfg_free(lcfg);
return(rc);
}
-EXPORT_SYMBOL(do_lcfg);
/** Call class_attach and class_setup. These methods in turn call
* obd type-specific methods.
mti->mti_config_ver, mti->mti_flags);
return 0;
}
-EXPORT_SYMBOL(server_mti_print);
/* Generate data for registration */
static int server_lsi2mti(struct lustre_sb_info *lsi,
obd->obd_recovery_time_hard = hard;
obd->obd_recovery_ir_factor = factor;
}
-EXPORT_SYMBOL(server_calc_timeout);
git://git.whamcloud.com / fs / lustre-release.git / commitdiff