blob: 2d1d151258cfcf9b751e5c53bf36e853782cde9e [file] [log] [blame]
Paul Menageddbcc7e2007-10-18 23:39:30 -07001#ifndef _LINUX_CGROUP_H
2#define _LINUX_CGROUP_H
3/*
4 * cgroup interface
5 *
6 * Copyright (C) 2003 BULL SA
7 * Copyright (C) 2004-2006 Silicon Graphics, Inc.
8 *
9 */
10
11#include <linux/sched.h>
12#include <linux/kref.h>
13#include <linux/cpumask.h>
14#include <linux/nodemask.h>
15#include <linux/rcupdate.h>
Balbir Singh846c7bb2007-10-18 23:39:44 -070016#include <linux/cgroupstats.h>
Cliff Wickman31a7df02008-02-07 00:14:42 -080017#include <linux/prio_heap.h>
Paul Menageddbcc7e2007-10-18 23:39:30 -070018
19#ifdef CONFIG_CGROUPS
20
21struct cgroupfs_root;
22struct cgroup_subsys;
23struct inode;
24
25extern int cgroup_init_early(void);
26extern int cgroup_init(void);
27extern void cgroup_init_smp(void);
28extern void cgroup_lock(void);
29extern void cgroup_unlock(void);
Paul Menageb4f48b62007-10-18 23:39:33 -070030extern void cgroup_fork(struct task_struct *p);
31extern void cgroup_fork_callbacks(struct task_struct *p);
Paul Menage817929e2007-10-18 23:39:36 -070032extern void cgroup_post_fork(struct task_struct *p);
Paul Menageb4f48b62007-10-18 23:39:33 -070033extern void cgroup_exit(struct task_struct *p, int run_callbacks);
Balbir Singh846c7bb2007-10-18 23:39:44 -070034extern int cgroupstats_build(struct cgroupstats *stats,
35 struct dentry *dentry);
Paul Menageddbcc7e2007-10-18 23:39:30 -070036
Paul Menagea4243162007-10-18 23:39:35 -070037extern struct file_operations proc_cgroup_operations;
38
Paul Menage817929e2007-10-18 23:39:36 -070039/* Define the enumeration of all cgroup subsystems */
40#define SUBSYS(_x) _x ## _subsys_id,
41enum cgroup_subsys_id {
42#include <linux/cgroup_subsys.h>
43 CGROUP_SUBSYS_COUNT
44};
45#undef SUBSYS
46
Paul Menageddbcc7e2007-10-18 23:39:30 -070047/* Per-subsystem/per-cgroup state maintained by the system. */
48struct cgroup_subsys_state {
49 /* The cgroup that this subsystem is attached to. Useful
50 * for subsystems that want to know about the cgroup
51 * hierarchy structure */
52 struct cgroup *cgroup;
53
54 /* State maintained by the cgroup system to allow
55 * subsystems to be "busy". Should be accessed via css_get()
56 * and css_put() */
57
58 atomic_t refcnt;
59
60 unsigned long flags;
61};
62
63/* bits in struct cgroup_subsys_state flags field */
64enum {
65 CSS_ROOT, /* This CSS is the root of the subsystem */
66};
67
68/*
69 * Call css_get() to hold a reference on the cgroup;
70 *
71 */
72
73static inline void css_get(struct cgroup_subsys_state *css)
74{
75 /* We don't need to reference count the root state */
76 if (!test_bit(CSS_ROOT, &css->flags))
77 atomic_inc(&css->refcnt);
78}
79/*
80 * css_put() should be called to release a reference taken by
81 * css_get()
82 */
83
Paul Menage81a6a5c2007-10-18 23:39:38 -070084extern void __css_put(struct cgroup_subsys_state *css);
Paul Menageddbcc7e2007-10-18 23:39:30 -070085static inline void css_put(struct cgroup_subsys_state *css)
86{
87 if (!test_bit(CSS_ROOT, &css->flags))
Paul Menage81a6a5c2007-10-18 23:39:38 -070088 __css_put(css);
Paul Menageddbcc7e2007-10-18 23:39:30 -070089}
90
Paul Menage3116f0e2008-04-29 01:00:04 -070091/* bits in struct cgroup flags field */
92enum {
93 /* Control Group is dead */
94 CGRP_REMOVED,
95 /* Control Group has previously had a child cgroup or a task,
96 * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set) */
97 CGRP_RELEASABLE,
98 /* Control Group requires release notifications to userspace */
99 CGRP_NOTIFY_ON_RELEASE,
100};
101
Paul Menageddbcc7e2007-10-18 23:39:30 -0700102struct cgroup {
103 unsigned long flags; /* "unsigned long" so bitops work */
104
105 /* count users of this cgroup. >0 means busy, but doesn't
106 * necessarily indicate the number of tasks in the
107 * cgroup */
108 atomic_t count;
109
110 /*
111 * We link our 'sibling' struct into our parent's 'children'.
112 * Our children link their 'sibling' into our 'children'.
113 */
114 struct list_head sibling; /* my parent's children */
115 struct list_head children; /* my children */
116
117 struct cgroup *parent; /* my parent */
118 struct dentry *dentry; /* cgroup fs entry */
119
120 /* Private pointers for each registered subsystem */
121 struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
122
123 struct cgroupfs_root *root;
124 struct cgroup *top_cgroup;
Paul Menage817929e2007-10-18 23:39:36 -0700125
126 /*
127 * List of cg_cgroup_links pointing at css_sets with
128 * tasks in this cgroup. Protected by css_set_lock
129 */
130 struct list_head css_sets;
Paul Menage81a6a5c2007-10-18 23:39:38 -0700131
132 /*
133 * Linked list running through all cgroups that can
134 * potentially be reaped by the release agent. Protected by
135 * release_list_lock
136 */
137 struct list_head release_list;
Paul Menage817929e2007-10-18 23:39:36 -0700138};
139
140/* A css_set is a structure holding pointers to a set of
141 * cgroup_subsys_state objects. This saves space in the task struct
142 * object and speeds up fork()/exit(), since a single inc/dec and a
143 * list_add()/del() can bump the reference count on the entire
144 * cgroup set for a task.
145 */
146
147struct css_set {
148
149 /* Reference count */
150 struct kref ref;
151
152 /*
153 * List running through all cgroup groups. Protected by
154 * css_set_lock
155 */
156 struct list_head list;
157
158 /*
159 * List running through all tasks using this cgroup
160 * group. Protected by css_set_lock
161 */
162 struct list_head tasks;
163
164 /*
165 * List of cg_cgroup_link objects on link chains from
166 * cgroups referenced from this css_set. Protected by
167 * css_set_lock
168 */
169 struct list_head cg_links;
170
171 /*
172 * Set of subsystem states, one for each subsystem. This array
173 * is immutable after creation apart from the init_css_set
174 * during subsystem registration (at boot time).
175 */
176 struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
177
Paul Menageddbcc7e2007-10-18 23:39:30 -0700178};
179
Paul Menage91796562008-04-29 01:00:01 -0700180/*
181 * cgroup_map_cb is an abstract callback API for reporting map-valued
182 * control files
183 */
184
185struct cgroup_map_cb {
186 int (*fill)(struct cgroup_map_cb *cb, const char *key, u64 value);
187 void *state;
188};
189
Paul Menageddbcc7e2007-10-18 23:39:30 -0700190/* struct cftype:
191 *
192 * The files in the cgroup filesystem mostly have a very simple read/write
193 * handling, some common function will take care of it. Nevertheless some cases
194 * (read tasks) are special and therefore I define this structure for every
195 * kind of file.
196 *
197 *
198 * When reading/writing to a file:
Li Zefana043e3b2008-02-23 15:24:09 -0800199 * - the cgroup to use is file->f_dentry->d_parent->d_fsdata
Paul Menageddbcc7e2007-10-18 23:39:30 -0700200 * - the 'cftype' of the file is file->f_dentry->d_fsdata
201 */
202
203#define MAX_CFTYPE_NAME 64
204struct cftype {
205 /* By convention, the name should begin with the name of the
206 * subsystem, followed by a period */
207 char name[MAX_CFTYPE_NAME];
208 int private;
209 int (*open) (struct inode *inode, struct file *file);
Li Zefanffd2d882008-02-23 15:24:09 -0800210 ssize_t (*read) (struct cgroup *cgrp, struct cftype *cft,
Paul Menageddbcc7e2007-10-18 23:39:30 -0700211 struct file *file,
212 char __user *buf, size_t nbytes, loff_t *ppos);
213 /*
Paul Menagef4c753b2008-04-29 00:59:56 -0700214 * read_u64() is a shortcut for the common case of returning a
Paul Menageddbcc7e2007-10-18 23:39:30 -0700215 * single integer. Use it in place of read()
216 */
Paul Menagef4c753b2008-04-29 00:59:56 -0700217 u64 (*read_u64) (struct cgroup *cgrp, struct cftype *cft);
Paul Menage91796562008-04-29 01:00:01 -0700218 /*
Paul Menagee73d2c62008-04-29 01:00:06 -0700219 * read_s64() is a signed version of read_u64()
220 */
221 s64 (*read_s64) (struct cgroup *cgrp, struct cftype *cft);
222 /*
Paul Menage91796562008-04-29 01:00:01 -0700223 * read_map() is used for defining a map of key/value
224 * pairs. It should call cb->fill(cb, key, value) for each
225 * entry. The key/value pairs (and their ordering) should not
226 * change between reboots.
227 */
228 int (*read_map) (struct cgroup *cont, struct cftype *cft,
229 struct cgroup_map_cb *cb);
230
Li Zefanffd2d882008-02-23 15:24:09 -0800231 ssize_t (*write) (struct cgroup *cgrp, struct cftype *cft,
Paul Menageddbcc7e2007-10-18 23:39:30 -0700232 struct file *file,
233 const char __user *buf, size_t nbytes, loff_t *ppos);
Paul Menage355e0c42007-10-18 23:39:33 -0700234
235 /*
Paul Menagef4c753b2008-04-29 00:59:56 -0700236 * write_u64() is a shortcut for the common case of accepting
Paul Menage355e0c42007-10-18 23:39:33 -0700237 * a single integer (as parsed by simple_strtoull) from
238 * userspace. Use in place of write(); return 0 or error.
239 */
Paul Menagef4c753b2008-04-29 00:59:56 -0700240 int (*write_u64) (struct cgroup *cgrp, struct cftype *cft, u64 val);
Paul Menagee73d2c62008-04-29 01:00:06 -0700241 /*
242 * write_s64() is a signed version of write_u64()
243 */
244 int (*write_s64) (struct cgroup *cgrp, struct cftype *cft, s64 val);
Paul Menage355e0c42007-10-18 23:39:33 -0700245
Pavel Emelyanovd447ea22008-04-29 01:00:08 -0700246 /*
247 * trigger() callback can be used to get some kick from the
248 * userspace, when the actual string written is not important
249 * at all. The private field can be used to determine the
250 * kick type for multiplexing.
251 */
252 int (*trigger)(struct cgroup *cgrp, unsigned int event);
253
Paul Menageddbcc7e2007-10-18 23:39:30 -0700254 int (*release) (struct inode *inode, struct file *file);
255};
256
Cliff Wickman31a7df02008-02-07 00:14:42 -0800257struct cgroup_scanner {
258 struct cgroup *cg;
259 int (*test_task)(struct task_struct *p, struct cgroup_scanner *scan);
260 void (*process_task)(struct task_struct *p,
261 struct cgroup_scanner *scan);
262 struct ptr_heap *heap;
263};
264
Paul Menageddbcc7e2007-10-18 23:39:30 -0700265/* Add a new file to the given cgroup directory. Should only be
266 * called by subsystems from within a populate() method */
Li Zefanffd2d882008-02-23 15:24:09 -0800267int cgroup_add_file(struct cgroup *cgrp, struct cgroup_subsys *subsys,
Paul Menageddbcc7e2007-10-18 23:39:30 -0700268 const struct cftype *cft);
269
270/* Add a set of new files to the given cgroup directory. Should
271 * only be called by subsystems from within a populate() method */
Li Zefanffd2d882008-02-23 15:24:09 -0800272int cgroup_add_files(struct cgroup *cgrp,
Paul Menageddbcc7e2007-10-18 23:39:30 -0700273 struct cgroup_subsys *subsys,
274 const struct cftype cft[],
275 int count);
276
Li Zefanffd2d882008-02-23 15:24:09 -0800277int cgroup_is_removed(const struct cgroup *cgrp);
Paul Menageddbcc7e2007-10-18 23:39:30 -0700278
Li Zefanffd2d882008-02-23 15:24:09 -0800279int cgroup_path(const struct cgroup *cgrp, char *buf, int buflen);
Paul Menageddbcc7e2007-10-18 23:39:30 -0700280
Li Zefanffd2d882008-02-23 15:24:09 -0800281int cgroup_task_count(const struct cgroup *cgrp);
Paul Menagebbcb81d2007-10-18 23:39:32 -0700282
Paul Menageddbcc7e2007-10-18 23:39:30 -0700283/* Return true if the cgroup is a descendant of the current cgroup */
Li Zefanffd2d882008-02-23 15:24:09 -0800284int cgroup_is_descendant(const struct cgroup *cgrp);
Paul Menageddbcc7e2007-10-18 23:39:30 -0700285
286/* Control Group subsystem type. See Documentation/cgroups.txt for details */
287
288struct cgroup_subsys {
289 struct cgroup_subsys_state *(*create)(struct cgroup_subsys *ss,
Li Zefanffd2d882008-02-23 15:24:09 -0800290 struct cgroup *cgrp);
291 void (*pre_destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
292 void (*destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
Paul Menageddbcc7e2007-10-18 23:39:30 -0700293 int (*can_attach)(struct cgroup_subsys *ss,
Li Zefanffd2d882008-02-23 15:24:09 -0800294 struct cgroup *cgrp, struct task_struct *tsk);
295 void (*attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
296 struct cgroup *old_cgrp, struct task_struct *tsk);
Paul Menageddbcc7e2007-10-18 23:39:30 -0700297 void (*fork)(struct cgroup_subsys *ss, struct task_struct *task);
298 void (*exit)(struct cgroup_subsys *ss, struct task_struct *task);
299 int (*populate)(struct cgroup_subsys *ss,
Li Zefanffd2d882008-02-23 15:24:09 -0800300 struct cgroup *cgrp);
301 void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
Paul Menageddbcc7e2007-10-18 23:39:30 -0700302 void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
303 int subsys_id;
304 int active;
Paul Menage8bab8dd2008-04-04 14:29:57 -0700305 int disabled;
Paul Menageddbcc7e2007-10-18 23:39:30 -0700306 int early_init;
307#define MAX_CGROUP_TYPE_NAMELEN 32
308 const char *name;
309
310 /* Protected by RCU */
311 struct cgroupfs_root *root;
312
313 struct list_head sibling;
314
315 void *private;
316};
317
318#define SUBSYS(_x) extern struct cgroup_subsys _x ## _subsys;
319#include <linux/cgroup_subsys.h>
320#undef SUBSYS
321
322static inline struct cgroup_subsys_state *cgroup_subsys_state(
Li Zefanffd2d882008-02-23 15:24:09 -0800323 struct cgroup *cgrp, int subsys_id)
Paul Menageddbcc7e2007-10-18 23:39:30 -0700324{
Li Zefanffd2d882008-02-23 15:24:09 -0800325 return cgrp->subsys[subsys_id];
Paul Menageddbcc7e2007-10-18 23:39:30 -0700326}
327
328static inline struct cgroup_subsys_state *task_subsys_state(
329 struct task_struct *task, int subsys_id)
330{
Paul Menage817929e2007-10-18 23:39:36 -0700331 return rcu_dereference(task->cgroups->subsys[subsys_id]);
Paul Menageddbcc7e2007-10-18 23:39:30 -0700332}
333
334static inline struct cgroup* task_cgroup(struct task_struct *task,
335 int subsys_id)
336{
337 return task_subsys_state(task, subsys_id)->cgroup;
338}
339
Paul Menage697f4162007-10-18 23:39:34 -0700340int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *ss);
341
Paul Menage817929e2007-10-18 23:39:36 -0700342/* A cgroup_iter should be treated as an opaque object */
343struct cgroup_iter {
344 struct list_head *cg_link;
345 struct list_head *task;
346};
347
348/* To iterate across the tasks in a cgroup:
349 *
350 * 1) call cgroup_iter_start to intialize an iterator
351 *
352 * 2) call cgroup_iter_next() to retrieve member tasks until it
353 * returns NULL or until you want to end the iteration
354 *
355 * 3) call cgroup_iter_end() to destroy the iterator.
Cliff Wickman31a7df02008-02-07 00:14:42 -0800356 *
357 * Or, call cgroup_scan_tasks() to iterate through every task in a cpuset.
358 * - cgroup_scan_tasks() holds the css_set_lock when calling the test_task()
359 * callback, but not while calling the process_task() callback.
Paul Menage817929e2007-10-18 23:39:36 -0700360 */
Li Zefanffd2d882008-02-23 15:24:09 -0800361void cgroup_iter_start(struct cgroup *cgrp, struct cgroup_iter *it);
362struct task_struct *cgroup_iter_next(struct cgroup *cgrp,
Paul Menage817929e2007-10-18 23:39:36 -0700363 struct cgroup_iter *it);
Li Zefanffd2d882008-02-23 15:24:09 -0800364void cgroup_iter_end(struct cgroup *cgrp, struct cgroup_iter *it);
Cliff Wickman31a7df02008-02-07 00:14:42 -0800365int cgroup_scan_tasks(struct cgroup_scanner *scan);
Cliff Wickman956db3c2008-02-07 00:14:43 -0800366int cgroup_attach_task(struct cgroup *, struct task_struct *);
Paul Menage817929e2007-10-18 23:39:36 -0700367
Paul Menageddbcc7e2007-10-18 23:39:30 -0700368#else /* !CONFIG_CGROUPS */
369
370static inline int cgroup_init_early(void) { return 0; }
371static inline int cgroup_init(void) { return 0; }
372static inline void cgroup_init_smp(void) {}
Paul Menageb4f48b62007-10-18 23:39:33 -0700373static inline void cgroup_fork(struct task_struct *p) {}
374static inline void cgroup_fork_callbacks(struct task_struct *p) {}
Paul Menage817929e2007-10-18 23:39:36 -0700375static inline void cgroup_post_fork(struct task_struct *p) {}
Paul Menageb4f48b62007-10-18 23:39:33 -0700376static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
Paul Menageddbcc7e2007-10-18 23:39:30 -0700377
378static inline void cgroup_lock(void) {}
379static inline void cgroup_unlock(void) {}
Balbir Singh846c7bb2007-10-18 23:39:44 -0700380static inline int cgroupstats_build(struct cgroupstats *stats,
381 struct dentry *dentry)
382{
383 return -EINVAL;
384}
Paul Menageddbcc7e2007-10-18 23:39:30 -0700385
386#endif /* !CONFIG_CGROUPS */
387
388#endif /* _LINUX_CGROUP_H */