fixed 'local VAR=$(ACTION) || ERROR' constructs; the 'local VAR=$(ACTION)'
[util-vserver.git] / util-vserver / kernel / cvirt.h
index da8c185..1c3e340 100644 (file)
+/* _VX_CVIRT_H defined below */
+
 #if    defined(__KERNEL__) && defined(_VX_INFO_DEF_)
 
 #include <linux/utsname.h>
 #include <linux/rwsem.h>
 #include <linux/jiffies.h>
 #include <linux/time.h>
+#include <linux/sched.h>
+#include <linux/kernel_stat.h>
 #include <asm/atomic.h>
 
 /* context sub struct */
 
+struct _vx_cvirt {
+       int max_threads;                /* maximum allowed threads */
+       atomic_t nr_threads;            /* number of current threads */
+       atomic_t nr_running;            /* number of running threads */
+
+       atomic_t nr_onhold;             /* processes on hold */
+       uint32_t onhold_last;           /* jiffies when put on hold */
+
+       struct timespec bias_idle;
+       struct timespec bias_uptime;    /* context creation point */
+
+       struct new_utsname utsname;
+
+       spinlock_t load_lock;           /* lock for the load averages */
+       uint32_t load_last;             /* last time load was cacled */
+       uint32_t load[3];               /* load averages 1,5,15 */
+
+       struct cpu_usage_stat cpustat[NR_CPUS];
+};
+
 struct sock_acc {
        atomic_t count;
        atomic_t total;
 };
 
