kernel/vserver/cvirt.c

   1 /*
   2  *  linux/kernel/vserver/cvirt.c
   3  *
   4  *  Virtual Server: Context Virtualization
   5  *
   6  *  Copyright (C) 2004  Herbert Pötzl
   7  *
   8  *  V0.01  broken out from limit.c
   9  *
  10  */
  11
  12 #include <linux/config.h>
  13 #include <linux/sched.h>
  14 #include <linux/types.h>
  15 #include <linux/vs_context.h>
  16 #include <linux/vs_cvirt.h>
  17 #include <linux/vserver/switch.h>
  18
  19 #include <asm/errno.h>
  20 #include <asm/uaccess.h>
  21
  22
  23 void vx_vsi_uptime(struct timespec *uptime, struct timespec *idle)
  24 {
  25         struct vx_info *vxi = current->vx_info;
  26
  27         set_normalized_timespec(uptime,
  28                 uptime->tv_sec - vxi->cvirt.bias_uptime.tv_sec,
  29                 uptime->tv_nsec - vxi->cvirt.bias_uptime.tv_nsec);
  30         if (!idle)
  31                 return;
  32         set_normalized_timespec(idle,
  33                 idle->tv_sec - vxi->cvirt.bias_idle.tv_sec,
  34                 idle->tv_nsec - vxi->cvirt.bias_idle.tv_nsec);
  35         return;
  36 }
  37
  38 uint64_t vx_idle_jiffies(void)
  39 {
  40         return init_task.utime + init_task.stime;
  41 }
  42
  43
  44
  45 static inline uint32_t __update_loadavg(uint32_t load,
  46         int wsize, int delta, int n)
  47 {
  48         unsigned long long calc, prev;
  49
  50         /* just set it to n */
  51         if (unlikely(delta >= wsize))
  52                 return (n << FSHIFT);
  53
  54         calc = delta * n;
  55         calc <<= FSHIFT;
  56         prev = (wsize - delta);
  57         prev *= load;
  58         calc += prev;
  59         do_div(calc, wsize);
  60         return calc;
  61 }
  62
  63
  64 void vx_update_load(struct vx_info *vxi)
  65 {
  66         uint32_t now, last, delta;
  67         unsigned int nr_running, nr_uninterruptible;
  68         unsigned int total;
  69
  70         spin_lock(&vxi->cvirt.load_lock);
  71
  72         now = jiffies;
  73         last = vxi->cvirt.load_last;
  74         delta = now - last;
  75
  76         if (delta < 5*HZ)
  77                 goto out;
  78
  79         nr_running = atomic_read(&vxi->cvirt.nr_running);
  80         nr_uninterruptible = atomic_read(&vxi->cvirt.nr_uninterruptible);
  81         total = nr_running + nr_uninterruptible;
  82
  83         vxi->cvirt.load[0] = __update_loadavg(vxi->cvirt.load[0],
  84                 60*HZ, delta, total);
  85         vxi->cvirt.load[1] = __update_loadavg(vxi->cvirt.load[1],
  86                 5*60*HZ, delta, total);
  87         vxi->cvirt.load[2] = __update_loadavg(vxi->cvirt.load[2],
  88                 15*60*HZ, delta, total);
  89
  90         vxi->cvirt.load_last = now;
  91 out:
  92         atomic_inc(&vxi->cvirt.load_updates);
  93         spin_unlock(&vxi->cvirt.load_lock);
  94 }
  95
  96
  97