sched.h 78 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776
  1. #ifndef _LINUX_SCHED_H
  2. #define _LINUX_SCHED_H
  3. #include <uapi/linux/sched.h>
  4. struct sched_param {
  5. int sched_priority;
  6. };
  7. #include <asm/param.h> /* for HZ */
  8. #include <linux/capability.h>
  9. #include <linux/threads.h>
  10. #include <linux/kernel.h>
  11. #include <linux/types.h>
  12. #include <linux/timex.h>
  13. #include <linux/jiffies.h>
  14. #include <linux/rbtree.h>
  15. #include <linux/thread_info.h>
  16. #include <linux/cpumask.h>
  17. #include <linux/errno.h>
  18. #include <linux/nodemask.h>
  19. #include <linux/mm_types.h>
  20. #include <linux/preempt.h>
  21. #include <asm/page.h>
  22. #include <asm/ptrace.h>
  23. #include <asm/cputime.h>
  24. #include <linux/smp.h>
  25. #include <linux/sem.h>
  26. #include <linux/signal.h>
  27. #include <linux/compiler.h>
  28. #include <linux/completion.h>
  29. #include <linux/pid.h>
  30. #include <linux/percpu.h>
  31. #include <linux/topology.h>
  32. #include <linux/proportions.h>
  33. #include <linux/seccomp.h>
  34. #include <linux/rcupdate.h>
  35. #include <linux/rculist.h>
  36. #include <linux/rtmutex.h>
  37. #include <linux/time.h>
  38. #include <linux/param.h>
  39. #include <linux/resource.h>
  40. #include <linux/timer.h>
  41. #include <linux/hrtimer.h>
  42. #include <linux/task_io_accounting.h>
  43. #include <linux/latencytop.h>
  44. #include <linux/cred.h>
  45. #include <linux/llist.h>
  46. #include <linux/uidgid.h>
  47. #include <linux/gfp.h>
  48. #include <asm/processor.h>
  49. struct exec_domain;
  50. struct futex_pi_state;
  51. struct robust_list_head;
  52. struct bio_list;
  53. struct fs_struct;
  54. struct perf_event_context;
  55. struct blk_plug;
  56. /*
  57. * List of flags we want to share for kernel threads,
  58. * if only because they are not used by them anyway.
  59. */
  60. #define CLONE_KERNEL (CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
  61. /*
  62. * These are the constant used to fake the fixed-point load-average
  63. * counting. Some notes:
  64. * - 11 bit fractions expand to 22 bits by the multiplies: this gives
  65. * a load-average precision of 10 bits integer + 11 bits fractional
  66. * - if you want to count load-averages more often, you need more
  67. * precision, or rounding will get you. With 2-second counting freq,
  68. * the EXP_n values would be 1981, 2034 and 2043 if still using only
  69. * 11 bit fractions.
  70. */
  71. extern unsigned long avenrun[]; /* Load averages */
  72. extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift);
  73. #define FSHIFT 11 /* nr of bits of precision */
  74. #define FIXED_1 (1<<FSHIFT) /* 1.0 as fixed-point */
  75. #define LOAD_FREQ (5*HZ+1) /* 5 sec intervals */
  76. #define EXP_1 1884 /* 1/exp(5sec/1min) as fixed-point */
  77. #define EXP_5 2014 /* 1/exp(5sec/5min) */
  78. #define EXP_15 2037 /* 1/exp(5sec/15min) */
  79. #define CALC_LOAD(load,exp,n) \
  80. load *= exp; \
  81. load += n*(FIXED_1-exp); \
  82. load >>= FSHIFT;
  83. extern unsigned long total_forks;
  84. extern int nr_threads;
  85. DECLARE_PER_CPU(unsigned long, process_counts);
  86. extern int nr_processes(void);
  87. extern unsigned long nr_running(void);
  88. extern unsigned long nr_iowait(void);
  89. extern unsigned long nr_iowait_cpu(int cpu);
  90. extern unsigned long this_cpu_load(void);
  91. extern void calc_global_load(unsigned long ticks);
  92. extern void update_cpu_load_nohz(void);
  93. extern unsigned long get_parent_ip(unsigned long addr);
  94. extern void dump_cpu_task(int cpu);
  95. struct seq_file;
  96. struct cfs_rq;
  97. struct task_group;
  98. #ifdef CONFIG_SCHED_DEBUG
  99. extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);
  100. extern void proc_sched_set_task(struct task_struct *p);
  101. extern void
  102. print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
  103. #endif
  104. /*
  105. * Task state bitmask. NOTE! These bits are also
  106. * encoded in fs/proc/array.c: get_task_state().
  107. *
  108. * We have two separate sets of flags: task->state
  109. * is about runnability, while task->exit_state are
  110. * about the task exiting. Confusing, but this way
  111. * modifying one set can't modify the other one by
  112. * mistake.
  113. */
  114. #define TASK_RUNNING 0
  115. #define TASK_INTERRUPTIBLE 1
  116. #define TASK_UNINTERRUPTIBLE 2
  117. #define __TASK_STOPPED 4
  118. #define __TASK_TRACED 8
  119. /* in tsk->exit_state */
  120. #define EXIT_ZOMBIE 16
  121. #define EXIT_DEAD 32
  122. /* in tsk->state again */
  123. #define TASK_DEAD 64
  124. #define TASK_WAKEKILL 128
  125. #define TASK_WAKING 256
  126. #define TASK_PARKED 512
  127. #define TASK_STATE_MAX 1024
  128. #define TASK_STATE_TO_CHAR_STR "RSDTtZXxKWP"
  129. extern char ___assert_task_state[1 - 2*!!(
  130. sizeof(TASK_STATE_TO_CHAR_STR)-1 != ilog2(TASK_STATE_MAX)+1)];
  131. /* Convenience macros for the sake of set_task_state */
  132. #define TASK_KILLABLE (TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
  133. #define TASK_STOPPED (TASK_WAKEKILL | __TASK_STOPPED)
  134. #define TASK_TRACED (TASK_WAKEKILL | __TASK_TRACED)
  135. /* Convenience macros for the sake of wake_up */
  136. #define TASK_NORMAL (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)
  137. #define TASK_ALL (TASK_NORMAL | __TASK_STOPPED | __TASK_TRACED)
  138. /* get_task_state() */
  139. #define TASK_REPORT (TASK_RUNNING | TASK_INTERRUPTIBLE | \
  140. TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \
  141. __TASK_TRACED)
  142. #define task_is_traced(task) ((task->state & __TASK_TRACED) != 0)
  143. #define task_is_stopped(task) ((task->state & __TASK_STOPPED) != 0)
  144. #define task_is_dead(task) ((task)->exit_state != 0)
  145. #define task_is_stopped_or_traced(task) \
  146. ((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)
  147. #define task_contributes_to_load(task) \
  148. ((task->state & TASK_UNINTERRUPTIBLE) != 0 && \
  149. (task->flags & PF_FROZEN) == 0)
  150. #define __set_task_state(tsk, state_value) \
  151. do { (tsk)->state = (state_value); } while (0)
  152. #define set_task_state(tsk, state_value) \
  153. set_mb((tsk)->state, (state_value))
  154. /*
  155. * set_current_state() includes a barrier so that the write of current->state
  156. * is correctly serialised wrt the caller's subsequent test of whether to
  157. * actually sleep:
  158. *
  159. * set_current_state(TASK_UNINTERRUPTIBLE);
  160. * if (do_i_need_to_sleep())
  161. * schedule();
  162. *
  163. * If the caller does not need such serialisation then use __set_current_state()
  164. */
  165. #define __set_current_state(state_value) \
  166. do { current->state = (state_value); } while (0)
  167. #define set_current_state(state_value) \
  168. set_mb(current->state, (state_value))
  169. /* Task command name length */
  170. #define TASK_COMM_LEN 16
  171. #include <linux/spinlock.h>
  172. /*
  173. * This serializes "schedule()" and also protects
  174. * the run-queue from deletions/modifications (but
  175. * _adding_ to the beginning of the run-queue has
  176. * a separate lock).
  177. */
  178. extern rwlock_t tasklist_lock;
  179. extern spinlock_t mmlist_lock;
  180. struct task_struct;
  181. #ifdef CONFIG_PROVE_RCU
  182. extern int lockdep_tasklist_lock_is_held(void);
  183. #endif /* #ifdef CONFIG_PROVE_RCU */
  184. extern void sched_init(void);
  185. extern void sched_init_smp(void);
  186. extern asmlinkage void schedule_tail(struct task_struct *prev);
  187. extern void init_idle(struct task_struct *idle, int cpu);
  188. extern void init_idle_bootup_task(struct task_struct *idle);
  189. extern int runqueue_is_locked(int cpu);
  190. #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
  191. extern void nohz_balance_enter_idle(int cpu);
  192. extern void set_cpu_sd_state_idle(void);
  193. extern int get_nohz_timer_target(void);
  194. #else
  195. static inline void nohz_balance_enter_idle(int cpu) { }
  196. static inline void set_cpu_sd_state_idle(void) { }
  197. #endif
  198. /*
  199. * Only dump TASK_* tasks. (0 for all tasks)
  200. */
  201. extern void show_state_filter(unsigned long state_filter);
  202. static inline void show_state(void)
  203. {
  204. show_state_filter(0);
  205. }
  206. extern void show_regs(struct pt_regs *);
  207. /*
  208. * TASK is a pointer to the task whose backtrace we want to see (or NULL for current
  209. * task), SP is the stack pointer of the first frame that should be shown in the back
  210. * trace (or NULL if the entire call-chain of the task should be shown).
  211. */
  212. extern void show_stack(struct task_struct *task, unsigned long *sp);
  213. void io_schedule(void);
  214. long io_schedule_timeout(long timeout);
  215. extern void cpu_init (void);
  216. extern void trap_init(void);
  217. extern void update_process_times(int user);
  218. extern void scheduler_tick(void);
  219. extern void sched_show_task(struct task_struct *p);
  220. #ifdef CONFIG_LOCKUP_DETECTOR
  221. extern void touch_softlockup_watchdog(void);
  222. extern void touch_softlockup_watchdog_sync(void);
  223. extern void touch_all_softlockup_watchdogs(void);
  224. extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,
  225. void __user *buffer,
  226. size_t *lenp, loff_t *ppos);
  227. extern unsigned int softlockup_panic;
  228. void lockup_detector_init(void);
  229. #else
  230. static inline void touch_softlockup_watchdog(void)
  231. {
  232. }
  233. static inline void touch_softlockup_watchdog_sync(void)
  234. {
  235. }
  236. static inline void touch_all_softlockup_watchdogs(void)
  237. {
  238. }
  239. static inline void lockup_detector_init(void)
  240. {
  241. }
  242. #endif
  243. /* Attach to any functions which should be ignored in wchan output. */
  244. #define __sched __attribute__((__section__(".sched.text")))
  245. /* Linker adds these: start and end of __sched functions */
  246. extern char __sched_text_start[], __sched_text_end[];
  247. /* Is this address in the __sched functions? */
  248. extern int in_sched_functions(unsigned long addr);
  249. #define MAX_SCHEDULE_TIMEOUT LONG_MAX
  250. extern signed long schedule_timeout(signed long timeout);
  251. extern signed long schedule_timeout_interruptible(signed long timeout);
  252. extern signed long schedule_timeout_killable(signed long timeout);
  253. extern signed long schedule_timeout_uninterruptible(signed long timeout);
  254. asmlinkage void schedule(void);
  255. extern void schedule_preempt_disabled(void);
  256. struct nsproxy;
  257. struct user_namespace;
  258. #ifdef CONFIG_MMU
  259. extern void arch_pick_mmap_layout(struct mm_struct *mm);
  260. extern unsigned long
  261. arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
  262. unsigned long, unsigned long);
  263. extern unsigned long
  264. arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
  265. unsigned long len, unsigned long pgoff,
  266. unsigned long flags);
  267. #else
  268. static inline void arch_pick_mmap_layout(struct mm_struct *mm) {}
  269. #endif
  270. extern void set_dumpable(struct mm_struct *mm, int value);
  271. extern int get_dumpable(struct mm_struct *mm);
  272. #define SUID_DUMP_DISABLE 0 /* No setuid dumping */
  273. #define SUID_DUMP_USER 1 /* Dump as user of process */
  274. #define SUID_DUMP_ROOT 2 /* Dump as root */
  275. /* mm flags */
  276. /* dumpable bits */
  277. #define MMF_DUMPABLE 0 /* core dump is permitted */
  278. #define MMF_DUMP_SECURELY 1 /* core file is readable only by root */
  279. #define MMF_DUMPABLE_BITS 2
  280. #define MMF_DUMPABLE_MASK ((1 << MMF_DUMPABLE_BITS) - 1)
  281. /* coredump filter bits */
  282. #define MMF_DUMP_ANON_PRIVATE 2
  283. #define MMF_DUMP_ANON_SHARED 3
  284. #define MMF_DUMP_MAPPED_PRIVATE 4
  285. #define MMF_DUMP_MAPPED_SHARED 5
  286. #define MMF_DUMP_ELF_HEADERS 6
  287. #define MMF_DUMP_HUGETLB_PRIVATE 7
  288. #define MMF_DUMP_HUGETLB_SHARED 8
  289. #define MMF_DUMP_FILTER_SHIFT MMF_DUMPABLE_BITS
  290. #define MMF_DUMP_FILTER_BITS 7
  291. #define MMF_DUMP_FILTER_MASK \
  292. (((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)
  293. #define MMF_DUMP_FILTER_DEFAULT \
  294. ((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED) |\
  295. (1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)
  296. #ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS
  297. # define MMF_DUMP_MASK_DEFAULT_ELF (1 << MMF_DUMP_ELF_HEADERS)
  298. #else
  299. # define MMF_DUMP_MASK_DEFAULT_ELF 0
  300. #endif
  301. /* leave room for more dump flags */
  302. #define MMF_VM_MERGEABLE 16 /* KSM may merge identical pages */
  303. #define MMF_VM_HUGEPAGE 17 /* set when VM_HUGEPAGE is set on vma */
  304. #define MMF_EXE_FILE_CHANGED 18 /* see prctl_set_mm_exe_file() */
  305. #define MMF_HAS_UPROBES 19 /* has uprobes */
  306. #define MMF_RECALC_UPROBES 20 /* MMF_HAS_UPROBES can be wrong */
  307. #define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK)
  308. struct sighand_struct {
  309. atomic_t count;
  310. struct k_sigaction action[_NSIG];
  311. spinlock_t siglock;
  312. wait_queue_head_t signalfd_wqh;
  313. };
  314. struct pacct_struct {
  315. int ac_flag;
  316. long ac_exitcode;
  317. unsigned long ac_mem;
  318. cputime_t ac_utime, ac_stime;
  319. unsigned long ac_minflt, ac_majflt;
  320. };
  321. struct cpu_itimer {
  322. cputime_t expires;
  323. cputime_t incr;
  324. u32 error;
  325. u32 incr_error;
  326. };
  327. /**
  328. * struct cputime - snaphsot of system and user cputime
  329. * @utime: time spent in user mode
  330. * @stime: time spent in system mode
  331. *
  332. * Gathers a generic snapshot of user and system time.
  333. */
  334. struct cputime {
  335. cputime_t utime;
  336. cputime_t stime;
  337. };
  338. /**
  339. * struct task_cputime - collected CPU time counts
  340. * @utime: time spent in user mode, in &cputime_t units
  341. * @stime: time spent in kernel mode, in &cputime_t units
  342. * @sum_exec_runtime: total time spent on the CPU, in nanoseconds
  343. *
  344. * This is an extension of struct cputime that includes the total runtime
  345. * spent by the task from the scheduler point of view.
  346. *
  347. * As a result, this structure groups together three kinds of CPU time
  348. * that are tracked for threads and thread groups. Most things considering
  349. * CPU time want to group these counts together and treat all three
  350. * of them in parallel.
  351. */
  352. struct task_cputime {
  353. cputime_t utime;
  354. cputime_t stime;
  355. unsigned long long sum_exec_runtime;
  356. };
  357. /* Alternate field names when used to cache expirations. */
  358. #define prof_exp stime
  359. #define virt_exp utime
  360. #define sched_exp sum_exec_runtime
  361. #define INIT_CPUTIME \
  362. (struct task_cputime) { \
  363. .utime = 0, \
  364. .stime = 0, \
  365. .sum_exec_runtime = 0, \
  366. }
  367. #define PREEMPT_ENABLED (PREEMPT_NEED_RESCHED)
  368. #ifdef CONFIG_PREEMPT_COUNT
  369. #define PREEMPT_DISABLED (1 + PREEMPT_ENABLED)
  370. #else
  371. #define PREEMPT_DISABLED PREEMPT_ENABLED
  372. #endif
  373. /*
  374. * Disable preemption until the scheduler is running.
  375. * Reset by start_kernel()->sched_init()->init_idle().
  376. *
  377. * We include PREEMPT_ACTIVE to avoid cond_resched() from working
  378. * before the scheduler is active -- see should_resched().
  379. */
  380. #define INIT_PREEMPT_COUNT (PREEMPT_DISABLED + PREEMPT_ACTIVE)
  381. /**
  382. * struct thread_group_cputimer - thread group interval timer counts
  383. * @cputime: thread group interval timers.
  384. * @running: non-zero when there are timers running and
  385. * @cputime receives updates.
  386. * @lock: lock for fields in this struct.
  387. *
  388. * This structure contains the version of task_cputime, above, that is
  389. * used for thread group CPU timer calculations.
  390. */
  391. struct thread_group_cputimer {
  392. struct task_cputime cputime;
  393. int running;
  394. raw_spinlock_t lock;
  395. };
  396. #include <linux/rwsem.h>
  397. struct autogroup;
  398. /*
  399. * NOTE! "signal_struct" does not have its own
  400. * locking, because a shared signal_struct always
  401. * implies a shared sighand_struct, so locking
  402. * sighand_struct is always a proper superset of
  403. * the locking of signal_struct.
  404. */
  405. struct signal_struct {
  406. atomic_t sigcnt;
  407. atomic_t live;
  408. int nr_threads;
  409. wait_queue_head_t wait_chldexit; /* for wait4() */
  410. /* current thread group signal load-balancing target: */
  411. struct task_struct *curr_target;
  412. /* shared signal handling: */
  413. struct sigpending shared_pending;
  414. /* thread group exit support */
  415. int group_exit_code;
  416. /* overloaded:
  417. * - notify group_exit_task when ->count is equal to notify_count
  418. * - everyone except group_exit_task is stopped during signal delivery
  419. * of fatal signals, group_exit_task processes the signal.
  420. */
  421. int notify_count;
  422. struct task_struct *group_exit_task;
  423. /* thread group stop support, overloads group_exit_code too */
  424. int group_stop_count;
  425. unsigned int flags; /* see SIGNAL_* flags below */
  426. /*
  427. * PR_SET_CHILD_SUBREAPER marks a process, like a service
  428. * manager, to re-parent orphan (double-forking) child processes
  429. * to this process instead of 'init'. The service manager is
  430. * able to receive SIGCHLD signals and is able to investigate
  431. * the process until it calls wait(). All children of this
  432. * process will inherit a flag if they should look for a
  433. * child_subreaper process at exit.
  434. */
  435. unsigned int is_child_subreaper:1;
  436. unsigned int has_child_subreaper:1;
  437. /* POSIX.1b Interval Timers */
  438. int posix_timer_id;
  439. struct list_head posix_timers;
  440. /* ITIMER_REAL timer for the process */
  441. struct hrtimer real_timer;
  442. struct pid *leader_pid;
  443. ktime_t it_real_incr;
  444. /*
  445. * ITIMER_PROF and ITIMER_VIRTUAL timers for the process, we use
  446. * CPUCLOCK_PROF and CPUCLOCK_VIRT for indexing array as these
  447. * values are defined to 0 and 1 respectively
  448. */
  449. struct cpu_itimer it[2];
  450. /*
  451. * Thread group totals for process CPU timers.
  452. * See thread_group_cputimer(), et al, for details.
  453. */
  454. struct thread_group_cputimer cputimer;
  455. /* Earliest-expiration cache. */
  456. struct task_cputime cputime_expires;
  457. struct list_head cpu_timers[3];
  458. struct pid *tty_old_pgrp;
  459. /* boolean value for session group leader */
  460. int leader;
  461. struct tty_struct *tty; /* NULL if no tty */
  462. #ifdef CONFIG_SCHED_AUTOGROUP
  463. struct autogroup *autogroup;
  464. #endif
  465. /*
  466. * Cumulative resource counters for dead threads in the group,
  467. * and for reaped dead child processes forked by this group.
  468. * Live threads maintain their own counters and add to these
  469. * in __exit_signal, except for the group leader.
  470. */
  471. cputime_t utime, stime, cutime, cstime;
  472. cputime_t gtime;
  473. cputime_t cgtime;
  474. #ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
  475. struct cputime prev_cputime;
  476. #endif
  477. unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
  478. unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
  479. unsigned long inblock, oublock, cinblock, coublock;
  480. unsigned long maxrss, cmaxrss;
  481. struct task_io_accounting ioac;
  482. /*
  483. * Cumulative ns of schedule CPU time fo dead threads in the
  484. * group, not including a zombie group leader, (This only differs
  485. * from jiffies_to_ns(utime + stime) if sched_clock uses something
  486. * other than jiffies.)
  487. */
  488. unsigned long long sum_sched_runtime;
  489. /*
  490. * We don't bother to synchronize most readers of this at all,
  491. * because there is no reader checking a limit that actually needs
  492. * to get both rlim_cur and rlim_max atomically, and either one
  493. * alone is a single word that can safely be read normally.
  494. * getrlimit/setrlimit use task_lock(current->group_leader) to
  495. * protect this instead of the siglock, because they really
  496. * have no need to disable irqs.
  497. */
  498. struct rlimit rlim[RLIM_NLIMITS];
  499. #ifdef CONFIG_BSD_PROCESS_ACCT
  500. struct pacct_struct pacct; /* per-process accounting information */
  501. #endif
  502. #ifdef CONFIG_TASKSTATS
  503. struct taskstats *stats;
  504. #endif
  505. #ifdef CONFIG_AUDIT
  506. unsigned audit_tty;
  507. unsigned audit_tty_log_passwd;
  508. struct tty_audit_buf *tty_audit_buf;
  509. #endif
  510. #ifdef CONFIG_CGROUPS
  511. /*
  512. * group_rwsem prevents new tasks from entering the threadgroup and
  513. * member tasks from exiting,a more specifically, setting of
  514. * PF_EXITING. fork and exit paths are protected with this rwsem
  515. * using threadgroup_change_begin/end(). Users which require
  516. * threadgroup to remain stable should use threadgroup_[un]lock()
  517. * which also takes care of exec path. Currently, cgroup is the
  518. * only user.
  519. */
  520. struct rw_semaphore group_rwsem;
  521. #endif
  522. oom_flags_t oom_flags;
  523. short oom_score_adj; /* OOM kill score adjustment */
  524. short oom_score_adj_min; /* OOM kill score adjustment min value.
  525. * Only settable by CAP_SYS_RESOURCE. */
  526. struct mutex cred_guard_mutex; /* guard against foreign influences on
  527. * credential calculations
  528. * (notably. ptrace) */
  529. };
  530. /*
  531. * Bits in flags field of signal_struct.
  532. */
  533. #define SIGNAL_STOP_STOPPED 0x00000001 /* job control stop in effect */
  534. #define SIGNAL_STOP_CONTINUED 0x00000002 /* SIGCONT since WCONTINUED reap */
  535. #define SIGNAL_GROUP_EXIT 0x00000004 /* group exit in progress */
  536. #define SIGNAL_GROUP_COREDUMP 0x00000008 /* coredump in progress */
  537. /*
  538. * Pending notifications to parent.
  539. */
  540. #define SIGNAL_CLD_STOPPED 0x00000010
  541. #define SIGNAL_CLD_CONTINUED 0x00000020
  542. #define SIGNAL_CLD_MASK (SIGNAL_CLD_STOPPED|SIGNAL_CLD_CONTINUED)
  543. #define SIGNAL_UNKILLABLE 0x00000040 /* for init: ignore fatal signals */
  544. /* If true, all threads except ->group_exit_task have pending SIGKILL */
  545. static inline int signal_group_exit(const struct signal_struct *sig)
  546. {
  547. return (sig->flags & SIGNAL_GROUP_EXIT) ||
  548. (sig->group_exit_task != NULL);
  549. }
  550. /*
  551. * Some day this will be a full-fledged user tracking system..
  552. */
  553. struct user_struct {
  554. atomic_t __count; /* reference count */
  555. atomic_t processes; /* How many processes does this user have? */
  556. atomic_t files; /* How many open files does this user have? */
  557. atomic_t sigpending; /* How many pending signals does this user have? */
  558. #ifdef CONFIG_INOTIFY_USER
  559. atomic_t inotify_watches; /* How many inotify watches does this user have? */
  560. atomic_t inotify_devs; /* How many inotify devs does this user have opened? */
  561. #endif
  562. #ifdef CONFIG_FANOTIFY
  563. atomic_t fanotify_listeners;
  564. #endif
  565. #ifdef CONFIG_EPOLL
  566. atomic_long_t epoll_watches; /* The number of file descriptors currently watched */
  567. #endif
  568. #ifdef CONFIG_POSIX_MQUEUE
  569. /* protected by mq_lock */
  570. unsigned long mq_bytes; /* How many bytes can be allocated to mqueue? */
  571. #endif
  572. unsigned long locked_shm; /* How many pages of mlocked shm ? */
  573. #ifdef CONFIG_KEYS
  574. struct key *uid_keyring; /* UID specific keyring */
  575. struct key *session_keyring; /* UID's default session keyring */
  576. #endif
  577. /* Hash table maintenance information */
  578. struct hlist_node uidhash_node;
  579. kuid_t uid;
  580. #ifdef CONFIG_PERF_EVENTS
  581. atomic_long_t locked_vm;
  582. #endif
  583. };
  584. extern int uids_sysfs_init(void);
  585. extern struct user_struct *find_user(kuid_t);
  586. extern struct user_struct root_user;
  587. #define INIT_USER (&root_user)
  588. struct backing_dev_info;
  589. struct reclaim_state;
  590. #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
  591. struct sched_info {
  592. /* cumulative counters */
  593. unsigned long pcount; /* # of times run on this cpu */
  594. unsigned long long run_delay; /* time spent waiting on a runqueue */
  595. /* timestamps */
  596. unsigned long long last_arrival,/* when we last ran on a cpu */
  597. last_queued; /* when we were last queued to run */
  598. };
  599. #endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */
  600. #ifdef CONFIG_TASK_DELAY_ACCT
  601. struct task_delay_info {
  602. spinlock_t lock;
  603. unsigned int flags; /* Private per-task flags */
  604. /* For each stat XXX, add following, aligned appropriately
  605. *
  606. * struct timespec XXX_start, XXX_end;
  607. * u64 XXX_delay;
  608. * u32 XXX_count;
  609. *
  610. * Atomicity of updates to XXX_delay, XXX_count protected by
  611. * single lock above (split into XXX_lock if contention is an issue).
  612. */
  613. /*
  614. * XXX_count is incremented on every XXX operation, the delay
  615. * associated with the operation is added to XXX_delay.
  616. * XXX_delay contains the accumulated delay time in nanoseconds.
  617. */
  618. struct timespec blkio_start, blkio_end; /* Shared by blkio, swapin */
  619. u64 blkio_delay; /* wait for sync block io completion */
  620. u64 swapin_delay; /* wait for swapin block io completion */
  621. u32 blkio_count; /* total count of the number of sync block */
  622. /* io operations performed */
  623. u32 swapin_count; /* total count of the number of swapin block */
  624. /* io operations performed */
  625. struct timespec freepages_start, freepages_end;
  626. u64 freepages_delay; /* wait for memory reclaim */
  627. u32 freepages_count; /* total count of memory reclaim */
  628. };
  629. #endif /* CONFIG_TASK_DELAY_ACCT */
  630. static inline int sched_info_on(void)
  631. {
  632. #ifdef CONFIG_SCHEDSTATS
  633. return 1;
  634. #elif defined(CONFIG_TASK_DELAY_ACCT)
  635. extern int delayacct_on;
  636. return delayacct_on;
  637. #else
  638. return 0;
  639. #endif
  640. }
  641. enum cpu_idle_type {
  642. CPU_IDLE,
  643. CPU_NOT_IDLE,
  644. CPU_NEWLY_IDLE,
  645. CPU_MAX_IDLE_TYPES
  646. };
  647. /*
  648. * Increase resolution of cpu_power calculations
  649. */
  650. #define SCHED_POWER_SHIFT 10
  651. #define SCHED_POWER_SCALE (1L << SCHED_POWER_SHIFT)
  652. /*
  653. * sched-domains (multiprocessor balancing) declarations:
  654. */
  655. #ifdef CONFIG_SMP
  656. #define SD_LOAD_BALANCE 0x0001 /* Do load balancing on this domain. */
  657. #define SD_BALANCE_NEWIDLE 0x0002 /* Balance when about to become idle */
  658. #define SD_BALANCE_EXEC 0x0004 /* Balance on exec */
  659. #define SD_BALANCE_FORK 0x0008 /* Balance on fork, clone */
  660. #define SD_BALANCE_WAKE 0x0010 /* Balance on wakeup */
  661. #define SD_WAKE_AFFINE 0x0020 /* Wake task to waking CPU */
  662. #define SD_SHARE_CPUPOWER 0x0080 /* Domain members share cpu power */
  663. #define SD_SHARE_PKG_RESOURCES 0x0200 /* Domain members share cpu pkg resources */
  664. #define SD_SERIALIZE 0x0400 /* Only a single load balancing instance */
  665. #define SD_ASYM_PACKING 0x0800 /* Place busy groups earlier in the domain */
  666. #define SD_PREFER_SIBLING 0x1000 /* Prefer to place tasks in a sibling domain */
  667. #define SD_OVERLAP 0x2000 /* sched_domains of this level overlap */
  668. #define SD_NUMA 0x4000 /* cross-node balancing */
  669. extern int __weak arch_sd_sibiling_asym_packing(void);
  670. struct sched_domain_attr {
  671. int relax_domain_level;
  672. };
  673. #define SD_ATTR_INIT (struct sched_domain_attr) { \
  674. .relax_domain_level = -1, \
  675. }
  676. extern int sched_domain_level_max;
  677. struct sched_group;
  678. struct sched_domain {
  679. /* These fields must be setup */
  680. struct sched_domain *parent; /* top domain must be null terminated */
  681. struct sched_domain *child; /* bottom domain must be null terminated */
  682. struct sched_group *groups; /* the balancing groups of the domain */
  683. unsigned long min_interval; /* Minimum balance interval ms */
  684. unsigned long max_interval; /* Maximum balance interval ms */
  685. unsigned int busy_factor; /* less balancing by factor if busy */
  686. unsigned int imbalance_pct; /* No balance until over watermark */
  687. unsigned int cache_nice_tries; /* Leave cache hot tasks for # tries */
  688. unsigned int busy_idx;
  689. unsigned int idle_idx;
  690. unsigned int newidle_idx;
  691. unsigned int wake_idx;
  692. unsigned int forkexec_idx;
  693. unsigned int smt_gain;
  694. int nohz_idle; /* NOHZ IDLE status */
  695. int flags; /* See SD_* */
  696. int level;
  697. /* Runtime fields. */
  698. unsigned long last_balance; /* init to jiffies. units in jiffies */
  699. unsigned int balance_interval; /* initialise to 1. units in ms. */
  700. unsigned int nr_balance_failed; /* initialise to 0 */
  701. /* idle_balance() stats */
  702. u64 max_newidle_lb_cost;
  703. unsigned long next_decay_max_lb_cost;
  704. #ifdef CONFIG_SCHEDSTATS
  705. /* load_balance() stats */
  706. unsigned int lb_count[CPU_MAX_IDLE_TYPES];
  707. unsigned int lb_failed[CPU_MAX_IDLE_TYPES];
  708. unsigned int lb_balanced[CPU_MAX_IDLE_TYPES];
  709. unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES];
  710. unsigned int lb_gained[CPU_MAX_IDLE_TYPES];
  711. unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES];
  712. unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES];
  713. unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES];
  714. /* Active load balancing */
  715. unsigned int alb_count;
  716. unsigned int alb_failed;
  717. unsigned int alb_pushed;
  718. /* SD_BALANCE_EXEC stats */
  719. unsigned int sbe_count;
  720. unsigned int sbe_balanced;
  721. unsigned int sbe_pushed;
  722. /* SD_BALANCE_FORK stats */
  723. unsigned int sbf_count;
  724. unsigned int sbf_balanced;
  725. unsigned int sbf_pushed;
  726. /* try_to_wake_up() stats */
  727. unsigned int ttwu_wake_remote;
  728. unsigned int ttwu_move_affine;
  729. unsigned int ttwu_move_balance;
  730. #endif
  731. #ifdef CONFIG_SCHED_DEBUG
  732. char *name;
  733. #endif
  734. union {
  735. void *private; /* used during construction */
  736. struct rcu_head rcu; /* used during destruction */
  737. };
  738. unsigned int span_weight;
  739. /*
  740. * Span of all CPUs in this domain.
  741. *
  742. * NOTE: this field is variable length. (Allocated dynamically
  743. * by attaching extra space to the end of the structure,
  744. * depending on how many CPUs the kernel has booted up with)
  745. */
  746. unsigned long span[0];
  747. };
  748. static inline struct cpumask *sched_domain_span(struct sched_domain *sd)
  749. {
  750. return to_cpumask(sd->span);
  751. }
  752. extern void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
  753. struct sched_domain_attr *dattr_new);
  754. /* Allocate an array of sched domains, for partition_sched_domains(). */
  755. cpumask_var_t *alloc_sched_domains(unsigned int ndoms);
  756. void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms);
  757. bool cpus_share_cache(int this_cpu, int that_cpu);
  758. #else /* CONFIG_SMP */
  759. struct sched_domain_attr;
  760. static inline void
  761. partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
  762. struct sched_domain_attr *dattr_new)
  763. {
  764. }
  765. static inline bool cpus_share_cache(int this_cpu, int that_cpu)
  766. {
  767. return true;
  768. }
  769. #endif /* !CONFIG_SMP */
  770. struct io_context; /* See blkdev.h */
  771. #ifdef ARCH_HAS_PREFETCH_SWITCH_STACK
  772. extern void prefetch_stack(struct task_struct *t);
  773. #else
  774. static inline void prefetch_stack(struct task_struct *t) { }
  775. #endif
  776. struct audit_context; /* See audit.c */
  777. struct mempolicy;
  778. struct pipe_inode_info;
  779. struct uts_namespace;
  780. struct load_weight {
  781. unsigned long weight, inv_weight;
  782. };
  783. struct sched_avg {
  784. /*
  785. * These sums represent an infinite geometric series and so are bound
  786. * above by 1024/(1-y). Thus we only need a u32 to store them for all
  787. * choices of y < 1-2^(-32)*1024.
  788. */
  789. u32 runnable_avg_sum, runnable_avg_period;
  790. u64 last_runnable_update;
  791. s64 decay_count;
  792. unsigned long load_avg_contrib;
  793. };
  794. #ifdef CONFIG_SCHEDSTATS
  795. struct sched_statistics {
  796. u64 wait_start;
  797. u64 wait_max;
  798. u64 wait_count;
  799. u64 wait_sum;
  800. u64 iowait_count;
  801. u64 iowait_sum;
  802. u64 sleep_start;
  803. u64 sleep_max;
  804. s64 sum_sleep_runtime;
  805. u64 block_start;
  806. u64 block_max;
  807. u64 exec_max;
  808. u64 slice_max;
  809. u64 nr_migrations_cold;
  810. u64 nr_failed_migrations_affine;
  811. u64 nr_failed_migrations_running;
  812. u64 nr_failed_migrations_hot;
  813. u64 nr_forced_migrations;
  814. u64 nr_wakeups;
  815. u64 nr_wakeups_sync;
  816. u64 nr_wakeups_migrate;
  817. u64 nr_wakeups_local;
  818. u64 nr_wakeups_remote;
  819. u64 nr_wakeups_affine;
  820. u64 nr_wakeups_affine_attempts;
  821. u64 nr_wakeups_passive;
  822. u64 nr_wakeups_idle;
  823. };
  824. #endif
  825. struct sched_entity {
  826. struct load_weight load; /* for load-balancing */
  827. struct rb_node run_node;
  828. struct list_head group_node;
  829. unsigned int on_rq;
  830. u64 exec_start;
  831. u64 sum_exec_runtime;
  832. u64 vruntime;
  833. u64 prev_sum_exec_runtime;
  834. u64 nr_migrations;
  835. #ifdef CONFIG_SCHEDSTATS
  836. struct sched_statistics statistics;
  837. #endif
  838. #ifdef CONFIG_FAIR_GROUP_SCHED
  839. struct sched_entity *parent;
  840. /* rq on which this entity is (to be) queued: */
  841. struct cfs_rq *cfs_rq;
  842. /* rq "owned" by this entity/group: */
  843. struct cfs_rq *my_q;
  844. #endif
  845. #ifdef CONFIG_SMP
  846. /* Per-entity load-tracking */
  847. struct sched_avg avg;
  848. #endif
  849. };
  850. struct sched_rt_entity {
  851. struct list_head run_list;
  852. unsigned long timeout;
  853. unsigned long watchdog_stamp;
  854. unsigned int time_slice;
  855. struct sched_rt_entity *back;
  856. #ifdef CONFIG_RT_GROUP_SCHED
  857. struct sched_rt_entity *parent;
  858. /* rq on which this entity is (to be) queued: */
  859. struct rt_rq *rt_rq;
  860. /* rq "owned" by this entity/group: */
  861. struct rt_rq *my_q;
  862. #endif
  863. };
  864. struct rcu_node;
  865. enum perf_event_task_context {
  866. perf_invalid_context = -1,
  867. perf_hw_context = 0,
  868. perf_sw_context,
  869. perf_nr_task_contexts,
  870. };
  871. struct task_struct {
  872. volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */
  873. void *stack;
  874. atomic_t usage;
  875. unsigned int flags; /* per process flags, defined below */
  876. unsigned int ptrace;
  877. #ifdef CONFIG_SMP
  878. struct llist_node wake_entry;
  879. int on_cpu;
  880. struct task_struct *last_wakee;
  881. unsigned long wakee_flips;
  882. unsigned long wakee_flip_decay_ts;
  883. int wake_cpu;
  884. #endif
  885. int on_rq;
  886. int prio, static_prio, normal_prio;
  887. unsigned int rt_priority;
  888. const struct sched_class *sched_class;
  889. struct sched_entity se;
  890. struct sched_rt_entity rt;
  891. #ifdef CONFIG_CGROUP_SCHED
  892. struct task_group *sched_task_group;
  893. #endif
  894. #ifdef CONFIG_PREEMPT_NOTIFIERS
  895. /* list of struct preempt_notifier: */
  896. struct hlist_head preempt_notifiers;
  897. #endif
  898. #ifdef CONFIG_BLK_DEV_IO_TRACE
  899. unsigned int btrace_seq;
  900. #endif
  901. unsigned int policy;
  902. int nr_cpus_allowed;
  903. cpumask_t cpus_allowed;
  904. #ifdef CONFIG_PREEMPT_RCU
  905. int rcu_read_lock_nesting;
  906. char rcu_read_unlock_special;
  907. struct list_head rcu_node_entry;
  908. #endif /* #ifdef CONFIG_PREEMPT_RCU */
  909. #ifdef CONFIG_TREE_PREEMPT_RCU
  910. struct rcu_node *rcu_blocked_node;
  911. #endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
  912. #ifdef CONFIG_RCU_BOOST
  913. struct rt_mutex *rcu_boost_mutex;
  914. #endif /* #ifdef CONFIG_RCU_BOOST */
  915. #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
  916. struct sched_info sched_info;
  917. #endif
  918. struct list_head tasks;
  919. #ifdef CONFIG_SMP
  920. struct plist_node pushable_tasks;
  921. #endif
  922. struct mm_struct *mm, *active_mm;
  923. #ifdef CONFIG_COMPAT_BRK
  924. unsigned brk_randomized:1;
  925. #endif
  926. #if defined(SPLIT_RSS_COUNTING)
  927. struct task_rss_stat rss_stat;
  928. #endif
  929. /* task state */
  930. int exit_state;
  931. int exit_code, exit_signal;
  932. int pdeath_signal; /* The signal sent when the parent dies */
  933. unsigned int jobctl; /* JOBCTL_*, siglock protected */
  934. /* Used for emulating ABI behavior of previous Linux versions */
  935. unsigned int personality;
  936. unsigned did_exec:1;
  937. unsigned in_execve:1; /* Tell the LSMs that the process is doing an
  938. * execve */
  939. unsigned in_iowait:1;
  940. /* task may not gain privileges */
  941. unsigned no_new_privs:1;
  942. /* Revert to default priority/policy when forking */
  943. unsigned sched_reset_on_fork:1;
  944. unsigned sched_contributes_to_load:1;
  945. pid_t pid;
  946. pid_t tgid;
  947. #ifdef CONFIG_CC_STACKPROTECTOR
  948. /* Canary value for the -fstack-protector gcc feature */
  949. unsigned long stack_canary;
  950. #endif
  951. /*
  952. * pointers to (original) parent process, youngest child, younger sibling,
  953. * older sibling, respectively. (p->father can be replaced with
  954. * p->real_parent->pid)
  955. */
  956. struct task_struct __rcu *real_parent; /* real parent process */
  957. struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */
  958. /*
  959. * children/sibling forms the list of my natural children
  960. */
  961. struct list_head children; /* list of my children */
  962. struct list_head sibling; /* linkage in my parent's children list */
  963. struct task_struct *group_leader; /* threadgroup leader */
  964. /*
  965. * ptraced is the list of tasks this task is using ptrace on.
  966. * This includes both natural children and PTRACE_ATTACH targets.
  967. * p->ptrace_entry is p's link on the p->parent->ptraced list.
  968. */
  969. struct list_head ptraced;
  970. struct list_head ptrace_entry;
  971. /* PID/PID hash table linkage. */
  972. struct pid_link pids[PIDTYPE_MAX];
  973. struct list_head thread_group;
  974. struct completion *vfork_done; /* for vfork() */
  975. int __user *set_child_tid; /* CLONE_CHILD_SETTID */
  976. int __user *clear_child_tid; /* CLONE_CHILD_CLEARTID */
  977. cputime_t utime, stime, utimescaled, stimescaled;
  978. cputime_t gtime;
  979. #ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
  980. struct cputime prev_cputime;
  981. #endif
  982. #ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
  983. seqlock_t vtime_seqlock;
  984. unsigned long long vtime_snap;
  985. enum {
  986. VTIME_SLEEPING = 0,
  987. VTIME_USER,
  988. VTIME_SYS,
  989. } vtime_snap_whence;
  990. #endif
  991. unsigned long nvcsw, nivcsw; /* context switch counts */
  992. struct timespec start_time; /* monotonic time */
  993. struct timespec real_start_time; /* boot based time */
  994. /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
  995. unsigned long min_flt, maj_flt;
  996. struct task_cputime cputime_expires;
  997. struct list_head cpu_timers[3];
  998. /* process credentials */
  999. const struct cred __rcu *real_cred; /* objective and real subjective task
  1000. * credentials (COW) */
  1001. const struct cred __rcu *cred; /* effective (overridable) subjective task
  1002. * credentials (COW) */
  1003. char comm[TASK_COMM_LEN]; /* executable name excluding path
  1004. - access with [gs]et_task_comm (which lock
  1005. it with task_lock())
  1006. - initialized normally by setup_new_exec */
  1007. /* file system info */
  1008. int link_count, total_link_count;
  1009. #ifdef CONFIG_SYSVIPC
  1010. /* ipc stuff */
  1011. struct sysv_sem sysvsem;
  1012. #endif
  1013. #ifdef CONFIG_DETECT_HUNG_TASK
  1014. /* hung task detection */
  1015. unsigned long last_switch_count;
  1016. #endif
  1017. /* CPU-specific state of this task */
  1018. struct thread_struct thread;
  1019. /* filesystem information */
  1020. struct fs_struct *fs;
  1021. /* open file information */
  1022. struct files_struct *files;
  1023. /* namespaces */
  1024. struct nsproxy *nsproxy;
  1025. /* signal handlers */
  1026. struct signal_struct *signal;
  1027. struct sighand_struct *sighand;
  1028. sigset_t blocked, real_blocked;
  1029. sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */
  1030. struct sigpending pending;
  1031. unsigned long sas_ss_sp;
  1032. size_t sas_ss_size;
  1033. int (*notifier)(void *priv);
  1034. void *notifier_data;
  1035. sigset_t *notifier_mask;
  1036. struct callback_head *task_works;
  1037. struct audit_context *audit_context;
  1038. #ifdef CONFIG_AUDITSYSCALL
  1039. kuid_t loginuid;
  1040. unsigned int sessionid;
  1041. #endif
  1042. struct seccomp seccomp;
  1043. /* Thread group tracking */
  1044. u32 parent_exec_id;
  1045. u32 self_exec_id;
  1046. /* Protection of (de-)allocation: mm, files, fs, tty, keyrings, mems_allowed,
  1047. * mempolicy */
  1048. spinlock_t alloc_lock;
  1049. /* Protection of the PI data structures: */
  1050. raw_spinlock_t pi_lock;
  1051. #ifdef CONFIG_RT_MUTEXES
  1052. /* PI waiters blocked on a rt_mutex held by this task */
  1053. struct plist_head pi_waiters;
  1054. /* Deadlock detection and priority inheritance handling */
  1055. struct rt_mutex_waiter *pi_blocked_on;
  1056. #endif
  1057. #ifdef CONFIG_DEBUG_MUTEXES
  1058. /* mutex deadlock detection */
  1059. struct mutex_waiter *blocked_on;
  1060. #endif
  1061. #ifdef CONFIG_TRACE_IRQFLAGS
  1062. unsigned int irq_events;
  1063. unsigned long hardirq_enable_ip;
  1064. unsigned long hardirq_disable_ip;
  1065. unsigned int hardirq_enable_event;
  1066. unsigned int hardirq_disable_event;
  1067. int hardirqs_enabled;
  1068. int hardirq_context;
  1069. unsigned long softirq_disable_ip;
  1070. unsigned long softirq_enable_ip;
  1071. unsigned int softirq_disable_event;
  1072. unsigned int softirq_enable_event;
  1073. int softirqs_enabled;
  1074. int softirq_context;
  1075. #endif
  1076. #ifdef CONFIG_LOCKDEP
  1077. # define MAX_LOCK_DEPTH 48UL
  1078. u64 curr_chain_key;
  1079. int lockdep_depth;
  1080. unsigned int lockdep_recursion;
  1081. struct held_lock held_locks[MAX_LOCK_DEPTH];
  1082. gfp_t lockdep_reclaim_gfp;
  1083. #endif
  1084. /* journalling filesystem info */
  1085. void *journal_info;
  1086. /* stacked block device info */
  1087. struct bio_list *bio_list;
  1088. #ifdef CONFIG_BLOCK
  1089. /* stack plugging */
  1090. struct blk_plug *plug;
  1091. #endif
  1092. /* VM state */
  1093. struct reclaim_state *reclaim_state;
  1094. struct backing_dev_info *backing_dev_info;
  1095. struct io_context *io_context;
  1096. unsigned long ptrace_message;
  1097. siginfo_t *last_siginfo; /* For ptrace use. */
  1098. struct task_io_accounting ioac;
  1099. #if defined(CONFIG_TASK_XACCT)
  1100. u64 acct_rss_mem1; /* accumulated rss usage */
  1101. u64 acct_vm_mem1; /* accumulated virtual memory usage */
  1102. cputime_t acct_timexpd; /* stime + utime since last update */
  1103. #endif
  1104. #ifdef CONFIG_CPUSETS
  1105. nodemask_t mems_allowed; /* Protected by alloc_lock */
  1106. seqcount_t mems_allowed_seq; /* Seqence no to catch updates */
  1107. int cpuset_mem_spread_rotor;
  1108. int cpuset_slab_spread_rotor;
  1109. #endif
  1110. #ifdef CONFIG_CGROUPS
  1111. /* Control Group info protected by css_set_lock */
  1112. struct css_set __rcu *cgroups;
  1113. /* cg_list protected by css_set_lock and tsk->alloc_lock */
  1114. struct list_head cg_list;
  1115. #endif
  1116. #ifdef CONFIG_FUTEX
  1117. struct robust_list_head __user *robust_list;
  1118. #ifdef CONFIG_COMPAT
  1119. struct compat_robust_list_head __user *compat_robust_list;
  1120. #endif
  1121. struct list_head pi_state_list;
  1122. struct futex_pi_state *pi_state_cache;
  1123. #endif
  1124. #ifdef CONFIG_PERF_EVENTS
  1125. struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts];
  1126. struct mutex perf_event_mutex;
  1127. struct list_head perf_event_list;
  1128. #endif
  1129. #ifdef CONFIG_NUMA
  1130. struct mempolicy *mempolicy; /* Protected by alloc_lock */
  1131. short il_next;
  1132. short pref_node_fork;
  1133. #endif
  1134. #ifdef CONFIG_NUMA_BALANCING
  1135. int numa_scan_seq;
  1136. unsigned int numa_scan_period;
  1137. unsigned int numa_scan_period_max;
  1138. int numa_preferred_nid;
  1139. int numa_migrate_deferred;
  1140. unsigned long numa_migrate_retry;
  1141. u64 node_stamp; /* migration stamp */
  1142. struct callback_head numa_work;
  1143. struct list_head numa_entry;
  1144. struct numa_group *numa_group;
  1145. /*
  1146. * Exponential decaying average of faults on a per-node basis.
  1147. * Scheduling placement decisions are made based on the these counts.
  1148. * The values remain static for the duration of a PTE scan
  1149. */
  1150. unsigned long *numa_faults;
  1151. unsigned long total_numa_faults;
  1152. /*
  1153. * numa_faults_buffer records faults per node during the current
  1154. * scan window. When the scan completes, the counts in numa_faults
  1155. * decay and these values are copied.
  1156. */
  1157. unsigned long *numa_faults_buffer;
  1158. /*
  1159. * numa_faults_locality tracks if faults recorded during the last
  1160. * scan window were remote/local. The task scan period is adapted
  1161. * based on the locality of the faults with different weights
  1162. * depending on whether they were shared or private faults
  1163. */
  1164. unsigned long numa_faults_locality[2];
  1165. unsigned long numa_pages_migrated;
  1166. #endif /* CONFIG_NUMA_BALANCING */
  1167. struct rcu_head rcu;
  1168. /*
  1169. * cache last used pipe for splice
  1170. */
  1171. struct pipe_inode_info *splice_pipe;
  1172. struct page_frag task_frag;
  1173. #ifdef CONFIG_TASK_DELAY_ACCT
  1174. struct task_delay_info *delays;
  1175. #endif
  1176. #ifdef CONFIG_FAULT_INJECTION
  1177. int make_it_fail;
  1178. #endif
  1179. /*
  1180. * when (nr_dirtied >= nr_dirtied_pause), it's time to call
  1181. * balance_dirty_pages() for some dirty throttling pause
  1182. */
  1183. int nr_dirtied;
  1184. int nr_dirtied_pause;
  1185. unsigned long dirty_paused_when; /* start of a write-and-pause period */
  1186. #ifdef CONFIG_LATENCYTOP
  1187. int latency_record_count;
  1188. struct latency_record latency_record[LT_SAVECOUNT];
  1189. #endif
  1190. /*
  1191. * time slack values; these are used to round up poll() and
  1192. * select() etc timeout values. These are in nanoseconds.
  1193. */
  1194. unsigned long timer_slack_ns;
  1195. unsigned long default_timer_slack_ns;
  1196. #ifdef CONFIG_FUNCTION_GRAPH_TRACER
  1197. /* Index of current stored address in ret_stack */
  1198. int curr_ret_stack;
  1199. /* Stack of return addresses for return function tracing */
  1200. struct ftrace_ret_stack *ret_stack;
  1201. /* time stamp for last schedule */
  1202. unsigned long long ftrace_timestamp;
  1203. /*
  1204. * Number of functions that haven't been traced
  1205. * because of depth overrun.
  1206. */
  1207. atomic_t trace_overrun;
  1208. /* Pause for the tracing */
  1209. atomic_t tracing_graph_pause;
  1210. #endif
  1211. #ifdef CONFIG_TRACING
  1212. /* state flags for use by tracers */
  1213. unsigned long trace;
  1214. /* bitmask and counter of trace recursion */
  1215. unsigned long trace_recursion;
  1216. #endif /* CONFIG_TRACING */
  1217. #ifdef CONFIG_MEMCG /* memcg uses this to do batch job */
  1218. struct memcg_batch_info {
  1219. int do_batch; /* incremented when batch uncharge started */
  1220. struct mem_cgroup *memcg; /* target memcg of uncharge */
  1221. unsigned long nr_pages; /* uncharged usage */
  1222. unsigned long memsw_nr_pages; /* uncharged mem+swap usage */
  1223. } memcg_batch;
  1224. unsigned int memcg_kmem_skip_account;
  1225. struct memcg_oom_info {
  1226. struct mem_cgroup *memcg;
  1227. gfp_t gfp_mask;
  1228. int order;
  1229. unsigned int may_oom:1;
  1230. } memcg_oom;
  1231. #endif
  1232. #ifdef CONFIG_UPROBES
  1233. struct uprobe_task *utask;
  1234. #endif
  1235. #if defined(CONFIG_BCACHE) || defined(CONFIG_BCACHE_MODULE)
  1236. unsigned int sequential_io;
  1237. unsigned int sequential_io_avg;
  1238. #endif
  1239. };
  1240. /* Future-safe accessor for struct task_struct's cpus_allowed. */
  1241. #define tsk_cpus_allowed(tsk) (&(tsk)->cpus_allowed)
  1242. #define TNF_MIGRATED 0x01
  1243. #define TNF_NO_GROUP 0x02
  1244. #define TNF_SHARED 0x04
  1245. #define TNF_FAULT_LOCAL 0x08
  1246. #ifdef CONFIG_NUMA_BALANCING
  1247. extern void task_numa_fault(int last_node, int node, int pages, int flags);
  1248. extern pid_t task_numa_group_id(struct task_struct *p);
  1249. extern void set_numabalancing_state(bool enabled);
  1250. extern void task_numa_free(struct task_struct *p);
  1251. extern unsigned int sysctl_numa_balancing_migrate_deferred;
  1252. #else
  1253. static inline void task_numa_fault(int last_node, int node, int pages,
  1254. int flags)
  1255. {
  1256. }
  1257. static inline pid_t task_numa_group_id(struct task_struct *p)
  1258. {
  1259. return 0;
  1260. }
  1261. static inline void set_numabalancing_state(bool enabled)
  1262. {
  1263. }
  1264. static inline void task_numa_free(struct task_struct *p)
  1265. {
  1266. }
  1267. #endif
  1268. static inline struct pid *task_pid(struct task_struct *task)
  1269. {
  1270. return task->pids[PIDTYPE_PID].pid;
  1271. }
  1272. static inline struct pid *task_tgid(struct task_struct *task)
  1273. {
  1274. return task->group_leader->pids[PIDTYPE_PID].pid;
  1275. }
  1276. /*
  1277. * Without tasklist or rcu lock it is not safe to dereference
  1278. * the result of task_pgrp/task_session even if task == current,
  1279. * we can race with another thread doing sys_setsid/sys_setpgid.
  1280. */
  1281. static inline struct pid *task_pgrp(struct task_struct *task)
  1282. {
  1283. return task->group_leader->pids[PIDTYPE_PGID].pid;
  1284. }
  1285. static inline struct pid *task_session(struct task_struct *task)
  1286. {
  1287. return task->group_leader->pids[PIDTYPE_SID].pid;
  1288. }
  1289. struct pid_namespace;
  1290. /*
  1291. * the helpers to get the task's different pids as they are seen
  1292. * from various namespaces
  1293. *
  1294. * task_xid_nr() : global id, i.e. the id seen from the init namespace;
  1295. * task_xid_vnr() : virtual id, i.e. the id seen from the pid namespace of
  1296. * current.
  1297. * task_xid_nr_ns() : id seen from the ns specified;
  1298. *
  1299. * set_task_vxid() : assigns a virtual id to a task;
  1300. *
  1301. * see also pid_nr() etc in include/linux/pid.h
  1302. */
  1303. pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type,
  1304. struct pid_namespace *ns);
  1305. static inline pid_t task_pid_nr(struct task_struct *tsk)
  1306. {
  1307. return tsk->pid;
  1308. }
  1309. static inline pid_t task_pid_nr_ns(struct task_struct *tsk,
  1310. struct pid_namespace *ns)
  1311. {
  1312. return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);
  1313. }
  1314. static inline pid_t task_pid_vnr(struct task_struct *tsk)
  1315. {
  1316. return __task_pid_nr_ns(tsk, PIDTYPE_PID, NULL);
  1317. }
  1318. static inline pid_t task_tgid_nr(struct task_struct *tsk)
  1319. {
  1320. return tsk->tgid;
  1321. }
  1322. pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
  1323. static inline pid_t task_tgid_vnr(struct task_struct *tsk)
  1324. {
  1325. return pid_vnr(task_tgid(tsk));
  1326. }
  1327. static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk,
  1328. struct pid_namespace *ns)
  1329. {
  1330. return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns);
  1331. }
  1332. static inline pid_t task_pgrp_vnr(struct task_struct *tsk)
  1333. {
  1334. return __task_pid_nr_ns(tsk, PIDTYPE_PGID, NULL);
  1335. }
  1336. static inline pid_t task_session_nr_ns(struct task_struct *tsk,
  1337. struct pid_namespace *ns)
  1338. {
  1339. return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns);
  1340. }
  1341. static inline pid_t task_session_vnr(struct task_struct *tsk)
  1342. {
  1343. return __task_pid_nr_ns(tsk, PIDTYPE_SID, NULL);
  1344. }
  1345. /* obsolete, do not use */
  1346. static inline pid_t task_pgrp_nr(struct task_struct *tsk)
  1347. {
  1348. return task_pgrp_nr_ns(tsk, &init_pid_ns);
  1349. }
  1350. /**
  1351. * pid_alive - check that a task structure is not stale
  1352. * @p: Task structure to be checked.
  1353. *
  1354. * Test if a process is not yet dead (at most zombie state)
  1355. * If pid_alive fails, then pointers within the task structure
  1356. * can be stale and must not be dereferenced.
  1357. *
  1358. * Return: 1 if the process is alive. 0 otherwise.
  1359. */
  1360. static inline int pid_alive(struct task_struct *p)
  1361. {
  1362. return p->pids[PIDTYPE_PID].pid != NULL;
  1363. }
  1364. /**
  1365. * is_global_init - check if a task structure is init
  1366. * @tsk: Task structure to be checked.
  1367. *
  1368. * Check if a task structure is the first user space task the kernel created.
  1369. *
  1370. * Return: 1 if the task structure is init. 0 otherwise.
  1371. */
  1372. static inline int is_global_init(struct task_struct *tsk)
  1373. {
  1374. return tsk->pid == 1;
  1375. }
  1376. extern struct pid *cad_pid;
  1377. extern void free_task(struct task_struct *tsk);
  1378. #define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
  1379. extern void __put_task_struct(struct task_struct *t);
  1380. static inline void put_task_struct(struct task_struct *t)
  1381. {
  1382. if (atomic_dec_and_test(&t->usage))
  1383. __put_task_struct(t);
  1384. }
  1385. #ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
  1386. extern void task_cputime(struct task_struct *t,
  1387. cputime_t *utime, cputime_t *stime);
  1388. extern void task_cputime_scaled(struct task_struct *t,
  1389. cputime_t *utimescaled, cputime_t *stimescaled);
  1390. extern cputime_t task_gtime(struct task_struct *t);
  1391. #else
  1392. static inline void task_cputime(struct task_struct *t,
  1393. cputime_t *utime, cputime_t *stime)
  1394. {
  1395. if (utime)
  1396. *utime = t->utime;
  1397. if (stime)
  1398. *stime = t->stime;
  1399. }
  1400. static inline void task_cputime_scaled(struct task_struct *t,
  1401. cputime_t *utimescaled,
  1402. cputime_t *stimescaled)
  1403. {
  1404. if (utimescaled)
  1405. *utimescaled = t->utimescaled;
  1406. if (stimescaled)
  1407. *stimescaled = t->stimescaled;
  1408. }
  1409. static inline cputime_t task_gtime(struct task_struct *t)
  1410. {
  1411. return t->gtime;
  1412. }
  1413. #endif
  1414. extern void task_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);
  1415. extern void thread_group_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);
  1416. /*
  1417. * Per process flags
  1418. */
  1419. #define PF_EXITING 0x00000004 /* getting shut down */
  1420. #define PF_EXITPIDONE 0x00000008 /* pi exit done on shut down */
  1421. #define PF_VCPU 0x00000010 /* I'm a virtual CPU */
  1422. #define PF_WQ_WORKER 0x00000020 /* I'm a workqueue worker */
  1423. #define PF_FORKNOEXEC 0x00000040 /* forked but didn't exec */
  1424. #define PF_MCE_PROCESS 0x00000080 /* process policy on mce errors */
  1425. #define PF_SUPERPRIV 0x00000100 /* used super-user privileges */
  1426. #define PF_DUMPCORE 0x00000200 /* dumped core */
  1427. #define PF_SIGNALED 0x00000400 /* killed by a signal */
  1428. #define PF_MEMALLOC 0x00000800 /* Allocating memory */
  1429. #define PF_NPROC_EXCEEDED 0x00001000 /* set_user noticed that RLIMIT_NPROC was exceeded */
  1430. #define PF_USED_MATH 0x00002000 /* if unset the fpu must be initialized before use */
  1431. #define PF_USED_ASYNC 0x00004000 /* used async_schedule*(), used by module init */
  1432. #define PF_NOFREEZE 0x00008000 /* this thread should not be frozen */
  1433. #define PF_FROZEN 0x00010000 /* frozen for system suspend */
  1434. #define PF_FSTRANS 0x00020000 /* inside a filesystem transaction */
  1435. #define PF_KSWAPD 0x00040000 /* I am kswapd */
  1436. #define PF_MEMALLOC_NOIO 0x00080000 /* Allocating memory without IO involved */
  1437. #define PF_LESS_THROTTLE 0x00100000 /* Throttle me less: I clean memory */
  1438. #define PF_KTHREAD 0x00200000 /* I am a kernel thread */
  1439. #define PF_RANDOMIZE 0x00400000 /* randomize virtual address space */
  1440. #define PF_SWAPWRITE 0x00800000 /* Allowed to write to swap */
  1441. #define PF_SPREAD_PAGE 0x01000000 /* Spread page cache over cpuset */
  1442. #define PF_SPREAD_SLAB 0x02000000 /* Spread some slab caches over cpuset */
  1443. #define PF_NO_SETAFFINITY 0x04000000 /* Userland is not allowed to meddle with cpus_allowed */
  1444. #define PF_MCE_EARLY 0x08000000 /* Early kill for mce process policy */
  1445. #define PF_MEMPOLICY 0x10000000 /* Non-default NUMA mempolicy */
  1446. #define PF_MUTEX_TESTER 0x20000000 /* Thread belongs to the rt mutex tester */
  1447. #define PF_FREEZER_SKIP 0x40000000 /* Freezer should not count it as freezable */
  1448. #define PF_SUSPEND_TASK 0x80000000 /* this thread called freeze_processes and should not be frozen */
  1449. /*
  1450. * Only the _current_ task can read/write to tsk->flags, but other
  1451. * tasks can access tsk->flags in readonly mode for example
  1452. * with tsk_used_math (like during threaded core dumping).
  1453. * There is however an exception to this rule during ptrace
  1454. * or during fork: the ptracer task is allowed to write to the
  1455. * child->flags of its traced child (same goes for fork, the parent
  1456. * can write to the child->flags), because we're guaranteed the
  1457. * child is not running and in turn not changing child->flags
  1458. * at the same time the parent does it.
  1459. */
  1460. #define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)
  1461. #define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)
  1462. #define clear_used_math() clear_stopped_child_used_math(current)
  1463. #define set_used_math() set_stopped_child_used_math(current)
  1464. #define conditional_stopped_child_used_math(condition, child) \
  1465. do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)
  1466. #define conditional_used_math(condition) \
  1467. conditional_stopped_child_used_math(condition, current)
  1468. #define copy_to_stopped_child_used_math(child) \
  1469. do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)
  1470. /* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */
  1471. #define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
  1472. #define used_math() tsk_used_math(current)
  1473. /* __GFP_IO isn't allowed if PF_MEMALLOC_NOIO is set in current->flags */
  1474. static inline gfp_t memalloc_noio_flags(gfp_t flags)
  1475. {
  1476. if (unlikely(current->flags & PF_MEMALLOC_NOIO))
  1477. flags &= ~__GFP_IO;
  1478. return flags;
  1479. }
  1480. static inline unsigned int memalloc_noio_save(void)
  1481. {
  1482. unsigned int flags = current->flags & PF_MEMALLOC_NOIO;
  1483. current->flags |= PF_MEMALLOC_NOIO;
  1484. return flags;
  1485. }
  1486. static inline void memalloc_noio_restore(unsigned int flags)
  1487. {
  1488. current->flags = (current->flags & ~PF_MEMALLOC_NOIO) | flags;
  1489. }
  1490. /*
  1491. * task->jobctl flags
  1492. */
  1493. #define JOBCTL_STOP_SIGMASK 0xffff /* signr of the last group stop */
  1494. #define JOBCTL_STOP_DEQUEUED_BIT 16 /* stop signal dequeued */
  1495. #define JOBCTL_STOP_PENDING_BIT 17 /* task should stop for group stop */
  1496. #define JOBCTL_STOP_CONSUME_BIT 18 /* consume group stop count */
  1497. #define JOBCTL_TRAP_STOP_BIT 19 /* trap for STOP */
  1498. #define JOBCTL_TRAP_NOTIFY_BIT 20 /* trap for NOTIFY */
  1499. #define JOBCTL_TRAPPING_BIT 21 /* switching to TRACED */
  1500. #define JOBCTL_LISTENING_BIT 22 /* ptracer is listening for events */
  1501. #define JOBCTL_STOP_DEQUEUED (1 << JOBCTL_STOP_DEQUEUED_BIT)
  1502. #define JOBCTL_STOP_PENDING (1 << JOBCTL_STOP_PENDING_BIT)
  1503. #define JOBCTL_STOP_CONSUME (1 << JOBCTL_STOP_CONSUME_BIT)
  1504. #define JOBCTL_TRAP_STOP (1 << JOBCTL_TRAP_STOP_BIT)
  1505. #define JOBCTL_TRAP_NOTIFY (1 << JOBCTL_TRAP_NOTIFY_BIT)
  1506. #define JOBCTL_TRAPPING (1 << JOBCTL_TRAPPING_BIT)
  1507. #define JOBCTL_LISTENING (1 << JOBCTL_LISTENING_BIT)
  1508. #define JOBCTL_TRAP_MASK (JOBCTL_TRAP_STOP | JOBCTL_TRAP_NOTIFY)
  1509. #define JOBCTL_PENDING_MASK (JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK)
  1510. extern bool task_set_jobctl_pending(struct task_struct *task,
  1511. unsigned int mask);
  1512. extern void task_clear_jobctl_trapping(struct task_struct *task);
  1513. extern void task_clear_jobctl_pending(struct task_struct *task,
  1514. unsigned int mask);
  1515. #ifdef CONFIG_PREEMPT_RCU
  1516. #define RCU_READ_UNLOCK_BLOCKED (1 << 0) /* blocked while in RCU read-side. */
  1517. #define RCU_READ_UNLOCK_NEED_QS (1 << 1) /* RCU core needs CPU response. */
  1518. static inline void rcu_copy_process(struct task_struct *p)
  1519. {
  1520. p->rcu_read_lock_nesting = 0;
  1521. p->rcu_read_unlock_special = 0;
  1522. #ifdef CONFIG_TREE_PREEMPT_RCU
  1523. p->rcu_blocked_node = NULL;
  1524. #endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
  1525. #ifdef CONFIG_RCU_BOOST
  1526. p->rcu_boost_mutex = NULL;
  1527. #endif /* #ifdef CONFIG_RCU_BOOST */
  1528. INIT_LIST_HEAD(&p->rcu_node_entry);
  1529. }
  1530. #else
  1531. static inline void rcu_copy_process(struct task_struct *p)
  1532. {
  1533. }
  1534. #endif
  1535. static inline void tsk_restore_flags(struct task_struct *task,
  1536. unsigned long orig_flags, unsigned long flags)
  1537. {
  1538. task->flags &= ~flags;
  1539. task->flags |= orig_flags & flags;
  1540. }
  1541. #ifdef CONFIG_SMP
  1542. extern void do_set_cpus_allowed(struct task_struct *p,
  1543. const struct cpumask *new_mask);
  1544. extern int set_cpus_allowed_ptr(struct task_struct *p,
  1545. const struct cpumask *new_mask);
  1546. #else
  1547. static inline void do_set_cpus_allowed(struct task_struct *p,
  1548. const struct cpumask *new_mask)
  1549. {
  1550. }
  1551. static inline int set_cpus_allowed_ptr(struct task_struct *p,
  1552. const struct cpumask *new_mask)
  1553. {
  1554. if (!cpumask_test_cpu(0, new_mask))
  1555. return -EINVAL;
  1556. return 0;
  1557. }
  1558. #endif
  1559. #ifdef CONFIG_NO_HZ_COMMON
  1560. void calc_load_enter_idle(void);
  1561. void calc_load_exit_idle(void);
  1562. #else
  1563. static inline void calc_load_enter_idle(void) { }
  1564. static inline void calc_load_exit_idle(void) { }
  1565. #endif /* CONFIG_NO_HZ_COMMON */
  1566. #ifndef CONFIG_CPUMASK_OFFSTACK
  1567. static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
  1568. {
  1569. return set_cpus_allowed_ptr(p, &new_mask);
  1570. }
  1571. #endif
  1572. /*
  1573. * Do not use outside of architecture code which knows its limitations.
  1574. *
  1575. * sched_clock() has no promise of monotonicity or bounded drift between
  1576. * CPUs, use (which you should not) requires disabling IRQs.
  1577. *
  1578. * Please use one of the three interfaces below.
  1579. */
  1580. extern unsigned long long notrace sched_clock(void);
  1581. /*
  1582. * See the comment in kernel/sched/clock.c
  1583. */
  1584. extern u64 cpu_clock(int cpu);
  1585. extern u64 local_clock(void);
  1586. extern u64 sched_clock_cpu(int cpu);
  1587. extern void sched_clock_init(void);
  1588. #ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
  1589. static inline void sched_clock_tick(void)
  1590. {
  1591. }
  1592. static inline void sched_clock_idle_sleep_event(void)
  1593. {
  1594. }
  1595. static inline void sched_clock_idle_wakeup_event(u64 delta_ns)
  1596. {
  1597. }
  1598. #else
  1599. /*
  1600. * Architectures can set this to 1 if they have specified
  1601. * CONFIG_HAVE_UNSTABLE_SCHED_CLOCK in their arch Kconfig,
  1602. * but then during bootup it turns out that sched_clock()
  1603. * is reliable after all:
  1604. */
  1605. extern int sched_clock_stable;
  1606. extern void sched_clock_tick(void);
  1607. extern void sched_clock_idle_sleep_event(void);
  1608. extern void sched_clock_idle_wakeup_event(u64 delta_ns);
  1609. #endif
  1610. #ifdef CONFIG_IRQ_TIME_ACCOUNTING
  1611. /*
  1612. * An i/f to runtime opt-in for irq time accounting based off of sched_clock.
  1613. * The reason for this explicit opt-in is not to have perf penalty with
  1614. * slow sched_clocks.
  1615. */
  1616. extern void enable_sched_clock_irqtime(void);
  1617. extern void disable_sched_clock_irqtime(void);
  1618. #else
  1619. static inline void enable_sched_clock_irqtime(void) {}
  1620. static inline void disable_sched_clock_irqtime(void) {}
  1621. #endif
  1622. extern unsigned long long
  1623. task_sched_runtime(struct task_struct *task);
  1624. /* sched_exec is called by processes performing an exec */
  1625. #ifdef CONFIG_SMP
  1626. extern void sched_exec(void);
  1627. #else
  1628. #define sched_exec() {}
  1629. #endif
  1630. extern void sched_clock_idle_sleep_event(void);
  1631. extern void sched_clock_idle_wakeup_event(u64 delta_ns);
  1632. #ifdef CONFIG_HOTPLUG_CPU
  1633. extern void idle_task_exit(void);
  1634. #else
  1635. static inline void idle_task_exit(void) {}
  1636. #endif
  1637. #if defined(CONFIG_NO_HZ_COMMON) && defined(CONFIG_SMP)
  1638. extern void wake_up_nohz_cpu(int cpu);
  1639. #else
  1640. static inline void wake_up_nohz_cpu(int cpu) { }
  1641. #endif
  1642. #ifdef CONFIG_NO_HZ_FULL
  1643. extern bool sched_can_stop_tick(void);
  1644. extern u64 scheduler_tick_max_deferment(void);
  1645. #else
  1646. static inline bool sched_can_stop_tick(void) { return false; }
  1647. #endif
  1648. #ifdef CONFIG_SCHED_AUTOGROUP
  1649. extern void sched_autogroup_create_attach(struct task_struct *p);
  1650. extern void sched_autogroup_detach(struct task_struct *p);
  1651. extern void sched_autogroup_fork(struct signal_struct *sig);
  1652. extern void sched_autogroup_exit(struct signal_struct *sig);
  1653. #ifdef CONFIG_PROC_FS
  1654. extern void proc_sched_autogroup_show_task(struct task_struct *p, struct seq_file *m);
  1655. extern int proc_sched_autogroup_set_nice(struct task_struct *p, int nice);
  1656. #endif
  1657. #else
  1658. static inline void sched_autogroup_create_attach(struct task_struct *p) { }
  1659. static inline void sched_autogroup_detach(struct task_struct *p) { }
  1660. static inline void sched_autogroup_fork(struct signal_struct *sig) { }
  1661. static inline void sched_autogroup_exit(struct signal_struct *sig) { }
  1662. #endif
  1663. extern bool yield_to(struct task_struct *p, bool preempt);
  1664. extern void set_user_nice(struct task_struct *p, long nice);
  1665. extern int task_prio(const struct task_struct *p);
  1666. extern int task_nice(const struct task_struct *p);
  1667. extern int can_nice(const struct task_struct *p, const int nice);
  1668. extern int task_curr(const struct task_struct *p);
  1669. extern int idle_cpu(int cpu);
  1670. extern int sched_setscheduler(struct task_struct *, int,
  1671. const struct sched_param *);
  1672. extern int sched_setscheduler_nocheck(struct task_struct *, int,
  1673. const struct sched_param *);
  1674. extern struct task_struct *idle_task(int cpu);
  1675. /**
  1676. * is_idle_task - is the specified task an idle task?
  1677. * @p: the task in question.
  1678. *
  1679. * Return: 1 if @p is an idle task. 0 otherwise.
  1680. */
  1681. static inline bool is_idle_task(const struct task_struct *p)
  1682. {
  1683. return p->pid == 0;
  1684. }
  1685. extern struct task_struct *curr_task(int cpu);
  1686. extern void set_curr_task(int cpu, struct task_struct *p);
  1687. void yield(void);
  1688. /*
  1689. * The default (Linux) execution domain.
  1690. */
  1691. extern struct exec_domain default_exec_domain;
  1692. union thread_union {
  1693. struct thread_info thread_info;
  1694. unsigned long stack[THREAD_SIZE/sizeof(long)];
  1695. };
  1696. #ifndef __HAVE_ARCH_KSTACK_END
  1697. static inline int kstack_end(void *addr)
  1698. {
  1699. /* Reliable end of stack detection:
  1700. * Some APM bios versions misalign the stack
  1701. */
  1702. return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));
  1703. }
  1704. #endif
  1705. extern union thread_union init_thread_union;
  1706. extern struct task_struct init_task;
  1707. extern struct mm_struct init_mm;
  1708. extern struct pid_namespace init_pid_ns;
  1709. /*
  1710. * find a task by one of its numerical ids
  1711. *
  1712. * find_task_by_pid_ns():
  1713. * finds a task by its pid in the specified namespace
  1714. * find_task_by_vpid():
  1715. * finds a task by its virtual pid
  1716. *
  1717. * see also find_vpid() etc in include/linux/pid.h
  1718. */
  1719. extern struct task_struct *find_task_by_vpid(pid_t nr);
  1720. extern struct task_struct *find_task_by_pid_ns(pid_t nr,
  1721. struct pid_namespace *ns);
  1722. /* per-UID process charging. */
  1723. extern struct user_struct * alloc_uid(kuid_t);
  1724. static inline struct user_struct *get_uid(struct user_struct *u)
  1725. {
  1726. atomic_inc(&u->__count);
  1727. return u;
  1728. }
  1729. extern void free_uid(struct user_struct *);
  1730. #include <asm/current.h>
  1731. extern void xtime_update(unsigned long ticks);
  1732. extern int wake_up_state(struct task_struct *tsk, unsigned int state);
  1733. extern int wake_up_process(struct task_struct *tsk);
  1734. extern void wake_up_new_task(struct task_struct *tsk);
  1735. #ifdef CONFIG_SMP
  1736. extern void kick_process(struct task_struct *tsk);
  1737. #else
  1738. static inline void kick_process(struct task_struct *tsk) { }
  1739. #endif
  1740. extern void sched_fork(unsigned long clone_flags, struct task_struct *p);
  1741. extern void sched_dead(struct task_struct *p);
  1742. extern void proc_caches_init(void);
  1743. extern void flush_signals(struct task_struct *);
  1744. extern void __flush_signals(struct task_struct *);
  1745. extern void ignore_signals(struct task_struct *);
  1746. extern void flush_signal_handlers(struct task_struct *, int force_default);
  1747. extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
  1748. static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
  1749. {
  1750. unsigned long flags;
  1751. int ret;
  1752. spin_lock_irqsave(&tsk->sighand->siglock, flags);
  1753. ret = dequeue_signal(tsk, mask, info);
  1754. spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
  1755. return ret;
  1756. }
  1757. extern void block_all_signals(int (*notifier)(void *priv), void *priv,
  1758. sigset_t *mask);
  1759. extern void unblock_all_signals(void);
  1760. extern void release_task(struct task_struct * p);
  1761. extern int send_sig_info(int, struct siginfo *, struct task_struct *);
  1762. extern int force_sigsegv(int, struct task_struct *);
  1763. extern int force_sig_info(int, struct siginfo *, struct task_struct *);
  1764. extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
  1765. extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
  1766. extern int kill_pid_info_as_cred(int, struct siginfo *, struct pid *,
  1767. const struct cred *, u32);
  1768. extern int kill_pgrp(struct pid *pid, int sig, int priv);
  1769. extern int kill_pid(struct pid *pid, int sig, int priv);
  1770. extern int kill_proc_info(int, struct siginfo *, pid_t);
  1771. extern __must_check bool do_notify_parent(struct task_struct *, int);
  1772. extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);
  1773. extern void force_sig(int, struct task_struct *);
  1774. extern int send_sig(int, struct task_struct *, int);
  1775. extern int zap_other_threads(struct task_struct *p);
  1776. extern struct sigqueue *sigqueue_alloc(void);
  1777. extern void sigqueue_free(struct sigqueue *);
  1778. extern int send_sigqueue(struct sigqueue *, struct task_struct *, int group);
  1779. extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
  1780. static inline void restore_saved_sigmask(void)
  1781. {
  1782. if (test_and_clear_restore_sigmask())
  1783. __set_current_blocked(&current->saved_sigmask);
  1784. }
  1785. static inline sigset_t *sigmask_to_save(void)
  1786. {
  1787. sigset_t *res = &current->blocked;
  1788. if (unlikely(test_restore_sigmask()))
  1789. res = &current->saved_sigmask;
  1790. return res;
  1791. }
  1792. static inline int kill_cad_pid(int sig, int priv)
  1793. {
  1794. return kill_pid(cad_pid, sig, priv);
  1795. }
  1796. /* These can be the second arg to send_sig_info/send_group_sig_info. */
  1797. #define SEND_SIG_NOINFO ((struct siginfo *) 0)
  1798. #define SEND_SIG_PRIV ((struct siginfo *) 1)
  1799. #define SEND_SIG_FORCED ((struct siginfo *) 2)
  1800. /*
  1801. * True if we are on the alternate signal stack.
  1802. */
  1803. static inline int on_sig_stack(unsigned long sp)
  1804. {
  1805. #ifdef CONFIG_STACK_GROWSUP
  1806. return sp >= current->sas_ss_sp &&
  1807. sp - current->sas_ss_sp < current->sas_ss_size;
  1808. #else
  1809. return sp > current->sas_ss_sp &&
  1810. sp - current->sas_ss_sp <= current->sas_ss_size;
  1811. #endif
  1812. }
  1813. static inline int sas_ss_flags(unsigned long sp)
  1814. {
  1815. return (current->sas_ss_size == 0 ? SS_DISABLE
  1816. : on_sig_stack(sp) ? SS_ONSTACK : 0);
  1817. }
  1818. static inline unsigned long sigsp(unsigned long sp, struct ksignal *ksig)
  1819. {
  1820. if (unlikely((ksig->ka.sa.sa_flags & SA_ONSTACK)) && ! sas_ss_flags(sp))
  1821. #ifdef CONFIG_STACK_GROWSUP
  1822. return current->sas_ss_sp;
  1823. #else
  1824. return current->sas_ss_sp + current->sas_ss_size;
  1825. #endif
  1826. return sp;
  1827. }
  1828. /*
  1829. * Routines for handling mm_structs
  1830. */
  1831. extern struct mm_struct * mm_alloc(void);
  1832. /* mmdrop drops the mm and the page tables */
  1833. extern void __mmdrop(struct mm_struct *);
  1834. static inline void mmdrop(struct mm_struct * mm)
  1835. {
  1836. if (unlikely(atomic_dec_and_test(&mm->mm_count)))
  1837. __mmdrop(mm);
  1838. }
  1839. /* mmput gets rid of the mappings and all user-space */
  1840. extern void mmput(struct mm_struct *);
  1841. /* Grab a reference to a task's mm, if it is not already going away */
  1842. extern struct mm_struct *get_task_mm(struct task_struct *task);
  1843. /*
  1844. * Grab a reference to a task's mm, if it is not already going away
  1845. * and ptrace_may_access with the mode parameter passed to it
  1846. * succeeds.
  1847. */
  1848. extern struct mm_struct *mm_access(struct task_struct *task, unsigned int mode);
  1849. /* Remove the current tasks stale references to the old mm_struct */
  1850. extern void mm_release(struct task_struct *, struct mm_struct *);
  1851. /* Allocate a new mm structure and copy contents from tsk->mm */
  1852. extern struct mm_struct *dup_mm(struct task_struct *tsk);
  1853. extern int copy_thread(unsigned long, unsigned long, unsigned long,
  1854. struct task_struct *);
  1855. extern void flush_thread(void);
  1856. extern void exit_thread(void);
  1857. extern void exit_files(struct task_struct *);
  1858. extern void __cleanup_sighand(struct sighand_struct *);
  1859. extern void exit_itimers(struct signal_struct *);
  1860. extern void flush_itimer_signals(void);
  1861. extern void do_group_exit(int);
  1862. extern int allow_signal(int);
  1863. extern int disallow_signal(int);
  1864. extern int do_execve(const char *,
  1865. const char __user * const __user *,
  1866. const char __user * const __user *);
  1867. extern long do_fork(unsigned long, unsigned long, unsigned long, int __user *, int __user *);
  1868. struct task_struct *fork_idle(int);
  1869. extern pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
  1870. extern void set_task_comm(struct task_struct *tsk, char *from);
  1871. extern char *get_task_comm(char *to, struct task_struct *tsk);
  1872. #ifdef CONFIG_SMP
  1873. void scheduler_ipi(void);
  1874. extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
  1875. #else
  1876. static inline void scheduler_ipi(void) { }
  1877. static inline unsigned long wait_task_inactive(struct task_struct *p,
  1878. long match_state)
  1879. {
  1880. return 1;
  1881. }
  1882. #endif
  1883. #define next_task(p) \
  1884. list_entry_rcu((p)->tasks.next, struct task_struct, tasks)
  1885. #define for_each_process(p) \
  1886. for (p = &init_task ; (p = next_task(p)) != &init_task ; )
  1887. extern bool current_is_single_threaded(void);
  1888. /*
  1889. * Careful: do_each_thread/while_each_thread is a double loop so
  1890. * 'break' will not work as expected - use goto instead.
  1891. */
  1892. #define do_each_thread(g, t) \
  1893. for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do
  1894. #define while_each_thread(g, t) \
  1895. while ((t = next_thread(t)) != g)
  1896. static inline int get_nr_threads(struct task_struct *tsk)
  1897. {
  1898. return tsk->signal->nr_threads;
  1899. }
  1900. static inline bool thread_group_leader(struct task_struct *p)
  1901. {
  1902. return p->exit_signal >= 0;
  1903. }
  1904. /* Do to the insanities of de_thread it is possible for a process
  1905. * to have the pid of the thread group leader without actually being
  1906. * the thread group leader. For iteration through the pids in proc
  1907. * all we care about is that we have a task with the appropriate
  1908. * pid, we don't actually care if we have the right task.
  1909. */
  1910. static inline bool has_group_leader_pid(struct task_struct *p)
  1911. {
  1912. return task_pid(p) == p->signal->leader_pid;
  1913. }
  1914. static inline
  1915. bool same_thread_group(struct task_struct *p1, struct task_struct *p2)
  1916. {
  1917. return p1->signal == p2->signal;
  1918. }
  1919. static inline struct task_struct *next_thread(const struct task_struct *p)
  1920. {
  1921. return list_entry_rcu(p->thread_group.next,
  1922. struct task_struct, thread_group);
  1923. }
  1924. static inline int thread_group_empty(struct task_struct *p)
  1925. {
  1926. return list_empty(&p->thread_group);
  1927. }
  1928. #define delay_group_leader(p) \
  1929. (thread_group_leader(p) && !thread_group_empty(p))
  1930. /*
  1931. * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
  1932. * subscriptions and synchronises with wait4(). Also used in procfs. Also
  1933. * pins the final release of task.io_context. Also protects ->cpuset and
  1934. * ->cgroup.subsys[]. And ->vfork_done.
  1935. *
  1936. * Nests both inside and outside of read_lock(&tasklist_lock).
  1937. * It must not be nested with write_lock_irq(&tasklist_lock),
  1938. * neither inside nor outside.
  1939. */
  1940. static inline void task_lock(struct task_struct *p)
  1941. {
  1942. spin_lock(&p->alloc_lock);
  1943. }
  1944. static inline void task_unlock(struct task_struct *p)
  1945. {
  1946. spin_unlock(&p->alloc_lock);
  1947. }
  1948. extern struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
  1949. unsigned long *flags);
  1950. static inline struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
  1951. unsigned long *flags)
  1952. {
  1953. struct sighand_struct *ret;
  1954. ret = __lock_task_sighand(tsk, flags);
  1955. (void)__cond_lock(&tsk->sighand->siglock, ret);
  1956. return ret;
  1957. }
  1958. static inline void unlock_task_sighand(struct task_struct *tsk,
  1959. unsigned long *flags)
  1960. {
  1961. spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
  1962. }
  1963. #ifdef CONFIG_CGROUPS
  1964. static inline void threadgroup_change_begin(struct task_struct *tsk)
  1965. {
  1966. down_read(&tsk->signal->group_rwsem);
  1967. }
  1968. static inline void threadgroup_change_end(struct task_struct *tsk)
  1969. {
  1970. up_read(&tsk->signal->group_rwsem);
  1971. }
  1972. /**
  1973. * threadgroup_lock - lock threadgroup
  1974. * @tsk: member task of the threadgroup to lock
  1975. *
  1976. * Lock the threadgroup @tsk belongs to. No new task is allowed to enter
  1977. * and member tasks aren't allowed to exit (as indicated by PF_EXITING) or
  1978. * change ->group_leader/pid. This is useful for cases where the threadgroup
  1979. * needs to stay stable across blockable operations.
  1980. *
  1981. * fork and exit paths explicitly call threadgroup_change_{begin|end}() for
  1982. * synchronization. While held, no new task will be added to threadgroup
  1983. * and no existing live task will have its PF_EXITING set.
  1984. *
  1985. * de_thread() does threadgroup_change_{begin|end}() when a non-leader
  1986. * sub-thread becomes a new leader.
  1987. */
  1988. static inline void threadgroup_lock(struct task_struct *tsk)
  1989. {
  1990. down_write(&tsk->signal->group_rwsem);
  1991. }
  1992. /**
  1993. * threadgroup_unlock - unlock threadgroup
  1994. * @tsk: member task of the threadgroup to unlock
  1995. *
  1996. * Reverse threadgroup_lock().
  1997. */
  1998. static inline void threadgroup_unlock(struct task_struct *tsk)
  1999. {
  2000. up_write(&tsk->signal->group_rwsem);
  2001. }
  2002. #else
  2003. static inline void threadgroup_change_begin(struct task_struct *tsk) {}
  2004. static inline void threadgroup_change_end(struct task_struct *tsk) {}
  2005. static inline void threadgroup_lock(struct task_struct *tsk) {}
  2006. static inline void threadgroup_unlock(struct task_struct *tsk) {}
  2007. #endif
  2008. #ifndef __HAVE_THREAD_FUNCTIONS
  2009. #define task_thread_info(task) ((struct thread_info *)(task)->stack)
  2010. #define task_stack_page(task) ((task)->stack)
  2011. static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
  2012. {
  2013. *task_thread_info(p) = *task_thread_info(org);
  2014. task_thread_info(p)->task = p;
  2015. }
  2016. static inline unsigned long *end_of_stack(struct task_struct *p)
  2017. {
  2018. return (unsigned long *)(task_thread_info(p) + 1);
  2019. }
  2020. #endif
  2021. static inline int object_is_on_stack(void *obj)
  2022. {
  2023. void *stack = task_stack_page(current);
  2024. return (obj >= stack) && (obj < (stack + THREAD_SIZE));
  2025. }
  2026. extern void thread_info_cache_init(void);
  2027. #ifdef CONFIG_DEBUG_STACK_USAGE
  2028. static inline unsigned long stack_not_used(struct task_struct *p)
  2029. {
  2030. unsigned long *n = end_of_stack(p);
  2031. do { /* Skip over canary */
  2032. n++;
  2033. } while (!*n);
  2034. return (unsigned long)n - (unsigned long)end_of_stack(p);
  2035. }
  2036. #endif
  2037. /* set thread flags in other task's structures
  2038. * - see asm/thread_info.h for TIF_xxxx flags available
  2039. */
  2040. static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
  2041. {
  2042. set_ti_thread_flag(task_thread_info(tsk), flag);
  2043. }
  2044. static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
  2045. {
  2046. clear_ti_thread_flag(task_thread_info(tsk), flag);
  2047. }
  2048. static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
  2049. {
  2050. return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);
  2051. }
  2052. static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
  2053. {
  2054. return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
  2055. }
  2056. static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
  2057. {
  2058. return test_ti_thread_flag(task_thread_info(tsk), flag);
  2059. }
  2060. static inline void set_tsk_need_resched(struct task_struct *tsk)
  2061. {
  2062. set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
  2063. }
  2064. static inline void clear_tsk_need_resched(struct task_struct *tsk)
  2065. {
  2066. clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
  2067. }
  2068. static inline int test_tsk_need_resched(struct task_struct *tsk)
  2069. {
  2070. return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED));
  2071. }
  2072. static inline int restart_syscall(void)
  2073. {
  2074. set_tsk_thread_flag(current, TIF_SIGPENDING);
  2075. return -ERESTARTNOINTR;
  2076. }
  2077. static inline int signal_pending(struct task_struct *p)
  2078. {
  2079. return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
  2080. }
  2081. static inline int __fatal_signal_pending(struct task_struct *p)
  2082. {
  2083. return unlikely(sigismember(&p->pending.signal, SIGKILL));
  2084. }
  2085. static inline int fatal_signal_pending(struct task_struct *p)
  2086. {
  2087. return signal_pending(p) && __fatal_signal_pending(p);
  2088. }
  2089. static inline int signal_pending_state(long state, struct task_struct *p)
  2090. {
  2091. if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))
  2092. return 0;
  2093. if (!signal_pending(p))
  2094. return 0;
  2095. return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);
  2096. }
  2097. /*
  2098. * cond_resched() and cond_resched_lock(): latency reduction via
  2099. * explicit rescheduling in places that are safe. The return
  2100. * value indicates whether a reschedule was done in fact.
  2101. * cond_resched_lock() will drop the spinlock before scheduling,
  2102. * cond_resched_softirq() will enable bhs before scheduling.
  2103. */
  2104. extern int _cond_resched(void);
  2105. #define cond_resched() ({ \
  2106. __might_sleep(__FILE__, __LINE__, 0); \
  2107. _cond_resched(); \
  2108. })
  2109. extern int __cond_resched_lock(spinlock_t *lock);
  2110. #ifdef CONFIG_PREEMPT_COUNT
  2111. #define PREEMPT_LOCK_OFFSET PREEMPT_OFFSET
  2112. #else
  2113. #define PREEMPT_LOCK_OFFSET 0
  2114. #endif
  2115. #define cond_resched_lock(lock) ({ \
  2116. __might_sleep(__FILE__, __LINE__, PREEMPT_LOCK_OFFSET); \
  2117. __cond_resched_lock(lock); \
  2118. })
  2119. extern int __cond_resched_softirq(void);
  2120. #define cond_resched_softirq() ({ \
  2121. __might_sleep(__FILE__, __LINE__, SOFTIRQ_DISABLE_OFFSET); \
  2122. __cond_resched_softirq(); \
  2123. })
  2124. static inline void cond_resched_rcu(void)
  2125. {
  2126. #if defined(CONFIG_DEBUG_ATOMIC_SLEEP) || !defined(CONFIG_PREEMPT_RCU)
  2127. rcu_read_unlock();
  2128. cond_resched();
  2129. rcu_read_lock();
  2130. #endif
  2131. }
  2132. /*
  2133. * Does a critical section need to be broken due to another
  2134. * task waiting?: (technically does not depend on CONFIG_PREEMPT,
  2135. * but a general need for low latency)
  2136. */
  2137. static inline int spin_needbreak(spinlock_t *lock)
  2138. {
  2139. #ifdef CONFIG_PREEMPT
  2140. return spin_is_contended(lock);
  2141. #else
  2142. return 0;
  2143. #endif
  2144. }
  2145. /*
  2146. * Idle thread specific functions to determine the need_resched
  2147. * polling state. We have two versions, one based on TS_POLLING in
  2148. * thread_info.status and one based on TIF_POLLING_NRFLAG in
  2149. * thread_info.flags
  2150. */
  2151. #ifdef TS_POLLING
  2152. static inline int tsk_is_polling(struct task_struct *p)
  2153. {
  2154. return task_thread_info(p)->status & TS_POLLING;
  2155. }
  2156. static inline void __current_set_polling(void)
  2157. {
  2158. current_thread_info()->status |= TS_POLLING;
  2159. }
  2160. static inline bool __must_check current_set_polling_and_test(void)
  2161. {
  2162. __current_set_polling();
  2163. /*
  2164. * Polling state must be visible before we test NEED_RESCHED,
  2165. * paired by resched_task()
  2166. */
  2167. smp_mb();
  2168. return unlikely(tif_need_resched());
  2169. }
  2170. static inline void __current_clr_polling(void)
  2171. {
  2172. current_thread_info()->status &= ~TS_POLLING;
  2173. }
  2174. static inline bool __must_check current_clr_polling_and_test(void)
  2175. {
  2176. __current_clr_polling();
  2177. /*
  2178. * Polling state must be visible before we test NEED_RESCHED,
  2179. * paired by resched_task()
  2180. */
  2181. smp_mb();
  2182. return unlikely(tif_need_resched());
  2183. }
  2184. #elif defined(TIF_POLLING_NRFLAG)
  2185. static inline int tsk_is_polling(struct task_struct *p)
  2186. {
  2187. return test_tsk_thread_flag(p, TIF_POLLING_NRFLAG);
  2188. }
  2189. static inline void __current_set_polling(void)
  2190. {
  2191. set_thread_flag(TIF_POLLING_NRFLAG);
  2192. }
  2193. static inline bool __must_check current_set_polling_and_test(void)
  2194. {
  2195. __current_set_polling();
  2196. /*
  2197. * Polling state must be visible before we test NEED_RESCHED,
  2198. * paired by resched_task()
  2199. *
  2200. * XXX: assumes set/clear bit are identical barrier wise.
  2201. */
  2202. smp_mb__after_clear_bit();
  2203. return unlikely(tif_need_resched());
  2204. }
  2205. static inline void __current_clr_polling(void)
  2206. {
  2207. clear_thread_flag(TIF_POLLING_NRFLAG);
  2208. }
  2209. static inline bool __must_check current_clr_polling_and_test(void)
  2210. {
  2211. __current_clr_polling();
  2212. /*
  2213. * Polling state must be visible before we test NEED_RESCHED,
  2214. * paired by resched_task()
  2215. */
  2216. smp_mb__after_clear_bit();
  2217. return unlikely(tif_need_resched());
  2218. }
  2219. #else
  2220. static inline int tsk_is_polling(struct task_struct *p) { return 0; }
  2221. static inline void __current_set_polling(void) { }
  2222. static inline void __current_clr_polling(void) { }
  2223. static inline bool __must_check current_set_polling_and_test(void)
  2224. {
  2225. return unlikely(tif_need_resched());
  2226. }
  2227. static inline bool __must_check current_clr_polling_and_test(void)
  2228. {
  2229. return unlikely(tif_need_resched());
  2230. }
  2231. #endif
  2232. static __always_inline bool need_resched(void)
  2233. {
  2234. return unlikely(tif_need_resched());
  2235. }
  2236. /*
  2237. * Thread group CPU time accounting.
  2238. */
  2239. void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);
  2240. void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times);
  2241. static inline void thread_group_cputime_init(struct signal_struct *sig)
  2242. {
  2243. raw_spin_lock_init(&sig->cputimer.lock);
  2244. }
  2245. /*
  2246. * Reevaluate whether the task has signals pending delivery.
  2247. * Wake the task if so.
  2248. * This is required every time the blocked sigset_t changes.
  2249. * callers must hold sighand->siglock.
  2250. */
  2251. extern void recalc_sigpending_and_wake(struct task_struct *t);
  2252. extern void recalc_sigpending(void);
  2253. extern void signal_wake_up_state(struct task_struct *t, unsigned int state);
  2254. static inline void signal_wake_up(struct task_struct *t, bool resume)
  2255. {
  2256. signal_wake_up_state(t, resume ? TASK_WAKEKILL : 0);
  2257. }
  2258. static inline void ptrace_signal_wake_up(struct task_struct *t, bool resume)
  2259. {
  2260. signal_wake_up_state(t, resume ? __TASK_TRACED : 0);
  2261. }
  2262. /*
  2263. * Wrappers for p->thread_info->cpu access. No-op on UP.
  2264. */
  2265. #ifdef CONFIG_SMP
  2266. static inline unsigned int task_cpu(const struct task_struct *p)
  2267. {
  2268. return task_thread_info(p)->cpu;
  2269. }
  2270. static inline int task_node(const struct task_struct *p)
  2271. {
  2272. return cpu_to_node(task_cpu(p));
  2273. }
  2274. extern void set_task_cpu(struct task_struct *p, unsigned int cpu);
  2275. #else
  2276. static inline unsigned int task_cpu(const struct task_struct *p)
  2277. {
  2278. return 0;
  2279. }
  2280. static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
  2281. {
  2282. }
  2283. #endif /* CONFIG_SMP */
  2284. extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
  2285. extern long sched_getaffinity(pid_t pid, struct cpumask *mask);
  2286. #ifdef CONFIG_CGROUP_SCHED
  2287. extern struct task_group root_task_group;
  2288. #endif /* CONFIG_CGROUP_SCHED */
  2289. extern int task_can_switch_user(struct user_struct *up,
  2290. struct task_struct *tsk);
  2291. #ifdef CONFIG_TASK_XACCT
  2292. static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
  2293. {
  2294. tsk->ioac.rchar += amt;
  2295. }
  2296. static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
  2297. {
  2298. tsk->ioac.wchar += amt;
  2299. }
  2300. static inline void inc_syscr(struct task_struct *tsk)
  2301. {
  2302. tsk->ioac.syscr++;
  2303. }
  2304. static inline void inc_syscw(struct task_struct *tsk)
  2305. {
  2306. tsk->ioac.syscw++;
  2307. }
  2308. #else
  2309. static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
  2310. {
  2311. }
  2312. static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
  2313. {
  2314. }
  2315. static inline void inc_syscr(struct task_struct *tsk)
  2316. {
  2317. }
  2318. static inline void inc_syscw(struct task_struct *tsk)
  2319. {
  2320. }
  2321. #endif
  2322. #ifndef TASK_SIZE_OF
  2323. #define TASK_SIZE_OF(tsk) TASK_SIZE
  2324. #endif
  2325. #ifdef CONFIG_MM_OWNER
  2326. extern void mm_update_next_owner(struct mm_struct *mm);
  2327. extern void mm_init_owner(struct mm_struct *mm, struct task_struct *p);
  2328. #else
  2329. static inline void mm_update_next_owner(struct mm_struct *mm)
  2330. {
  2331. }
  2332. static inline void mm_init_owner(struct mm_struct *mm, struct task_struct *p)
  2333. {
  2334. }
  2335. #endif /* CONFIG_MM_OWNER */
  2336. static inline unsigned long task_rlimit(const struct task_struct *tsk,
  2337. unsigned int limit)
  2338. {
  2339. return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_cur);
  2340. }
  2341. static inline unsigned long task_rlimit_max(const struct task_struct *tsk,
  2342. unsigned int limit)
  2343. {
  2344. return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_max);
  2345. }
  2346. static inline unsigned long rlimit(unsigned int limit)
  2347. {
  2348. return task_rlimit(current, limit);
  2349. }
  2350. static inline unsigned long rlimit_max(unsigned int limit)
  2351. {
  2352. return task_rlimit_max(current, limit);
  2353. }
  2354. #endif