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 /*
  26  * A cgroup is freezing if any FREEZING flags are set.  FREEZING_SELF is
  27  * set if "FROZEN" is written to freezer.state cgroupfs file, and cleared
  28  * for "THAWED".  FREEZING_PARENT is set if the parent freezer is FREEZING
  29  * for whatever reason.  IOW, a cgroup has FREEZING_PARENT set if one of
  30  * its ancestors has FREEZING_SELF set.
  31  */
  32 enum freezer_state_flags {
  33         CGROUP_FREEZER_ONLINE   = (1 << 0), /* freezer is fully online */
  34         CGROUP_FREEZING_SELF    = (1 << 1), /* this freezer is freezing */
  35         CGROUP_FREEZING_PARENT  = (1 << 2), /* the parent freezer is freezing */
  36         CGROUP_FROZEN           = (1 << 3), /* this and its descendants frozen */
  37
  38         /* mask for all FREEZING flags */
  39         CGROUP_FREEZING         = CGROUP_FREEZING_SELF | CGROUP_FREEZING_PARENT,
  40 };
  41
  42 struct freezer {
  43         struct cgroup_subsys_state      css;
  44         unsigned int                    state;
  45         spinlock_t                      lock;
  46 };
  47
  48 static inline struct freezer *css_freezer(struct cgroup_subsys_state *css)
  49 {
  50         return css ? container_of(css, struct freezer, css) : NULL;
  51 }
  52
  53 static inline struct freezer *cgroup_freezer(struct cgroup *cgroup)
  54 {
  55         return css_freezer(cgroup_css(cgroup, freezer_subsys_id));
  56 }
  57
  58 static inline struct freezer *task_freezer(struct task_struct *task)
  59 {
  60         return css_freezer(task_css(task, freezer_subsys_id));
  61 }
  62
  63 static struct freezer *parent_freezer(struct freezer *freezer)
  64 {
  65         return css_freezer(css_parent(&freezer->css));
  66 }
  67
  68 bool cgroup_freezing(struct task_struct *task)
  69 {
  70         bool ret;
  71
  72         rcu_read_lock();
  73         ret = task_freezer(task)->state & CGROUP_FREEZING;
  74         rcu_read_unlock();
  75
  76         return ret;
  77 }
  78
  79 /*
  80  * cgroups_write_string() limits the size of freezer state strings to
  81  * CGROUP_LOCAL_BUFFER_SIZE
  82  */
  83 static const char *freezer_state_strs(unsigned int state)
  84 {
  85         if (state & CGROUP_FROZEN)
  86                 return "FROZEN";
  87         if (state & CGROUP_FREEZING)
  88                 return "FREEZING";
  89         return "THAWED";
  90 };
  91
  92 struct cgroup_subsys freezer_subsys;
  93
  94 static struct cgroup_subsys_state *freezer_css_alloc(struct cgroup *cgroup)
  95 {
  96         struct freezer *freezer;
  97
  98         freezer = kzalloc(sizeof(struct freezer), GFP_KERNEL);
  99         if (!freezer)
 100                 return ERR_PTR(-ENOMEM);
 101
 102         spin_lock_init(&freezer->lock);
 103         return &freezer->css;
 104 }
 105
 106 /**
 107  * freezer_css_online - commit creation of a freezer cgroup
 108  * @cgroup: cgroup being created
 109  *
 110  * We're committing to creation of @cgroup.  Mark it online and inherit
 111  * parent's freezing state while holding both parent's and our
 112  * freezer->lock.
 113  */
 114 static int freezer_css_online(struct cgroup *cgroup)
 115 {
 116         struct freezer *freezer = cgroup_freezer(cgroup);
 117         struct freezer *parent = parent_freezer(freezer);
 118
 119         /*
 120          * The following double locking and freezing state inheritance
 121          * guarantee that @cgroup can never escape ancestors' freezing
 122          * states.  See cgroup_for_each_descendant_pre() for details.
 123          */
 124         if (parent)
 125                 spin_lock_irq(&parent->lock);
 126         spin_lock_nested(&freezer->lock, SINGLE_DEPTH_NESTING);
 127
 128         freezer->state |= CGROUP_FREEZER_ONLINE;
 129
 130         if (parent && (parent->state & CGROUP_FREEZING)) {
 131                 freezer->state |= CGROUP_FREEZING_PARENT | CGROUP_FROZEN;
 132                 atomic_inc(&system_freezing_cnt);
 133         }
 134
 135         spin_unlock(&freezer->lock);
 136         if (parent)
 137                 spin_unlock_irq(&parent->lock);
 138
 139         return 0;
 140 }
 141
 142 /**
 143  * freezer_css_offline - initiate destruction of @cgroup
 144  * @cgroup: cgroup being destroyed
 145  *
 146  * @cgroup is going away.  Mark it dead and decrement system_freezing_count
 147  * if it was holding one.
 148  */
 149 static void freezer_css_offline(struct cgroup *cgroup)
 150 {
 151         struct freezer *freezer = cgroup_freezer(cgroup);
 152
 153         spin_lock_irq(&freezer->lock);
 154
 155         if (freezer->state & CGROUP_FREEZING)
 156                 atomic_dec(&system_freezing_cnt);
 157
 158         freezer->state = 0;
 159
 160         spin_unlock_irq(&freezer->lock);
 161 }
 162
 163 static void freezer_css_free(struct cgroup *cgroup)
 164 {
 165         kfree(cgroup_freezer(cgroup));
 166 }
 167
 168 /*
 169  * Tasks can be migrated into a different freezer anytime regardless of its
 170  * current state.  freezer_attach() is responsible for making new tasks
 171  * conform to the current state.
 172  *
 173  * Freezer state changes and task migration are synchronized via
 174  * @freezer->lock.  freezer_attach() makes the new tasks conform to the
 175  * current state and all following state changes can see the new tasks.
 176  */
 177 static void freezer_attach(struct cgroup *new_cgrp, struct cgroup_taskset *tset)
 178 {
 179         struct freezer *freezer = cgroup_freezer(new_cgrp);
 180         struct task_struct *task;
 181         bool clear_frozen = false;
 182
 183         spin_lock_irq(&freezer->lock);
 184
 185         /*
 186          * Make the new tasks conform to the current state of @new_cgrp.
 187          * For simplicity, when migrating any task to a FROZEN cgroup, we
 188          * revert it to FREEZING and let update_if_frozen() determine the
 189          * correct state later.
 190          *
 191          * Tasks in @tset are on @new_cgrp but may not conform to its
 192          * current state before executing the following - !frozen tasks may
 193          * be visible in a FROZEN cgroup and frozen tasks in a THAWED one.
 194          */
 195         cgroup_taskset_for_each(task, new_cgrp, tset) {
 196                 if (!(freezer->state & CGROUP_FREEZING)) {
 197                         __thaw_task(task);
 198                 } else {
 199                         freeze_task(task);
 200                         freezer->state &= ~CGROUP_FROZEN;
 201                         clear_frozen = true;
 202                 }
 203         }
 204
 205         spin_unlock_irq(&freezer->lock);
 206
 207         /*
 208          * Propagate FROZEN clearing upwards.  We may race with
 209          * update_if_frozen(), but as long as both work bottom-up, either
 210          * update_if_frozen() sees child's FROZEN cleared or we clear the
 211          * parent's FROZEN later.  No parent w/ !FROZEN children can be
 212          * left FROZEN.
 213          */
 214         while (clear_frozen && (freezer = parent_freezer(freezer))) {
 215                 spin_lock_irq(&freezer->lock);
 216                 freezer->state &= ~CGROUP_FROZEN;
 217                 clear_frozen = freezer->state & CGROUP_FREEZING;
 218                 spin_unlock_irq(&freezer->lock);
 219         }
 220 }
 221
 222 static void freezer_fork(struct task_struct *task)
 223 {
 224         struct freezer *freezer;
 225
 226         rcu_read_lock();
 227         freezer = task_freezer(task);
 228
 229         /*
 230          * The root cgroup is non-freezable, so we can skip the
 231          * following check.
 232          */
 233         if (!parent_freezer(freezer))
 234                 goto out;
 235
 236         spin_lock_irq(&freezer->lock);
 237         if (freezer->state & CGROUP_FREEZING)
 238                 freeze_task(task);
 239         spin_unlock_irq(&freezer->lock);
 240 out:
 241         rcu_read_unlock();
 242 }
 243
 244 /**
 245  * update_if_frozen - update whether a cgroup finished freezing
 246  * @cgroup: cgroup of interest
 247  *
 248  * Once FREEZING is initiated, transition to FROZEN is lazily updated by
 249  * calling this function.  If the current state is FREEZING but not FROZEN,
 250  * this function checks whether all tasks of this cgroup and the descendant
 251  * cgroups finished freezing and, if so, sets FROZEN.
 252  *
 253  * The caller is responsible for grabbing RCU read lock and calling
 254  * update_if_frozen() on all descendants prior to invoking this function.
 255  *
 256  * Task states and freezer state might disagree while tasks are being
 257  * migrated into or out of @cgroup, so we can't verify task states against
 258  * @freezer state here.  See freezer_attach() for details.
 259  */
 260 static void update_if_frozen(struct cgroup *cgroup)
 261 {
 262         struct freezer *freezer = cgroup_freezer(cgroup);
 263         struct cgroup *pos;
 264         struct cgroup_iter it;
 265         struct task_struct *task;
 266
 267         WARN_ON_ONCE(!rcu_read_lock_held());
 268
 269         spin_lock_irq(&freezer->lock);
 270
 271         if (!(freezer->state & CGROUP_FREEZING) ||
 272             (freezer->state & CGROUP_FROZEN))
 273                 goto out_unlock;
 274
 275         /* are all (live) children frozen? */
 276         cgroup_for_each_child(pos, cgroup) {
 277                 struct freezer *child = cgroup_freezer(pos);
 278
 279                 if ((child->state & CGROUP_FREEZER_ONLINE) &&
 280                     !(child->state & CGROUP_FROZEN))
 281                         goto out_unlock;
 282         }
 283
 284         /* are all tasks frozen? */
 285         cgroup_iter_start(cgroup, &it);
 286
 287         while ((task = cgroup_iter_next(cgroup, &it))) {
 288                 if (freezing(task)) {
 289                         /*
 290                          * freezer_should_skip() indicates that the task
 291                          * should be skipped when determining freezing
 292                          * completion.  Consider it frozen in addition to
 293                          * the usual frozen condition.
 294                          */
 295                         if (!frozen(task) && !freezer_should_skip(task))
 296                                 goto out_iter_end;
 297                 }
 298         }
 299
 300         freezer->state |= CGROUP_FROZEN;
 301 out_iter_end:
 302         cgroup_iter_end(cgroup, &it);
 303 out_unlock:
 304         spin_unlock_irq(&freezer->lock);
 305 }
 306
 307 static int freezer_read(struct cgroup *cgroup, struct cftype *cft,
 308                         struct seq_file *m)
 309 {
 310         struct cgroup *pos;
 311
 312         rcu_read_lock();
 313
 314         /* update states bottom-up */
 315         cgroup_for_each_descendant_post(pos, cgroup)
 316                 update_if_frozen(pos);
 317         update_if_frozen(cgroup);
 318
 319         rcu_read_unlock();
 320
 321         seq_puts(m, freezer_state_strs(cgroup_freezer(cgroup)->state));
 322         seq_putc(m, '\n');
 323         return 0;
 324 }
 325
 326 static void freeze_cgroup(struct freezer *freezer)
 327 {
 328         struct cgroup *cgroup = freezer->css.cgroup;
 329         struct cgroup_iter it;
 330         struct task_struct *task;
 331
 332         cgroup_iter_start(cgroup, &it);
 333         while ((task = cgroup_iter_next(cgroup, &it)))
 334                 freeze_task(task);
 335         cgroup_iter_end(cgroup, &it);
 336 }
 337
 338 static void unfreeze_cgroup(struct freezer *freezer)
 339 {
 340         struct cgroup *cgroup = freezer->css.cgroup;
 341         struct cgroup_iter it;
 342         struct task_struct *task;
 343
 344         cgroup_iter_start(cgroup, &it);
 345         while ((task = cgroup_iter_next(cgroup, &it)))
 346                 __thaw_task(task);
 347         cgroup_iter_end(cgroup, &it);
 348 }
 349
 350 /**
 351  * freezer_apply_state - apply state change to a single cgroup_freezer
 352  * @freezer: freezer to apply state change to
 353  * @freeze: whether to freeze or unfreeze
 354  * @state: CGROUP_FREEZING_* flag to set or clear
 355  *
 356  * Set or clear @state on @cgroup according to @freeze, and perform
 357  * freezing or thawing as necessary.
 358  */
 359 static void freezer_apply_state(struct freezer *freezer, bool freeze,
 360                                 unsigned int state)
 361 {
 362         /* also synchronizes against task migration, see freezer_attach() */
 363         lockdep_assert_held(&freezer->lock);
 364
 365         if (!(freezer->state & CGROUP_FREEZER_ONLINE))
 366                 return;
 367
 368         if (freeze) {
 369                 if (!(freezer->state & CGROUP_FREEZING))
 370                         atomic_inc(&system_freezing_cnt);
 371                 freezer->state |= state;
 372                 freeze_cgroup(freezer);
 373         } else {
 374                 bool was_freezing = freezer->state & CGROUP_FREEZING;
 375
 376                 freezer->state &= ~state;
 377
 378                 if (!(freezer->state & CGROUP_FREEZING)) {
 379                         if (was_freezing)
 380                                 atomic_dec(&system_freezing_cnt);
 381                         freezer->state &= ~CGROUP_FROZEN;
 382                         unfreeze_cgroup(freezer);
 383                 }
 384         }
 385 }
 386
 387 /**
 388  * freezer_change_state - change the freezing state of a cgroup_freezer
 389  * @freezer: freezer of interest
 390  * @freeze: whether to freeze or thaw
 391  *
 392  * Freeze or thaw @freezer according to @freeze.  The operations are
 393  * recursive - all descendants of @freezer will be affected.
 394  */
 395 static void freezer_change_state(struct freezer *freezer, bool freeze)
 396 {
 397         struct cgroup *pos;
 398
 399         /* update @freezer */
 400         spin_lock_irq(&freezer->lock);
 401         freezer_apply_state(freezer, freeze, CGROUP_FREEZING_SELF);
 402         spin_unlock_irq(&freezer->lock);
 403
 404         /*
 405          * Update all its descendants in pre-order traversal.  Each
 406          * descendant will try to inherit its parent's FREEZING state as
 407          * CGROUP_FREEZING_PARENT.
 408          */
 409         rcu_read_lock();
 410         cgroup_for_each_descendant_pre(pos, freezer->css.cgroup) {
 411                 struct freezer *pos_f = cgroup_freezer(pos);
 412                 struct freezer *parent = parent_freezer(pos_f);
 413
 414                 /*
 415                  * Our update to @parent->state is already visible which is
 416                  * all we need.  No need to lock @parent.  For more info on
 417                  * synchronization, see freezer_post_create().
 418                  */
 419                 spin_lock_irq(&pos_f->lock);
 420                 freezer_apply_state(pos_f, parent->state & CGROUP_FREEZING,
 421                                     CGROUP_FREEZING_PARENT);
 422                 spin_unlock_irq(&pos_f->lock);
 423         }
 424         rcu_read_unlock();
 425 }
 426
 427 static int freezer_write(struct cgroup *cgroup, struct cftype *cft,
 428                          const char *buffer)
 429 {
 430         bool freeze;
 431
 432         if (strcmp(buffer, freezer_state_strs(0)) == 0)
 433                 freeze = false;
 434         else if (strcmp(buffer, freezer_state_strs(CGROUP_FROZEN)) == 0)
 435                 freeze = true;
 436         else
 437                 return -EINVAL;
 438
 439         freezer_change_state(cgroup_freezer(cgroup), freeze);
 440         return 0;
 441 }
 442
 443 static u64 freezer_self_freezing_read(struct cgroup *cgroup, struct cftype *cft)
 444 {
 445         struct freezer *freezer = cgroup_freezer(cgroup);
 446
 447         return (bool)(freezer->state & CGROUP_FREEZING_SELF);
 448 }
 449
 450 static u64 freezer_parent_freezing_read(struct cgroup *cgroup, struct cftype *cft)
 451 {
 452         struct freezer *freezer = cgroup_freezer(cgroup);
 453
 454         return (bool)(freezer->state & CGROUP_FREEZING_PARENT);
 455 }
 456
 457 static struct cftype files[] = {
 458         {
 459                 .name = "state",
 460                 .flags = CFTYPE_NOT_ON_ROOT,
 461                 .read_seq_string = freezer_read,
 462                 .write_string = freezer_write,
 463         },
 464         {
 465                 .name = "self_freezing",
 466                 .flags = CFTYPE_NOT_ON_ROOT,
 467                 .read_u64 = freezer_self_freezing_read,
 468         },
 469         {
 470                 .name = "parent_freezing",
 471                 .flags = CFTYPE_NOT_ON_ROOT,
 472                 .read_u64 = freezer_parent_freezing_read,
 473         },
 474         { }     /* terminate */
 475 };
 476
 477 struct cgroup_subsys freezer_subsys = {
 478         .name           = "freezer",
 479         .css_alloc      = freezer_css_alloc,
 480         .css_online     = freezer_css_online,
 481         .css_offline    = freezer_css_offline,
 482         .css_free       = freezer_css_free,
 483         .subsys_id      = freezer_subsys_id,
 484         .attach         = freezer_attach,
 485         .fork           = freezer_fork,
 486         .base_cftypes   = files,
 487 };