X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fllite%2Flproc_llite.c;h=35676f2bf5de2520773cd0b6a12de90608ffca15;hp=14eac3f3e8a8f9e5a212a766fb36acc653f44c92;hb=cbd3a230274e1197d378725ee9e2aed6e35d2cb6;hpb=067c526a4e5592095a3335478ec2580535ed2be4 diff --git a/lustre/llite/lproc_llite.c b/lustre/llite/lproc_llite.c index 14eac3f..35676f2 100644 --- a/lustre/llite/lproc_llite.c +++ b/lustre/llite/lproc_llite.c @@ -22,13 +22,16 @@ #define DEBUG_SUBSYSTEM S_LLITE #include -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)) -#include -#endif #include #include +#include +#include + +#include "llite_internal.h" /* /proc/lustre/llite mount point registration */ +struct proc_dir_entry *proc_lustre_fs_root; +struct file_operations llite_dump_pgcache_fops; #ifndef LPROCFS int lprocfs_register_mountpoint(struct proc_dir_entry *parent, @@ -39,36 +42,127 @@ int lprocfs_register_mountpoint(struct proc_dir_entry *parent, void lprocfs_unregister_mountpoint(struct ll_sb_info *sbi){} #else -#define LPROC_LLITE_STAT_FCT(fct_name, get_statfs_fct) \ -int fct_name(char *page, char **start, off_t off, \ - int count, int *eof, void *data) \ -{ \ - struct statfs sfs; \ - int rc; \ - LASSERT(data != NULL); \ - rc = get_statfs_fct((struct super_block*)data, &sfs); \ - return (rc==0 \ - ? lprocfs_##fct_name (page, start, off, count, eof, &sfs) \ - : rc); \ +long long mnt_instance; + +static int ll_rd_blksize(char *page, char **start, off_t off, int count, + int *eof, void *data) +{ + struct super_block *sb = (struct super_block *)data; + struct obd_statfs osfs; + int rc; + + LASSERT(sb != NULL); + rc = ll_statfs_internal(sb, &osfs, jiffies - HZ); + if (!rc) { + *eof = 1; + rc = snprintf(page, count, "%u\n", osfs.os_bsize); + } + + return rc; } -long long mnt_instance; +static int ll_rd_kbytestotal(char *page, char **start, off_t off, int count, + int *eof, void *data) +{ + struct super_block *sb = (struct super_block *)data; + struct obd_statfs osfs; + int rc; -LPROC_LLITE_STAT_FCT(rd_blksize, vfs_statfs); -LPROC_LLITE_STAT_FCT(rd_kbytestotal, vfs_statfs); -LPROC_LLITE_STAT_FCT(rd_kbytesfree, vfs_statfs); -LPROC_LLITE_STAT_FCT(rd_filestotal, vfs_statfs); -LPROC_LLITE_STAT_FCT(rd_filesfree, vfs_statfs); -LPROC_LLITE_STAT_FCT(rd_filegroups, vfs_statfs); + LASSERT(sb != NULL); + rc = ll_statfs_internal(sb, &osfs, jiffies - HZ); + if (!rc) { + __u32 blk_size = osfs.os_bsize >> 10; + __u64 result = osfs.os_blocks; + + while (blk_size >>= 1) + result <<= 1; + + *eof = 1; + rc = snprintf(page, count, LPU64"\n", result); + } + return rc; -int rd_path(char *page, char **start, off_t off, int count, int *eof, - void *data) +} + +static int ll_rd_kbytesfree(char *page, char **start, off_t off, int count, + int *eof, void *data) { - return 0; + struct super_block *sb = (struct super_block *)data; + struct obd_statfs osfs; + int rc; + + LASSERT(sb != NULL); + rc = ll_statfs_internal(sb, &osfs, jiffies - HZ); + if (!rc) { + __u32 blk_size = osfs.os_bsize >> 10; + __u64 result = osfs.os_bfree; + + while (blk_size >>= 1) + result <<= 1; + + *eof = 1; + rc = snprintf(page, count, LPU64"\n", result); + } + return rc; +} + +static int ll_rd_kbytesavail(char *page, char **start, off_t off, int count, + int *eof, void *data) +{ + struct super_block *sb = (struct super_block *)data; + struct obd_statfs osfs; + int rc; + + LASSERT(sb != NULL); + rc = ll_statfs_internal(sb, &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; +} + +static int ll_rd_filestotal(char *page, char **start, off_t off, int count, + int *eof, void *data) +{ + struct super_block *sb = (struct super_block *)data; + struct obd_statfs osfs; + int rc; + + LASSERT(sb != NULL); + rc = ll_statfs_internal(sb, &osfs, jiffies - HZ); + if (!rc) { + *eof = 1; + rc = snprintf(page, count, LPU64"\n", osfs.os_files); + } + return rc; +} + +static int ll_rd_filesfree(char *page, char **start, off_t off, int count, + int *eof, void *data) +{ + struct super_block *sb = (struct super_block *)data; + struct obd_statfs osfs; + int rc; + + LASSERT(sb != NULL); + rc = ll_statfs_internal(sb, &osfs, jiffies - HZ); + if (!rc) { + *eof = 1; + rc = snprintf(page, count, LPU64"\n", osfs.os_ffree); + } + return rc; + } -int rd_fstype(char *page, char **start, off_t off, int count, int *eof, - void *data) +static int ll_rd_fstype(char *page, char **start, off_t off, int count, + int *eof, void *data) { struct super_block *sb = (struct super_block*)data; @@ -77,8 +171,8 @@ int rd_fstype(char *page, char **start, off_t off, int count, int *eof, return snprintf(page, count, "%s\n", sb->s_type->name); } -int rd_sb_uuid(char *page, char **start, off_t off, int count, int *eof, - void *data) +static int ll_rd_sb_uuid(char *page, char **start, off_t off, int count, + int *eof, void *data) { struct super_block *sb = (struct super_block *)data; @@ -87,16 +181,88 @@ int rd_sb_uuid(char *page, char **start, off_t off, int count, int *eof, return snprintf(page, count, "%s\n", ll_s2sbi(sb)->ll_sb_uuid.uuid); } -struct lprocfs_vars lprocfs_obd_vars[] = { - { "uuid", rd_sb_uuid, 0, 0 }, - { "mntpt_path", rd_path, 0, 0 }, - { "fstype", rd_fstype, 0, 0 }, - { "blocksize", rd_blksize, 0, 0 }, - { "kbytestotal", rd_kbytestotal, 0, 0 }, - { "kbytesfree", rd_kbytesfree, 0, 0 }, - { "filestotal", rd_filestotal, 0, 0 }, - { "filesfree", rd_filesfree, 0, 0 }, - { "filegroups", rd_filegroups, 0, 0 }, +static int ll_rd_read_ahead(char *page, char **start, off_t off, int count, + int *eof, void *data) +{ + struct super_block *sb = (struct super_block*)data; + struct ll_sb_info *sbi = ll_s2sbi(sb); + int val, rc; + ENTRY; + + *eof = 1; + val = (sbi->ll_flags & LL_SBI_READAHEAD) ? 1 : 0; + rc = snprintf(page, count, "%d\n", val); + RETURN(rc); +} + +static int ll_wr_read_ahead(struct file *file, const char *buffer, + unsigned long count, void *data) +{ + struct super_block *sb = (struct super_block*)data; + struct ll_sb_info *sbi = ll_s2sbi(sb); + int readahead; + ENTRY; + + if (1 != sscanf(buffer, "%d", &readahead)) + RETURN(-EINVAL); + + if (readahead) + sbi->ll_flags |= LL_SBI_READAHEAD; + else + sbi->ll_flags &= ~LL_SBI_READAHEAD; + + RETURN(count); +} + +static int ll_rd_max_read_ahead_mb(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + struct super_block *sb = data; + struct ll_sb_info *sbi = ll_s2sbi(sb); + unsigned val; + + spin_lock(&sbi->ll_lock); + val = (sbi->ll_max_read_ahead_pages << PAGE_CACHE_SHIFT) >> 20; + spin_unlock(&sbi->ll_lock); + + return snprintf(page, count, "%u\n", val); +} + +static int ll_wr_max_read_ahead_mb(struct file *file, const char *buffer, + unsigned long count, void *data) +{ + struct super_block *sb = data; + struct ll_sb_info *sbi = ll_s2sbi(sb); + int val, rc; + + rc = lprocfs_write_helper(buffer, count, &val); + if (rc) + return rc; + + if (val < 0 || val > (num_physpages << PAGE_SHIFT) >> 20) + return -ERANGE; + + spin_lock(&sbi->ll_lock); + sbi->ll_max_read_ahead_pages = (val << 20) >> PAGE_CACHE_SHIFT; + spin_unlock(&sbi->ll_lock); + + return count; +} + +static struct lprocfs_vars lprocfs_obd_vars[] = { + { "uuid", ll_rd_sb_uuid, 0, 0 }, + //{ "mntpt_path", ll_rd_path, 0, 0 }, + { "fstype", ll_rd_fstype, 0, 0 }, + { "blocksize", ll_rd_blksize, 0, 0 }, + { "kbytestotal", ll_rd_kbytestotal, 0, 0 }, + { "kbytesfree", ll_rd_kbytesfree, 0, 0 }, + { "kbytesavail", ll_rd_kbytesavail, 0, 0 }, + { "filestotal", ll_rd_filestotal, 0, 0 }, + { "filesfree", ll_rd_filesfree, 0, 0 }, + //{ "filegroups", lprocfs_rd_filegroups, 0, 0 }, + { "read_ahead", ll_rd_read_ahead, ll_wr_read_ahead, 0 }, + { "max_read_ahead_mb", ll_rd_max_read_ahead_mb, + ll_wr_max_read_ahead_mb, 0 }, { 0 } }; @@ -108,8 +274,6 @@ struct llite_file_opcode { const char *opname; } llite_opcode_table[LPROC_LL_FILE_OPCODES] = { /* file operation */ - { LPROC_LL_DIRTY_PAGES, LPROCFS_CNTR_AVGMINMAX|LPROCFS_TYPE_PAGES, - "dirty_pages" }, { LPROC_LL_DIRTY_HITS, LPROCFS_TYPE_REGS, "dirty_pages_hits" }, { LPROC_LL_DIRTY_MISSES, LPROCFS_TYPE_REGS, "dirty_pages_misses" }, { LPROC_LL_WB_WRITEPAGE, LPROCFS_CNTR_AVGMINMAX|LPROCFS_TYPE_PAGES, @@ -136,7 +300,6 @@ struct llite_file_opcode { { LPROC_LL_LLSEEK, LPROCFS_TYPE_REGS, "seek" }, { LPROC_LL_FSYNC, LPROCFS_TYPE_REGS, "fsync" }, /* inode operation */ - { LPROC_LL_SETATTR_RAW, LPROCFS_TYPE_REGS, "setattr_raw" }, { LPROC_LL_SETATTR, LPROCFS_TYPE_REGS, "setattr" }, { LPROC_LL_TRUNC, LPROCFS_TYPE_REGS, "punch" }, #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) @@ -161,9 +324,9 @@ int lprocfs_register_mountpoint(struct proc_dir_entry *parent, struct ll_sb_info *sbi = ll_s2sbi(sb); struct obd_device *obd; char name[MAX_STRING_SIZE + 1]; - struct obd_uuid uuid; int err, id; struct lprocfs_stats *svc_stats = NULL; + struct proc_dir_entry *entry; ENTRY; memset(lvars, 0, sizeof(lvars)); @@ -186,6 +349,12 @@ int lprocfs_register_mountpoint(struct proc_dir_entry *parent, RETURN(err); } + entry = create_proc_entry("dump_page_cache", 0444, sbi->ll_proc_root); + if (entry == NULL) + GOTO(out, err = -ENOMEM); + entry->proc_fops = &llite_dump_pgcache_fops; + entry->data = sbi; + svc_stats = lprocfs_alloc_stats(LPROC_LL_FILE_OPCODES); if (svc_stats == NULL) { err = -ENOMEM; @@ -222,8 +391,7 @@ int lprocfs_register_mountpoint(struct proc_dir_entry *parent, goto out; /* MDC info */ - strncpy(uuid.uuid, mdc, sizeof(uuid.uuid)); - obd = class_uuid2obd(&uuid); + obd = class_name2obd(mdc); LASSERT(obd != NULL); LASSERT(obd->obd_type != NULL); @@ -243,8 +411,7 @@ int lprocfs_register_mountpoint(struct proc_dir_entry *parent, goto out; /* OSC */ - strncpy(uuid.uuid, osc, sizeof(uuid.uuid)); - obd = class_uuid2obd(&uuid); + obd = class_name2obd(osc); LASSERT(obd != NULL); LASSERT(obd->obd_type != NULL); @@ -283,4 +450,191 @@ void lprocfs_unregister_mountpoint(struct ll_sb_info *sbi) } } #undef MAX_STRING_SIZE + +static struct ll_async_page *llite_pglist_next_llap(struct ll_sb_info *sbi, + struct list_head *list) +{ + struct ll_async_page *llap; + struct list_head *pos; + + list_for_each(pos, list) { + if (pos == &sbi->ll_pglist) + return NULL; + llap = list_entry(pos, struct ll_async_page, llap_proc_item); + if (llap->llap_page == NULL) + continue; + return llap; + } + LBUG(); + return NULL; +} + +#define seq_page_flag(seq, page, flag, has_flags) do { \ + if (test_bit(PG_##flag, &(page)->flags)) { \ + if (!has_flags) \ + has_flags = 1; \ + else \ + seq_putc(seq, '|'); \ + seq_puts(seq, #flag); \ + } \ + } while(0); + +static int llite_dump_pgcache_seq_show(struct seq_file *seq, void *v) +{ + struct ll_async_page *llap, *dummy_llap = seq->private; + struct ll_sb_info *sbi = dummy_llap->llap_cookie; + + /* 2.4 doesn't seem to have SEQ_START_TOKEN, so we implement + * it in our own state */ + if (dummy_llap->llap_magic == 0) { + seq_printf(seq, "generation | llap .cookie | page "); + seq_printf(seq, "inode .index [ page flags ]\n"); + return 0; + } + + spin_lock(&sbi->ll_lock); + + llap = llite_pglist_next_llap(sbi, &dummy_llap->llap_proc_item); + if (llap != NULL) { + int has_flags = 0; + struct page *page = llap->llap_page; + + seq_printf(seq, "%lu | %p %p | %p %p %lu [", + sbi->ll_pglist_gen, + llap, llap->llap_cookie, + page, page->mapping->host, page->index); + seq_page_flag(seq, page, locked, has_flags); + seq_page_flag(seq, page, error, has_flags); + seq_page_flag(seq, page, referenced, has_flags); + seq_page_flag(seq, page, uptodate, has_flags); + seq_page_flag(seq, page, dirty, has_flags); + seq_page_flag(seq, page, highmem, has_flags); + if (!has_flags) + seq_puts(seq, "-]\n"); + else + seq_puts(seq, "]\n"); + } + + spin_unlock(&sbi->ll_lock); + + return 0; +} + +static void *llite_dump_pgcache_seq_start(struct seq_file *seq, loff_t *pos) +{ + struct ll_async_page *llap = seq->private; + + if (llap->llap_magic == 2) + return NULL; + + return (void *)1; +} + +static void *llite_dump_pgcache_seq_next(struct seq_file *seq, void *v, + loff_t *pos) +{ + struct ll_async_page *llap, *dummy_llap = seq->private; + struct ll_sb_info *sbi = dummy_llap->llap_cookie; + + /* bail if we just displayed the banner */ + if (dummy_llap->llap_magic == 0) { + dummy_llap->llap_magic = 1; + return dummy_llap; + } + + /* we've just displayed the llap that is after us in the list. + * we advance to a position beyond it, returning null if there + * isn't another llap in the list beyond that new position. */ + spin_lock(&sbi->ll_lock); + llap = llite_pglist_next_llap(sbi, &dummy_llap->llap_proc_item); + list_del_init(&dummy_llap->llap_proc_item); + if (llap) { + list_add(&dummy_llap->llap_proc_item, &llap->llap_proc_item); + llap = llite_pglist_next_llap(sbi, &dummy_llap->llap_proc_item); + } + spin_unlock(&sbi->ll_lock); + + ++*pos; + if (llap == NULL) { + dummy_llap->llap_magic = 2; + return NULL; + } + return dummy_llap; +} + +static void llite_dump_pgcache_seq_stop(struct seq_file *seq, void *v) +{ +} + +struct seq_operations llite_dump_pgcache_seq_sops = { + .start = llite_dump_pgcache_seq_start, + .stop = llite_dump_pgcache_seq_stop, + .next = llite_dump_pgcache_seq_next, + .show = llite_dump_pgcache_seq_show, +}; + +/* we're displaying llaps in a list_head list. we don't want to hold a lock + * while we walk the entire list, and we don't want to have to seek into + * the right position in the list as an app advances with many syscalls. we + * allocate a dummy llap and hang it off file->private. its position in + * the list records where the app is currently displaying. this way our + * seq .start and .stop don't actually do anything. .next returns null + * when the dummy hits the end of the list which eventually leads to .release + * where we tear down. this kind of displaying is super-racey, so we put + * a generation counter on the list so the output shows when the list + * changes between reads. + */ +static int llite_dump_pgcache_seq_open(struct inode *inode, struct file *file) +{ + struct proc_dir_entry *dp = PDE(inode); + struct ll_async_page *llap; + struct seq_file *seq; + struct ll_sb_info *sbi = dp->data; + int rc; + + OBD_ALLOC_GFP(llap, sizeof(*llap), GFP_KERNEL); + if (llap == NULL) + return -ENOMEM; + llap->llap_page = NULL; + llap->llap_cookie = sbi; + llap->llap_magic = 0; + + rc = seq_open(file, &llite_dump_pgcache_seq_sops); + if (rc) { + OBD_FREE(llap, sizeof(*llap)); + return rc; + } + seq = file->private_data; + seq->private = llap; + + spin_lock(&sbi->ll_lock); + list_add(&llap->llap_proc_item, &sbi->ll_pglist); + spin_unlock(&sbi->ll_lock); + + return 0; +} + +static int llite_dump_pgcache_seq_release(struct inode *inode, + struct file *file) +{ + struct seq_file *seq = file->private_data; + struct ll_async_page *llap = seq->private; + struct ll_sb_info *sbi = llap->llap_cookie; + + spin_lock(&sbi->ll_lock); + if (!list_empty(&llap->llap_proc_item)) + list_del_init(&llap->llap_proc_item); + spin_unlock(&sbi->ll_lock); + OBD_FREE(llap, sizeof(*llap)); + + return seq_release(inode, file); +} + +struct file_operations llite_dump_pgcache_fops = { + .owner = THIS_MODULE, + .open = llite_dump_pgcache_seq_open, + .read = seq_read, + .release = llite_dump_pgcache_seq_release, +}; + #endif /* LPROCFS */