kernel/cgroup_freezer.c

   1 /*
   2  * cgroup_freezer.c -  control group freezer subsystem
   3  *
   4  * Copyright IBM Corporation, 2007
   5  *
   6  * Author : Cedric Le Goater <clg@fr.ibm.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of version 2.1 of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it would be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  15  */
  16
  17 #include <linux/export.h>
  18 #include <linux/slab.h>
  19 #include <linux/cgroup.h>
  20 #include <linux/fs.h>
  21 #include <linux/uaccess.h>
  22 #include <linux/freezer.h>
  23 #include <linux/seq_file.h>
  24
  25 enum freezer_state_flags {
  26         CGROUP_FREEZING_SELF    = (1 << 1), /* this freezer is freezing */
  27         CGROUP_FREEZING_PARENT  = (1 << 2), /* the parent freezer is freezing */
  28         CGROUP_FROZEN           = (1 << 3), /* this and its descendants frozen */
  29
  30         /* mask for all FREEZING flags */
  31         CGROUP_FREEZING         = CGROUP_FREEZING_SELF | CGROUP_FREEZING_PARENT,
  32 };
  33
  34 struct freezer {
  35         struct cgroup_subsys_state      css;
  36         unsigned int                    state;
  37         spinlock_t                      lock;
  38 };
  39
  40 static inline struct freezer *cgroup_freezer(struct cgroup *cgroup)
  41 {
  42         return container_of(cgroup_subsys_state(cgroup, freezer_subsys_id),
  43                             struct freezer, css);
  44 }
  45
  46 static inline struct freezer *task_freezer(struct task_struct *task)
  47 {
  48         return container_of(task_subsys_state(task, freezer_subsys_id),
  49                             struct freezer, css);
  50 }
  51
  52 bool cgroup_freezing(struct task_struct *task)
  53 {
  54         bool ret;
  55
  56         rcu_read_lock();
  57         ret = task_freezer(task)->state & CGROUP_FREEZING;
  58         rcu_read_unlock();
  59
  60         return ret;
  61 }
  62
  63 /*
  64  * cgroups_write_string() limits the size of freezer state strings to
  65  * CGROUP_LOCAL_BUFFER_SIZE
  66  */
  67 static const char *freezer_state_strs(unsigned int state)
  68 {
  69         if (state & CGROUP_FROZEN)
  70                 return "FROZEN";
  71         if (state & CGROUP_FREEZING)
  72                 return "FREEZING";
  73         return "THAWED";
  74 };
  75
  76 /*
  77  * State diagram
  78  * Transitions are caused by userspace writes to the freezer.state file.
  79  * The values in parenthesis are state labels. The rest are edge labels.
  80  *
  81  * (THAWED) --FROZEN--> (FREEZING) --FROZEN--> (FROZEN)
  82  *    ^ ^                    |                     |
  83  *    | \_______THAWED_______/                     |
  84  *    \__________________________THAWED____________/
  85  */
  86
  87 struct cgroup_subsys freezer_subsys;
  88
  89 static struct cgroup_subsys_state *freezer_create(struct cgroup *cgroup)
  90 {
  91         struct freezer *freezer;
  92
  93         freezer = kzalloc(sizeof(struct freezer), GFP_KERNEL);
  94         if (!freezer)
  95                 return ERR_PTR(-ENOMEM);
  96
  97         spin_lock_init(&freezer->lock);
  98         return &freezer->css;
  99 }
 100
 101 static void freezer_destroy(struct cgroup *cgroup)
 102 {
 103         struct freezer *freezer = cgroup_freezer(cgroup);
 104
 105         if (freezer->state & CGROUP_FREEZING)
 106                 atomic_dec(&system_freezing_cnt);
 107         kfree(freezer);
 108 }
 109
 110 /*
 111  * Tasks can be migrated into a different freezer anytime regardless of its
 112  * current state.  freezer_attach() is responsible for making new tasks
 113  * conform to the current state.
 114  *
 115  * Freezer state changes and task migration are synchronized via
 116  * @freezer->lock.  freezer_attach() makes the new tasks conform to the
 117  * current state and all following state changes can see the new tasks.
 118  */
 119 static void freezer_attach(struct cgroup *new_cgrp, struct cgroup_taskset *tset)
 120 {
 121         struct freezer *freezer = cgroup_freezer(new_cgrp);
 122         struct task_struct *task;
 123
 124         spin_lock_irq(&freezer->lock);
 125
 126         /*
 127          * Make the new tasks conform to the current state of @new_cgrp.
 128          * For simplicity, when migrating any task to a FROZEN cgroup, we
 129          * revert it to FREEZING and let update_if_frozen() determine the
 130          * correct state later.
 131          *
 132          * Tasks in @tset are on @new_cgrp but may not conform to its
 133          * current state before executing the following - !frozen tasks may
 134          * be visible in a FROZEN cgroup and frozen tasks in a THAWED one.
 135          */
 136         cgroup_taskset_for_each(task, new_cgrp, tset) {
 137                 if (!(freezer->state & CGROUP_FREEZING)) {
 138                         __thaw_task(task);
 139                 } else {
 140                         freeze_task(task);
 141                         freezer->state &= ~CGROUP_FROZEN;
 142                 }
 143         }
 144
 145         spin_unlock_irq(&freezer->lock);
 146 }
 147
 148 static void freezer_fork(struct task_struct *task)
 149 {
 150         struct freezer *freezer;
 151
 152         rcu_read_lock();
 153         freezer = task_freezer(task);
 154
 155         /*
 156          * The root cgroup is non-freezable, so we can skip the
 157          * following check.
 158          */
 159         if (!freezer->css.cgroup->parent)
 160                 goto out;
 161
 162         spin_lock_irq(&freezer->lock);
 163         if (freezer->state & CGROUP_FREEZING)
 164                 freeze_task(task);
 165         spin_unlock_irq(&freezer->lock);
 166 out:
 167         rcu_read_unlock();
 168 }
 169
 170 /*
 171  * We change from FREEZING to FROZEN lazily if the cgroup was only
 172  * partially frozen when we exitted write.  Caller must hold freezer->lock.
 173  *
 174  * Task states and freezer state might disagree while tasks are being
 175  * migrated into or out of @cgroup, so we can't verify task states against
 176  * @freezer state here.  See freezer_attach() for details.
 177  */
 178 static void update_if_frozen(struct freezer *freezer)
 179 {
 180         struct cgroup *cgroup = freezer->css.cgroup;
 181         struct cgroup_iter it;
 182         struct task_struct *task;
 183
 184         if (!(freezer->state & CGROUP_FREEZING) ||
 185             (freezer->state & CGROUP_FROZEN))
 186                 return;
 187
 188         cgroup_iter_start(cgroup, &it);
 189
 190         while ((task = cgroup_iter_next(cgroup, &it))) {
 191                 if (freezing(task)) {
 192                         /*
 193                          * freezer_should_skip() indicates that the task
 194                          * should be skipped when determining freezing
 195                          * completion.  Consider it frozen in addition to
 196                          * the usual frozen condition.
 197                          */
 198                         if (!frozen(task) && !freezer_should_skip(task))
 199                                 goto notyet;
 200                 }
 201         }
 202
 203         freezer->state |= CGROUP_FROZEN;
 204 notyet:
 205         cgroup_iter_end(cgroup, &it);
 206 }
 207
 208 static int freezer_read(struct cgroup *cgroup, struct cftype *cft,
 209                         struct seq_file *m)
 210 {
 211         struct freezer *freezer = cgroup_freezer(cgroup);
 212         unsigned int state;
 213
 214         spin_lock_irq(&freezer->lock);
 215         update_if_frozen(freezer);
 216         state = freezer->state;
 217         spin_unlock_irq(&freezer->lock);
 218
 219         seq_puts(m, freezer_state_strs(state));
 220         seq_putc(m, '\n');
 221         return 0;
 222 }
 223
 224 static void freeze_cgroup(struct freezer *freezer)
 225 {
 226         struct cgroup *cgroup = freezer->css.cgroup;
 227         struct cgroup_iter it;
 228         struct task_struct *task;
 229
 230         cgroup_iter_start(cgroup, &it);
 231         while ((task = cgroup_iter_next(cgroup, &it)))
 232                 freeze_task(task);
 233         cgroup_iter_end(cgroup, &it);
 234 }
 235
 236 static void unfreeze_cgroup(struct freezer *freezer)
 237 {
 238         struct cgroup *cgroup = freezer->css.cgroup;
 239         struct cgroup_iter it;
 240         struct task_struct *task;
 241
 242         cgroup_iter_start(cgroup, &it);
 243         while ((task = cgroup_iter_next(cgroup, &it)))
 244                 __thaw_task(task);
 245         cgroup_iter_end(cgroup, &it);
 246 }
 247
 248 /**
 249  * freezer_apply_state - apply state change to a single cgroup_freezer
 250  * @freezer: freezer to apply state change to
 251  * @freeze: whether to freeze or unfreeze
 252  * @state: CGROUP_FREEZING_* flag to set or clear
 253  *
 254  * Set or clear @state on @cgroup according to @freeze, and perform
 255  * freezing or thawing as necessary.
 256  */
 257 static void freezer_apply_state(struct freezer *freezer, bool freeze,
 258                                 unsigned int state)
 259 {
 260         /* also synchronizes against task migration, see freezer_attach() */
 261         lockdep_assert_held(&freezer->lock);
 262
 263         if (freeze) {
 264                 if (!(freezer->state & CGROUP_FREEZING))
 265                         atomic_inc(&system_freezing_cnt);
 266                 freezer->state |= state;
 267                 freeze_cgroup(freezer);
 268         } else {
 269                 bool was_freezing = freezer->state & CGROUP_FREEZING;
 270
 271                 freezer->state &= ~state;
 272
 273                 if (!(freezer->state & CGROUP_FREEZING)) {
 274                         if (was_freezing)
 275                                 atomic_dec(&system_freezing_cnt);
 276                         freezer->state &= ~CGROUP_FROZEN;
 277                         unfreeze_cgroup(freezer);
 278                 }
 279         }
 280 }
 281
 282 /**
 283  * freezer_change_state - change the freezing state of a cgroup_freezer
 284  * @freezer: freezer of interest
 285  * @freeze: whether to freeze or thaw
 286  *
 287  * Freeze or thaw @cgroup according to @freeze.
 288  */
 289 static void freezer_change_state(struct freezer *freezer, bool freeze)
 290 {
 291         /* update @freezer */
 292         spin_lock_irq(&freezer->lock);
 293         freezer_apply_state(freezer, freeze, CGROUP_FREEZING_SELF);
 294         spin_unlock_irq(&freezer->lock);
 295 }
 296
 297 static int freezer_write(struct cgroup *cgroup, struct cftype *cft,
 298                          const char *buffer)
 299 {
 300         bool freeze;
 301
 302         if (strcmp(buffer, freezer_state_strs(0)) == 0)
 303                 freeze = false;
 304         else if (strcmp(buffer, freezer_state_strs(CGROUP_FROZEN)) == 0)
 305                 freeze = true;
 306         else
 307                 return -EINVAL;
 308
 309         freezer_change_state(cgroup_freezer(cgroup), freeze);
 310         return 0;
 311 }
 312
 313 static u64 freezer_self_freezing_read(struct cgroup *cgroup, struct cftype *cft)
 314 {
 315         struct freezer *freezer = cgroup_freezer(cgroup);
 316
 317         return (bool)(freezer->state & CGROUP_FREEZING_SELF);
 318 }
 319
 320 static u64 freezer_parent_freezing_read(struct cgroup *cgroup, struct cftype *cft)
 321 {
 322         struct freezer *freezer = cgroup_freezer(cgroup);
 323
 324         return (bool)(freezer->state & CGROUP_FREEZING_PARENT);
 325 }
 326
 327 static struct cftype files[] = {
 328         {
 329                 .name = "state",
 330                 .flags = CFTYPE_NOT_ON_ROOT,
 331                 .read_seq_string = freezer_read,
 332                 .write_string = freezer_write,
 333         },
 334         {
 335                 .name = "self_freezing",
 336                 .flags = CFTYPE_NOT_ON_ROOT,
 337                 .read_u64 = freezer_self_freezing_read,
 338         },
 339         {
 340                 .name = "parent_freezing",
 341                 .flags = CFTYPE_NOT_ON_ROOT,
 342                 .read_u64 = freezer_parent_freezing_read,
 343         },
 344         { }     /* terminate */
 345 };
 346
 347 struct cgroup_subsys freezer_subsys = {
 348         .name           = "freezer",
 349         .create         = freezer_create,
 350         .destroy        = freezer_destroy,
 351         .subsys_id      = freezer_subsys_id,
 352         .attach         = freezer_attach,
 353         .fork           = freezer_fork,
 354         .base_cftypes   = files,
 355
 356         /*
 357          * freezer subsys doesn't handle hierarchy at all.  Frozen state
 358          * should be inherited through the hierarchy - if a parent is
 359          * frozen, all its children should be frozen.  Fix it and remove
 360          * the following.
 361          */
 362         .broken_hierarchy = true,
 363 };