---

elsacct.c

Go to the documentation of this file.

/*
 *  driver/elsacct/elsacct.c
 * 
 *  ELSA - Enhanced Linux System Accounting
 *  Guillaume Thouvenin - 26/04/2004
 *
 *  This module implements Enhanced Linux System Accounting. 
 *  We implement a character driver to transfer data between 
 *  BANK that are in the kernel adress space and the user 
 *  adress space. 
 *
 *  This code is licenced under GPL.
 */

#include <linux/module.h>
#include <linux/config.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/blkdev.h>
#include <linux/times.h>

#include <linux/elsacct.h>
#include <linux/bank.h>

#include <asm/uaccess.h>

#ifdef CONFIG_ELSACCT_DEBUG
#define dprintk(format...) printk(format)
#else
#define dprintk(format...)
#endif

/* Currently, informations are stored in the same file and we cannot chose it */
#define ELSACCT_FILE    "/var/log/bank"

/* It's the head on the list of banks */
static struct bank_root elsa_br = BANK_ROOT_INIT(elsa_br);

/* this is the major number dynamically got when registered */
static int elsa_major;

/* lock used to protect bank's list modifications */
static spinlock_t elsa_lock = SPIN_LOCK_UNLOCKED;

#define MANTSIZE        13      /* 13 bit mantissa. */
#define EXPSIZE         3       /* Base 8 (3 bit) exponent. */
#define MAXFRACT        ((1 << MANTSIZE) - 1)   /* Maximum fractional value. */

typedef __u16 comp_t;

static comp_t encode_comp_t(unsigned long value)
{
        int exp, rnd;

        exp = rnd = 0;
        while (value > MAXFRACT) {
                rnd = value & (1 << (EXPSIZE - 1));     /* Round up? */
                value >>= EXPSIZE;      /* Base 8 exponent == 3 bit shift. */
                exp++;
        }

        /*
         * If we need to round up, do it (and handle overflow correctly).
         */
        if (rnd && (++value > MAXFRACT)) {
                value >>= EXPSIZE;
                exp++;
        }

        /*
         * Clean it up and polish it off.
         */
        exp <<= MANTSIZE;       /* Shift the exponent into place */
        exp += value;           /* and add on the mantissa. */
        return exp;
}

static int do_elsacct_bank(struct elsa_bank *b)
{
        static struct file *filp;
        //static int irq_restore;
        struct elsa_acct *info = (struct elsa_acct *)b->info;
        mm_segment_t old_fs;

        if (!info)
                return -EINVAL;

        /* Set bank ID */
        info->eac_bid = b->bid;

        /* Cannot open a file if irqs are disabled */
        //if (irqs_disabled()) {
        //      local_irq_enable();
        //      irq_restore = 1;
        //}

        /* Open file where accounting information will be written */
        filp = filp_open(ELSACCT_FILE, O_CREAT | O_RDWR | O_APPEND, 0666);

        if (IS_ERR(filp)) {
                return (PTR_ERR(filp));
        }

        if (!filp->f_op->write) {
                filp_close(filp, NULL);
                return (-EIO);
        }

        /*
         * Kernel segment override to datasegment and write it
         * to the accounting file. 
         */
        old_fs = get_fs();
        set_fs(KERNEL_DS);

        filp->f_op->write(filp, (char *)info,
                          sizeof(struct elsa_acct), &filp->f_pos);

        set_fs(old_fs);

        filp_close(filp, NULL);

        //if (irq_restore)
        //      local_irq_disable();

        return 0;
}

static int do_elsacct_data(struct elsa_bank *b, struct elsa_data *d)
{
        u64 elapsed;
        struct elsa_acct *info = (struct elsa_acct *)b->info;
        struct task_struct *p = d->process;

        if (!info)
                return -EINVAL;

        /* One more process in the bank */
        info->eac_ptot++;

        /* elapsed time */
        elapsed = jiffies_64_to_clock_t(get_jiffies_64() - p->start_time);
        info->eac_etime += encode_comp_t(elapsed < (unsigned long)-1l ?
                                         (unsigned long)elapsed : (unsigned
                                                                   long)-1l);

        /* user time and system time */
        info->eac_utime += encode_comp_t(jiffies_to_clock_t(p->utime));
        info->eac_stime += encode_comp_t(jiffies_to_clock_t(p->stime));

        /* minor and major page faults */
        info->eac_minflt += encode_comp_t(p->min_flt);
        info->eac_majflt += encode_comp_t(p->maj_flt);

        return 0;
}

