mod3/itc-mod.c

   1 #include <linux/signal.h>
   2 #include <linux/sched.h>
   3 #include <linux/interrupt.h>
   4
   5 #include <linux/fs.h>
   6 #include <linux/version.h>
   7 #include <linux/vmalloc.h>
   8 #include <linux/module.h>
   9 #include <linux/delay.h>
  10 #include <linux/init.h>
  11 #include <linux/slab.h>
  12 #include <linux/smp.h>
  13 #include <linux/mm.h>
  14 #include <linux/pm.h>
  15 #include <linux/miscdevice.h>
  16 #include <linux/kernel_stat.h>
  17 #include <linux/cpuidle.h>
  18
  19 #include <asm/uaccess.h>
  20 #include <asm/idle.h>
  21
  22 #if defined CONFIG_6xx || defined CONFIG_PPC64
  23 #define ACCOUNT_IRQ
  24 #endif
  25
  26 MODULE_DESCRIPTION ("Idle time collector");
  27 MODULE_LICENSE ("GPL");
  28
  29 #define DEVNAME "itc"
  30
  31 #if LINUX_VERSION_CODE < KERNEL_VERSION (3, 0, 0)
  32 static spinlock_t lock = SPIN_LOCK_UNLOCKED;
  33 #else
  34 DEFINE_SPINLOCK (lock);
  35 #endif
  36
  37 static unsigned int itc_major;
  38 static atomic_t in_use;
  39
  40 struct itc
  41 {
  42   struct timeval cumm_sleep_time;
  43   struct timeval sleep_started;
  44   int sleeping;
  45 };
  46
  47 static struct itc global_itc[NR_CPUS];
  48
  49 /**********************************************************************
  50  *
  51  * Utility functions
  52  *
  53  **********************************************************************/
  54 static void
  55 cpeamb (struct timeval *c, struct timeval *a, struct timeval *b)
  56 {
  57   __typeof (c->tv_sec) sec = a->tv_sec - b->tv_sec;
  58   __typeof (c->tv_usec) usec = a->tv_usec - b->tv_usec;
  59
  60   if (usec < 0)
  61     {
  62       sec -= 1;
  63       usec = 1000000 + usec;
  64     }
  65   c->tv_usec += usec;
  66   if (c->tv_usec > 1000000)
  67     {
  68       c->tv_sec += sec + 1;
  69       c->tv_usec -= 1000000;
  70     }
  71   else
  72     {
  73       c->tv_sec += sec;
  74     }
  75 }
  76
  77 static void
  78 itc_monotonic (struct timeval *tv)
  79 {
  80   do_gettimeofday (tv);
  81 }
  82
  83 #ifdef ACCOUNT_IRQ
  84 static  cputime64_t
  85 itc_irq_time (void)
  86 {
  87   struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
  88   return cpustat->irq;
  89 }
  90 #endif
  91
  92 /**********************************************************************
  93  *
  94  * File operations
  95  *
  96  **********************************************************************/
  97 static int
  98 itc_open (struct inode * inode, struct file * file);
  99
 100 static int
 101 itc_release (struct inode * inode, struct file * file);
 102
 103 static ssize_t
 104 itc_read (struct file * file, char * buf, size_t count, loff_t * ppos);
 105
 106 static struct file_operations itc_fops =
 107   {
 108     .owner   = THIS_MODULE,
 109     .open    = itc_open,
 110     .release = itc_release,
 111     .llseek  = no_llseek,
 112     .read    = itc_read,
 113   };
 114
 115 static struct miscdevice itc_misc_dev =
 116   {
 117     .minor = MISC_DYNAMIC_MINOR,
 118     .name  = "itc",
 119     .fops  = &itc_fops
 120   };
 121
 122
 123 static int idle_notification (struct notifier_block *nblk, unsigned long cmd,
 124                               void *y)
 125 {
 126   struct itc *itc;
 127   struct timeval tv;
 128
 129   itc = &global_itc[smp_processor_id ()];
 130   if (cmd == IDLE_START)
 131     {
 132       itc_monotonic (&itc->sleep_started);
 133       itc->sleeping = 1;
 134     }
 135   else
 136     {
 137       itc_monotonic (&tv);
 138       cpeamb (&itc->cumm_sleep_time, &tv, &itc->sleep_started);
 139       itc->sleeping = 0;
 140     }
 141   /* printk ("idle_notification %ld %p\n", cmd, y); */
 142   return 0;
 143 }
 144
 145 static struct notifier_block nblk =
 146   {
 147     .notifier_call = idle_notification
 148   };
 149
 150 static int
 151 itc_release (struct inode * inode, struct file * filp)
 152 {
 153   idle_notifier_unregister (&nblk);
 154   atomic_set (&in_use, 0);
 155   return 0;
 156 }
 157
 158 static int
 159 itc_open (struct inode * inode, struct file * filp)
 160 {
 161   int ret = 0;
 162   unsigned int minor = iminor (inode);
 163
 164   if (itc_major)
 165     {
 166       if (minor != 0)
 167         {
 168           return -ENODEV;
 169         }
 170     }
 171
 172   if (atomic_cmpxchg (&in_use, 0, 1))
 173     {
 174       return -EALREADY;
 175     }
 176
 177   filp->f_op = &itc_fops;
 178   idle_notifier_register (&nblk);
 179
 180   return ret;
 181 }
 182
 183 static ssize_t
 184 itc_read (struct file *file, char * buf, size_t count, loff_t * ppos)
 185 {
 186   int i;
 187   size_t itemsize = sizeof (global_itc[0].cumm_sleep_time);
 188   ssize_t retval = 0;
 189   unsigned long flags;
 190   struct itc *itc = &global_itc[0];
 191   struct timeval tmp[NR_CPUS], *tmpp;
 192
 193   tmpp = tmp;
 194   if (count < itemsize * num_present_cpus ())
 195     {
 196       printk (KERN_ERR
 197               "attempt to read something funny %zu expected %zu(%zu,%u)\n",
 198               count, itemsize * num_present_cpus (),
 199               itemsize, num_present_cpus ());
 200       return -EINVAL;
 201     }
 202
 203   spin_lock_irqsave (&lock, flags);
 204   for (i = 0; i < NR_CPUS; ++i, ++itc)
 205     {
 206       if (cpu_present (i))
 207         {
 208           if (itc->sleeping)
 209             {
 210               struct timeval tv;
 211
 212               itc_monotonic (&tv);
 213               cpeamb (&itc->cumm_sleep_time, &tv, &itc->sleep_started);
 214               itc->sleep_started.tv_sec = tv.tv_sec;
 215               itc->sleep_started.tv_usec = tv.tv_usec;
 216             }
 217
 218           *tmpp++ = itc->cumm_sleep_time;
 219           retval += itemsize;
 220         }
 221     }
 222   spin_unlock_irqrestore (&lock, flags);
 223
 224   if (copy_to_user (buf, tmp, retval))
 225     {
 226       printk (KERN_ERR "failed to write %zu bytes to %p\n",
 227               retval, buf);
 228       retval = -EFAULT;
 229     }
 230   return retval;
 231 }
 232
 233 /**********************************************************************
 234  *
 235  * Module constructor
 236  *
 237  **********************************************************************/
 238 static __init int
 239 init (void)
 240 {
 241   int err;
 242
 243   if (itc_major)
 244     {
 245       err = register_chrdev (itc_major, DEVNAME, &itc_fops);
 246       if (err < 0 || ((itc_major && err) || (!itc_major && !err)))
 247         {
 248           printk (KERN_ERR "itc: register_chrdev failed itc_major=%d err=%d\n",
 249                   itc_major, err);
 250           return -ENODEV;
 251         }
 252
 253       if (!itc_major)
 254         {
 255           itc_major = err;
 256         }
 257     }
 258   else
 259     {
 260       err = misc_register (&itc_misc_dev);
 261       if (err < 0)
 262         {
 263           printk (KERN_ERR "itc: misc_register failed err=%d\n", err);
 264           return err;
 265         }
 266     }
 267
 268   return err;
 269 }
 270
 271 /**********************************************************************
 272  *
 273  * Module destructor
 274  *
 275  **********************************************************************/
 276 static __exit void
 277 fini (void)
 278 {
 279   if (itc_major)
 280     {
 281       unregister_chrdev (itc_major, DEVNAME);
 282     }
 283   else
 284     {
 285       misc_deregister (&itc_misc_dev);
 286     }
 287   printk (KERN_DEBUG "itc: unloaded\n");
 288 }
 289
 290 module_init (init);
 291 module_exit (fini);