CFS_DECLARE_RWSEM(_lprocfs_lock);
EXPORT_SYMBOL(_lprocfs_lock);
+int lprocfs_single_release(struct inode *inode, struct file *file)
+{
+ LPROCFS_EXIT();
+ return single_release(inode, file);
+}
+EXPORT_SYMBOL(lprocfs_single_release);
+
int lprocfs_seq_release(struct inode *inode, struct file *file)
{
LPROCFS_EXIT();
LPROCFS_SRCH_EXIT();
return temp;
}
+EXPORT_SYMBOL(lprocfs_srch);
/* lprocfs API calls */
LPROCFS_WRITE_EXIT();
return proc;
}
+EXPORT_SYMBOL(lprocfs_add_simple);
struct proc_dir_entry *lprocfs_add_symlink(const char *name,
struct proc_dir_entry *parent, const char *format, ...)
OBD_FREE(dest, MAX_STRING_SIZE + 1);
return entry;
}
+EXPORT_SYMBOL(lprocfs_add_symlink);
static ssize_t lprocfs_fops_read(struct file *f, char __user *buf,
size_t size, loff_t *ppos)
LPROCFS_WRITE_EXIT();
return rc;
}
+EXPORT_SYMBOL(lprocfs_add_vars);
-void lprocfs_remove(struct proc_dir_entry **rooth)
+void lprocfs_remove_nolock(struct proc_dir_entry **rooth)
{
struct proc_dir_entry *root = *rooth;
struct proc_dir_entry *temp = root;
parent = root->parent;
LASSERT(parent != NULL);
- LPROCFS_WRITE_ENTRY(); /* search vs remove race */
while (1) {
while (temp->subdir != NULL)
if (temp == parent)
break;
}
- LPROCFS_WRITE_EXIT();
}
+void lprocfs_remove(struct proc_dir_entry **rooth)
+{
+ LPROCFS_WRITE_ENTRY(); /* search vs remove race */
+ lprocfs_remove_nolock(rooth);
+ LPROCFS_WRITE_EXIT();
+}
+EXPORT_SYMBOL(lprocfs_remove);
+
void lprocfs_remove_proc_entry(const char *name, struct proc_dir_entry *parent)
{
LASSERT(parent != NULL);
remove_proc_entry(name, parent);
}
+EXPORT_SYMBOL(lprocfs_remove_proc_entry);
+
+void lprocfs_try_remove_proc_entry(const char *name,
+ struct proc_dir_entry *parent)
+{
+ struct proc_dir_entry *t = NULL;
+ struct proc_dir_entry **p;
+ int len, busy = 0;
+
+ LASSERT(parent != NULL);
+ len = strlen(name);
+
+ LPROCFS_WRITE_ENTRY();
+
+ /* lookup target name */
+ for (p = &parent->subdir; *p; p = &(*p)->next) {
+ if ((*p)->namelen != len)
+ continue;
+ if (memcmp(name, (*p)->name, len))
+ continue;
+ t = *p;
+ break;
+ }
+
+ if (t) {
+ /* verify it's empty: do not count "num_refs" */
+ for (p = &t->subdir; *p; p = &(*p)->next) {
+ if ((*p)->namelen != strlen("num_refs")) {
+ busy = 1;
+ break;
+ }
+ if (memcmp("num_refs", (*p)->name,
+ strlen("num_refs"))) {
+ busy = 1;
+ break;
+ }
+ }
+ }
+
+ if (busy == 0)
+ lprocfs_remove_nolock(&t);
+
+ LPROCFS_WRITE_EXIT();
+
+ return;
+}
+EXPORT_SYMBOL(lprocfs_try_remove_proc_entry);
struct proc_dir_entry *lprocfs_register(const char *name,
struct proc_dir_entry *parent,
}
return newchild;
}
+EXPORT_SYMBOL(lprocfs_register);
/* Generic callbacks */
int lprocfs_rd_uint(char *page, char **start, off_t off,
unsigned int *temp = data;
return snprintf(page, count, "%u\n", *temp);
}
+EXPORT_SYMBOL(lprocfs_rd_uint);
int lprocfs_wr_uint(struct file *file, const char *buffer,
unsigned long count, void *data)
*p = (unsigned int)tmp;
return count;
}
+EXPORT_SYMBOL(lprocfs_wr_uint);
int lprocfs_rd_u64(char *page, char **start, off_t off,
int count, int *eof, void *data)
*eof = 1;
return snprintf(page, count, LPU64"\n", *(__u64 *)data);
}
+EXPORT_SYMBOL(lprocfs_rd_u64);
int lprocfs_rd_atomic(char *page, char **start, off_t off,
int count, int *eof, void *data)
*eof = 1;
return snprintf(page, count, "%d\n", cfs_atomic_read(atom));
}
+EXPORT_SYMBOL(lprocfs_rd_atomic);
int lprocfs_wr_atomic(struct file *file, const char *buffer,
unsigned long count, void *data)
cfs_atomic_set(atm, val);
return count;
}
+EXPORT_SYMBOL(lprocfs_wr_atomic);
int lprocfs_rd_uuid(char *page, char **start, off_t off, int count,
int *eof, void *data)
*eof = 1;
return snprintf(page, count, "%s\n", obd->obd_uuid.uuid);
}
+EXPORT_SYMBOL(lprocfs_rd_uuid);
int lprocfs_rd_name(char *page, char **start, off_t off, int count,
int *eof, void *data)
*eof = 1;
return snprintf(page, count, "%s\n", dev->obd_name);
}
+EXPORT_SYMBOL(lprocfs_rd_name);
int lprocfs_rd_fstype(char *page, char **start, off_t off, int count, int *eof,
void *data)
LASSERT(obd->obd_fsops->fs_type != NULL);
return snprintf(page, count, "%s\n", obd->obd_fsops->fs_type);
}
+EXPORT_SYMBOL(lprocfs_rd_fstype);
int lprocfs_rd_blksize(char *page, char **start, off_t off, int count,
int *eof, void *data)
}
return rc;
}
+EXPORT_SYMBOL(lprocfs_rd_blksize);
int lprocfs_osd_rd_blksize(char *page, char **start, off_t off,
int count, int *eof, void *data)
}
return rc;
}
+EXPORT_SYMBOL(lprocfs_osd_rd_blksize);
int lprocfs_rd_kbytestotal(char *page, char **start, off_t off, int count,
int *eof, void *data)
}
return rc;
}
+EXPORT_SYMBOL(lprocfs_rd_kbytestotal);
int lprocfs_osd_rd_kbytestotal(char *page, char **start, off_t off,
int count, int *eof, void *data)
}
return rc;
}
+EXPORT_SYMBOL(lprocfs_osd_rd_kbytestotal);
int lprocfs_rd_kbytesfree(char *page, char **start, off_t off, int count,
int *eof, void *data)
}
return rc;
}
+EXPORT_SYMBOL(lprocfs_rd_kbytesfree);
int lprocfs_osd_rd_kbytesfree(char *page, char **start, off_t off,
int count, int *eof, void *data)
}
return rc;
}
+EXPORT_SYMBOL(lprocfs_osd_rd_kbytesfree);
int lprocfs_rd_kbytesavail(char *page, char **start, off_t off, int count,
int *eof, void *data)
}
return rc;
}
+EXPORT_SYMBOL(lprocfs_rd_kbytesavail);
int lprocfs_osd_rd_kbytesavail(char *page, char **start, off_t off,
int count, int *eof, void *data)
}
return rc;
}
+EXPORT_SYMBOL(lprocfs_osd_rd_kbytesavail);
int lprocfs_rd_filestotal(char *page, char **start, off_t off, int count,
int *eof, void *data)
return rc;
}
+EXPORT_SYMBOL(lprocfs_rd_filestotal);
int lprocfs_osd_rd_filestotal(char *page, char **start, off_t off,
int count, int *eof, void *data)
return rc;
}
+EXPORT_SYMBOL(lprocfs_osd_rd_filestotal);
int lprocfs_rd_filesfree(char *page, char **start, off_t off, int count,
int *eof, void *data)
}
return rc;
}
+EXPORT_SYMBOL(lprocfs_rd_filesfree);
int lprocfs_osd_rd_filesfree(char *page, char **start, off_t off,
int count, int *eof, void *data)
}
return rc;
}
+EXPORT_SYMBOL(lprocfs_osd_rd_filesfree);
int lprocfs_rd_server_uuid(char *page, char **start, off_t off, int count,
int *eof, void *data)
LPROCFS_CLIMP_EXIT(obd);
return rc;
}
+EXPORT_SYMBOL(lprocfs_rd_server_uuid);
int lprocfs_rd_conn_uuid(char *page, char **start, off_t off, int count,
int *eof, void *data)
LPROCFS_CLIMP_EXIT(obd);
return rc;
}
+EXPORT_SYMBOL(lprocfs_rd_conn_uuid);
/** add up per-cpu counters */
void lprocfs_stats_collect(struct lprocfs_stats *stats, int idx,
cnt->lc_units = stats->ls_percpu[0]->lp_cntr[idx].lc_units;
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.
"umask",
"einprogress",
"grant_param",
+ "nanoseconds_times",
+ "lvb_type",
+ "unknown",
+ "lightweight_conn",
+ "short_io",
NULL
};
libcfs_nid2str(conn->oic_conn->c_peer.nid));
j++;
}
- cfs_spin_unlock(&imp->imp_lock);
- i += snprintf(page + i, count - i,
- "]\n"
- " current_connection: %s\n"
- " connection_attempts: %u\n"
- " generation: %u\n"
- " in-progress_invalidations: %u\n",
- libcfs_nid2str(imp->imp_connection->c_peer.nid),
- imp->imp_conn_cnt,
- imp->imp_generation,
- cfs_atomic_read(&imp->imp_inval_count));
+ i += snprintf(page + i, count - i,
+ "]\n"
+ " current_connection: %s\n"
+ " connection_attempts: %u\n"
+ " generation: %u\n"
+ " in-progress_invalidations: %u\n",
+ imp->imp_connection == NULL ? "<none>" :
+ libcfs_nid2str(imp->imp_connection->c_peer.nid),
+ imp->imp_conn_cnt,
+ imp->imp_generation,
+ cfs_atomic_read(&imp->imp_inval_count));
+ cfs_spin_unlock(&imp->imp_lock);
lprocfs_stats_collect(obd->obd_svc_stats, PTLRPC_REQWAIT_CNTR, &ret);
if (ret.lc_count != 0) {
LPROCFS_CLIMP_EXIT(obd);
return i;
}
+EXPORT_SYMBOL(lprocfs_rd_import);
int lprocfs_rd_state(char *page, char **start, off_t off, int count,
int *eof, void *data)
LPROCFS_CLIMP_EXIT(obd);
return i;
}
+EXPORT_SYMBOL(lprocfs_rd_state);
int lprocfs_at_hist_helper(char *page, int count, int rc,
struct adaptive_timeout *at)
rc += snprintf(page + rc, count - rc, "\n");
return rc;
}
+EXPORT_SYMBOL(lprocfs_at_hist_helper);
/* See also ptlrpc_lprocfs_rd_timeouts */
int lprocfs_rd_timeouts(char *page, char **start, off_t off, int count,
LPROCFS_CLIMP_EXIT(obd);
return rc;
}
+EXPORT_SYMBOL(lprocfs_rd_timeouts);
int lprocfs_rd_connect_flags(char *page, char **start, off_t off,
int count, int *eof, void *data)
*eof = 1;
return snprintf(page, count, "%u\n", obd->obd_num_exports);
}
+EXPORT_SYMBOL(lprocfs_rd_num_exports);
int lprocfs_rd_numrefs(char *page, char **start, off_t off, int count,
int *eof, void *data)
*eof = 1;
return snprintf(page, count, "%d\n", class->typ_refcnt);
}
+EXPORT_SYMBOL(lprocfs_rd_numrefs);
int lprocfs_obd_setup(struct obd_device *obd, struct lprocfs_vars *list)
{
}
return rc;
}
+EXPORT_SYMBOL(lprocfs_obd_setup);
int lprocfs_obd_cleanup(struct obd_device *obd)
{
}
return 0;
}
+EXPORT_SYMBOL(lprocfs_obd_cleanup);
static void lprocfs_free_client_stats(struct nid_stat *client_stat)
{
}
EXIT;
}
+EXPORT_SYMBOL(lprocfs_free_per_client_stats);
struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num,
enum lprocfs_stats_flags flags)
stats->ls_num = num;
stats->ls_biggest_alloc_num = 1;
- if (flags & LPROCFS_STATS_FLAG_NOPERCPU) {
- stats->ls_flags = flags;
- cfs_spin_lock_init(&stats->ls_lock);
- /* Use this lock only if there are no percpu areas */
- } else {
- stats->ls_flags = 0;
- }
+ stats->ls_flags = flags;
+ cfs_spin_lock_init(&stats->ls_lock);
percpusize = offsetof(struct lprocfs_percpu, lp_cntr[num]);
if (num_entry > 1)
}
return stats;
}
+EXPORT_SYMBOL(lprocfs_alloc_stats);
void lprocfs_free_stats(struct lprocfs_stats **statsh)
{
OBD_FREE(stats->ls_percpu[i], percpusize);
OBD_FREE(stats, offsetof(typeof(*stats), ls_percpu[num_entry]));
}
+EXPORT_SYMBOL(lprocfs_free_stats);
void lprocfs_clear_stats(struct lprocfs_stats *stats)
{
int i;
int j;
unsigned int num_entry;
- unsigned int percpusize;
unsigned long flags = 0;
num_entry = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU, &flags);
- percpusize = offsetof(struct lprocfs_percpu, lp_cntr[stats->ls_num]);
- if (num_entry > 1)
- percpusize = CFS_L1_CACHE_ALIGN(percpusize);
-
for (i = 0; i < num_entry; i++) {
if (stats->ls_percpu[i] == NULL)
continue;
- /* the 1st percpu entry was statically allocated in
- * lprocfs_alloc_stats() */
- if (i > 0) {
- OBD_FREE(stats->ls_percpu[i], percpusize);
- stats->ls_percpu[i] = NULL;
- continue;
- }
for (j = 0; j < stats->ls_num; j++) {
percpu_cntr = &(stats->ls_percpu[i])->lp_cntr[j];
cfs_atomic_inc(&percpu_cntr->lc_cntl.la_entry);
lprocfs_stats_unlock(stats, LPROCFS_GET_NUM_CPU, &flags);
}
+EXPORT_SYMBOL(lprocfs_clear_stats);
static ssize_t lprocfs_stats_seq_write(struct file *file, const char *buf,
size_t len, loff_t *off)
return 0;
}
+EXPORT_SYMBOL(lprocfs_register_stats);
void lprocfs_counter_init(struct lprocfs_stats *stats, int index,
unsigned conf, const char *name, const char *units)
LPROCFS_OBD_OP_INIT(num_private_stats, stats, get_uuid);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, quotacheck);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, quotactl);
- LPROCFS_OBD_OP_INIT(num_private_stats, stats, quota_adjust_qunit);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, ping);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, pool_new);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, pool_rem);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, getref);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, putref);
}
+EXPORT_SYMBOL(lprocfs_init_ops_stats);
int lprocfs_alloc_obd_stats(struct obd_device *obd, unsigned num_private_stats)
{
}
return rc;
}
+EXPORT_SYMBOL(lprocfs_alloc_obd_stats);
void lprocfs_free_obd_stats(struct obd_device *obd)
{
if (obd->obd_stats)
lprocfs_free_stats(&obd->obd_stats);
}
+EXPORT_SYMBOL(lprocfs_free_obd_stats);
#define LPROCFS_MD_OP_INIT(base, stats, op) \
do { \
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 num_private_stats)
}
return rc;
}
+EXPORT_SYMBOL(lprocfs_alloc_md_stats);
void lprocfs_free_md_stats(struct obd_device *obd)
{
lprocfs_free_stats(&stats);
}
}
+EXPORT_SYMBOL(lprocfs_free_md_stats);
void lprocfs_init_ldlm_stats(struct lprocfs_stats *ldlm_stats)
{
LDLM_GL_CALLBACK - LDLM_FIRST_OPC,
0, "ldlm_gl_callback", "reqs");
}
+EXPORT_SYMBOL(lprocfs_init_ldlm_stats);
int lprocfs_exp_rd_nid(char *page, char **start, off_t off, int count,
int *eof, void *data)
OBD_FREE_PTR(new_stat);
RETURN(rc);
}
+EXPORT_SYMBOL(lprocfs_exp_setup);
int lprocfs_exp_cleanup(struct obd_export *exp)
{
return 0;
}
+EXPORT_SYMBOL(lprocfs_exp_cleanup);
int lprocfs_write_helper(const char *buffer, unsigned long count,
int *val)
{
return lprocfs_write_frac_helper(buffer, count, val, 1);
}
+EXPORT_SYMBOL(lprocfs_write_helper);
int lprocfs_write_frac_helper(const char *buffer, unsigned long count,
int *val, int mult)
}
return 0;
}
+EXPORT_SYMBOL(lprocfs_write_frac_helper);
int lprocfs_read_frac_helper(char *buffer, unsigned long count, long val,
int mult)
buffer[prtn++] ='\n';
return prtn;
}
+EXPORT_SYMBOL(lprocfs_read_frac_helper);
int lprocfs_write_u64_helper(const char *buffer, unsigned long count,__u64 *val)
{
return lprocfs_write_frac_u64_helper(buffer, count, val, 1);
}
+EXPORT_SYMBOL(lprocfs_write_u64_helper);
int lprocfs_write_frac_u64_helper(const char *buffer, unsigned long count,
__u64 *val, int mult)
*val = whole * mult + frac;
return 0;
}
+EXPORT_SYMBOL(lprocfs_write_frac_u64_helper);
int lprocfs_seq_create(cfs_proc_dir_entry_t *parent, char *name, mode_t mode,
struct file_operations *seq_fops, void *data)
c += cfs_hash_debug_str(obd->obd_uuid_hash, page + c, count - c);
c += cfs_hash_debug_str(obd->obd_nid_hash, page + c, count - c);
c += cfs_hash_debug_str(obd->obd_nid_stats_hash, page+c, count-c);
-#ifdef HAVE_QUOTA_SUPPORT
- if (obd->u.obt.obt_qctxt.lqc_lqs_hash)
- c += cfs_hash_debug_str(obd->u.obt.obt_qctxt.lqc_lqs_hash,
- page + c, count - c);
-#endif
return c;
}
"last_transno: "LPD64"\n",
obd->obd_next_recovery_transno - 1)<=0)
goto out;
- if (lprocfs_obd_snprintf(&page, size, &len, "VBR: %s\n",
- obd->obd_version_recov ? "ON" : "OFF")<=0)
+ if (lprocfs_obd_snprintf(&page, size, &len, "VBR: %s\n",
+ obd->obd_version_recov ?
+ "ENABLED" : "DISABLED") <=0)
goto out;
- if (lprocfs_obd_snprintf(&page, size, &len, "IR: %s\n",
- obd->obd_no_ir ? "OFF" : "ON") <= 0)
+ if (lprocfs_obd_snprintf(&page, size, &len, "IR: %s\n",
+ obd->obd_no_ir ?
+ "DISABLED" : "ENABLED") <= 0)
goto out;
goto fclose;
}
int lprocfs_obd_rd_mntdev(char *page, char **start, off_t off,
int count, int *eof, void *data)
{
- struct obd_device *obd = (struct obd_device *)data;
+ struct obd_device *obd = (struct obd_device *)data;
- LASSERT(obd != NULL);
- LASSERT(obd->u.obt.obt_vfsmnt->mnt_devname);
- *eof = 1;
- return snprintf(page, count, "%s\n",
- obd->u.obt.obt_vfsmnt->mnt_devname);
+ LASSERT(obd != NULL);
+ LASSERT(mnt_get_devname(obd->u.obt.obt_vfsmnt));
+ *eof = 1;
+ return snprintf(page, count, "%s\n",
+ mnt_get_devname(obd->u.obt.obt_vfsmnt));
}
EXPORT_SYMBOL(lprocfs_obd_rd_mntdev);
return snprintf(page, count, "%u\n", obd->u.obt.obt_instance);
}
EXPORT_SYMBOL(lprocfs_target_rd_instance);
-
-EXPORT_SYMBOL(lprocfs_register);
-EXPORT_SYMBOL(lprocfs_srch);
-EXPORT_SYMBOL(lprocfs_remove);
-EXPORT_SYMBOL(lprocfs_remove_proc_entry);
-EXPORT_SYMBOL(lprocfs_add_vars);
-EXPORT_SYMBOL(lprocfs_obd_setup);
-EXPORT_SYMBOL(lprocfs_obd_cleanup);
-EXPORT_SYMBOL(lprocfs_add_simple);
-EXPORT_SYMBOL(lprocfs_add_symlink);
-EXPORT_SYMBOL(lprocfs_free_per_client_stats);
-EXPORT_SYMBOL(lprocfs_alloc_stats);
-EXPORT_SYMBOL(lprocfs_free_stats);
-EXPORT_SYMBOL(lprocfs_clear_stats);
-EXPORT_SYMBOL(lprocfs_register_stats);
-EXPORT_SYMBOL(lprocfs_init_ops_stats);
-EXPORT_SYMBOL(lprocfs_init_mps_stats);
-EXPORT_SYMBOL(lprocfs_init_ldlm_stats);
-EXPORT_SYMBOL(lprocfs_alloc_obd_stats);
-EXPORT_SYMBOL(lprocfs_alloc_md_stats);
-EXPORT_SYMBOL(lprocfs_free_obd_stats);
-EXPORT_SYMBOL(lprocfs_free_md_stats);
-EXPORT_SYMBOL(lprocfs_exp_setup);
-EXPORT_SYMBOL(lprocfs_exp_cleanup);
-
-EXPORT_SYMBOL(lprocfs_rd_u64);
-EXPORT_SYMBOL(lprocfs_rd_atomic);
-EXPORT_SYMBOL(lprocfs_wr_atomic);
-EXPORT_SYMBOL(lprocfs_rd_uint);
-EXPORT_SYMBOL(lprocfs_wr_uint);
-EXPORT_SYMBOL(lprocfs_rd_uuid);
-EXPORT_SYMBOL(lprocfs_rd_name);
-EXPORT_SYMBOL(lprocfs_rd_fstype);
-EXPORT_SYMBOL(lprocfs_rd_server_uuid);
-EXPORT_SYMBOL(lprocfs_rd_conn_uuid);
-EXPORT_SYMBOL(lprocfs_rd_num_exports);
-EXPORT_SYMBOL(lprocfs_rd_numrefs);
-EXPORT_SYMBOL(lprocfs_at_hist_helper);
-EXPORT_SYMBOL(lprocfs_rd_import);
-EXPORT_SYMBOL(lprocfs_rd_state);
-EXPORT_SYMBOL(lprocfs_rd_timeouts);
-EXPORT_SYMBOL(lprocfs_rd_blksize);
-EXPORT_SYMBOL(lprocfs_rd_kbytestotal);
-EXPORT_SYMBOL(lprocfs_rd_kbytesfree);
-EXPORT_SYMBOL(lprocfs_rd_kbytesavail);
-EXPORT_SYMBOL(lprocfs_rd_filestotal);
-EXPORT_SYMBOL(lprocfs_rd_filesfree);
-
-EXPORT_SYMBOL(lprocfs_write_helper);
-EXPORT_SYMBOL(lprocfs_write_frac_helper);
-EXPORT_SYMBOL(lprocfs_read_frac_helper);
-EXPORT_SYMBOL(lprocfs_write_u64_helper);
-EXPORT_SYMBOL(lprocfs_write_frac_u64_helper);
-EXPORT_SYMBOL(lprocfs_stats_collect);
#endif /* LPROCFS*/
git://git.whamcloud.com / fs / lustre-release.git / blobdiff