mod/itc-mod.c

   1 #ifdef CONFIG_PREEMPT
   2 #define ITC_PREEMPT_HACK
   3 #endif
   4
   5 #include <linux/signal.h>
   6 #include <linux/sched.h>
   7 #include <linux/interrupt.h>
   8
   9 #include <linux/fs.h>
  10 #include <linux/version.h>
  11 #include <linux/vmalloc.h>
  12 #include <linux/module.h>
  13 #include <linux/delay.h>
  14 #include <linux/init.h>
  15 #include <linux/slab.h>
  16 #include <linux/smp.h>
  17 #include <linux/mm.h>
  18 #include <linux/pm.h>
  19 #include <linux/miscdevice.h>
  20 #include <linux/kernel_stat.h>
  21
  22 #include <asm/system.h>
  23 #include <asm/uaccess.h>
  24
  25 #ifdef CONFIG_6xx
  26 #include <asm/machdep.h>
  27 #define pm_idle ppc_md.power_save
  28 #define ACCOUNT_IRQ
  29 #endif
  30
  31 #if !(defined CONFIG_X86 || defined CONFIG_6xx)
  32 #error Support for this architecture is not written yet
  33 #endif
  34
  35 #if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 0)
  36     #include <linux/wrapper.h>
  37     #include <linux/smp_lock.h>
  38     #ifdef CONFIG_SMP
  39         #error Support for SMP on 2.4 series of kernels is not written yet
  40     #else
  41         #define num_present_cpus() 1
  42         #define num_online_cpus() 1
  43         /* #define cpu_online(n) 1 */
  44         #define cpu_present(n) 1
  45     #endif
  46
  47     #if LINUX_VERSION_CODE < KERNEL_VERSION (2, 4, 20)
  48         #define iminor(inode) MINOR((inode)->i_rdev)
  49     #else
  50         #define iminor(inode) minor((inode)->i_rdev)
  51     #endif
  52 #endif
  53
  54 #ifdef CONFIG_PREEMPT
  55 #define itc_enter_bkl() do {                    \
  56   preempt_disable ();                           \
  57   lock_kernel ();                               \
  58 } while (0)
  59 #define itc_leave_bkl() do {                    \
  60   unlock_kernel ();                             \
  61   preempt_enable ();                            \
  62 } while (0)
  63 #else
  64 #define itc_enter_bkl lock_kernel
  65 #define itc_leave_bkl unlock_kernel
  66 #ifdef ITC_PREEMPT_HACK
  67 #error Attempt to enable ITC_PREEMPT_HACK on non preemptible kernel
  68 #endif
  69 #endif
  70
  71 MODULE_DESCRIPTION ("Idle time collector");
  72
  73 #ifdef CONFIG_X86
  74 static void (*fidle_func) (void);
  75 static long idle_func;
  76 #if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 0)
  77 MODULE_PARM (idle_func, "l");
  78 #else
  79 module_param (idle_func, long, 0644);
  80 #endif
  81 MODULE_PARM_DESC (idle_func, "address of default idle function");
  82 #endif
  83
  84 #define DEVNAME "itc"
  85 static spinlock_t lock = SPIN_LOCK_UNLOCKED;
  86
  87 static void (*orig_pm_idle) (void);
  88 static unsigned int itc_major;
  89
  90 struct itc
  91 {
  92   struct timeval cumm_sleep_time;
  93   struct timeval sleep_started;
  94   int sleeping;
  95 };
  96
  97 static int in_use;
  98 static struct itc global_itc[NR_CPUS];
  99
 100 /**********************************************************************
 101  *
 102  * Utility functions
 103  *
 104  **********************************************************************/
 105 static void
 106 cpeamb (struct timeval *c, struct timeval *a, struct timeval *b)
 107 {
 108   __typeof (c->tv_sec) sec = a->tv_sec - b->tv_sec;
 109   __typeof (c->tv_usec) usec = a->tv_usec - b->tv_usec;
 110
 111   if (usec < 0)
 112     {
 113       sec -= 1;
 114       usec = 1000000 + usec;
 115     }
 116   c->tv_usec += usec;
 117   if (c->tv_usec > 1000000)
 118     {
 119       c->tv_sec += sec + 1;
 120       c->tv_usec -= 1000000;
 121     }
 122   else
 123     {
 124       c->tv_sec += sec;
 125     }
 126 }
 127
 128 #if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 0)
 129 /* XXX: 2.4 */
 130 /**********************************************************************
 131  *
 132  * Dummy to make sure we are unloaded properly
 133  *
 134  **********************************************************************/
 135 static void
 136 dummy_wakeup (void *unused)
 137 {
 138   printk (KERN_DEBUG "waking up %d\n", smp_processor_id ());
 139   /* needed? safe? */
 140   set_need_resched ();
 141 }
 142 #endif
 143
 144 /**********************************************************************
 145  *
 146  * idle
 147  *
 148  **********************************************************************/
 149 #if LINUX_VERSION_CODE > KERNEL_VERSION (2, 6, 0)
 150 #define QUIRK
 151 #else
 152 void default_idle (void);
 153 #endif
 154
 155 static void
 156 itc_monotonic (struct timeval *tv)
 157 {
 158   do_gettimeofday (tv);
 159 }
 160
 161 #ifdef ACCOUNT_IRQ
 162 static  cputime64_t
 163 itc_irq_time (void)
 164 {
 165   struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
 166   return cpustat->irq;
 167 }
 168 #endif
 169
 170 static void
 171 itc_idle (void)
 172 {
 173   struct itc *itc;
 174   struct timeval tv;
 175   unsigned long flags;
 176 #ifdef ACCOUNT_IRQ
 177   struct timeval tv_irq_before, tv_irq_after;
 178   cputime64_t irq_time_before, irq_time_after;
 179 #endif
 180
 181 #ifdef ITC_PREEMPT_HACK
 182   preempt_disable ();
 183 #endif
 184
 185   /* printk ("idle in %d\n", smp_processor_id ()); */
 186   spin_lock_irqsave (&lock, flags);
 187   itc = &global_itc[smp_processor_id ()];
 188   itc_monotonic (&itc->sleep_started);
 189   itc->sleeping = 1;
 190 #ifdef ACCOUNT_IRQ
 191   irq_time_before = itc_irq_time ();
 192 #endif
 193   spin_unlock_irqrestore (&lock, flags);
 194
 195 #ifdef QUIRK
 196   if (orig_pm_idle)
 197     {
 198       orig_pm_idle ();
 199     }
 200 #ifdef CONFIG_X86
 201   else
 202     {
 203       fidle_func ();
 204     }
 205 #endif
 206 #else
 207   if (orig_pm_idle)
 208     {
 209       orig_pm_idle ();
 210     }
 211   else
 212     {
 213 #ifdef CONFIG_X86
 214       if (fidle_func)
 215         {
 216           fidle_func ();
 217         }
 218       else
 219 #endif
 220         {
 221           default_idle ();
 222         }
 223     }
 224 #endif
 225
 226   spin_lock_irqsave (&lock, flags);
 227   itc_monotonic (&tv);
 228
 229 #ifdef ACCOUNT_IRQ
 230   irq_time_after = itc_irq_time ();
 231
 232   cputime_to_timeval (irq_time_before, &tv_irq_before);
 233   cputime_to_timeval (irq_time_after, &tv_irq_after);
 234
 235   cpeamb (&itc->cumm_sleep_time, &tv, &itc->sleep_started);
 236   cpeamb (&itc->cumm_sleep_time, &tv_irq_before, &tv_irq_after);
 237 #else
 238   cpeamb (&itc->cumm_sleep_time, &tv, &itc->sleep_started);
 239 #endif
 240
 241   itc->sleeping = 0;
 242   spin_unlock_irqrestore (&lock, flags);
 243   /* printk ("idle out %d\n", smp_processor_id ()); */
 244
 245 #ifdef ITC_PREEMPT_HACK
 246   preempt_enable ();
 247 #endif
 248 }
 249
 250 /**********************************************************************
 251  *
 252  * File operations
 253  *
 254  **********************************************************************/
 255 static int
 256 itc_open (struct inode * inode, struct file * file);
 257
 258 static int
 259 itc_release (struct inode * inode, struct file * file);
 260
 261 static int
 262 itc_ioctl (struct inode * inode, struct file * file,
 263            unsigned int cmd, unsigned long arg);
 264
 265 static ssize_t
 266 itc_read (struct file * file, char * buf, size_t count, loff_t * ppos);
 267
 268 static struct file_operations itc_fops =
 269   {
 270     .owner   = THIS_MODULE,
 271     .open    = itc_open,
 272     .release = itc_release,
 273     .ioctl   = itc_ioctl,
 274     .llseek  = no_llseek,
 275     .read    = itc_read,
 276   };
 277
 278 static struct miscdevice itc_misc_dev =
 279   {
 280     .minor = MISC_DYNAMIC_MINOR,
 281     .name  = "itc",
 282     .fops  = &itc_fops
 283   };
 284
 285 static int
 286 itc_release (struct inode * inode, struct file * filp)
 287 {
 288   itc_enter_bkl ();
 289   pm_idle = orig_pm_idle;
 290   in_use = 0;
 291   itc_leave_bkl ();
 292 #if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 0)
 293   /* XXX: 2.4 */
 294   on_each_cpu (dummy_wakeup, NULL, 0, 1);
 295 #endif
 296   return 0;
 297 }
 298
 299 static int
 300 itc_open (struct inode * inode, struct file * filp)
 301 {
 302   int ret = 0;
 303   const struct file_operations *old_fops = filp->f_op;
 304   unsigned int minor = iminor (inode);
 305
 306   if (itc_major)
 307     {
 308       if (minor != 0)
 309         {
 310           return -ENODEV;
 311         }
 312     }
 313
 314   if (in_use)
 315     {
 316       return -EALREADY;
 317     }
 318
 319   /* old_fops = filp->f_op; */
 320   filp->f_op = fops_get (&itc_fops);
 321   fops_put (old_fops);
 322
 323   itc_enter_bkl ();
 324   if (pm_idle != itc_idle)
 325     {
 326       orig_pm_idle = pm_idle;
 327     }
 328   pm_idle = itc_idle;
 329   in_use = 1;
 330   itc_leave_bkl ();
 331
 332   return ret;
 333 }
 334
 335 static ssize_t
 336 itc_read (struct file *file, char * buf, size_t count, loff_t * ppos)
 337 {
 338   int i;
 339   size_t itemsize = sizeof (global_itc[0].cumm_sleep_time);
 340   ssize_t retval = 0;
 341   unsigned long flags;
 342   struct itc *itc = &global_itc[0];
 343   struct timeval tmp[NR_CPUS], *tmpp;
 344
 345   tmpp = tmp;
 346   if (count < itemsize * num_present_cpus ())
 347     {
 348       printk (KERN_ERR
 349               "attempt to read something funny %d expected %d(%d,%d)\n",
 350               count, itemsize * num_present_cpus (),
 351               itemsize, num_present_cpus ());
 352       return -EINVAL;
 353     }
 354
 355   spin_lock_irqsave (&lock, flags);
 356   for (i = 0; i < NR_CPUS; ++i, ++itc)
 357     {
 358       if (cpu_present (i))
 359         {
 360           if (itc->sleeping)
 361             {
 362               struct timeval tv;
 363
 364               itc_monotonic (&tv);
 365               cpeamb (&itc->cumm_sleep_time, &tv, &itc->sleep_started);
 366               itc->sleep_started.tv_sec = tv.tv_sec;
 367               itc->sleep_started.tv_usec = tv.tv_usec;
 368             }
 369
 370           *tmpp++ = itc->cumm_sleep_time;
 371           retval += itemsize;
 372         }
 373     }
 374   spin_unlock_irqrestore (&lock, flags);
 375
 376   if (copy_to_user (buf, tmp, retval))
 377     {
 378       printk (KERN_ERR "failed to write %zu bytes to %p\n",
 379               retval, buf);
 380       retval = -EFAULT;
 381     }
 382   return retval;
 383 }
 384
 385 /**********************************************************************
 386  *
 387  * ioctl handler
 388  *
 389  **********************************************************************/
 390 static int
 391 itc_ioctl (struct inode * inode, struct file * filp,
 392            unsigned int cmd, unsigned long arg)
 393 {
 394   return -EINVAL;
 395 }
 396
 397 /**********************************************************************
 398  *
 399  * Module constructor
 400  *
 401  **********************************************************************/
 402 static __init int
 403 init (void)
 404 {
 405   int err;
 406
 407 #ifdef CONFIG_X86
 408   fidle_func = (void (*) (void)) idle_func;
 409 #endif
 410
 411 #ifdef QUIRK
 412   if (!pm_idle
 413 #ifdef CONFIG_X86
 414       && !fidle_func
 415 #endif
 416       )
 417     {
 418       printk
 419         (KERN_ERR
 420          "itc: no idle function\n"
 421          "itc: boot kernel with idle=halt option\n"
 422          "itc: or specify idle_func (modprobe itc idle_func=<address>)\n");
 423       return -ENODEV;
 424     }
 425 #endif
 426
 427   if (itc_major)
 428     {
 429       err = register_chrdev (itc_major, DEVNAME, &itc_fops);
 430       if (err < 0 || ((itc_major && err) || (!itc_major && !err)))
 431         {
 432           printk (KERN_ERR "itc: register_chrdev failed itc_major=%d err=%d\n",
 433                   itc_major, err);
 434           return -ENODEV;
 435         }
 436
 437       if (!itc_major)
 438         {
 439           itc_major = err;
 440         }
 441     }
 442   else
 443     {
 444       err = misc_register (&itc_misc_dev);
 445       if (err < 0)
 446         {
 447           printk (KERN_ERR "itc: misc_register failed err=%d\n", err);
 448           return err;
 449         }
 450     }
 451
 452   orig_pm_idle = pm_idle;
 453   printk
 454     (KERN_DEBUG
 455      "itc: driver loaded pm_idle=%p default_idle=%p"
 456 #ifdef CONFIG_X86
 457      ", idle_func=%p"
 458 #endif
 459      "\n",
 460      pm_idle
 461 #ifdef QUIRK
 462      , NULL
 463 #else
 464      , default_idle
 465 #endif
 466 #ifdef CONFIG_X86
 467      , fidle_func
 468 #endif
 469      );
 470   printk (KERN_DEBUG "itc: CPUs(%d present=%d online=%d)"
 471 #ifdef QUIRK
 472           " Q"
 473 #endif
 474 #ifdef CONFIG_APM
 475           " A"
 476 #endif
 477 #ifdef CONFIG_SMP
 478           " S"
 479 #endif
 480 #ifdef CONFIG_PREEMPT
 481           " P"
 482 #endif
 483           "\n",
 484           NR_CPUS, num_present_cpus (), num_online_cpus ());
 485   return 0;
 486 }
 487
 488 /**********************************************************************
 489  *
 490  * Module destructor
 491  *
 492  **********************************************************************/
 493 static __exit void
 494 fini (void)
 495 {
 496   printk (KERN_DEBUG "itc: unloading (resetting pm_idle to %p)\n",
 497           orig_pm_idle);
 498   if (itc_major)
 499     {
 500       unregister_chrdev (itc_major, DEVNAME);
 501     }
 502   else
 503     {
 504       misc_deregister (&itc_misc_dev);
 505     }
 506   printk (KERN_DEBUG "itc: unloaded\n");
 507 }
 508
 509 module_init (init);
 510 module_exit (fini);