+
+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 origin | page ");
+ seq_printf(seq, "inode index count [ 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;
+ static char *origins[] = {
+ [LLAP_ORIGIN_UNKNOWN] = "--",
+ [LLAP_ORIGIN_READPAGE] = "rp",
+ [LLAP_ORIGIN_READAHEAD] = "ra",
+ [LLAP_ORIGIN_COMMIT_WRITE] = "cw",
+ [LLAP_ORIGIN_WRITEPAGE] = "wp",
+ };
+
+ LASSERTF(llap->llap_origin < LLAP__ORIGIN_MAX, "%u\n",
+ llap->llap_origin);
+
+ seq_printf(seq, "%lu | %p %p %s | %p %p %lu %u [",
+ sbi->ll_pglist_gen,
+ llap, llap->llap_cookie,
+ origins[llap->llap_origin],
+ page, page->mapping->host, page->index,
+ page_count(page));
+ 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,
+};
+static int ll_ra_stats_seq_show(struct seq_file *seq, void *v)
+{
+ struct timeval now;
+ struct ll_sb_info *sbi = seq->private;
+ struct ll_ra_info *ra = &sbi->ll_ra_info;
+ int i;
+ static char *ra_stat_strings[] = {
+ [RA_STAT_HIT] = "hits",
+ [RA_STAT_MISS] = "misses",
+ [RA_STAT_DISTANT_READPAGE] = "readpage not consecutive",
+ [RA_STAT_MISS_IN_WINDOW] = "miss inside window",
+ [RA_STAT_FAILED_MATCH] = "failed lock match",
+ [RA_STAT_DISCARDED] = "read but discarded",
+ [RA_STAT_ZERO_LEN] = "zero length file",
+ [RA_STAT_ZERO_WINDOW] = "zero size window",
+ [RA_STAT_EOF] = "read-ahead to EOF",
+ [RA_STAT_MAX_IN_FLIGHT] = "hit max r-a issue",
+ };
+
+ do_gettimeofday(&now);
+
+ spin_lock(&sbi->ll_lock);
+
+ seq_printf(seq, "snapshot_time: %lu.%lu (secs.usecs)\n",
+ now.tv_sec, now.tv_usec);
+ seq_printf(seq, "pending issued pages: %lu\n",
+ ra->ra_cur_pages);
+
+ for(i = 0; i < _NR_RA_STAT; i++)
+ seq_printf(seq, "%-25s %lu\n", ra_stat_strings[i],
+ ra->ra_stats[i]);
+
+ spin_unlock(&sbi->ll_lock);
+
+ return 0;
+}
+
+static void *ll_ra_stats_seq_start(struct seq_file *p, loff_t *pos)
+{
+ if (*pos == 0)
+ return (void *)1;
+ return NULL;
+}
+static void *ll_ra_stats_seq_next(struct seq_file *p, void *v, loff_t *pos)
+{
+ ++*pos;
+ return NULL;
+}
+static void ll_ra_stats_seq_stop(struct seq_file *p, void *v)
+{
+}
+struct seq_operations ll_ra_stats_seq_sops = {
+ .start = ll_ra_stats_seq_start,
+ .stop = ll_ra_stats_seq_stop,
+ .next = ll_ra_stats_seq_next,
+ .show = ll_ra_stats_seq_show,
+};
+
+static int ll_ra_stats_seq_open(struct inode *inode, struct file *file)
+{
+ struct proc_dir_entry *dp = PDE(inode);
+ struct seq_file *seq;
+ int rc;
+
+ rc = seq_open(file, &ll_ra_stats_seq_sops);
+ if (rc)
+ return rc;
+ seq = file->private_data;
+ seq->private = dp->data;
+ return 0;
+}
+
+static ssize_t ll_ra_stats_seq_write(struct file *file, const char *buf,
+ size_t len, loff_t *off)
+{
+ struct seq_file *seq = file->private_data;
+ struct ll_sb_info *sbi = seq->private;
+ struct ll_ra_info *ra = &sbi->ll_ra_info;
+
+ spin_lock(&sbi->ll_lock);
+ memset(ra->ra_stats, 0, sizeof(ra->ra_stats));
+ spin_unlock(&sbi->ll_lock);
+
+ return len;
+}
+
+struct file_operations ll_ra_stats_fops = {
+ .owner = THIS_MODULE,
+ .open = ll_ra_stats_seq_open,
+ .read = seq_read,
+ .write = ll_ra_stats_seq_write,
+ .llseek = seq_lseek,
+ .release = seq_release,
+};
+
+#define PRINTF_STIME(stime) (unsigned long)(stime)->st_num, \
+ lprocfs_stime_avg_ms(stime), lprocfs_stime_avg_us(stime)
+
+static int llite_wait_times_seq_show(struct seq_file *seq, void *v)
+{
+ struct ll_sb_info *sbi = seq->private;
+ struct timeval now;
+
+ do_gettimeofday(&now);
+
+ spin_lock(&sbi->ll_lock);
+
+ seq_printf(seq, "snapshot_time: %lu.%lu (secs.usecs)\n\n",
+ now.tv_sec, now.tv_usec);
+
+ seq_printf(seq, "lock wait times: (num, average ms)\n");
+ seq_printf(seq, "\tread\t%lu\t%lu.%04lu\n",
+ PRINTF_STIME(&sbi->ll_read_stime));
+ seq_printf(seq, "\twrite\t%lu\t%lu.%04lu\n",
+ PRINTF_STIME(&sbi->ll_write_stime));
+ seq_printf(seq, "\tgroup\t%lu\t%lu.%04lu\n",
+ PRINTF_STIME(&sbi->ll_grouplock_stime));
+ seq_printf(seq, "\tseek\t%lu\t%lu.%04lu\n",
+ PRINTF_STIME(&sbi->ll_seek_stime));
+ seq_printf(seq, "\tsetattr\t%lu\t%lu.%04lu\n\n",
+ PRINTF_STIME(&sbi->ll_setattr_stime));
+
+ seq_printf(seq, "io path wait times: (num, average ms)\n");
+ seq_printf(seq, "\tll_brw\t%lu\t%lu.%04lu\n",
+ PRINTF_STIME(&sbi->ll_brw_stime));
+#if 0
+ seq_printf(seq, "\tdone\t%lu\t%lu.%04lu\n",
+ PRINTF_STIME(&sbi->ll_done_stime));
+#endif
+
+ spin_unlock(&sbi->ll_lock);
+
+ return 0;
+}
+#undef pct
+
+static void *llite_wait_times_seq_start(struct seq_file *p, loff_t *pos)
+{
+ if (*pos == 0)
+ return (void *)1;
+ return NULL;
+}
+static void *llite_wait_times_seq_next(struct seq_file *p, void *v, loff_t *pos)
+{
+ ++*pos;
+ return NULL;
+}
+static void llite_wait_times_seq_stop(struct seq_file *p, void *v)
+{
+}
+struct seq_operations llite_wait_times_seq_sops = {
+ .start = llite_wait_times_seq_start,
+ .stop = llite_wait_times_seq_stop,
+ .next = llite_wait_times_seq_next,
+ .show = llite_wait_times_seq_show,
+};
+
+static int llite_wait_times_seq_open(struct inode *inode, struct file *file)
+{
+ struct proc_dir_entry *dp = PDE(inode);
+ struct seq_file *seq;
+ int rc;
+
+ rc = seq_open(file, &llite_wait_times_seq_sops);
+ if (rc)
+ return rc;
+ seq = file->private_data;
+ seq->private = dp->data;
+ return 0;
+}
+
+static ssize_t llite_wait_times_seq_write(struct file *file, const char *buf,
+ size_t len, loff_t *off)
+{
+ struct seq_file *seq = file->private_data;
+ struct ll_sb_info *sbi = seq->private;
+
+ spin_lock(&sbi->ll_lock);
+ memset(&sbi->ll_read_stime, 0, sizeof(sbi->ll_read_stime));
+ memset(&sbi->ll_write_stime, 0, sizeof(sbi->ll_write_stime));
+ memset(&sbi->ll_grouplock_stime, 0, sizeof(sbi->ll_grouplock_stime));
+ memset(&sbi->ll_seek_stime, 0, sizeof(sbi->ll_seek_stime));
+ memset(&sbi->ll_setattr_stime, 0, sizeof(sbi->ll_setattr_stime));
+ memset(&sbi->ll_brw_stime, 0, sizeof(sbi->ll_brw_stime));
+// memset(&sbi->ll_done_stime, 0, sizeof(sbi->ll_done_stime));
+ spin_unlock(&sbi->ll_lock);
+
+ return len;
+}
+
+struct file_operations llite_wait_times_fops = {
+ .owner = THIS_MODULE,
+ .open = llite_wait_times_seq_open,
+ .read = seq_read,
+ .write = llite_wait_times_seq_write,
+ .llseek = seq_lseek,
+ .release = seq_release,
+};
+
+#endif /* LPROCFS */