/* Slow work debugging
 *
 * Copyright (C) 2009 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public Licence
 * as published by the Free Software Foundation; either version
 * 2 of the Licence, or (at your option) any later version.
 */

#include <linux/module.h>
#include <linux/slow-work.h>
#include <linux/fs.h>
#include <linux/time.h>
#include <linux/seq_file.h>
#include "slow-work.h"

#define ITERATOR_SHIFT          (BITS_PER_LONG - 4)
#define ITERATOR_SELECTOR       (0xfUL << ITERATOR_SHIFT)
#define ITERATOR_COUNTER        (~ITERATOR_SELECTOR)

void slow_work_new_thread_desc(struct slow_work *work, struct seq_file *m)
{
        seq_puts(m, "Slow-work: New thread");
}

/*
 * Render the time mark field on a work item into a 5-char time with units plus
 * a space
 */
static void slow_work_print_mark(struct seq_file *m, struct slow_work *work)
{
        struct timespec now, diff;

        now = CURRENT_TIME;
        diff = timespec_sub(now, work->mark);

        if (diff.tv_sec < 0)
                seq_puts(m, "  -ve ");
        else if (diff.tv_sec == 0 && diff.tv_nsec < 1000)
                seq_printf(m, "%3luns ", diff.tv_nsec);
        else if (diff.tv_sec == 0 && diff.tv_nsec < 1000000)
                seq_printf(m, "%3luus ", diff.tv_nsec / 1000);
        else if (diff.tv_sec == 0 && diff.tv_nsec < 1000000000)
                seq_printf(m, "%3lums ", diff.tv_nsec / 1000000);
        else if (diff.tv_sec <= 1)
                seq_puts(m, "   1s ");
        else if (diff.tv_sec < 60)
                seq_printf(m, "%4lus ", diff.tv_sec);
        else if (diff.tv_sec < 60 * 60)
                seq_printf(m, "%4lum ", diff.tv_sec / 60);
        else if (diff.tv_sec < 60 * 60 * 24)
                seq_printf(m, "%4luh ", diff.tv_sec / 3600);
        else
                seq_puts(m, "exces ");
}

/*
 * Describe a slow work item for debugfs
 */
static int slow_work_runqueue_show(struct seq_file *m, void *v)
{
        struct slow_work *work;
        struct list_head *p = v;
        unsigned long id;

        switch ((unsigned long) v) {
        case 1:
                seq_puts(m, "THR PID   ITEM ADDR        FL MARK  DESC\n");
                return 0;
        case 2:
                seq_puts(m, "=== ===== ================ == ===== ==========\n");
                return 0;

        case 3 ... 3 + SLOW_WORK_THREAD_LIMIT - 1:
                id = (unsigned long) v - 3;

                read_lock(&slow_work_execs_lock);
                work = slow_work_execs[id];
                if (work) {
                        smp_read_barrier_depends();

                        seq_printf(m, "%3lu %5d %16p %2lx ",
                                   id, slow_work_pids[id], work, work->flags);
                        slow_work_print_mark(m, work);

                        if (work->ops->desc)
                                work->ops->desc(work, m);
                        seq_putc(m, '\n');
                }
                read_unlock(&slow_work_execs_lock);
                return 0;

        default:
                work = list_entry(p, struct slow_work, link);
                seq_printf(m, "%3s     - %16p %2lx ",
                           work->flags & SLOW_WORK_VERY_SLOW ? "vsq" : "sq",
                           work, work->flags);
                slow_work_print_mark(m, work);

                if (work->ops->desc)
                        work->ops->desc(work, m);
                seq_putc(m, '\n');
                return 0;
        }
}

/*
 * map the iterator to a work item
 */
static void *slow_work_runqueue_index(struct seq_file *m, loff_t *_pos)
{
        struct list_head *p;
        unsigned long count, id;

        switch (*_pos >> ITERATOR_SHIFT) {
        case 0x0:
                if (*_pos == 0)
                        *_pos = 1;
                if (*_pos < 3)
                        return (void *)(unsigned long) *_pos;
                if (*_pos < 3 + SLOW_WORK_THREAD_LIMIT)
                        for (id = *_pos - 3;
                             id < SLOW_WORK_THREAD_LIMIT;
                             id++, (*_pos)++)
                                if (slow_work_execs[id])
                                        return (void *)(unsigned long) *_pos;
                *_pos = 0x1UL << ITERATOR_SHIFT;

        case 0x1:
                count = *_pos & ITERATOR_COUNTER;
                list_for_each(p, &slow_work_queue) {
                        if (count == 0)
                                return p;
                        count--;
                }
                *_pos = 0x2UL << ITERATOR_SHIFT;

        case 0x2:
                count = *_pos & ITERATOR_COUNTER;
                list_for_each(p, &vslow_work_queue) {
                        if (count == 0)
                                return p;
                        count--;
                }
                *_pos = 0x3UL << ITERATOR_SHIFT;

        default:
                return NULL;
        }
}

/*
 * set up the iterator to start reading from the first line
 */
static void *slow_work_runqueue_start(struct seq_file *m, loff_t *_pos)
{
        spin_lock_irq(&slow_work_queue_lock);
        return slow_work_runqueue_index(m, _pos);
}

/*
 * move to the next line
 */
static void *slow_work_runqueue_next(struct seq_file *m, void *v, loff_t *_pos)
{
        struct list_head *p = v;
        unsigned long selector = *_pos >> ITERATOR_SHIFT;

        (*_pos)++;
        switch (selector) {
        case 0x0:
                return slow_work_runqueue_index(m, _pos);

        case 0x1:
                if (*_pos >> ITERATOR_SHIFT == 0x1) {
                        p = p->next;
                        if (p != &slow_work_queue)
                                return p;
                }
                *_pos = 0x2UL << ITERATOR_SHIFT;
                p = &vslow_work_queue;

        case 0x2:
                if (*_pos >> ITERATOR_SHIFT == 0x2) {
                        p = p->next;
                        if (p != &vslow_work_queue)
                                return p;
                }
                *_pos = 0x3UL << ITERATOR_SHIFT;

        default:
                return NULL;
        }
}

/*
 * clean up after reading
 */
static void slow_work_runqueue_stop(struct seq_file *m, void *v)
{
        spin_unlock_irq(&slow_work_queue_lock);
}

static const struct seq_operations slow_work_runqueue_ops = {
        .start          = slow_work_runqueue_start,
        .stop           = slow_work_runqueue_stop,
        .next           = slow_work_runqueue_next,
        .show           = slow_work_runqueue_show,
};

/*
 * open "/sys/kernel/debug/slow_work/runqueue" to list queue contents
 */
static int slow_work_runqueue_open(struct inode *inode, struct file *file)
{
        return seq_open(file, &slow_work_runqueue_ops);
}

const struct file_operations slow_work_runqueue_fops = {
        .owner          = THIS_MODULE,
        .open           = slow_work_runqueue_open,
        .read           = seq_read,
        .llseek         = seq_lseek,
        .release        = seq_release,
};