#include <linux/fs.h>
#include <linux/init.h>
#include <linux/pid_namespace.h>
#include <linux/proc_fs.h>
#include <linux/sched.h>
#include <linux/seq_file.h>
#include <linux/seqlock.h>
#include <linux/timer.h>

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/kernel_stat.h>
#include <linux/netdevice.h>


MODULE_LICENSE("GPL");


#define FSHIFT          11              /* nr of bits of precision */
#define FIXED_1         (1<<FSHIFT)     /* 1.0 as fixed-point */
#define LOAD_INT(x) ((x) >> FSHIFT)
#define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)

#define per_cpu(var, cpu) \
                  (*SHIFT_PERCPU_PTR(&(var), per_cpu_offset(cpu)))

DECLARE_PER_CPU(struct rq, runqueues);

#define cpu_rq(cpu)  (&per_cpu(runqueues, (cpu)))

extern int nr_threads;
extern unsigned long avnrun[]; /* Load averages */
 
/* get_avenrun - get the load average array
 @loads: pointer to dest load array
 @offset: offset to add
 @shift: shift count to shift the result left
*/
extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift)
{
   loads[0] = (avenrun[0] + offset) << shift;
   loads[1] = (avenrun[1] + offset) << shift;
   loads[2] = (avenrun[2] + offset) << shift;
}

 /*nr_running:
  externally visible scheduler statistics: current number of runnable
  threads performed since bootup
 */
extern unsigned long nr_running(void)
 {
         unsigned long i, sum = 0;
         
        for_each_online_cpu(i)
                 sum += cpu_rq(i)->nr_running;
 
         return sum;
 }
EXPORT_SYMBOL_GPL(nr_running);

   
/*calcualation of cpu load*/
static int loadavg_proc_show(struct seq_file *m, void *v)
{
  //unsigned long avnrun[3];
  get_avenrun(avnrun, FIXED_1/200, 0);
  
  seq_printf(m, "%lu.%02lu %lu.%02lu %lu.%02lu /%d %d\n",
              LOAD_INT(avnrun[0]), LOAD_FRAC(avnrun[0]),
              LOAD_INT(avnrun[1]), LOAD_FRAC(avnrun[1]),
              LOAD_INT(avnrun[2]), LOAD_FRAC(avnrun[2]),
              nr_threads,
             task_active_pid_ns(current)->last_pid);
  return 0;
}

/* single_open open the virtual file.when output time comes it will call
   loadavg_proc_show function*/

static int loadavg_proc_open(struct inode *inode, struct file *file)
{
    return single_open(file, loadavg_proc_show, NULL);
}

/*The operations  - read(), llseek(), and release() - are
   all implemented by the seq_file code itself. So a virtual file's
   file_operations structure */
static const struct file_operations loadavg_proc_fops = {
                 .open	= loadavg_proc_open,
                 .read	= seq_read,
                 .llseek = seq_lseek,
                 .release = single_release,
};

/*loading the module*/
static int __init proc_loadavg_init(void)
{
   proc_create("loadavg", 0, NULL, &loadavg_proc_fops);
   return 0;
}

/*unloading the module*/
static void __exit proc_loadavg_exit(void)
 {
     remove_proc_entry("loadavg", NULL);
 }

module_init(proc_loadavg_init);
module_exit(proc_loadavg_exit);