/* * kernel/cpu_acct.c - CPU accounting cgroup subsystem * * Copyright (C) Google Inc, 2006 * * Developed by Paul Menage (menage@google.com) and Balbir Singh * (balbir@in.ibm.com) * */ /* * Example cgroup subsystem for reporting total CPU usage of tasks in a * cgroup, along with percentage load over a time interval */ #include <linux/module.h> #include <linux/cgroup.h> #include <linux/fs.h> #include <linux/rcupdate.h> #include <asm/div64.h> struct cpuacct { struct cgroup_subsys_state css; spinlock_t lock; /* total time used by this class */ cputime64_t time; /* time when next load calculation occurs */ u64 next_interval_check; /* time used in current period */ cputime64_t current_interval_time; /* time used in last period */ cputime64_t last_interval_time; }; struct cgroup_subsys cpuacct_subsys; static inline struct cpuacct *cgroup_ca(struct cgroup *cont) { return container_of(cgroup_subsys_state(cont, cpuacct_subsys_id), struct cpuacct, css); } static inline struct cpuacct *task_ca(struct task_struct *task) { return container_of(task_subsys_state(task, cpuacct_subsys_id), struct cpuacct, css); } #define INTERVAL (HZ * 10) static inline u64 next_interval_boundary(u64 now) { /* calculate the next interval boundary beyond the * current time */ do_div(now, INTERVAL); return (now + 1) * INTERVAL; } static struct cgroup_subsys_state *cpuacct_create( struct cgroup_subsys *ss, struct cgroup *cont) { struct cpuacct *ca = kzalloc(sizeof(*ca), GFP_KERNEL); if (!ca) return ERR_PTR(-ENOMEM); spin_lock_init(&ca->lock); ca->next_interval_check = next_interval_boundary(get_jiffies_64()); return &ca->css; } static void cpuacct_destroy(struct cgroup_subsys *ss, struct cgroup *cont) { kfree(cgroup_ca(cont)); } /* Lazily update the load calculation if necessary. Called with ca locked */ static void cpuusage_update(struct cpuacct *ca) { u64 now = get_jiffies_64(); /* If we're not due for an update, return */ if (ca->next_interval_check > now) return; if (ca->next_interval_check <= (now - INTERVAL)) { /* If it's been more than an interval since the last * check, then catch up - the last interval must have * been zero load */ ca->last_interval_time = 0; ca->next_interval_check = next_interval_boundary(now); } else { /* If a steal takes the last interval time negative, * then we just ignore it */ if ((s64)ca->current_interval_time > 0) ca->last_interval_time = ca->current_interval_time; else ca->last_interval_time = 0; ca->next_interval_check += INTERVAL; } ca->current_interval_time = 0; } static u64 cpuusage_read(struct cgroup *cont, struct cftype *cft) { struct cpuacct *ca = cgroup_ca(cont); u64 time; spin_lock_irq(&ca->lock); cpuusage_update(ca); time = cputime64_to_jiffies64(ca->time); spin_unlock_irq(&ca->lock); /* Convert 64-bit jiffies to seconds */ time *= 1000; do_div(time, HZ); return time; } static u64 load_read(struct cgroup *cont, struct cftype *cft) { struct cpuacct *ca = cgroup_ca(cont); u64 time; /* Find the time used in the previous interval */ spin_lock_irq(&ca->lock); cpuusage_update(ca); time = cputime64_to_jiffies64(ca->last_interval_time); spin_unlock_irq(&ca->lock); /* Convert time to a percentage, to give the load in the * previous period */ time *= 100; do_div(time, INTERVAL); return time; } static struct cftype files[] = { { .name = "usage", .read_uint = cpuusage_read, }, { .name = "load", .read_uint = load_read, } }; static int cpuacct_populate(struct cgroup_subsys *ss, struct cgroup *cont) { return cgroup_add_files(cont, ss, files, ARRAY_SIZE(files)); } void cpuacct_charge(struct task_struct *task, cputime_t cputime) { struct cpuacct *ca; unsigned long flags; if (!cpuacct_subsys.active) return; rcu_read_lock(); ca = task_ca(task); if (ca) { spin_lock_irqsave(&ca->lock, flags); cpuusage_update(ca); ca->time = cputime64_add(ca->time, cputime); ca->current_interval_time = cputime64_add(ca->current_interval_time, cputime); spin_unlock_irqrestore(&ca->lock, flags); } rcu_read_unlock(); } struct cgroup_subsys cpuacct_subsys = { .name = "cpuacct", .create = cpuacct_create, .destroy = cpuacct_destroy, .populate = cpuacct_populate, .subsys_id = cpuacct_subsys_id, };