-struct _vx_cvirt {
-       int nr_threads;
-       int nr_running;
-       int max_threads;
+struct _vx_cacct {
        unsigned long total_forks;
 
-       unsigned int bias_cswtch;
-       long bias_jiffies;
-       long bias_idle;
-       struct timespec bias_tp;
-
-       struct new_utsname utsname;
-
        struct sock_acc sock[5][3];
 };
 
 
-static inline long vx_sock_count(struct _vx_cvirt *cvirt, int type, int pos)
+static inline long vx_sock_count(struct _vx_cacct *cacct, int type, int pos)
 {
-       return atomic_read(&cvirt->sock[type][pos].count);
+       return atomic_read(&cacct->sock[type][pos].count);
 }
 
 
-static inline long vx_sock_total(struct _vx_cvirt *cvirt, int type, int pos)
+static inline long vx_sock_total(struct _vx_cacct *cacct, int type, int pos)
 {
-       return atomic_read(&cvirt->sock[type][pos].total);
+       return atomic_read(&cacct->sock[type][pos].total);
 }
 
 
+extern uint64_t vx_idle_jiffies(void);
+
 static inline void vx_info_init_cvirt(struct _vx_cvirt *cvirt)
 {
-       int i,j;
+       uint64_t idle_jiffies = vx_idle_jiffies();
 
-       cvirt->nr_threads = 1;
-       // new->virt.bias_cswtch = kstat.context_swtch;
-       cvirt->bias_jiffies = jiffies;
-       /* new->virt.bias_idle = init_tasks[0]->times.tms_utime +
-               init_tasks[0]->times.tms_stime;
-       */
-       do_posix_clock_monotonic_gettime(&cvirt->bias_tp);
+       do_posix_clock_monotonic_gettime(&cvirt->bias_uptime);
+       jiffies_to_timespec(idle_jiffies, &cvirt->bias_idle);
+       atomic_set(&cvirt->nr_threads, 0);
+       atomic_set(&cvirt->nr_running, 0);
+       atomic_set(&cvirt->nr_onhold, 0);
 
        down_read(&uts_sem);
        cvirt->utsname = system_utsname;
        up_read(&uts_sem);
 
+       spin_lock_init(&cvirt->load_lock);
+       cvirt->load_last = jiffies;
+       cvirt->load[0] = 0;
+       cvirt->load[1] = 0;
+       cvirt->load[2] = 0;
+}
+
+static inline void vx_info_exit_cvirt(struct _vx_cvirt *cvirt)
+{
+#ifdef CONFIG_VSERVER_DEBUG
+       int value;
+
+       if ((value = atomic_read(&cvirt->nr_threads)))
+               printk("!!! cvirt: %p[nr_threads] = %d on exit.\n",
+                       cvirt, value);
+       if ((value = atomic_read(&cvirt->nr_running)))
+               printk("!!! cvirt: %p[nr_running] = %d on exit.\n",
+                       cvirt, value);
+#endif
+       return;
+}
+
+static inline void vx_info_init_cacct(struct _vx_cacct *cacct)
+{
+       int i,j;
+
        for (i=0; i<5; i++) {
                for (j=0; j<3; j++) {
-                       atomic_set(&cvirt->sock[i][j].count, 0);
-                       atomic_set(&cvirt->sock[i][j].total, 0);
+                       atomic_set(&cacct->sock[i][j].count, 0);
+                       atomic_set(&cacct->sock[i][j].total, 0);
                }
        }
 }
 
+static inline void vx_info_exit_cacct(struct _vx_cacct *cacct)
+{
+       return;
+}
+
+#define LOAD_INT(x) ((x) >> FSHIFT)
+#define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
+
+
 static inline int vx_info_proc_cvirt(struct _vx_cvirt *cvirt, char *buffer)
 {
+       int length = 0;
+       int a, b, c;
+
+       length += sprintf(buffer + length,
+               "BiasUptime:\t%lu.%02lu\n", 
+                       (unsigned long)cvirt->bias_uptime.tv_sec,
+                       (cvirt->bias_uptime.tv_nsec / (NSEC_PER_SEC / 100)));
+       length += sprintf(buffer + length,
+               "SysName:\t%.*s\n"
+               "NodeName:\t%.*s\n"
+               "Release:\t%.*s\n"
+               "Version:\t%.*s\n"
+               "Machine:\t%.*s\n"
+               "DomainName:\t%.*s\n"
+               ,__NEW_UTS_LEN, cvirt->utsname.sysname
+               ,__NEW_UTS_LEN, cvirt->utsname.nodename
+               ,__NEW_UTS_LEN, cvirt->utsname.release
+               ,__NEW_UTS_LEN, cvirt->utsname.version
+               ,__NEW_UTS_LEN, cvirt->utsname.machine
+               ,__NEW_UTS_LEN, cvirt->utsname.domainname
+               );
+
+       a = cvirt->load[0] + (FIXED_1/200);
+       b = cvirt->load[1] + (FIXED_1/200);
+       c = cvirt->load[2] + (FIXED_1/200);
+       length += sprintf(buffer + length,
+               "nr_threads:\t%d\n"
+               "nr_running:\t%d\n"
+               "nr_onhold:\t%d\n"
+               "loadavg:\t%d.%02d %d.%02d %d.%02d\n"
+               ,atomic_read(&cvirt->nr_threads)
+               ,atomic_read(&cvirt->nr_running)
+               ,atomic_read(&cvirt->nr_onhold)
+               ,LOAD_INT(a), LOAD_FRAC(a)
+               ,LOAD_INT(b), LOAD_FRAC(b)
+               ,LOAD_INT(c), LOAD_FRAC(c)
+               );
+       return length;
+}
+
+static inline int vx_info_proc_cacct(struct _vx_cacct *cacct, char *buffer)
+{
        int i,j, length = 0;
        static char *type[] = { "UNSPEC", "UNIX", "INET", "INET6", "OTHER" };
 
@@ -77,12 +168,14 @@ static inline int vx_info_proc_cvirt(struct _vx_cvirt *cvirt, char *buffer)
                for (j=0; j<3; j++) {
                        length += sprintf(buffer + length,
                                "\t%12lu/%-12lu"
-                               ,vx_sock_count(cvirt, i, j)
-                               ,vx_sock_total(cvirt, i, j)
+                               ,vx_sock_count(cacct, i, j)
+                               ,vx_sock_total(cacct, i, j)
                                );
-               }       
+               }
                buffer[length++] = '\n';
        }
+       length += sprintf(buffer + length,
+               "forks:\t%lu\n", cacct->total_forks);
        return length;
 }
 
@@ -99,7 +192,12 @@ static inline int vx_info_proc_cvirt(struct _vx_cvirt *cvirt, char *buffer)
 
 struct timespec;
 
-void vx_vsi_uptime(struct timespec *uptime);
+void vx_vsi_uptime(struct timespec *, struct timespec *);
+
+struct vx_info;
+
+void vx_update_load(struct vx_info *);
+
 
 #endif /* __KERNEL__ */