int do_elsacct(int opcode, struct elsa_bank *b, struct elsa_data *d)
{
        int retval = 0;

        switch (opcode) {
        case ELSA_BANK_CALLBACK:
                BUG_ON(b == NULL);
                retval = do_elsacct_bank(b);
                break;
        case ELSA_DATA_CALLBACK:
                BUG_ON(b == NULL);
                BUG_ON(d == NULL);
                retval = do_elsacct_data(b, d);
                break;
        default:
                printk("do_elsacct: unknown opcode\n");
                retval = -ENOIOCTLCMD;
                break;
        }

        return retval;
}

/* Used internally by kernel/fork.c */
void elsacct_process_copy(struct task_struct *from, struct task_struct *to)
{
        static struct list_head *entry; /* entry == NULL */
        static struct elsa_bank *b;     /* b == NULL */
        static struct elsa_data *d;     /* d == NULL */
        static struct elsa_data *new_d; /* d == NULL */

        /* 
         * First, initialize to->bank_head otherwise, if 
         * from->bank_head is NULL it won't be initialize
         */
        write_lock_irq(&tasklist_lock);
        INIT_LIST_HEAD(&(to->bank_head));
        write_unlock_irq(&tasklist_lock);

        list_for_each(entry, &from->bank_head) {
                read_lock_irq(&tasklist_lock);
                d = list_entry(entry, struct elsa_data, bank_list);
                read_unlock_irq(&tasklist_lock);

                new_d = elsa_data_alloc();
                if (new_d) {
                        spin_lock_irq(&elsa_lock);
                        b = elsa_get_bank(&elsa_br, d->bid);
                        if (!b) {
                                /* release memory */
                                elsa_data_free(new_d);
                        } else {
                                new_d->process = to;
                                if (!elsa_data_add(b, new_d))
                                        elsa_data_free(new_d);
                        }
                        spin_unlock_irq(&elsa_lock);
                }
        }
}

/* Used internally by kernel/exit.c */
void elsacct_process_remove(struct task_struct *p)
{
        static struct elsa_data *d;     /* d == NULL */
        static struct elsa_bank *b;     /* b == NULL */
        int empty = 0;

        while (!empty) {
                int bid;

                spin_lock_irq(&elsa_lock);

                read_lock(&tasklist_lock);
                if (list_empty(&p->bank_head)) {
                        d = NULL;
                } else {
                        d = list_entry((p->bank_head).next,
                                       struct elsa_data, bank_list);
                }
                read_unlock(&tasklist_lock);

                if (d != NULL) {
                        /* We don't need to check the return value */
                        b = elsa_get_bank(&elsa_br, d->bid);
                        bid = elsa_data_remove(b, d);

                        elsa_data_free(d);

                        if (bid) {
                                /* bank is empty */
                                elsa_bank_remove(b);
                                /* 
                                 * unlock before releasing memory used by 
                                 * the bank
                                 */
                                spin_unlock_irq(&elsa_lock);
                                kfree(b->info);
                                elsa_bank_free(b);
                        }
                } else {
                        empty = 1;
                        spin_unlock_irq(&elsa_lock);
                }

        }
}

 /**************************************************************
 * functions used to manipulate the device                     *
 *                                                             *
 * The enhanced linux system accounting device is /dev/elsacct *
 * and the major number is dynamically given by OS             *
 **************************************************************/

/* 
 * The process context, represented as a typical driver method - ioctl(), must 
 * use spin_lock_irq() because it knows that interrupts are always enabled 
 * while executing the device ioctl() method.
 */

