LASSERT(root != NULL);
parent = root->parent;
LASSERT(parent != NULL);
-
+
while (1) {
while (temp->subdir != NULL)
temp = temp->subdir;
rm_entry = temp;
temp = temp->parent;
+
+ /* Memory corruption once caused this to fail, and
+ without this LASSERT we would loop here forever. */
+ LASSERTF(strlen(rm_entry->name) == rm_entry->namelen,
+ "0x%p %s/%s len %d\n", rm_entry, temp->name,
+ rm_entry->name, (int)strlen(rm_entry->name));
+
remove_proc_entry(rm_entry->name, rm_entry->parent);
if (temp == parent)
break;
return rc;
}
+int lprocfs_rd_kbytesavail(char *page, char **start, off_t off, int count,
+ int *eof, void *data)
+{
+ struct obd_statfs osfs;
+ int rc = obd_statfs(data, &osfs, jiffies - HZ);
+ if (!rc) {
+ __u32 blk_size = osfs.os_bsize >> 10;
+ __u64 result = osfs.os_bavail;
+
+ while (blk_size >>= 1)
+ result <<= 1;
+
+ *eof = 1;
+ rc = snprintf(page, count, LPU64"\n", result);
+ }
+ return rc;
+}
+
int lprocfs_rd_filestotal(char *page, char **start, off_t off, int count,
int *eof, void *data)
{
return rc;
}
-int lprocfs_rd_filegroups(char *page, char **start, off_t off, int count,
- int *eof, void *data)
-{
- *eof = 1;
- return snprintf(page, count, "unimplemented\n");
-}
-
int lprocfs_rd_server_uuid(char *page, char **start, off_t off, int count,
int *eof, void *data)
{
struct obd_device *obd = (struct obd_device *)data;
struct obd_import *imp;
- static char* import_state_names[] = {
- "<UNKNOWN 0>", "INVALID", "NEW", "DISCONN", "CONNECTING",
- "REPLAY", "RECOVER", "FULL", "EVICTED",
- };
char *imp_state_name = NULL;
-
+
LASSERT(obd != NULL);
imp = obd->u.cli.cl_import;
- LASSERT(imp->imp_state <= LUSTRE_IMP_EVICTED);
- imp_state_name = import_state_names[imp->imp_state];
+ imp_state_name = ptlrpc_import_state_name(imp->imp_state);
*eof = 1;
return snprintf(page, count, "%s\t%s\n",
imp->imp_target_uuid.uuid, imp_state_name);
return snprintf(page, count, "%s\n", conn->c_remote_uuid.uuid);
}
+int lprocfs_rd_num_exports(char *page, char **start, off_t off, int count,
+ int *eof, void *data)
+{
+ struct obd_device *obd = (struct obd_device*)data;
+
+ LASSERT(obd != NULL);
+ *eof = 1;
+ return snprintf(page, count, "%u\n", obd->obd_num_exports);
+}
+
int lprocfs_rd_numrefs(char *page, char **start, off_t off, int count,
int *eof, void *data)
{
return snprintf(page, count, "%d\n", class->typ_refcnt);
}
-int lprocfs_obd_attach(struct obd_device *dev, struct lprocfs_vars *list)
+int lprocfs_obd_setup(struct obd_device *obd, struct lprocfs_vars *list)
{
int rc = 0;
- LASSERT(dev != NULL);
- LASSERT(dev->obd_type != NULL);
- LASSERT(dev->obd_type->typ_procroot != NULL);
-
- dev->obd_proc_entry = lprocfs_register(dev->obd_name,
- dev->obd_type->typ_procroot,
- list, dev);
- if (IS_ERR(dev->obd_proc_entry)) {
- rc = PTR_ERR(dev->obd_proc_entry);
- dev->obd_proc_entry = NULL;
+ LASSERT(obd != NULL);
+ LASSERT(obd->obd_type != NULL);
+ LASSERT(obd->obd_type->typ_procroot != NULL);
+
+ obd->obd_proc_entry = lprocfs_register(obd->obd_name,
+ obd->obd_type->typ_procroot,
+ list, obd);
+ if (IS_ERR(obd->obd_proc_entry)) {
+ rc = PTR_ERR(obd->obd_proc_entry);
+ CERROR("error %d setting up lprocfs for %s\n",rc,obd->obd_name);
+ obd->obd_proc_entry = NULL;
}
return rc;
}
-int lprocfs_obd_detach(struct obd_device *dev)
+int lprocfs_obd_cleanup(struct obd_device *obd)
{
- if (dev && dev->obd_proc_entry) {
- lprocfs_remove(dev->obd_proc_entry);
- dev->obd_proc_entry = NULL;
+ if (obd && obd->obd_proc_entry) {
+ lprocfs_remove(obd->obd_proc_entry);
+ obd->obd_proc_entry = NULL;
}
return 0;
}
static int lprocfs_stats_seq_open(struct inode *inode, struct file *file)
{
- struct proc_dir_entry *dp = inode->u.generic_ip;
+ struct proc_dir_entry *dp = PDE(inode);
struct seq_file *seq;
int rc;
}
struct file_operations lprocfs_stats_seq_fops = {
- open: lprocfs_stats_seq_open,
- read: seq_read,
- llseek: seq_lseek,
- release: seq_release,
+ .owner = THIS_MODULE,
+ .open = lprocfs_stats_seq_open,
+ .read = seq_read,
+ .llseek = seq_lseek,
+ .release = seq_release,
};
int lprocfs_register_stats(struct proc_dir_entry *root, const char *name,
LPROCFS_OBD_OP_INIT(num_private_stats, stats, attach);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, detach);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, setup);
- LPROCFS_OBD_OP_INIT(num_private_stats, stats, postsetup);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, precleanup);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, cleanup);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, postrecov);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, prep_async_page);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, queue_async_io);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, set_async_flags);
- LPROCFS_OBD_OP_INIT(num_private_stats, stats, queue_sync_io);
- LPROCFS_OBD_OP_INIT(num_private_stats, stats, trigger_sync_io);
+ LPROCFS_OBD_OP_INIT(num_private_stats, stats, queue_group_io);
+ LPROCFS_OBD_OP_INIT(num_private_stats, stats, trigger_group_io);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, teardown_async_page);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, punch);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, sync);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, san_preprw);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, init_export);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, destroy_export);
- LPROCFS_OBD_OP_INIT(num_private_stats, stats, lock_contains);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, llog_init);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, llog_finish);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, pin);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, unpin);
- LPROCFS_OBD_OP_INIT(num_private_stats, stats, invalidate_import);
+ LPROCFS_OBD_OP_INIT(num_private_stats, stats, import_event);
LPROCFS_OBD_OP_INIT(num_private_stats, stats, notify);
for (i = num_private_stats; i < num_stats; i++) {
int *val)
{
char kernbuf[20], *end;
-
+
if (count > (sizeof(kernbuf) - 1))
return -EINVAL;
return 0;
}
-int lprocfs_obd_seq_create(struct obd_device *dev, char *name, mode_t mode,
+int lprocfs_write_u64_helper(const char *buffer, unsigned long count,
+ __u64 *val)
+{
+ char kernbuf[22], *end;
+
+ if (count > (sizeof(kernbuf) - 1))
+ return -EINVAL;
+
+ if (copy_from_user(kernbuf, buffer, count))
+ return -EFAULT;
+
+ kernbuf[count] = '\0';
+
+ *val = simple_strtoull(kernbuf, &end, 0);
+ if (kernbuf == end)
+ return -EINVAL;
+
+ return 0;
+}
+
+int lprocfs_obd_seq_create(struct obd_device *dev, char *name, mode_t mode,
struct file_operations *seq_fops, void *data)
{
struct proc_dir_entry *entry;
EXPORT_SYMBOL(lprocfs_srch);
EXPORT_SYMBOL(lprocfs_remove);
EXPORT_SYMBOL(lprocfs_add_vars);
-EXPORT_SYMBOL(lprocfs_obd_attach);
-EXPORT_SYMBOL(lprocfs_obd_detach);
+EXPORT_SYMBOL(lprocfs_obd_setup);
+EXPORT_SYMBOL(lprocfs_obd_cleanup);
EXPORT_SYMBOL(lprocfs_alloc_stats);
EXPORT_SYMBOL(lprocfs_free_stats);
EXPORT_SYMBOL(lprocfs_register_stats);
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_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_rd_filegroups);
EXPORT_SYMBOL(lprocfs_write_helper);
+EXPORT_SYMBOL(lprocfs_write_u64_helper);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff