+/* _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" };
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;
}
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__ */