int elsacct_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
                  unsigned long arg)
{
        static int retval;      /* retval == 0 */
        static struct elsa_ioctl_args iarg;
        static struct task_struct *p;
        static struct elsa_bank *b;
        static struct elsa_data *d;

        /* We can make some checks */
        if (_IOC_TYPE(cmd) != ELSACCT_MAGIC)
                return -ENOTTY;
        if (_IOC_NR(cmd) > ELSACCT_MAXNR)
                return -ENOTTY;
        if ((cmd != ELSACCT_PROCESS_ADD) && (cmd != ELSACCT_PROCESS_REMOVE) &&
            (cmd != ELSACCT_PROCESS_REMOVE_ALL) && (cmd != ELSACCT_BANK_CLEAN))
                return -ENOTTY;

        if (!access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd)))
                return -EFAULT;

        /* Recover ioctl parameters */
        if (copy_from_user(&iarg, (struct elsa_ioctl_args *)arg,
                           sizeof(struct elsa_ioctl_args))) {
                return -EFAULT;
        }

        dprintk("ELSAIOCTL: iarg = {bid#%d - pid#%d}\n", iarg.bid, iarg.pid);

        switch (cmd) {
        case ELSACCT_PROCESS_ADD:
                /*
                 * To add a process to a bank we need to perform 
                 * following actions:
                 *     1) Allocate memory space to data (container)
                 *     2) Allocate memory space to a bank or get a 
                 *        pointer to an existing bank if BID != 0
                 *     3) Update process in data field
                 *     4) Add the container to the bank
                 */
                /* 
                 * We need the pointer to task_struct. We catch it now so if 
                 * it fails we will not allocate memory for new data
                 */
                read_lock(&tasklist_lock);
                p = find_task_by_pid(iarg.pid);
                read_unlock(&tasklist_lock);
                if (!p) {
                        dprintk("elsacct_ioct: PID#%d not found\n", iarg.pid);
                        return -EAGAIN;
                }

                d = elsa_data_alloc();
                if (!d) {
                        return -ENOMEM;
                }

                if (iarg.bid == 0) {
                        struct elsa_acct *acctinfo;
                        int bid;

                        acctinfo = (struct elsa_acct *)
                            kmalloc(sizeof(struct elsa_acct), GFP_KERNEL);
                        if (!acctinfo) {
                                printk
                                    ("ELSA: cannot allocate space for accounting \n");
                                return -ENOMEM;
                        }

                        b = elsa_bank_alloc();
                        if (!b) {
                                dprintk("elsacct_ioct: cannot create BID\n");
                                /* release memory */
                                elsa_data_free(d);
                                kfree(acctinfo);
                                return -ENOMEM;
                        }

                        /* Macro to initialize accounting informations */
                        elsa_acct_init(acctinfo);

                        spin_lock_irq(&elsa_lock);
                        bid = elsa_bank_add(&elsa_br, b, &do_elsacct, acctinfo);
                        spin_unlock_irq(&elsa_lock);

                        if (!bid) {
                                dprintk
                                    ("elsacct_ioct: error during bank creation\n");
                                /* release memory */
                                elsa_data_free(d);
                                elsa_bank_free(b);
                                kfree(acctinfo);
                                return -EFAULT;
                        }
                } else {
                        b = elsa_get_bank(&elsa_br, iarg.bid);
                        if (!b) {
                                dprintk("elsacct_ioct: BID#%d not found\n",
                                        iarg.bid);
                                /* release memory */
                                elsa_data_free(d);
                                return -EINVAL;
                        }
                }

                /* At this point, b cannot be NULL */

                d->process = p;

                spin_lock_irq(&elsa_lock);
                retval = elsa_data_add(b, d);
                spin_unlock_irq(&elsa_lock);
                break;

        case ELSACCT_PROCESS_REMOVE:
                /*
                 * We want to remove a process from one given bank
                 * Steps are:
                 *      1) get a pointer to the given bank
                 *      2) get a pointer to the container of the process
                 *      3) remove the process
                 *      4) free memory used by it
                 *      5) release bank if empty
                 */
                spin_lock_irq(&elsa_lock);

                b = elsa_get_bank(&elsa_br, iarg.bid);
                if (!b) {
                        spin_unlock_irq(&elsa_lock);
                        dprintk("EBR: bank not found\n");
                        return -EINVAL;
                }

                d = elsa_get_data(iarg.pid, iarg.bid);
                if (!d) {
                        spin_unlock_irq(&elsa_lock);
                        dprintk("EBR: data not found\n");
                        return -EINVAL;
                }

                retval = elsa_data_remove(b, d);

                elsa_data_free(d);

                if (retval) {
                        dprintk("EBR: Bank is now empty\n");

                        elsa_bank_remove(b);

                        dprintk("EBR: bank release\n");

                        spin_unlock_irq(&elsa_lock);
                        kfree(b->info);
                        elsa_bank_free(b);
                } else {
                        spin_unlock_irq(&elsa_lock);
                }

                retval = 0;
                break;

        case ELSACCT_PROCESS_REMOVE_ALL:
                /*
                 * remove a process from all banks that it
                 * belongs. To achieve this we need to:
                 *      1) get a pointer to the process
                 *      2) get the first data 
                 *      3) remove it from the bank
                 *      4) release the data
                 *      5) if necessary, remove and release bank
                 *
                 */
                read_lock(&tasklist_lock);
                p = find_task_by_pid(iarg.pid);
                read_unlock(&tasklist_lock);
                if (!p) {
                        dprintk("elsacct_ioct: PID#%d not found\n", iarg.pid);
                        return -EAGAIN;
                }

                retval = 1;
                while (retval) {
                        int bid;

                        spin_lock_irq(&elsa_lock);

                        read_lock(&tasklist_lock);
                        if (list_empty(&p->bank_head)) {
                                d = NULL;
                        } else {
                                d = list_entry((p->bank_head).next,
                                               struct elsa_data, bank_list);
                                dprintk("EPRA: remove ...");
                                BUG_ON(d == NULL);
                                dprintk(" from bank #%d ...", d->bid);
                                dprintk(" pid #%d\n", d->process->pid);
                        }
                        read_unlock(&tasklist_lock);

                        if (d != NULL) {
                                /* We don't need to check the return value */
                                b = elsa_get_bank(&elsa_br, d->bid);
                                bid = elsa_data_remove(b, d);

                                elsa_data_free(d);

                                if (bid) {
                                        /* bank is empty */
                                        elsa_bank_remove(b);
                                        /* 
                                         * unlock before releasing memory 
                                         * occupied by the bank 
                                         */
                                        spin_unlock_irq(&elsa_lock);
                                        kfree(b->info);
                                        elsa_bank_free(b);
                                }
                        } else {
                                dprintk
                                    ("EPRA: Process removed from all banks\n");
                                retval = 0;
                                spin_unlock_irq(&elsa_lock);
                        }

                }
                break;

        case ELSACCT_BANK_CLEAN:
                /*
                 * remove all process from one given bank
                 * Steps are:
                 *      1) get a pointer to the given bank
                 *      2) while there is data in the bank
                 *              -> remove the data
                 *      3) release bank
                 */
                spin_lock_irq(&elsa_lock);
                b = elsa_get_bank(&elsa_br, iarg.bid);

                if (!b) {
                        spin_unlock_irq(&elsa_lock);
                        dprintk("EBC: bank not found\n");
                        return -EINVAL;
                }

                retval = 1;
                while (retval) {

                        if (list_empty(&b->data_head)) {
                                d = NULL;
                        } else {
                                d = list_entry((b->data_head).next,
                                               struct elsa_data, data_list);
                        }

                        if (d) {
                                dprintk("EBC: Remove pid#%d from bank#%d\n",
                                        d->process->pid, b->bid);
                                /* We don't need to check the return value */
                                elsa_data_remove(b, d);
                                elsa_data_free(d);
                        } else {
                                retval = 0;
                                dprintk("EBC: Bank#%d is now empty\n", b->bid);
                        }
                }

                /* bank is empty */
                elsa_bank_remove(b);

                spin_unlock_irq(&elsa_lock);
                kfree(b->info);
                elsa_bank_free(b);

                break;

        default:
                /*
                 * The POSIX standard, states that if an inappropriate ioctl command 
                 * has been issued, then -ENOTTY should be returned.
                 */
                retval = -ENOTTY;
        };

        return retval;
}

