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