Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

1 files changed, 73 insertions, 7 deletions

diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index a6a6035a4e1e..e155aa78d859 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -88,6 +88,17 @@ static inline void css_put(struct cgroup_subsys_state *css)
                 __css_put(css);
 }
 
+/* bits in struct cgroup flags field */
+enum {
+        /* Control Group is dead */
+        CGRP_REMOVED,
+        /* Control Group has previously had a child cgroup or a task,
+         * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set) */
+        CGRP_RELEASABLE,
+        /* Control Group requires release notifications to userspace */
+        CGRP_NOTIFY_ON_RELEASE,
+};
+
 struct cgroup {
         unsigned long flags;            /* "unsigned long" so bitops work */
 
@@ -139,10 +150,10 @@ struct css_set {
         struct kref ref;
 
         /*
-         * List running through all cgroup groups. Protected by
-         * css_set_lock
+         * List running through all cgroup groups in the same hash
+         * slot. Protected by css_set_lock
          */
-        struct list_head list;
+        struct hlist_node hlist;
 
         /*
          * List running through all tasks using this cgroup
@@ -163,7 +174,16 @@ struct css_set {
          * during subsystem registration (at boot time).
          */
         struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
+};
+
+/*
+ * cgroup_map_cb is an abstract callback API for reporting map-valued
+ * control files
+ */
 
+struct cgroup_map_cb {
+        int (*fill)(struct cgroup_map_cb *cb, const char *key, u64 value);
+        void *state;
 };
 
 /* struct cftype:
@@ -190,20 +210,51 @@ struct cftype {
                          struct file *file,
                          char __user *buf, size_t nbytes, loff_t *ppos);
         /*
-         * read_uint() is a shortcut for the common case of returning a
+         * read_u64() is a shortcut for the common case of returning a
          * single integer. Use it in place of read()
          */
-        u64 (*read_uint) (struct cgroup *cgrp, struct cftype *cft);
+        u64 (*read_u64) (struct cgroup *cgrp, struct cftype *cft);
+        /*
+         * read_s64() is a signed version of read_u64()
+         */
+        s64 (*read_s64) (struct cgroup *cgrp, struct cftype *cft);
+        /*
+         * read_map() is used for defining a map of key/value
+         * pairs. It should call cb->fill(cb, key, value) for each
+         * entry. The key/value pairs (and their ordering) should not
+         * change between reboots.
+         */
+        int (*read_map) (struct cgroup *cont, struct cftype *cft,
+                         struct cgroup_map_cb *cb);
+        /*
+         * read_seq_string() is used for outputting a simple sequence
+         * using seqfile.
+         */
+        int (*read_seq_string) (struct cgroup *cont, struct cftype *cft,
+                         struct seq_file *m);
+
         ssize_t (*write) (struct cgroup *cgrp, struct cftype *cft,
                           struct file *file,
                           const char __user *buf, size_t nbytes, loff_t *ppos);
 
         /*
-         * write_uint() is a shortcut for the common case of accepting
+         * write_u64() is a shortcut for the common case of accepting
          * a single integer (as parsed by simple_strtoull) from
          * userspace. Use in place of write(); return 0 or error.
          */
-        int (*write_uint) (struct cgroup *cgrp, struct cftype *cft, u64 val);
+        int (*write_u64) (struct cgroup *cgrp, struct cftype *cft, u64 val);
+        /*
+         * write_s64() is a signed version of write_u64()
+         */
+        int (*write_s64) (struct cgroup *cgrp, struct cftype *cft, s64 val);
+
+        /*
+         * trigger() callback can be used to get some kick from the
+         * userspace, when the actual string written is not important
+         * at all. The private field can be used to determine the
+         * kick type for multiplexing.
+         */
+        int (*trigger)(struct cgroup *cgrp, unsigned int event);
 
         int (*release) (struct inode *inode, struct file *file);
 };
@@ -254,6 +305,12 @@ struct cgroup_subsys {
                         struct cgroup *cgrp);
         void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
         void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
+        /*
+         * This routine is called with the task_lock of mm->owner held
+         */
+        void (*mm_owner_changed)(struct cgroup_subsys *ss,
+                                        struct cgroup *old,
+                                        struct cgroup *new);
         int subsys_id;
         int active;
         int disabled;
@@ -339,4 +396,13 @@ static inline int cgroupstats_build(struct cgroupstats *stats,
 
 #endif /* !CONFIG_CGROUPS */
 
+#ifdef CONFIG_MM_OWNER
+extern void
+cgroup_mm_owner_callbacks(struct task_struct *old, struct task_struct *new);
+#else /* !CONFIG_MM_OWNER */
+static inline void
+cgroup_mm_owner_callbacks(struct task_struct *old, struct task_struct *new)
+{
+}
+#endif /* CONFIG_MM_OWNER */
 #endif /* _LINUX_CGROUP_H */