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