struct file_operations elsa_fops = {
        .owner = THIS_MODULE,
        .ioctl = elsacct_ioctl,
};

static int __init elsacct_init(void)
{
        int retval = 0;
        struct proc_dir_entry *entry;

        /* register character device with a dynamic major number */
        elsa_major = register_chrdev(0, "elsacct", &elsa_fops);
        if (!elsa_major) {
                dprintk(KERN_WARNING
                        "elsacct_init: can't get major %d\n", elsa_major);
                return -EIO;
        }

        /* 
         * To get the major number we use a script that parse /proc/devices
         * and get the correct major number. We don't use elsa_major except
         * to test if the device is registered.
         */
        dprintk(KERN_INFO "ELSACCT: device driver is recorded\n");
        /*
         * From here, dev is registered. Thus, if there is a problem
         * we must unregister the device.
         */

#ifdef CONFIG_PROC_FS
        /* create /proc entry */
        entry = create_proc_entry("bankinfo", 0, NULL);
        if (entry) {
                entry->proc_fops = &proc_bankinfo_ops;
        } else {
                unregister_chrdev(elsa_major, "elsacct");
                return -EIO;
        }
#endif

        /* succeed */
        return retval;
}

 /*********************************
 * functions used to manage /proc *
 *                                *
 * The entry is /proc/bankinfo    *
 *********************************/

