if (page == NULL)
return -ENOMEM;
- LPROCFS_ENTRY();
+ if (LPROCFS_ENTRY_AND_CHECK(dp))
+ return -ENOENT;
+
OBD_FAIL_TIMEOUT(OBD_FAIL_LPROC_REMOVE, 10);
- if (!dp->deleted && dp->read_proc)
+ if (dp->read_proc)
rc = dp->read_proc(page, &start, *ppos, CFS_PAGE_SIZE,
&eof, dp->data);
LPROCFS_EXIT();
struct proc_dir_entry *dp = PDE(f->f_dentry->d_inode);
int rc = -EIO;
- LPROCFS_ENTRY();
- if (!dp->deleted && dp->write_proc)
+ if (LPROCFS_ENTRY_AND_CHECK(dp))
+ return -ENOENT;
+ if (dp->write_proc)
rc = dp->write_proc(f, buf, size, dp->data);
LPROCFS_EXIT();
return rc;
LPROCFS_CLIMP_CHECK(obd);
conn = obd->u.cli.cl_import->imp_connection;
- LASSERT(conn != NULL);
*eof = 1;
- if (obd->u.cli.cl_import) {
+ if (conn && obd->u.cli.cl_import) {
rc = snprintf(page, count, "%s\n",
conn->c_remote_uuid.uuid);
} else {
"truncate_lock",
"initial_transno",
"inode_bit_locks",
- "join_file",
+ "join_file(obsolete)",
"getattr_by_fid",
"no_oh_for_devices",
- "local_client",
"remote_client",
+ "remote_client_by_force",
"max_byte_per_rpc",
"64bit_qdata",
"mds_capability",
"oss_capability",
"early_lock_cancel",
- "size_on_mds",
+ "som",
"adaptive_timeouts",
"lru_resize",
"mds_mds_connection",
return rc;
}
+int lprocfs_rd_quota_resend_count(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
+{
+ struct obd_device *obd = data;
+
+ return snprintf(page, count, "%d\n",
+ atomic_read(&obd->u.cli.cl_quota_resends));
+}
+
+int lprocfs_wr_quota_resend_count(struct file *file, const char *buffer,
+ unsigned long count, void *data)
+{
+ struct obd_device *obd = data;
+ int val, rc;
+
+ rc = lprocfs_write_helper(buffer, count, &val);
+ if (rc)
+ return rc;
+
+ atomic_set(&obd->u.cli.cl_quota_resends, val);
+
+ return count;
+}
+
/* See also ptlrpc_lprocfs_rd_timeouts */
int lprocfs_rd_timeouts(char *page, char **start, off_t off, int count,
int *eof, void *data)
client_stat->nid_proc, client_stat->nid_stats,
client_stat->nid_brw_stats);
- LASSERTF(client_stat->nid_exp_ref_count == 0, "count %d\n",
- client_stat->nid_exp_ref_count);
+ LASSERTF(atomic_read(&client_stat->nid_exp_ref_count) == 0,
+ "count %d\n", atomic_read(&client_stat->nid_exp_ref_count));
hlist_del_init(&client_stat->nid_hash);
struct seq_file *seq;
int rc;
- LPROCFS_ENTRY_AND_CHECK(dp);
+ if (LPROCFS_ENTRY_AND_CHECK(dp))
+ return -ENOENT;
+
rc = seq_open(file, &lprocfs_stats_seq_sops);
if (rc) {
LPROCFS_EXIT();
LPROCFS_OBD_OP_INIT(num_private_stats, stats, statfs_async);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, packmd);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, unpackmd);
- LPROCFS_OBD_OP_INIT(num_private_stats, stats, checkmd);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, preallocate);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, precreate);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, create);
+ LPROCFS_OBD_OP_INIT(num_private_stats, stats, create_async);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, destroy);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, setattr);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, setattr_async);
*eof = 1;
page[0] = '\0';
lprocfs_exp_rd_cb_data_init(&cb_data, page, count, eof, &len);
- lustre_hash_for_each_key(obd->obd_nid_hash, &stats->nid,
- lprocfs_exp_print_uuid, &cb_data);
+ cfs_hash_for_each_key(obd->obd_nid_hash, &stats->nid,
+ lprocfs_exp_print_uuid, &cb_data);
return (*cb_data.len);
}
{
struct exp_uuid_cb_data *data = cb_data;
struct obd_export *exp = obj;
- lustre_hash_t *lh;
+ cfs_hash_t *hs;
- lh = exp->exp_lock_hash;
- if (lh) {
+ hs = exp->exp_lock_hash;
+ if (hs) {
if (!*data->len)
- *data->len += lustre_hash_debug_header(data->page,
- data->count);
+ *data->len += cfs_hash_debug_header(data->page,
+ data->count);
- *data->len += lustre_hash_debug_str(lh, data->page + *data->len,
- data->count);
+ *data->len += cfs_hash_debug_str(hs, data->page + *data->len,
+ data->count);
}
}
page[0] = '\0';
lprocfs_exp_rd_cb_data_init(&cb_data, page, count, eof, &len);
- lustre_hash_for_each_key(obd->obd_nid_hash, &stats->nid,
- lprocfs_exp_print_hash, &cb_data);
+ cfs_hash_for_each_key(obd->obd_nid_hash, &stats->nid,
+ lprocfs_exp_print_hash, &cb_data);
return (*cb_data.len);
}
ENTRY;
/* object has only hash + iterate_all references.
* add/delete blocked by hash bucket lock */
- CDEBUG(D_INFO,"refcnt %d\n", stat->nid_exp_ref_count);
- if (stat->nid_exp_ref_count == 2) {
+ CDEBUG(D_INFO,"refcnt %d\n", atomic_read(&stat->nid_exp_ref_count));
+ if (atomic_read(&stat->nid_exp_ref_count) == 2) {
hlist_del_init(&stat->nid_hash);
- stat->nid_exp_ref_count--;
+ nidstat_putref(stat);
spin_lock(&stat->nid_obd->obd_nid_lock);
list_move(&stat->nid_list, data);
spin_unlock(&stat->nid_obd->obd_nid_lock);
struct nid_stat *client_stat;
CFS_LIST_HEAD(free_list);
- lustre_hash_for_each(obd->obd_nid_stats_hash,
- lprocfs_nid_stats_clear_write_cb, &free_list);
+ cfs_hash_for_each(obd->obd_nid_stats_hash,
+ lprocfs_nid_stats_clear_write_cb, &free_list);
while (!list_empty(&free_list)) {
client_stat = list_entry(free_list.next, struct nid_stat,
int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid, int *newnid)
{
struct nid_stat *new_stat, *old_stat;
- struct nid_stat_uuid *new_ns_uuid;
struct obd_device *obd = NULL;
cfs_proc_dir_entry_t *entry;
int rc = 0;
if (new_stat == NULL)
RETURN(-ENOMEM);
- OBD_ALLOC_PTR(new_ns_uuid);
- if (new_ns_uuid == NULL) {
- OBD_FREE_PTR(new_stat);
- RETURN(-ENOMEM);
- }
- CFS_INIT_LIST_HEAD(&new_ns_uuid->ns_uuid_list);
- strncpy(new_ns_uuid->ns_uuid.uuid, exp->exp_client_uuid.uuid,
- sizeof(struct obd_uuid));
-
- CFS_INIT_LIST_HEAD(&new_stat->nid_uuid_list);
new_stat->nid = *nid;
new_stat->nid_obd = exp->exp_obd;
- new_stat->nid_exp_ref_count = 1; /* live in hash after destroy export */
+ atomic_set(&new_stat->nid_exp_ref_count, 0);
- old_stat = lustre_hash_findadd_unique(obd->obd_nid_stats_hash,
- nid, &new_stat->nid_hash);
+ old_stat = cfs_hash_findadd_unique(obd->obd_nid_stats_hash,
+ nid, &new_stat->nid_hash);
CDEBUG(D_INFO, "Found stats %p for nid %s - ref %d\n",
- old_stat, libcfs_nid2str(*nid), new_stat->nid_exp_ref_count);
+ old_stat, libcfs_nid2str(*nid),
+ atomic_read(&new_stat->nid_exp_ref_count));
/* Return -EALREADY here so that we know that the /proc
* entry already has been created */
if (old_stat != new_stat) {
- struct nid_stat_uuid *tmp_uuid;
- int found = 0;
-
- exp->exp_nid_stats = old_stat;
- /* We need to decrement the refcount if the uuid was
- * already in our list */
spin_lock(&obd->obd_nid_lock);
- list_for_each_entry(tmp_uuid, &old_stat->nid_uuid_list,
- ns_uuid_list) {
- if (tmp_uuid && obd_uuid_equals(&tmp_uuid->ns_uuid,
- &exp->exp_client_uuid)){
- found = 1;
- --old_stat->nid_exp_ref_count;
- break;
- }
+ if (exp->exp_nid_stats != old_stat) {
+ if (exp->exp_nid_stats)
+ nidstat_putref(exp->exp_nid_stats);
+ exp->exp_nid_stats = old_stat;
+ } else {
+ /* cfs_hash_findadd_unique() has added
+ * old_stat's refcount */
+ nidstat_putref(old_stat);
}
- if (!found)
- list_add(&new_ns_uuid->ns_uuid_list,
- &old_stat->nid_uuid_list);
- else
- OBD_FREE_PTR(new_ns_uuid);
-
spin_unlock(&obd->obd_nid_lock);
GOTO(destroy_new, rc = -EALREADY);
GOTO(destroy_new_ns, rc = -ENOMEM);
}
- /* Add in uuid to our nid_stats list */
- spin_lock(&obd->obd_nid_lock);
- list_add(&new_ns_uuid->ns_uuid_list, &new_stat->nid_uuid_list);
- spin_unlock(&obd->obd_nid_lock);
-
entry = lprocfs_add_simple(new_stat->nid_proc, "uuid",
lprocfs_exp_rd_uuid, NULL, new_stat, NULL);
if (IS_ERR(entry)) {
GOTO(destroy_new_ns, rc);
}
+ if (exp->exp_nid_stats)
+ nidstat_putref(exp->exp_nid_stats);
+ nidstat_getref(new_stat);
exp->exp_nid_stats = new_stat;
*newnid = 1;
/* protect competitive add to list, not need locking on destroy */
destroy_new_ns:
if (new_stat->nid_proc != NULL)
lprocfs_remove(&new_stat->nid_proc);
- lustre_hash_del(obd->obd_nid_stats_hash, nid, &new_stat->nid_hash);
- OBD_FREE_PTR(new_ns_uuid);
+ cfs_hash_del(obd->obd_nid_stats_hash, nid, &new_stat->nid_hash);
destroy_new:
OBD_FREE_PTR(new_stat);
int lprocfs_exp_cleanup(struct obd_export *exp)
{
struct nid_stat *stat = exp->exp_nid_stats;
- struct nid_stat_uuid *cursor, *tmp;
- int found = 0;
if(!stat || !exp->exp_obd)
RETURN(0);
- spin_lock(&exp->exp_obd->obd_nid_lock);
- list_for_each_entry_safe(cursor, tmp,
- &stat->nid_uuid_list,
- ns_uuid_list) {
- if (cursor && obd_uuid_equals(&cursor->ns_uuid,
- &exp->exp_client_uuid)) {
- found = 1;
- list_del(&cursor->ns_uuid_list);
- OBD_FREE_PTR(cursor);
- --stat->nid_exp_ref_count;
- CDEBUG(D_INFO, "Put stat %p - %d\n", stat,
- stat->nid_exp_ref_count);
- break;
- }
- }
- spin_unlock(&exp->exp_obd->obd_nid_lock);
- if (!found)
- CERROR("obd_export's client uuid %s are not found in its "
- "nid_stats list\n", exp->exp_client_uuid.uuid);
-
+ nidstat_putref(exp->exp_nid_stats);
exp->exp_nid_stats = NULL;
- lprocfs_free_md_stats(exp->exp_obd);
return 0;
}
if (obd == NULL)
return 0;
- c += lustre_hash_debug_header(page, count);
- c += lustre_hash_debug_str(obd->obd_uuid_hash, page + c, count - c);
- c += lustre_hash_debug_str(obd->obd_nid_hash, page + c, count - c);
- c += lustre_hash_debug_str(obd->obd_nid_stats_hash, page+c, count-c);
+ c += cfs_hash_debug_header(page, count);
+ 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);
return c;
}
if (lprocfs_obd_snprintf(&page, size, &len,
"completed_clients: %d/%d\n",
obd->obd_max_recoverable_clients -
- obd->obd_recoverable_clients,
+ obd->obd_stale_clients,
obd->obd_max_recoverable_clients) <= 0)
goto out;
if (lprocfs_obd_snprintf(&page, size, &len,
"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)
+ goto out;
goto fclose;
}
obd->obd_max_recoverable_clients) <= 0)
goto out;
/* Number of clients that have completed recovery */
- if (lprocfs_obd_snprintf(&page, size, &len,"completed_clients: %d/%d\n",
- obd->obd_max_recoverable_clients -
- obd->obd_recoverable_clients,
- obd->obd_max_recoverable_clients) <= 0)
+ if (lprocfs_obd_snprintf(&page, size, &len,"req_replay_clients: %d\n",
+ atomic_read(&obd->obd_req_replay_clients))<= 0)
+ goto out;
+ if (lprocfs_obd_snprintf(&page, size, &len,"lock_repay_clients: %d\n",
+ atomic_read(&obd->obd_lock_replay_clients))<=0)
+ goto out;
+ if (lprocfs_obd_snprintf(&page, size, &len,"completed_clients: %d\n",
+ obd->obd_connected_clients -
+ atomic_read(&obd->obd_lock_replay_clients))<=0)
goto out;
- if (lprocfs_obd_snprintf(&page, size, &len,"replayed_requests: %d/??\n",
+ if (lprocfs_obd_snprintf(&page, size, &len,"evicted_clients: %d\n",
+ obd->obd_stale_clients) <= 0)
+ goto out;
+ if (lprocfs_obd_snprintf(&page, size, &len,"replayed_requests: %d\n",
obd->obd_replayed_requests) <= 0)
goto out;
if (lprocfs_obd_snprintf(&page, size, &len, "queued_requests: %d\n",
EXPORT_SYMBOL(lprocfs_obd_wr_recovery_maxtime);
-/**** Changelogs *****/
-#define D_CHANGELOG 0
-
-DECLARE_CHANGELOG_NAMES;
-
-/* How many records per seq_show. Too small, we spawn llog_process threads
- too often; too large, we run out of buffer space */
-#define CHANGELOG_CHUNK_SIZE 100
-
-static int changelog_show_cb(struct llog_handle *llh, struct llog_rec_hdr *hdr,
- void *data)
-{
- struct seq_file *seq = (struct seq_file *)data;
- struct changelog_seq_iter *csi = seq->private;
- struct llog_changelog_rec *rec = (struct llog_changelog_rec *)hdr;
- int rc;
- ENTRY;
-
- if ((rec->cr_hdr.lrh_type != CHANGELOG_REC) ||
- (rec->cr_type >= CL_LAST)) {
- CERROR("Not a changelog rec %d/%d\n", rec->cr_hdr.lrh_type,
- rec->cr_type);
- RETURN(-EINVAL);
- }
-
- CDEBUG(D_CHANGELOG, "rec="LPU64" start="LPU64" cat=%d:%d start=%d:%d\n",
- rec->cr_index, csi->csi_startrec,
- llh->lgh_hdr->llh_cat_idx, llh->lgh_cur_idx,
- csi->csi_startcat, csi->csi_startidx);
-
- if (rec->cr_index < csi->csi_startrec)
- /* Skip entries earlier than what we are interested in */
- RETURN(0);
- if (rec->cr_index == csi->csi_startrec) {
- /* Remember where we started, since seq_read will re-read
- * the data when it reallocs space. Sigh, if only there was
- * a way to tell seq_file how big the buf should be in the
- * first place...
- */
- csi->csi_startcat = llh->lgh_hdr->llh_cat_idx;
- csi->csi_startidx = rec->cr_hdr.lrh_index - 1;
- }
- if (csi->csi_wrote > CHANGELOG_CHUNK_SIZE) {
- /* Stop at some point with a reasonable seq_file buffer size.
- * Start from here the next time.
- */
- csi->csi_endrec = rec->cr_index - 1;
- csi->csi_startcat = llh->lgh_hdr->llh_cat_idx;
- csi->csi_startidx = rec->cr_hdr.lrh_index - 1;
- csi->csi_wrote = 0;
- RETURN(LLOG_PROC_BREAK);
- }
-
- rc = seq_printf(seq, LPU64" %02d%-5s "LPU64" 0x%x t="DFID,
- rec->cr_index, rec->cr_type,
- changelog_str[rec->cr_type], rec->cr_time,
- rec->cr_flags & CLF_FLAGMASK, PFID(&rec->cr_tfid));
-
- if (rec->cr_namelen)
- /* namespace rec includes parent and filename */
- rc += seq_printf(seq, " p="DFID" %.*s\n", PFID(&rec->cr_pfid),
- rec->cr_namelen, rec->cr_name);
- else
- rc += seq_puts(seq, "\n");
-
- if (rc < 0) {
- /* Ran out of room in the seq buffer. seq_read will dump
- * the whole buffer and re-seq_start with a larger one;
- * no point in continuing the llog_process */
- CDEBUG(D_CHANGELOG, "rec="LPU64" overflow "LPU64"<-"LPU64"\n",
- rec->cr_index, csi->csi_startrec, csi->csi_endrec);
- csi->csi_endrec = csi->csi_startrec - 1;
- csi->csi_wrote = 0;
- RETURN(LLOG_PROC_BREAK);
- }
-
- csi->csi_wrote++;
- csi->csi_endrec = rec->cr_index;
-
- RETURN(0);
-}
-
-static int changelog_seq_show(struct seq_file *seq, void *v)
-{
- struct changelog_seq_iter *csi = seq->private;
- int rc;
- ENTRY;
-
- if (csi->csi_fill) {
- /* seq_read wants more data to fill his buffer. But we already
- filled the buf as much as we cared to; force seq_read to
- accept that by padding with 0's */
- while (seq_putc(seq, 0) == 0);
- RETURN(0);
- }
-
- /* Since we have to restart the llog_cat_process for each chunk of the
- seq_ functions, start from where we left off. */
- rc = llog_cat_process(csi->csi_llh, changelog_show_cb, seq,
- csi->csi_startcat, csi->csi_startidx);
-
- CDEBUG(D_CHANGELOG,"seq_show "LPU64"-"LPU64" cat=%d:%d wrote=%d rc=%d\n",
- csi->csi_startrec, csi->csi_endrec, csi->csi_startcat,
- csi->csi_startidx, csi->csi_wrote, rc);
-
- if (rc == 0)
- csi->csi_done = 1;
- if (rc == LLOG_PROC_BREAK)
- /* more records left, but seq_show must return 0 */
- rc = 0;
- RETURN(rc);
-}
-
-static void *changelog_seq_start(struct seq_file *seq, loff_t *pos)
-{
- struct changelog_seq_iter *csi = seq->private;
- LASSERT(csi);
-
- CDEBUG(D_CHANGELOG, "start "LPU64"-"LPU64" pos="LPU64"\n",
- csi->csi_startrec, csi->csi_endrec, *pos);
-
- csi->csi_fill = 0;
-
- if (csi->csi_done)
- /* no more records, seq_read should return 0 if buffer
- is empty */
- return NULL;
-
- if (*pos > csi->csi_pos) {
- /* The seq_read implementation sucks. It may call start
- multiple times, using pos to indicate advances, if any,
- by arbitrarily increasing it by 1. So ignore the actual
- value of pos, and just register any increase as
- "seq_read wants the next values". */
- csi->csi_startrec = csi->csi_endrec + 1;
- csi->csi_pos = *pos;
- }
- /* else use old startrec/startidx */
-
- return csi;
-}
-
-static void changelog_seq_stop(struct seq_file *seq, void *v)
-{
- struct changelog_seq_iter *csi = seq->private;
-
- CDEBUG(D_CHANGELOG, "stop "LPU64"-"LPU64"\n",
- csi->csi_startrec, csi->csi_endrec);
-}
-
-static void *changelog_seq_next(struct seq_file *seq, void *v, loff_t *pos)
-{
- struct changelog_seq_iter *csi = seq->private;
-
- CDEBUG(D_CHANGELOG, "next "LPU64"-"LPU64" pos="LPU64"\n",
- csi->csi_startrec, csi->csi_endrec, *pos);
-
- csi->csi_fill = 1;
-
- return csi;
-}
-
-static struct seq_operations changelog_sops = {
- .start = changelog_seq_start,
- .stop = changelog_seq_stop,
- .next = changelog_seq_next,
- .show = changelog_seq_show,
-};
-
-int changelog_seq_open(struct inode *inode, struct file *file,
- struct changelog_seq_iter **csih)
-{
- struct changelog_seq_iter *csi;
- struct proc_dir_entry *dp = PDE(inode);
- struct seq_file *seq;
- int rc;
-
- LPROCFS_ENTRY_AND_CHECK(dp);
-
- rc = seq_open(file, &changelog_sops);
- if (rc) {
- LPROCFS_EXIT();
- return rc;
- }
-
- OBD_ALLOC_PTR(csi);
- if (csi == NULL) {
- lprocfs_seq_release(inode, file);
- return -ENOMEM;
- }
-
- csi->csi_dev = dp->data;
- seq = file->private_data;
- seq->private = csi;
- *csih = csi;
-
- return rc;
-}
-EXPORT_SYMBOL(changelog_seq_open);
-
-int changelog_seq_release(struct inode *inode, struct file *file)
-{
- struct seq_file *seq = file->private_data;
- struct changelog_seq_iter *csi = seq->private;
-
- if (csi)
- OBD_FREE_PTR(csi);
-
- return lprocfs_seq_release(inode, file);
-}
-EXPORT_SYMBOL(changelog_seq_release);
-
-#ifndef SEEK_CUR /* SLES10 needs this */
-#define SEEK_CUR 1
-#define SEEK_END 2
-#endif
-
-loff_t changelog_seq_lseek(struct file *file, loff_t offset, int origin)
-{
- struct seq_file *seq = (struct seq_file *)file->private_data;
- struct changelog_seq_iter *csi = seq->private;
-
- CDEBUG(D_CHANGELOG,"seek "LPU64"-"LPU64" off="LPU64":%d fpos="LPU64"\n",
- csi->csi_startrec, csi->csi_endrec, offset, origin, file->f_pos);
-
- LL_SEQ_LOCK(seq);
-
- switch (origin) {
- case SEEK_CUR:
- offset += csi->csi_endrec;
- break;
- case SEEK_END:
- /* we don't know the last rec */
- offset = -1;
- }
-
- /* SEEK_SET */
-
- if (offset < 0) {
- LL_SEQ_UNLOCK(seq);
- return -EINVAL;
- }
-
- csi->csi_startrec = offset;
- csi->csi_endrec = offset ? offset - 1 : 0;
-
- /* drop whatever is left in sucky seq_read's buffer */
- seq->count = 0;
- seq->from = 0;
- seq->index++;
- LL_SEQ_UNLOCK(seq);
- file->f_pos = csi->csi_startrec;
- return csi->csi_startrec;
-}
-EXPORT_SYMBOL(changelog_seq_lseek);
-
EXPORT_SYMBOL(lprocfs_register);
EXPORT_SYMBOL(lprocfs_srch);
EXPORT_SYMBOL(lprocfs_remove);
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_kbytesavail);
EXPORT_SYMBOL(lprocfs_rd_filestotal);
EXPORT_SYMBOL(lprocfs_rd_filesfree);
+EXPORT_SYMBOL(lprocfs_rd_quota_resend_count);
+EXPORT_SYMBOL(lprocfs_wr_quota_resend_count);
EXPORT_SYMBOL(lprocfs_write_helper);
EXPORT_SYMBOL(lprocfs_write_frac_helper);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff