~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/cgroup_freezer.c

Version: ~ [ linux-5.5-rc1 ] ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 {
 26         CGROUP_THAWED = 0,
 27         CGROUP_FREEZING,
 28         CGROUP_FROZEN,
 29 };
 30 
 31 struct freezer {
 32         struct cgroup_subsys_state css;
 33         enum freezer_state state;
 34         spinlock_t lock; /* protects _writes_ to state */
 35 };
 36 
 37 static inline struct freezer *cgroup_freezer(
 38                 struct cgroup *cgroup)
 39 {
 40         return container_of(
 41                 cgroup_subsys_state(cgroup, freezer_subsys_id),
 42                 struct freezer, css);
 43 }
 44 
 45 static inline struct freezer *task_freezer(struct task_struct *task)
 46 {
 47         return container_of(task_subsys_state(task, freezer_subsys_id),
 48                             struct freezer, css);
 49 }
 50 
 51 static inline int __cgroup_freezing_or_frozen(struct task_struct *task)
 52 {
 53         enum freezer_state state = task_freezer(task)->state;
 54         return (state == CGROUP_FREEZING) || (state == CGROUP_FROZEN);
 55 }
 56 
 57 int cgroup_freezing_or_frozen(struct task_struct *task)
 58 {
 59         int result;
 60         task_lock(task);
 61         result = __cgroup_freezing_or_frozen(task);
 62         task_unlock(task);
 63         return result;
 64 }
 65 
 66 /*
 67  * cgroups_write_string() limits the size of freezer state strings to
 68  * CGROUP_LOCAL_BUFFER_SIZE
 69  */
 70 static const char *freezer_state_strs[] = {
 71         "THAWED",
 72         "FREEZING",
 73         "FROZEN",
 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 /* Locks taken and their ordering
 90  * ------------------------------
 91  * cgroup_mutex (AKA cgroup_lock)
 92  * freezer->lock
 93  * css_set_lock
 94  * task->alloc_lock (AKA task_lock)
 95  * task->sighand->siglock
 96  *
 97  * cgroup code forces css_set_lock to be taken before task->alloc_lock
 98  *
 99  * freezer_create(), freezer_destroy():
100  * cgroup_mutex [ by cgroup core ]
101  *
102  * freezer_can_attach():
103  * cgroup_mutex (held by caller of can_attach)
104  *
105  * cgroup_freezing_or_frozen():
106  * task->alloc_lock (to get task's cgroup)
107  *
108  * freezer_fork() (preserving fork() performance means can't take cgroup_mutex):
109  * freezer->lock
110  *  sighand->siglock (if the cgroup is freezing)
111  *
112  * freezer_read():
113  * cgroup_mutex
114  *  freezer->lock
115  *   write_lock css_set_lock (cgroup iterator start)
116  *    task->alloc_lock
117  *   read_lock css_set_lock (cgroup iterator start)
118  *
119  * freezer_write() (freeze):
120  * cgroup_mutex
121  *  freezer->lock
122  *   write_lock css_set_lock (cgroup iterator start)
123  *    task->alloc_lock
124  *   read_lock css_set_lock (cgroup iterator start)
125  *    sighand->siglock (fake signal delivery inside freeze_task())
126  *
127  * freezer_write() (unfreeze):
128  * cgroup_mutex
129  *  freezer->lock
130  *   write_lock css_set_lock (cgroup iterator start)
131  *    task->alloc_lock
132  *   read_lock css_set_lock (cgroup iterator start)
133  *    task->alloc_lock (inside thaw_process(), prevents race with refrigerator())
134  *     sighand->siglock
135  */
136 static struct cgroup_subsys_state *freezer_create(struct cgroup_subsys *ss,
137                                                   struct cgroup *cgroup)
138 {
139         struct freezer *freezer;
140 
141         freezer = kzalloc(sizeof(struct freezer), GFP_KERNEL);
142         if (!freezer)
143                 return ERR_PTR(-ENOMEM);
144 
145         spin_lock_init(&freezer->lock);
146         freezer->state = CGROUP_THAWED;
147         return &freezer->css;
148 }
149 
150 static void freezer_destroy(struct cgroup_subsys *ss,
151                             struct cgroup *cgroup)
152 {
153         kfree(cgroup_freezer(cgroup));
154 }
155 
156 /* task is frozen or will freeze immediately when next it gets woken */
157 static bool is_task_frozen_enough(struct task_struct *task)
158 {
159         return frozen(task) ||
160                 (task_is_stopped_or_traced(task) && freezing(task));
161 }
162 
163 /*
164  * The call to cgroup_lock() in the freezer.state write method prevents
165  * a write to that file racing against an attach, and hence the
166  * can_attach() result will remain valid until the attach completes.
167  */
168 static int freezer_can_attach(struct cgroup_subsys *ss,
169                               struct cgroup *new_cgroup,
170                               struct task_struct *task)
171 {
172         struct freezer *freezer;
173 
174         /*
175          * Anything frozen can't move or be moved to/from.
176          */
177 
178         freezer = cgroup_freezer(new_cgroup);
179         if (freezer->state != CGROUP_THAWED)
180                 return -EBUSY;
181 
182         return 0;
183 }
184 
185 static int freezer_can_attach_task(struct cgroup *cgrp, struct task_struct *tsk)
186 {
187         rcu_read_lock();
188         if (__cgroup_freezing_or_frozen(tsk)) {
189                 rcu_read_unlock();
190                 return -EBUSY;
191         }
192         rcu_read_unlock();
193         return 0;
194 }
195 
196 static void freezer_fork(struct cgroup_subsys *ss, struct task_struct *task)
197 {
198         struct freezer *freezer;
199 
200         rcu_read_lock();
201         freezer = task_freezer(task);
202 
203         /*
204          * The root cgroup is non-freezable, so we can skip the
205          * following check.
206          */
207         if (!freezer->css.cgroup->parent)
208                 goto out;
209 
210         spin_lock_irq(&freezer->lock);
211         BUG_ON(freezer->state == CGROUP_FROZEN);
212 
213         /* Locking avoids race with FREEZING -> THAWED transitions. */
214         if (freezer->state == CGROUP_FREEZING)
215                 freeze_task(task, true);
216 
217         spin_unlock_irq(&freezer->lock);
218 out:
219         rcu_read_unlock();
220 }
221 
222 /*
223  * caller must hold freezer->lock
224  */
225 static void update_if_frozen(struct cgroup *cgroup,
226                                  struct freezer *freezer)
227 {
228         struct cgroup_iter it;
229         struct task_struct *task;
230         unsigned int nfrozen = 0, ntotal = 0;
231         enum freezer_state old_state = freezer->state;
232 
233         cgroup_iter_start(cgroup, &it);
234         while ((task = cgroup_iter_next(cgroup, &it))) {
235                 ntotal++;
236                 if (is_task_frozen_enough(task))
237                         nfrozen++;
238         }
239 
240         if (old_state == CGROUP_THAWED) {
241                 BUG_ON(nfrozen > 0);
242         } else if (old_state == CGROUP_FREEZING) {
243                 if (nfrozen == ntotal)
244                         freezer->state = CGROUP_FROZEN;
245         } else { /* old_state == CGROUP_FROZEN */
246                 BUG_ON(nfrozen != ntotal);
247         }
248 
249         cgroup_iter_end(cgroup, &it);
250 }
251 
252 static int freezer_read(struct cgroup *cgroup, struct cftype *cft,
253                         struct seq_file *m)
254 {
255         struct freezer *freezer;
256         enum freezer_state state;
257 
258         if (!cgroup_lock_live_group(cgroup))
259                 return -ENODEV;
260 
261         freezer = cgroup_freezer(cgroup);
262         spin_lock_irq(&freezer->lock);
263         state = freezer->state;
264         if (state == CGROUP_FREEZING) {
265                 /* We change from FREEZING to FROZEN lazily if the cgroup was
266                  * only partially frozen when we exitted write. */
267                 update_if_frozen(cgroup, freezer);
268                 state = freezer->state;
269         }
270         spin_unlock_irq(&freezer->lock);
271         cgroup_unlock();
272 
273         seq_puts(m, freezer_state_strs[state]);
274         seq_putc(m, '\n');
275         return 0;
276 }
277 
278 static int try_to_freeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
279 {
280         struct cgroup_iter it;
281         struct task_struct *task;
282         unsigned int num_cant_freeze_now = 0;
283 
284         freezer->state = CGROUP_FREEZING;
285         cgroup_iter_start(cgroup, &it);
286         while ((task = cgroup_iter_next(cgroup, &it))) {
287                 if (!freeze_task(task, true))
288                         continue;
289                 if (is_task_frozen_enough(task))
290                         continue;
291                 if (!freezing(task) && !freezer_should_skip(task))
292                         num_cant_freeze_now++;
293         }
294         cgroup_iter_end(cgroup, &it);
295 
296         return num_cant_freeze_now ? -EBUSY : 0;
297 }
298 
299 static void unfreeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
300 {
301         struct cgroup_iter it;
302         struct task_struct *task;
303 
304         cgroup_iter_start(cgroup, &it);
305         while ((task = cgroup_iter_next(cgroup, &it))) {
306                 thaw_process(task);
307         }
308         cgroup_iter_end(cgroup, &it);
309 
310         freezer->state = CGROUP_THAWED;
311 }
312 
313 static int freezer_change_state(struct cgroup *cgroup,
314                                 enum freezer_state goal_state)
315 {
316         struct freezer *freezer;
317         int retval = 0;
318 
319         freezer = cgroup_freezer(cgroup);
320 
321         spin_lock_irq(&freezer->lock);
322 
323         update_if_frozen(cgroup, freezer);
324         if (goal_state == freezer->state)
325                 goto out;
326 
327         switch (goal_state) {
328         case CGROUP_THAWED:
329                 unfreeze_cgroup(cgroup, freezer);
330                 break;
331         case CGROUP_FROZEN:
332                 retval = try_to_freeze_cgroup(cgroup, freezer);
333                 break;
334         default:
335                 BUG();
336         }
337 out:
338         spin_unlock_irq(&freezer->lock);
339 
340         return retval;
341 }
342 
343 static int freezer_write(struct cgroup *cgroup,
344                          struct cftype *cft,
345                          const char *buffer)
346 {
347         int retval;
348         enum freezer_state goal_state;
349 
350         if (strcmp(buffer, freezer_state_strs[CGROUP_THAWED]) == 0)
351                 goal_state = CGROUP_THAWED;
352         else if (strcmp(buffer, freezer_state_strs[CGROUP_FROZEN]) == 0)
353                 goal_state = CGROUP_FROZEN;
354         else
355                 return -EINVAL;
356 
357         if (!cgroup_lock_live_group(cgroup))
358                 return -ENODEV;
359         retval = freezer_change_state(cgroup, goal_state);
360         cgroup_unlock();
361         return retval;
362 }
363 
364 static struct cftype files[] = {
365         {
366                 .name = "state",
367                 .read_seq_string = freezer_read,
368                 .write_string = freezer_write,
369         },
370 };
371 
372 static int freezer_populate(struct cgroup_subsys *ss, struct cgroup *cgroup)
373 {
374         if (!cgroup->parent)
375                 return 0;
376         return cgroup_add_files(cgroup, ss, files, ARRAY_SIZE(files));
377 }
378 
379 struct cgroup_subsys freezer_subsys = {
380         .name           = "freezer",
381         .create         = freezer_create,
382         .destroy        = freezer_destroy,
383         .populate       = freezer_populate,
384         .subsys_id      = freezer_subsys_id,
385         .can_attach     = freezer_can_attach,
386         .can_attach_task = freezer_can_attach_task,
387         .pre_attach     = NULL,
388         .attach_task    = NULL,
389         .attach         = NULL,
390         .fork           = freezer_fork,
391         .exit           = NULL,
392 };
393 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp