cgroup_freezer.c 9.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383
  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. #include <linux/export.h>
  17. #include <linux/slab.h>
  18. #include <linux/cgroup.h>
  19. #include <linux/fs.h>
  20. #include <linux/uaccess.h>
  21. #include <linux/freezer.h>
  22. #include <linux/seq_file.h>
  23. enum freezer_state {
  24. CGROUP_THAWED = 0,
  25. CGROUP_FREEZING,
  26. CGROUP_FROZEN,
  27. };
  28. struct freezer {
  29. struct cgroup_subsys_state css;
  30. enum freezer_state state;
  31. spinlock_t lock; /* protects _writes_ to state */
  32. };
  33. static inline struct freezer *cgroup_freezer(
  34. struct cgroup *cgroup)
  35. {
  36. return container_of(
  37. cgroup_subsys_state(cgroup, freezer_subsys_id),
  38. struct freezer, css);
  39. }
  40. static inline struct freezer *task_freezer(struct task_struct *task)
  41. {
  42. return container_of(task_subsys_state(task, freezer_subsys_id),
  43. struct freezer, css);
  44. }
  45. bool cgroup_freezing(struct task_struct *task)
  46. {
  47. enum freezer_state state;
  48. bool ret;
  49. rcu_read_lock();
  50. state = task_freezer(task)->state;
  51. ret = state == CGROUP_FREEZING || state == CGROUP_FROZEN;
  52. rcu_read_unlock();
  53. return ret;
  54. }
  55. /*
  56. * cgroups_write_string() limits the size of freezer state strings to
  57. * CGROUP_LOCAL_BUFFER_SIZE
  58. */
  59. static const char *freezer_state_strs[] = {
  60. "THAWED",
  61. "FREEZING",
  62. "FROZEN",
  63. };
  64. /*
  65. * State diagram
  66. * Transitions are caused by userspace writes to the freezer.state file.
  67. * The values in parenthesis are state labels. The rest are edge labels.
  68. *
  69. * (THAWED) --FROZEN--> (FREEZING) --FROZEN--> (FROZEN)
  70. * ^ ^ | |
  71. * | \_______THAWED_______/ |
  72. * \__________________________THAWED____________/
  73. */
  74. struct cgroup_subsys freezer_subsys;
  75. /* Locks taken and their ordering
  76. * ------------------------------
  77. * cgroup_mutex (AKA cgroup_lock)
  78. * freezer->lock
  79. * css_set_lock
  80. * task->alloc_lock (AKA task_lock)
  81. * task->sighand->siglock
  82. *
  83. * cgroup code forces css_set_lock to be taken before task->alloc_lock
  84. *
  85. * freezer_create(), freezer_destroy():
  86. * cgroup_mutex [ by cgroup core ]
  87. *
  88. * freezer_can_attach():
  89. * cgroup_mutex (held by caller of can_attach)
  90. *
  91. * freezer_fork() (preserving fork() performance means can't take cgroup_mutex):
  92. * freezer->lock
  93. * sighand->siglock (if the cgroup is freezing)
  94. *
  95. * freezer_read():
  96. * cgroup_mutex
  97. * freezer->lock
  98. * write_lock css_set_lock (cgroup iterator start)
  99. * task->alloc_lock
  100. * read_lock css_set_lock (cgroup iterator start)
  101. *
  102. * freezer_write() (freeze):
  103. * cgroup_mutex
  104. * freezer->lock
  105. * write_lock css_set_lock (cgroup iterator start)
  106. * task->alloc_lock
  107. * read_lock css_set_lock (cgroup iterator start)
  108. * sighand->siglock (fake signal delivery inside freeze_task())
  109. *
  110. * freezer_write() (unfreeze):
  111. * cgroup_mutex
  112. * freezer->lock
  113. * write_lock css_set_lock (cgroup iterator start)
  114. * task->alloc_lock
  115. * read_lock css_set_lock (cgroup iterator start)
  116. * task->alloc_lock (inside __thaw_task(), prevents race with refrigerator())
  117. * sighand->siglock
  118. */
  119. static struct cgroup_subsys_state *freezer_create(struct cgroup_subsys *ss,
  120. struct cgroup *cgroup)
  121. {
  122. struct freezer *freezer;
  123. freezer = kzalloc(sizeof(struct freezer), GFP_KERNEL);
  124. if (!freezer)
  125. return ERR_PTR(-ENOMEM);
  126. spin_lock_init(&freezer->lock);
  127. freezer->state = CGROUP_THAWED;
  128. return &freezer->css;
  129. }
  130. static void freezer_destroy(struct cgroup_subsys *ss,
  131. struct cgroup *cgroup)
  132. {
  133. struct freezer *freezer = cgroup_freezer(cgroup);
  134. if (freezer->state != CGROUP_THAWED)
  135. atomic_dec(&system_freezing_cnt);
  136. kfree(freezer);
  137. }
  138. /*
  139. * The call to cgroup_lock() in the freezer.state write method prevents
  140. * a write to that file racing against an attach, and hence the
  141. * can_attach() result will remain valid until the attach completes.
  142. */
  143. static int freezer_can_attach(struct cgroup_subsys *ss,
  144. struct cgroup *new_cgroup,
  145. struct task_struct *task)
  146. {
  147. struct freezer *freezer;
  148. /*
  149. * Anything frozen can't move or be moved to/from.
  150. */
  151. freezer = cgroup_freezer(new_cgroup);
  152. if (freezer->state != CGROUP_THAWED)
  153. return -EBUSY;
  154. return 0;
  155. }
  156. static int freezer_can_attach_task(struct cgroup *cgrp, struct task_struct *tsk)
  157. {
  158. return cgroup_freezing(tsk) ? -EBUSY : 0;
  159. }
  160. static void freezer_fork(struct cgroup_subsys *ss, struct task_struct *task)
  161. {
  162. struct freezer *freezer;
  163. /*
  164. * No lock is needed, since the task isn't on tasklist yet,
  165. * so it can't be moved to another cgroup, which means the
  166. * freezer won't be removed and will be valid during this
  167. * function call. Nevertheless, apply RCU read-side critical
  168. * section to suppress RCU lockdep false positives.
  169. */
  170. rcu_read_lock();
  171. freezer = task_freezer(task);
  172. rcu_read_unlock();
  173. /*
  174. * The root cgroup is non-freezable, so we can skip the
  175. * following check.
  176. */
  177. if (!freezer->css.cgroup->parent)
  178. return;
  179. spin_lock_irq(&freezer->lock);
  180. BUG_ON(freezer->state == CGROUP_FROZEN);
  181. /* Locking avoids race with FREEZING -> THAWED transitions. */
  182. if (freezer->state == CGROUP_FREEZING)
  183. freeze_task(task);
  184. spin_unlock_irq(&freezer->lock);
  185. }
  186. /*
  187. * caller must hold freezer->lock
  188. */
  189. static void update_if_frozen(struct cgroup *cgroup,
  190. struct freezer *freezer)
  191. {
  192. struct cgroup_iter it;
  193. struct task_struct *task;
  194. unsigned int nfrozen = 0, ntotal = 0;
  195. enum freezer_state old_state = freezer->state;
  196. cgroup_iter_start(cgroup, &it);
  197. while ((task = cgroup_iter_next(cgroup, &it))) {
  198. ntotal++;
  199. if (freezing(task) && frozen(task))
  200. nfrozen++;
  201. }
  202. if (old_state == CGROUP_THAWED) {
  203. BUG_ON(nfrozen > 0);
  204. } else if (old_state == CGROUP_FREEZING) {
  205. if (nfrozen == ntotal)
  206. freezer->state = CGROUP_FROZEN;
  207. } else { /* old_state == CGROUP_FROZEN */
  208. BUG_ON(nfrozen != ntotal);
  209. }
  210. cgroup_iter_end(cgroup, &it);
  211. }
  212. static int freezer_read(struct cgroup *cgroup, struct cftype *cft,
  213. struct seq_file *m)
  214. {
  215. struct freezer *freezer;
  216. enum freezer_state state;
  217. if (!cgroup_lock_live_group(cgroup))
  218. return -ENODEV;
  219. freezer = cgroup_freezer(cgroup);
  220. spin_lock_irq(&freezer->lock);
  221. state = freezer->state;
  222. if (state == CGROUP_FREEZING) {
  223. /* We change from FREEZING to FROZEN lazily if the cgroup was
  224. * only partially frozen when we exitted write. */
  225. update_if_frozen(cgroup, freezer);
  226. state = freezer->state;
  227. }
  228. spin_unlock_irq(&freezer->lock);
  229. cgroup_unlock();
  230. seq_puts(m, freezer_state_strs[state]);
  231. seq_putc(m, '\n');
  232. return 0;
  233. }
  234. static int try_to_freeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
  235. {
  236. struct cgroup_iter it;
  237. struct task_struct *task;
  238. unsigned int num_cant_freeze_now = 0;
  239. cgroup_iter_start(cgroup, &it);
  240. while ((task = cgroup_iter_next(cgroup, &it))) {
  241. if (!freeze_task(task))
  242. continue;
  243. if (frozen(task))
  244. continue;
  245. if (!freezing(task) && !freezer_should_skip(task))
  246. num_cant_freeze_now++;
  247. }
  248. cgroup_iter_end(cgroup, &it);
  249. return num_cant_freeze_now ? -EBUSY : 0;
  250. }
  251. static void unfreeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
  252. {
  253. struct cgroup_iter it;
  254. struct task_struct *task;
  255. cgroup_iter_start(cgroup, &it);
  256. while ((task = cgroup_iter_next(cgroup, &it)))
  257. __thaw_task(task);
  258. cgroup_iter_end(cgroup, &it);
  259. }
  260. static int freezer_change_state(struct cgroup *cgroup,
  261. enum freezer_state goal_state)
  262. {
  263. struct freezer *freezer;
  264. int retval = 0;
  265. freezer = cgroup_freezer(cgroup);
  266. spin_lock_irq(&freezer->lock);
  267. update_if_frozen(cgroup, freezer);
  268. switch (goal_state) {
  269. case CGROUP_THAWED:
  270. if (freezer->state != CGROUP_THAWED)
  271. atomic_dec(&system_freezing_cnt);
  272. freezer->state = CGROUP_THAWED;
  273. unfreeze_cgroup(cgroup, freezer);
  274. break;
  275. case CGROUP_FROZEN:
  276. if (freezer->state == CGROUP_THAWED)
  277. atomic_inc(&system_freezing_cnt);
  278. freezer->state = CGROUP_FREEZING;
  279. retval = try_to_freeze_cgroup(cgroup, freezer);
  280. break;
  281. default:
  282. BUG();
  283. }
  284. spin_unlock_irq(&freezer->lock);
  285. return retval;
  286. }
  287. static int freezer_write(struct cgroup *cgroup,
  288. struct cftype *cft,
  289. const char *buffer)
  290. {
  291. int retval;
  292. enum freezer_state goal_state;
  293. if (strcmp(buffer, freezer_state_strs[CGROUP_THAWED]) == 0)
  294. goal_state = CGROUP_THAWED;
  295. else if (strcmp(buffer, freezer_state_strs[CGROUP_FROZEN]) == 0)
  296. goal_state = CGROUP_FROZEN;
  297. else
  298. return -EINVAL;
  299. if (!cgroup_lock_live_group(cgroup))
  300. return -ENODEV;
  301. retval = freezer_change_state(cgroup, goal_state);
  302. cgroup_unlock();
  303. return retval;
  304. }
  305. static struct cftype files[] = {
  306. {
  307. .name = "state",
  308. .read_seq_string = freezer_read,
  309. .write_string = freezer_write,
  310. },
  311. };
  312. static int freezer_populate(struct cgroup_subsys *ss, struct cgroup *cgroup)
  313. {
  314. if (!cgroup->parent)
  315. return 0;
  316. return cgroup_add_files(cgroup, ss, files, ARRAY_SIZE(files));
  317. }
  318. struct cgroup_subsys freezer_subsys = {
  319. .name = "freezer",
  320. .create = freezer_create,
  321. .destroy = freezer_destroy,
  322. .populate = freezer_populate,
  323. .subsys_id = freezer_subsys_id,
  324. .can_attach = freezer_can_attach,
  325. .can_attach_task = freezer_can_attach_task,
  326. .pre_attach = NULL,
  327. .attach_task = NULL,
  328. .attach = NULL,
  329. .fork = freezer_fork,
  330. .exit = NULL,
  331. };