/*
 * Add an entry in /proc to get informations concerning
 * banks. This entry is called /proc/bankinfo
 */
#ifdef CONFIG_PROC_FS
static void *b_start(struct seq_file *m, loff_t * pos)
{
        loff_t n = *pos;
        struct list_head *p;

        /* Header is displaying just during the first called */
        if (!n) {
                seq_puts(m, "# - bankinfo -\n");
                seq_puts(m, "# bankid:\t<process> <process> ...\n");
        }

        if (list_empty(&elsa_br.bank_head))
                return NULL;

        p = elsa_br.bank_head.next;
        while (n--) {
                p = p->next;
                if (p == &elsa_br.bank_head)
                        return NULL;
        }

        /* we return a pointer to the data in the bank */
        return list_entry(p, struct elsa_bank, bank_list);

}

static void b_stop(struct seq_file *m, void *v)
{
}

static void *b_next(struct seq_file *m, void *v, loff_t * pos)
{
        struct elsa_bank *bank = v;

        ++*pos;
        return bank->bank_list.next == &elsa_br.bank_head ? NULL :
            list_entry(bank->bank_list.next, struct elsa_bank, bank_list);
}

static int show_bankinfo(struct seq_file *m, void *v)
{
        struct elsa_bank *bank = v;
        struct elsa_data *data;

        if (!bank) {
                seq_printf(m, "There is no banks\n");
        } else {
                /* display bank identifier */
                seq_printf(m, "%d:", bank->bid);
                /* add a tabulation */
                seq_printf(m, "\t");
                /* display list of processus */
                if (list_empty(&(bank->data_head))) {
                        seq_printf(m, "Empty");
                } else {
                        list_for_each_entry(data, &(bank->data_head), data_list)
                            seq_printf(m, "%d ", data->process->pid);
                }
                /* add EOL */
                seq_printf(m, "\n");
        }

        return 0;
}

/* 
 * bankinfo_op - iterator that generates /proc/bankinfo
 * Output layout is:
 *     bankID   pid ...
 */
struct seq_operations bankinfo_op = {
        .start = b_start,
        .stop = b_stop,
        .next = b_next,
        .show = show_bankinfo,
};

int bankinfo_open(struct inode *inode, struct file *file)
{
        return seq_open(file, &bankinfo_op);
}

struct file_operations proc_bankinfo_ops = {
        .open = bankinfo_open,
        .read = seq_read,
        .llseek = seq_lseek,
        .release = seq_release,
};

EXPORT_SYMBOL(proc_bankinfo_ops);

#endif

 /************************
 * Module initialization *
 ************************/

static int __init elsacct_init_module(void)
{
        dprintk(KERN_INFO "ELSA accounting started\n");
        return elsacct_init();
}

static void __exit elsacct_cleanup_module(void)
{
        /* release the major number when module is unloaded */
        if (unregister_chrdev(elsa_major, "elsacct"))
                dprintk(KERN_WARNING
                        "elsacct_cleanup: cannot unregister blkdev\n");
        else
                dprintk(KERN_INFO "elsacct_cleanup: accounting terminated\n");
}

module_init(elsacct_init_module);
module_exit(elsacct_cleanup_module);

MODULE_DESCRIPTION("Enhanced Linux System Accounting.");
MODULE_AUTHOR("Guillaume Thouvenin <guillaume.thouvenin@bull.net>");

MODULE_LICENSE("GPL");

---