Doug / smarc-fsl-linux-kernel

1

#ifndef _LINUX_SCHED_H

1

#ifndef _LINUX_SCHED_H

2

#define _LINUX_SCHED_H

2

#define _LINUX_SCHED_H

3

4

#include <uapi/linux/sched.h>

4

#include <uapi/linux/sched.h>

5

6

7

struct sched_param {

7

struct sched_param {

8

int sched_priority;

8

int sched_priority;

9

};

9

};

10

11

#include <asm/param.h> /* for HZ */

11

#include <asm/param.h> /* for HZ */

12

13

#include <linux/capability.h>

13

#include <linux/capability.h>

14

#include <linux/threads.h>

14

#include <linux/threads.h>

15

#include <linux/kernel.h>

15

#include <linux/kernel.h>

16

#include <linux/types.h>

16

#include <linux/types.h>

17

#include <linux/timex.h>

17

#include <linux/timex.h>

18

#include <linux/jiffies.h>

18

#include <linux/jiffies.h>

19

#include <linux/rbtree.h>

19

#include <linux/rbtree.h>

20

#include <linux/thread_info.h>

20

#include <linux/thread_info.h>

21

#include <linux/cpumask.h>

21

#include <linux/cpumask.h>

22

#include <linux/errno.h>

22

#include <linux/errno.h>

23

#include <linux/nodemask.h>

23

#include <linux/nodemask.h>

24

#include <linux/mm_types.h>

24

#include <linux/mm_types.h>

25

#include <linux/preempt.h>

25

#include <linux/preempt.h>

26

27

#include <asm/page.h>

27

#include <asm/page.h>

28

#include <asm/ptrace.h>

28

#include <asm/ptrace.h>

29

#include <asm/cputime.h>

29

#include <asm/cputime.h>

30

31

#include <linux/smp.h>

31

#include <linux/smp.h>

32

#include <linux/sem.h>

32

#include <linux/sem.h>

33

#include <linux/signal.h>

33

#include <linux/signal.h>

34

#include <linux/compiler.h>

34

#include <linux/compiler.h>

35

#include <linux/completion.h>

35

#include <linux/completion.h>

36

#include <linux/pid.h>

36

#include <linux/pid.h>

37

#include <linux/percpu.h>

37

#include <linux/percpu.h>

38

#include <linux/topology.h>

38

#include <linux/topology.h>

39

#include <linux/proportions.h>

39

#include <linux/proportions.h>

40

#include <linux/seccomp.h>

40

#include <linux/seccomp.h>

41

#include <linux/rcupdate.h>

41

#include <linux/rcupdate.h>

42

#include <linux/rculist.h>

42

#include <linux/rculist.h>

43

#include <linux/rtmutex.h>

43

#include <linux/rtmutex.h>

44

45

#include <linux/time.h>

45

#include <linux/time.h>

46

#include <linux/param.h>

46

#include <linux/param.h>

47

#include <linux/resource.h>

47

#include <linux/resource.h>

48

#include <linux/timer.h>

48

#include <linux/timer.h>

49

#include <linux/hrtimer.h>

49

#include <linux/hrtimer.h>

50

#include <linux/task_io_accounting.h>

50

#include <linux/task_io_accounting.h>

51

#include <linux/latencytop.h>

51

#include <linux/latencytop.h>

52

#include <linux/cred.h>

52

#include <linux/cred.h>

53

#include <linux/llist.h>

53

#include <linux/llist.h>

54

#include <linux/uidgid.h>

54

#include <linux/uidgid.h>

55

#include <linux/gfp.h>

55

#include <linux/gfp.h>

56

57

#include <asm/processor.h>

57

#include <asm/processor.h>

58

59

struct exec_domain;

59

struct exec_domain;

60

struct futex_pi_state;

60

struct futex_pi_state;

61

struct robust_list_head;

61

struct robust_list_head;

62

struct bio_list;

62

struct bio_list;

63

struct fs_struct;

63

struct fs_struct;

64

struct perf_event_context;

64

struct perf_event_context;

65

struct blk_plug;

65

struct blk_plug;

66

67

/*

67

/*

68

* List of flags we want to share for kernel threads,

68

* List of flags we want to share for kernel threads,

69

* if only because they are not used by them anyway.

69

* if only because they are not used by them anyway.

70

*/

70

*/

71

#define CLONE_KERNEL (CLONE_FS | CLONE_FILES | CLONE_SIGHAND)

71

#define CLONE_KERNEL (CLONE_FS | CLONE_FILES | CLONE_SIGHAND)

72

73

/*

73

/*

74

* These are the constant used to fake the fixed-point load-average

74

* These are the constant used to fake the fixed-point load-average

75

* counting. Some notes:

75

* counting. Some notes:

76

* - 11 bit fractions expand to 22 bits by the multiplies: this gives

76

* - 11 bit fractions expand to 22 bits by the multiplies: this gives

77

* a load-average precision of 10 bits integer + 11 bits fractional

77

* a load-average precision of 10 bits integer + 11 bits fractional

78

* - if you want to count load-averages more often, you need more

78

* - if you want to count load-averages more often, you need more

79

* precision, or rounding will get you. With 2-second counting freq,

79

* precision, or rounding will get you. With 2-second counting freq,

80

* the EXP_n values would be 1981, 2034 and 2043 if still using only

80

* the EXP_n values would be 1981, 2034 and 2043 if still using only

81

* 11 bit fractions.

81

* 11 bit fractions.

82

*/

82

*/

83

extern unsigned long avenrun[]; /* Load averages */

83

extern unsigned long avenrun[]; /* Load averages */

84

extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift);

84

extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift);

85

86

#define FSHIFT 11 /* nr of bits of precision */

86

#define FSHIFT 11 /* nr of bits of precision */

87

#define FIXED_1 (1<<FSHIFT) /* 1.0 as fixed-point */

87

#define FIXED_1 (1<<FSHIFT) /* 1.0 as fixed-point */

88

#define LOAD_FREQ (5*HZ+1) /* 5 sec intervals */

88

#define LOAD_FREQ (5*HZ+1) /* 5 sec intervals */

89

#define EXP_1 1884 /* 1/exp(5sec/1min) as fixed-point */

89

#define EXP_1 1884 /* 1/exp(5sec/1min) as fixed-point */

90

#define EXP_5 2014 /* 1/exp(5sec/5min) */

90

#define EXP_5 2014 /* 1/exp(5sec/5min) */

91

#define EXP_15 2037 /* 1/exp(5sec/15min) */

91

#define EXP_15 2037 /* 1/exp(5sec/15min) */

92

93

#define CALC_LOAD(load,exp,n) \

93

#define CALC_LOAD(load,exp,n) \

94

load *= exp; \

94

load *= exp; \

95

load += n*(FIXED_1-exp); \

95

load += n*(FIXED_1-exp); \

96

load >>= FSHIFT;

96

load >>= FSHIFT;

97

98

extern unsigned long total_forks;

98

extern unsigned long total_forks;

99

extern int nr_threads;

99

extern int nr_threads;

100

DECLARE_PER_CPU(unsigned long, process_counts);

100

DECLARE_PER_CPU(unsigned long, process_counts);

101

extern int nr_processes(void);

101

extern int nr_processes(void);

102

extern unsigned long nr_running(void);

102

extern unsigned long nr_running(void);

103

extern unsigned long nr_iowait(void);

103

extern unsigned long nr_iowait(void);

104

extern unsigned long nr_iowait_cpu(int cpu);

104

extern unsigned long nr_iowait_cpu(int cpu);

105

extern unsigned long this_cpu_load(void);

105

extern unsigned long this_cpu_load(void);

106

107

108

extern void calc_global_load(unsigned long ticks);

108

extern void calc_global_load(unsigned long ticks);

109

extern void update_cpu_load_nohz(void);

109

extern void update_cpu_load_nohz(void);

110

111

extern unsigned long get_parent_ip(unsigned long addr);

111

extern unsigned long get_parent_ip(unsigned long addr);

112

113

extern void dump_cpu_task(int cpu);

113

extern void dump_cpu_task(int cpu);

114

115

struct seq_file;

115

struct seq_file;

116

struct cfs_rq;

116

struct cfs_rq;

117

struct task_group;

117

struct task_group;

118

#ifdef CONFIG_SCHED_DEBUG

118

#ifdef CONFIG_SCHED_DEBUG

119

extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);

119

extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);

120

extern void proc_sched_set_task(struct task_struct *p);

120

extern void proc_sched_set_task(struct task_struct *p);

121

extern void

121

extern void

122

print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);

122

print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);

123

#endif

123

#endif

124

125

/*

125

/*

126

* Task state bitmask. NOTE! These bits are also

126

* Task state bitmask. NOTE! These bits are also

127

* encoded in fs/proc/array.c: get_task_state().

127

* encoded in fs/proc/array.c: get_task_state().

128

*

128

*

129

* We have two separate sets of flags: task->state

129

* We have two separate sets of flags: task->state

130

* is about runnability, while task->exit_state are

130

* is about runnability, while task->exit_state are

131

* about the task exiting. Confusing, but this way

131

* about the task exiting. Confusing, but this way

132

* modifying one set can't modify the other one by

132

* modifying one set can't modify the other one by

133

* mistake.

133

* mistake.

134

*/

134

*/

135

#define TASK_RUNNING 0

135

#define TASK_RUNNING 0

136

#define TASK_INTERRUPTIBLE 1

136

#define TASK_INTERRUPTIBLE 1

137

#define TASK_UNINTERRUPTIBLE 2

137

#define TASK_UNINTERRUPTIBLE 2

138

#define __TASK_STOPPED 4

138

#define __TASK_STOPPED 4

139

#define __TASK_TRACED 8

139

#define __TASK_TRACED 8

140

/* in tsk->exit_state */

140

/* in tsk->exit_state */

141

#define EXIT_ZOMBIE 16

141

#define EXIT_ZOMBIE 16

142

#define EXIT_DEAD 32

142

#define EXIT_DEAD 32

143

/* in tsk->state again */

143

/* in tsk->state again */

144

#define TASK_DEAD 64

144

#define TASK_DEAD 64

145

#define TASK_WAKEKILL 128

145

#define TASK_WAKEKILL 128

146

#define TASK_WAKING 256

146

#define TASK_WAKING 256

147

#define TASK_PARKED 512

147

#define TASK_PARKED 512

148

#define TASK_STATE_MAX 1024

148

#define TASK_STATE_MAX 1024

149

150

#define TASK_STATE_TO_CHAR_STR "RSDTtZXxKWP"

150

#define TASK_STATE_TO_CHAR_STR "RSDTtZXxKWP"

151

152

extern char ___assert_task_state[1 - 2*!!(

152

extern char ___assert_task_state[1 - 2*!!(

153

sizeof(TASK_STATE_TO_CHAR_STR)-1 != ilog2(TASK_STATE_MAX)+1)];

153

sizeof(TASK_STATE_TO_CHAR_STR)-1 != ilog2(TASK_STATE_MAX)+1)];

154

155

/* Convenience macros for the sake of set_task_state */

155

/* Convenience macros for the sake of set_task_state */

156

#define TASK_KILLABLE (TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)

156

#define TASK_KILLABLE (TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)

157

#define TASK_STOPPED (TASK_WAKEKILL | __TASK_STOPPED)

157

#define TASK_STOPPED (TASK_WAKEKILL | __TASK_STOPPED)

158

#define TASK_TRACED (TASK_WAKEKILL | __TASK_TRACED)

158

#define TASK_TRACED (TASK_WAKEKILL | __TASK_TRACED)

159

160

/* Convenience macros for the sake of wake_up */

160

/* Convenience macros for the sake of wake_up */

161

#define TASK_NORMAL (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)

161

#define TASK_NORMAL (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)

162

#define TASK_ALL (TASK_NORMAL | __TASK_STOPPED | __TASK_TRACED)

162

#define TASK_ALL (TASK_NORMAL | __TASK_STOPPED | __TASK_TRACED)

163

164

/* get_task_state() */

164

/* get_task_state() */

165

#define TASK_REPORT (TASK_RUNNING | TASK_INTERRUPTIBLE | \

165

#define TASK_REPORT (TASK_RUNNING | TASK_INTERRUPTIBLE | \

166

TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \

166

TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \

167

__TASK_TRACED)

167

__TASK_TRACED)

168

169

#define task_is_traced(task) ((task->state & __TASK_TRACED) != 0)

169

#define task_is_traced(task) ((task->state & __TASK_TRACED) != 0)

170

#define task_is_stopped(task) ((task->state & __TASK_STOPPED) != 0)

170

#define task_is_stopped(task) ((task->state & __TASK_STOPPED) != 0)

171

#define task_is_dead(task) ((task)->exit_state != 0)

171

#define task_is_dead(task) ((task)->exit_state != 0)

172

#define task_is_stopped_or_traced(task) \

172

#define task_is_stopped_or_traced(task) \

173

((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)

173

((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)

174

#define task_contributes_to_load(task) \

174

#define task_contributes_to_load(task) \

175

((task->state & TASK_UNINTERRUPTIBLE) != 0 && \

175

((task->state & TASK_UNINTERRUPTIBLE) != 0 && \

176

(task->flags & PF_FROZEN) == 0)

176

(task->flags & PF_FROZEN) == 0)

177

178

#define __set_task_state(tsk, state_value) \

178

#define __set_task_state(tsk, state_value) \

179

do { (tsk)->state = (state_value); } while (0)

179

do { (tsk)->state = (state_value); } while (0)

180

#define set_task_state(tsk, state_value) \

180

#define set_task_state(tsk, state_value) \

181

set_mb((tsk)->state, (state_value))

181

set_mb((tsk)->state, (state_value))

182

183

/*

183

/*

184

* set_current_state() includes a barrier so that the write of current->state

184

* set_current_state() includes a barrier so that the write of current->state

185

* is correctly serialised wrt the caller's subsequent test of whether to

185

* is correctly serialised wrt the caller's subsequent test of whether to

186

* actually sleep:

186

* actually sleep:

187

*

187

*

188

* set_current_state(TASK_UNINTERRUPTIBLE);

188

* set_current_state(TASK_UNINTERRUPTIBLE);

189

* if (do_i_need_to_sleep())

189

* if (do_i_need_to_sleep())

190

* schedule();

190

* schedule();

191

*

191

*

192

* If the caller does not need such serialisation then use __set_current_state()

192

* If the caller does not need such serialisation then use __set_current_state()

193

*/

193

*/

194

#define __set_current_state(state_value) \

194

#define __set_current_state(state_value) \

195

do { current->state = (state_value); } while (0)

195

do { current->state = (state_value); } while (0)

196

#define set_current_state(state_value) \

196

#define set_current_state(state_value) \

197

set_mb(current->state, (state_value))

197

set_mb(current->state, (state_value))

198

199

/* Task command name length */

199

/* Task command name length */

200

#define TASK_COMM_LEN 16

200

#define TASK_COMM_LEN 16

201

202

#include <linux/spinlock.h>

202

#include <linux/spinlock.h>

203

204

/*

204

/*

205

* This serializes "schedule()" and also protects

205

* This serializes "schedule()" and also protects

206

* the run-queue from deletions/modifications (but

206

* the run-queue from deletions/modifications (but

207

* _adding_ to the beginning of the run-queue has

207

* _adding_ to the beginning of the run-queue has

208

* a separate lock).

208

* a separate lock).

209

*/

209

*/

210

extern rwlock_t tasklist_lock;

210

extern rwlock_t tasklist_lock;

211

extern spinlock_t mmlist_lock;

211

extern spinlock_t mmlist_lock;

212

213

struct task_struct;

213

struct task_struct;

214

215

#ifdef CONFIG_PROVE_RCU

215

#ifdef CONFIG_PROVE_RCU

216

extern int lockdep_tasklist_lock_is_held(void);

216

extern int lockdep_tasklist_lock_is_held(void);

217

#endif /* #ifdef CONFIG_PROVE_RCU */

217

#endif /* #ifdef CONFIG_PROVE_RCU */

218

219

extern void sched_init(void);

219

extern void sched_init(void);

220

extern void sched_init_smp(void);

220

extern void sched_init_smp(void);

221

extern asmlinkage void schedule_tail(struct task_struct *prev);

221

extern asmlinkage void schedule_tail(struct task_struct *prev);

222

extern void init_idle(struct task_struct *idle, int cpu);

222

extern void init_idle(struct task_struct *idle, int cpu);

223

extern void init_idle_bootup_task(struct task_struct *idle);

223

extern void init_idle_bootup_task(struct task_struct *idle);

224

225

extern int runqueue_is_locked(int cpu);

225

extern int runqueue_is_locked(int cpu);

226

227

#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)

227

#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)

228

extern void nohz_balance_enter_idle(int cpu);

228

extern void nohz_balance_enter_idle(int cpu);

229

extern void set_cpu_sd_state_idle(void);

229

extern void set_cpu_sd_state_idle(void);

230

extern int get_nohz_timer_target(void);

230

extern int get_nohz_timer_target(void);

231

#else

231

#else

232

static inline void nohz_balance_enter_idle(int cpu) { }

232

static inline void nohz_balance_enter_idle(int cpu) { }

233

static inline void set_cpu_sd_state_idle(void) { }

233

static inline void set_cpu_sd_state_idle(void) { }

234

#endif

234

#endif

235

236

/*

236

/*

237

* Only dump TASK_* tasks. (0 for all tasks)

237

* Only dump TASK_* tasks. (0 for all tasks)

238

*/

238

*/

239

extern void show_state_filter(unsigned long state_filter);

239

extern void show_state_filter(unsigned long state_filter);

240

241

static inline void show_state(void)

241

static inline void show_state(void)

242

{

242

{

243

show_state_filter(0);

243

show_state_filter(0);

244

}

244

}

245

246

extern void show_regs(struct pt_regs *);

246

extern void show_regs(struct pt_regs *);

247

248

/*

248

/*

249

* TASK is a pointer to the task whose backtrace we want to see (or NULL for current

249

* TASK is a pointer to the task whose backtrace we want to see (or NULL for current

250

* task), SP is the stack pointer of the first frame that should be shown in the back

250

* task), SP is the stack pointer of the first frame that should be shown in the back

251

* trace (or NULL if the entire call-chain of the task should be shown).

251

* trace (or NULL if the entire call-chain of the task should be shown).

252

*/

252

*/

253

extern void show_stack(struct task_struct *task, unsigned long *sp);

253

extern void show_stack(struct task_struct *task, unsigned long *sp);

254

255

void io_schedule(void);

255

void io_schedule(void);

256

long io_schedule_timeout(long timeout);

256

long io_schedule_timeout(long timeout);

257

258

extern void cpu_init (void);

258

extern void cpu_init (void);

259

extern void trap_init(void);

259

extern void trap_init(void);

260

extern void update_process_times(int user);

260

extern void update_process_times(int user);

261

extern void scheduler_tick(void);

261

extern void scheduler_tick(void);

262

263

extern void sched_show_task(struct task_struct *p);

263

extern void sched_show_task(struct task_struct *p);

264

265

#ifdef CONFIG_LOCKUP_DETECTOR

265

#ifdef CONFIG_LOCKUP_DETECTOR

266

extern void touch_softlockup_watchdog(void);

266

extern void touch_softlockup_watchdog(void);

267

extern void touch_softlockup_watchdog_sync(void);

267

extern void touch_softlockup_watchdog_sync(void);

268

extern void touch_all_softlockup_watchdogs(void);

268

extern void touch_all_softlockup_watchdogs(void);

269

extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,

269

extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,

270

void __user *buffer,

270

void __user *buffer,

271

size_t *lenp, loff_t *ppos);

271

size_t *lenp, loff_t *ppos);

272

extern unsigned int softlockup_panic;

272

extern unsigned int softlockup_panic;

273

void lockup_detector_init(void);

273

void lockup_detector_init(void);

274

#else

274

#else

275

static inline void touch_softlockup_watchdog(void)

275

static inline void touch_softlockup_watchdog(void)

276

{

276

{

277

}

277

}

278

static inline void touch_softlockup_watchdog_sync(void)

278

static inline void touch_softlockup_watchdog_sync(void)

279

{

279

{

280

}

280

}

281

static inline void touch_all_softlockup_watchdogs(void)

281

static inline void touch_all_softlockup_watchdogs(void)

282

{

282

{

283

}

283

}

284

static inline void lockup_detector_init(void)

284

static inline void lockup_detector_init(void)

285

{

285

{

286

}

286

}

287

#endif

287

#endif

288

289

/* Attach to any functions which should be ignored in wchan output. */

289

/* Attach to any functions which should be ignored in wchan output. */

290

#define __sched __attribute__((__section__(".sched.text")))

290

#define __sched __attribute__((__section__(".sched.text")))

291

292

/* Linker adds these: start and end of __sched functions */

292

/* Linker adds these: start and end of __sched functions */

293

extern char __sched_text_start[], __sched_text_end[];

293

extern char __sched_text_start[], __sched_text_end[];

294

295

/* Is this address in the __sched functions? */

295

/* Is this address in the __sched functions? */

296

extern int in_sched_functions(unsigned long addr);

296

extern int in_sched_functions(unsigned long addr);

297

298

#define MAX_SCHEDULE_TIMEOUT LONG_MAX

298

#define MAX_SCHEDULE_TIMEOUT LONG_MAX

299

extern signed long schedule_timeout(signed long timeout);

299

extern signed long schedule_timeout(signed long timeout);

300

extern signed long schedule_timeout_interruptible(signed long timeout);

300

extern signed long schedule_timeout_interruptible(signed long timeout);

301

extern signed long schedule_timeout_killable(signed long timeout);

301

extern signed long schedule_timeout_killable(signed long timeout);

302

extern signed long schedule_timeout_uninterruptible(signed long timeout);

302

extern signed long schedule_timeout_uninterruptible(signed long timeout);

303

asmlinkage void schedule(void);

303

asmlinkage void schedule(void);

304

extern void schedule_preempt_disabled(void);

304

extern void schedule_preempt_disabled(void);

305

306

struct nsproxy;

306

struct nsproxy;

307

struct user_namespace;

307

struct user_namespace;

308

309

#ifdef CONFIG_MMU

309

#ifdef CONFIG_MMU

310

extern void arch_pick_mmap_layout(struct mm_struct *mm);

310

extern void arch_pick_mmap_layout(struct mm_struct *mm);

311

extern unsigned long

311

extern unsigned long

312

arch_get_unmapped_area(struct file *, unsigned long, unsigned long,

312

arch_get_unmapped_area(struct file *, unsigned long, unsigned long,

313

unsigned long, unsigned long);

313

unsigned long, unsigned long);

314

extern unsigned long

314

extern unsigned long

315

arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,

315

arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,

316

unsigned long len, unsigned long pgoff,

316

unsigned long len, unsigned long pgoff,

317

unsigned long flags);

317

unsigned long flags);

318

#else

318

#else

319

static inline void arch_pick_mmap_layout(struct mm_struct *mm) {}

319

static inline void arch_pick_mmap_layout(struct mm_struct *mm) {}

320

#endif

320

#endif

321

322

323

extern void set_dumpable(struct mm_struct *mm, int value);

323

extern void set_dumpable(struct mm_struct *mm, int value);

324

extern int get_dumpable(struct mm_struct *mm);

324

extern int get_dumpable(struct mm_struct *mm);

325

326

/* mm flags */

326

/* mm flags */

327

/* dumpable bits */

327

/* dumpable bits */

328

#define MMF_DUMPABLE 0 /* core dump is permitted */

328

#define MMF_DUMPABLE 0 /* core dump is permitted */

329

#define MMF_DUMP_SECURELY 1 /* core file is readable only by root */

329

#define MMF_DUMP_SECURELY 1 /* core file is readable only by root */

330

331

#define MMF_DUMPABLE_BITS 2

331

#define MMF_DUMPABLE_BITS 2

332

#define MMF_DUMPABLE_MASK ((1 << MMF_DUMPABLE_BITS) - 1)

332

#define MMF_DUMPABLE_MASK ((1 << MMF_DUMPABLE_BITS) - 1)

333

334

/* coredump filter bits */

334

/* coredump filter bits */

335

#define MMF_DUMP_ANON_PRIVATE 2

335

#define MMF_DUMP_ANON_PRIVATE 2

336

#define MMF_DUMP_ANON_SHARED 3

336

#define MMF_DUMP_ANON_SHARED 3

337

#define MMF_DUMP_MAPPED_PRIVATE 4

337

#define MMF_DUMP_MAPPED_PRIVATE 4

338

#define MMF_DUMP_MAPPED_SHARED 5

338

#define MMF_DUMP_MAPPED_SHARED 5

339

#define MMF_DUMP_ELF_HEADERS 6

339

#define MMF_DUMP_ELF_HEADERS 6

340

#define MMF_DUMP_HUGETLB_PRIVATE 7

340

#define MMF_DUMP_HUGETLB_PRIVATE 7

341

#define MMF_DUMP_HUGETLB_SHARED 8

341

#define MMF_DUMP_HUGETLB_SHARED 8

342

343

#define MMF_DUMP_FILTER_SHIFT MMF_DUMPABLE_BITS

343

#define MMF_DUMP_FILTER_SHIFT MMF_DUMPABLE_BITS

344

#define MMF_DUMP_FILTER_BITS 7

344

#define MMF_DUMP_FILTER_BITS 7

345

#define MMF_DUMP_FILTER_MASK \

345

#define MMF_DUMP_FILTER_MASK \

346

(((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)

346

(((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)

347

#define MMF_DUMP_FILTER_DEFAULT \

347

#define MMF_DUMP_FILTER_DEFAULT \

348

((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED) |\

348

((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED) |\

349

(1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)

349

(1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)

350

351

#ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS

351

#ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS

352

# define MMF_DUMP_MASK_DEFAULT_ELF (1 << MMF_DUMP_ELF_HEADERS)

352

# define MMF_DUMP_MASK_DEFAULT_ELF (1 << MMF_DUMP_ELF_HEADERS)

353

#else

353

#else

354

# define MMF_DUMP_MASK_DEFAULT_ELF 0

354

# define MMF_DUMP_MASK_DEFAULT_ELF 0

355

#endif

355

#endif

356

/* leave room for more dump flags */

356

/* leave room for more dump flags */

357

#define MMF_VM_MERGEABLE 16 /* KSM may merge identical pages */

357

#define MMF_VM_MERGEABLE 16 /* KSM may merge identical pages */

358

#define MMF_VM_HUGEPAGE 17 /* set when VM_HUGEPAGE is set on vma */

358

#define MMF_VM_HUGEPAGE 17 /* set when VM_HUGEPAGE is set on vma */

359

#define MMF_EXE_FILE_CHANGED 18 /* see prctl_set_mm_exe_file() */

359

#define MMF_EXE_FILE_CHANGED 18 /* see prctl_set_mm_exe_file() */

360

361

#define MMF_HAS_UPROBES 19 /* has uprobes */

361

#define MMF_HAS_UPROBES 19 /* has uprobes */

362

#define MMF_RECALC_UPROBES 20 /* MMF_HAS_UPROBES can be wrong */

362

#define MMF_RECALC_UPROBES 20 /* MMF_HAS_UPROBES can be wrong */

363

364

#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK)

364

#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK)

365

366

struct sighand_struct {

366

struct sighand_struct {

367

atomic_t count;

367

atomic_t count;

368

struct k_sigaction action[_NSIG];

368

struct k_sigaction action[_NSIG];

369

spinlock_t siglock;

369

spinlock_t siglock;

370

wait_queue_head_t signalfd_wqh;

370

wait_queue_head_t signalfd_wqh;

371

};

371

};

372

373

struct pacct_struct {

373

struct pacct_struct {

374

int ac_flag;

374

int ac_flag;

375

long ac_exitcode;

375

long ac_exitcode;

376

unsigned long ac_mem;

376

unsigned long ac_mem;

377

cputime_t ac_utime, ac_stime;

377

cputime_t ac_utime, ac_stime;

378

unsigned long ac_minflt, ac_majflt;

378

unsigned long ac_minflt, ac_majflt;

379

};

379

};

380

381

struct cpu_itimer {

381

struct cpu_itimer {

382

cputime_t expires;

382

cputime_t expires;

383

cputime_t incr;

383

cputime_t incr;

384

u32 error;

384

u32 error;

385

u32 incr_error;

385

u32 incr_error;

386

};

386

};

387

388

/**

388

/**

389

* struct cputime - snaphsot of system and user cputime

389

* struct cputime - snaphsot of system and user cputime

390

* @utime: time spent in user mode

390

* @utime: time spent in user mode

391

* @stime: time spent in system mode

391

* @stime: time spent in system mode

392

*

392

*

393

* Gathers a generic snapshot of user and system time.

393

* Gathers a generic snapshot of user and system time.

394

*/

394

*/

395

struct cputime {

395

struct cputime {

396

cputime_t utime;

396

cputime_t utime;

397

cputime_t stime;

397

cputime_t stime;

398

};

398

};

399

400

/**

400

/**

401

* struct task_cputime - collected CPU time counts

401

* struct task_cputime - collected CPU time counts

402

* @utime: time spent in user mode, in &cputime_t units

402

* @utime: time spent in user mode, in &cputime_t units

403

* @stime: time spent in kernel mode, in &cputime_t units

403

* @stime: time spent in kernel mode, in &cputime_t units

404

* @sum_exec_runtime: total time spent on the CPU, in nanoseconds

404

* @sum_exec_runtime: total time spent on the CPU, in nanoseconds

405

*

405

*

406

* This is an extension of struct cputime that includes the total runtime

406

* This is an extension of struct cputime that includes the total runtime

407

* spent by the task from the scheduler point of view.

407

* spent by the task from the scheduler point of view.

408

*

408

*

409

* As a result, this structure groups together three kinds of CPU time

409

* As a result, this structure groups together three kinds of CPU time

410

* that are tracked for threads and thread groups. Most things considering

410

* that are tracked for threads and thread groups. Most things considering

411

* CPU time want to group these counts together and treat all three

411

* CPU time want to group these counts together and treat all three

412

* of them in parallel.

412

* of them in parallel.

413

*/

413

*/

414

struct task_cputime {

414

struct task_cputime {

415

cputime_t utime;

415

cputime_t utime;

416

cputime_t stime;

416

cputime_t stime;

417

unsigned long long sum_exec_runtime;

417

unsigned long long sum_exec_runtime;

418

};

418

};

419

/* Alternate field names when used to cache expirations. */

419

/* Alternate field names when used to cache expirations. */

420

#define prof_exp stime

420

#define prof_exp stime

421

#define virt_exp utime

421

#define virt_exp utime

422

#define sched_exp sum_exec_runtime

422

#define sched_exp sum_exec_runtime

423

424

#define INIT_CPUTIME \

424

#define INIT_CPUTIME \

425

(struct task_cputime) { \

425

(struct task_cputime) { \

426

.utime = 0, \

426

.utime = 0, \

427

.stime = 0, \

427

.stime = 0, \

428

.sum_exec_runtime = 0, \

428

.sum_exec_runtime = 0, \

429

}

429

}

430

431

#define PREEMPT_ENABLED (PREEMPT_NEED_RESCHED)

431

#define PREEMPT_ENABLED (PREEMPT_NEED_RESCHED)

432

433

#ifdef CONFIG_PREEMPT_COUNT

433

#ifdef CONFIG_PREEMPT_COUNT

434

#define PREEMPT_DISABLED (1 + PREEMPT_ENABLED)

434

#define PREEMPT_DISABLED (1 + PREEMPT_ENABLED)

435

#else

435

#else

436

#define PREEMPT_DISABLED PREEMPT_ENABLED

436

#define PREEMPT_DISABLED PREEMPT_ENABLED

437

#endif

437

#endif

438

439

/*

439

/*

440

* Disable preemption until the scheduler is running.

440

* Disable preemption until the scheduler is running.

441

* Reset by start_kernel()->sched_init()->init_idle().

441

* Reset by start_kernel()->sched_init()->init_idle().

442

*

442

*

443

* We include PREEMPT_ACTIVE to avoid cond_resched() from working

443

* We include PREEMPT_ACTIVE to avoid cond_resched() from working

444

* before the scheduler is active -- see should_resched().

444

* before the scheduler is active -- see should_resched().

445

*/

445

*/

446

#define INIT_PREEMPT_COUNT (PREEMPT_DISABLED + PREEMPT_ACTIVE)

446

#define INIT_PREEMPT_COUNT (PREEMPT_DISABLED + PREEMPT_ACTIVE)

447

448

/**

448

/**

449

* struct thread_group_cputimer - thread group interval timer counts

449

* struct thread_group_cputimer - thread group interval timer counts

450

* @cputime: thread group interval timers.

450

* @cputime: thread group interval timers.

451

* @running: non-zero when there are timers running and

451

* @running: non-zero when there are timers running and

452

* @cputime receives updates.

452

* @cputime receives updates.

453

* @lock: lock for fields in this struct.

453

* @lock: lock for fields in this struct.

454

*

454

*

455

* This structure contains the version of task_cputime, above, that is

455

* This structure contains the version of task_cputime, above, that is

456

* used for thread group CPU timer calculations.

456

* used for thread group CPU timer calculations.

457

*/

457

*/

458

struct thread_group_cputimer {

458

struct thread_group_cputimer {

459

struct task_cputime cputime;

459

struct task_cputime cputime;

460

int running;

460

int running;

461

raw_spinlock_t lock;

461

raw_spinlock_t lock;

462

};

462

};

463

464

#include <linux/rwsem.h>

464

#include <linux/rwsem.h>

465

struct autogroup;

465

struct autogroup;

466

467

/*

467

/*

468

* NOTE! "signal_struct" does not have its own

468

* NOTE! "signal_struct" does not have its own

469

* locking, because a shared signal_struct always

469

* locking, because a shared signal_struct always

470

* implies a shared sighand_struct, so locking

470

* implies a shared sighand_struct, so locking

471

* sighand_struct is always a proper superset of

471

* sighand_struct is always a proper superset of

472

* the locking of signal_struct.

472

* the locking of signal_struct.

473

*/

473

*/

474

struct signal_struct {

474

struct signal_struct {

475

atomic_t sigcnt;

475

atomic_t sigcnt;

476

atomic_t live;

476

atomic_t live;

477

int nr_threads;

477

int nr_threads;

478

479

wait_queue_head_t wait_chldexit; /* for wait4() */

479

wait_queue_head_t wait_chldexit; /* for wait4() */

480

481

/* current thread group signal load-balancing target: */

481

/* current thread group signal load-balancing target: */

482

struct task_struct *curr_target;

482

struct task_struct *curr_target;

483

484

/* shared signal handling: */

484

/* shared signal handling: */

485

struct sigpending shared_pending;

485

struct sigpending shared_pending;

486

487

/* thread group exit support */

487

/* thread group exit support */

488

int group_exit_code;

488

int group_exit_code;

489

/* overloaded:

489

/* overloaded:

490

* - notify group_exit_task when ->count is equal to notify_count

490

* - notify group_exit_task when ->count is equal to notify_count

491

* - everyone except group_exit_task is stopped during signal delivery

491

* - everyone except group_exit_task is stopped during signal delivery

492

* of fatal signals, group_exit_task processes the signal.

492

* of fatal signals, group_exit_task processes the signal.

493

*/

493

*/

494

int notify_count;

494

int notify_count;

495

struct task_struct *group_exit_task;

495

struct task_struct *group_exit_task;

496

497

/* thread group stop support, overloads group_exit_code too */

497

/* thread group stop support, overloads group_exit_code too */

498

int group_stop_count;

498

int group_stop_count;

499

unsigned int flags; /* see SIGNAL_* flags below */

499

unsigned int flags; /* see SIGNAL_* flags below */

500

501

/*

501

/*

502

* PR_SET_CHILD_SUBREAPER marks a process, like a service

502

* PR_SET_CHILD_SUBREAPER marks a process, like a service

503

* manager, to re-parent orphan (double-forking) child processes

503

* manager, to re-parent orphan (double-forking) child processes

504

* to this process instead of 'init'. The service manager is

504

* to this process instead of 'init'. The service manager is

505

* able to receive SIGCHLD signals and is able to investigate

505

* able to receive SIGCHLD signals and is able to investigate

506

* the process until it calls wait(). All children of this

506

* the process until it calls wait(). All children of this

507

* process will inherit a flag if they should look for a

507

* process will inherit a flag if they should look for a

508

* child_subreaper process at exit.

508

* child_subreaper process at exit.

509

*/

509

*/

510

unsigned int is_child_subreaper:1;

510

unsigned int is_child_subreaper:1;

511

unsigned int has_child_subreaper:1;

511

unsigned int has_child_subreaper:1;

512

513

/* POSIX.1b Interval Timers */

513

/* POSIX.1b Interval Timers */

514

int posix_timer_id;

514

int posix_timer_id;

515

struct list_head posix_timers;

515

struct list_head posix_timers;

516

517

/* ITIMER_REAL timer for the process */

517

/* ITIMER_REAL timer for the process */

518

struct hrtimer real_timer;

518

struct hrtimer real_timer;

519

struct pid *leader_pid;

519

struct pid *leader_pid;

520

ktime_t it_real_incr;

520

ktime_t it_real_incr;

521

522

/*

522

/*

523

* ITIMER_PROF and ITIMER_VIRTUAL timers for the process, we use

523

* ITIMER_PROF and ITIMER_VIRTUAL timers for the process, we use

524

* CPUCLOCK_PROF and CPUCLOCK_VIRT for indexing array as these

524

* CPUCLOCK_PROF and CPUCLOCK_VIRT for indexing array as these

525

* values are defined to 0 and 1 respectively

525

* values are defined to 0 and 1 respectively

526

*/

526

*/

527

struct cpu_itimer it[2];

527

struct cpu_itimer it[2];

528

529

/*

529

/*

530

* Thread group totals for process CPU timers.

530

* Thread group totals for process CPU timers.

531

* See thread_group_cputimer(), et al, for details.

531

* See thread_group_cputimer(), et al, for details.

532

*/

532

*/

533

struct thread_group_cputimer cputimer;

533

struct thread_group_cputimer cputimer;

534

535

/* Earliest-expiration cache. */

535

/* Earliest-expiration cache. */

536

struct task_cputime cputime_expires;

536

struct task_cputime cputime_expires;

537

538

struct list_head cpu_timers[3];

538

struct list_head cpu_timers[3];

539

540

struct pid *tty_old_pgrp;

540

struct pid *tty_old_pgrp;

541

542

/* boolean value for session group leader */

542

/* boolean value for session group leader */

543

int leader;

543

int leader;

544

545

struct tty_struct *tty; /* NULL if no tty */

545

struct tty_struct *tty; /* NULL if no tty */

546

547

#ifdef CONFIG_SCHED_AUTOGROUP

547

#ifdef CONFIG_SCHED_AUTOGROUP

548

struct autogroup *autogroup;

548

struct autogroup *autogroup;

549

#endif

549

#endif

550

/*

550

/*

551

* Cumulative resource counters for dead threads in the group,

551

* Cumulative resource counters for dead threads in the group,

552

* and for reaped dead child processes forked by this group.

552

* and for reaped dead child processes forked by this group.

553

* Live threads maintain their own counters and add to these

553

* Live threads maintain their own counters and add to these

554

* in __exit_signal, except for the group leader.

554

* in __exit_signal, except for the group leader.

555

*/

555

*/

556

cputime_t utime, stime, cutime, cstime;

556

cputime_t utime, stime, cutime, cstime;

557

cputime_t gtime;

557

cputime_t gtime;

558

cputime_t cgtime;

558

cputime_t cgtime;

559

#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE

559

#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE

560

struct cputime prev_cputime;

560

struct cputime prev_cputime;

561

#endif

561

#endif

562

unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;

562

unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;

563

unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;

563

unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;

564

unsigned long inblock, oublock, cinblock, coublock;

564

unsigned long inblock, oublock, cinblock, coublock;

565

unsigned long maxrss, cmaxrss;

565

unsigned long maxrss, cmaxrss;

566

struct task_io_accounting ioac;

566

struct task_io_accounting ioac;

567

568

/*

568

/*

569

* Cumulative ns of schedule CPU time fo dead threads in the

569

* Cumulative ns of schedule CPU time fo dead threads in the

570

* group, not including a zombie group leader, (This only differs

570

* group, not including a zombie group leader, (This only differs

571

* from jiffies_to_ns(utime + stime) if sched_clock uses something

571

* from jiffies_to_ns(utime + stime) if sched_clock uses something

572

* other than jiffies.)

572

* other than jiffies.)

573

*/

573

*/

574

unsigned long long sum_sched_runtime;

574

unsigned long long sum_sched_runtime;

575

576

/*

576

/*

577

* We don't bother to synchronize most readers of this at all,

577

* We don't bother to synchronize most readers of this at all,

578

* because there is no reader checking a limit that actually needs

578

* because there is no reader checking a limit that actually needs

579

* to get both rlim_cur and rlim_max atomically, and either one

579

* to get both rlim_cur and rlim_max atomically, and either one

580

* alone is a single word that can safely be read normally.

580

* alone is a single word that can safely be read normally.

581

* getrlimit/setrlimit use task_lock(current->group_leader) to

581

* getrlimit/setrlimit use task_lock(current->group_leader) to

582

* protect this instead of the siglock, because they really

582

* protect this instead of the siglock, because they really

583

* have no need to disable irqs.

583

* have no need to disable irqs.

584

*/

584

*/

585

struct rlimit rlim[RLIM_NLIMITS];

585

struct rlimit rlim[RLIM_NLIMITS];

586

587

#ifdef CONFIG_BSD_PROCESS_ACCT

587

#ifdef CONFIG_BSD_PROCESS_ACCT

588

struct pacct_struct pacct; /* per-process accounting information */

588

struct pacct_struct pacct; /* per-process accounting information */

589

#endif

589

#endif

590

#ifdef CONFIG_TASKSTATS

590

#ifdef CONFIG_TASKSTATS

591

struct taskstats *stats;

591

struct taskstats *stats;

592

#endif

592

#endif

593

#ifdef CONFIG_AUDIT

593

#ifdef CONFIG_AUDIT

594

unsigned audit_tty;

594

unsigned audit_tty;

595

unsigned audit_tty_log_passwd;

595

unsigned audit_tty_log_passwd;

596

struct tty_audit_buf *tty_audit_buf;

596

struct tty_audit_buf *tty_audit_buf;

597

#endif

597

#endif

598

#ifdef CONFIG_CGROUPS

598

#ifdef CONFIG_CGROUPS

599

/*

599

/*

600

* group_rwsem prevents new tasks from entering the threadgroup and

600

* group_rwsem prevents new tasks from entering the threadgroup and

601

* member tasks from exiting,a more specifically, setting of

601

* member tasks from exiting,a more specifically, setting of

602

* PF_EXITING. fork and exit paths are protected with this rwsem

602

* PF_EXITING. fork and exit paths are protected with this rwsem

603

* using threadgroup_change_begin/end(). Users which require

603

* using threadgroup_change_begin/end(). Users which require

604

* threadgroup to remain stable should use threadgroup_[un]lock()

604

* threadgroup to remain stable should use threadgroup_[un]lock()

605

* which also takes care of exec path. Currently, cgroup is the

605

* which also takes care of exec path. Currently, cgroup is the

606

* only user.

606

* only user.

607

*/

607

*/

608

struct rw_semaphore group_rwsem;

608

struct rw_semaphore group_rwsem;

609

#endif

609

#endif

610

611

oom_flags_t oom_flags;

611

oom_flags_t oom_flags;

612

short oom_score_adj; /* OOM kill score adjustment */

612

short oom_score_adj; /* OOM kill score adjustment */

613

short oom_score_adj_min; /* OOM kill score adjustment min value.

613

short oom_score_adj_min; /* OOM kill score adjustment min value.

614

* Only settable by CAP_SYS_RESOURCE. */

614

* Only settable by CAP_SYS_RESOURCE. */

615

616

struct mutex cred_guard_mutex; /* guard against foreign influences on

616

struct mutex cred_guard_mutex; /* guard against foreign influences on

617

* credential calculations

617

* credential calculations

618

* (notably. ptrace) */

618

* (notably. ptrace) */

619

};

619

};

620

621

/*

621

/*

622

* Bits in flags field of signal_struct.

622

* Bits in flags field of signal_struct.

623

*/

623

*/

624

#define SIGNAL_STOP_STOPPED 0x00000001 /* job control stop in effect */

624

#define SIGNAL_STOP_STOPPED 0x00000001 /* job control stop in effect */

625

#define SIGNAL_STOP_CONTINUED 0x00000002 /* SIGCONT since WCONTINUED reap */

625

#define SIGNAL_STOP_CONTINUED 0x00000002 /* SIGCONT since WCONTINUED reap */

626

#define SIGNAL_GROUP_EXIT 0x00000004 /* group exit in progress */

626

#define SIGNAL_GROUP_EXIT 0x00000004 /* group exit in progress */

627

#define SIGNAL_GROUP_COREDUMP 0x00000008 /* coredump in progress */

627

#define SIGNAL_GROUP_COREDUMP 0x00000008 /* coredump in progress */

628

/*

628

/*

629

* Pending notifications to parent.

629

* Pending notifications to parent.

630

*/

630

*/

631

#define SIGNAL_CLD_STOPPED 0x00000010

631

#define SIGNAL_CLD_STOPPED 0x00000010

632

#define SIGNAL_CLD_CONTINUED 0x00000020

632

#define SIGNAL_CLD_CONTINUED 0x00000020

633

#define SIGNAL_CLD_MASK (SIGNAL_CLD_STOPPED|SIGNAL_CLD_CONTINUED)

633

#define SIGNAL_CLD_MASK (SIGNAL_CLD_STOPPED|SIGNAL_CLD_CONTINUED)

634

635

#define SIGNAL_UNKILLABLE 0x00000040 /* for init: ignore fatal signals */

635

#define SIGNAL_UNKILLABLE 0x00000040 /* for init: ignore fatal signals */

636

637

/* If true, all threads except ->group_exit_task have pending SIGKILL */

637

/* If true, all threads except ->group_exit_task have pending SIGKILL */

638

static inline int signal_group_exit(const struct signal_struct *sig)

638

static inline int signal_group_exit(const struct signal_struct *sig)

639

{

639

{

640

return (sig->flags & SIGNAL_GROUP_EXIT) ||

640

return (sig->flags & SIGNAL_GROUP_EXIT) ||

641

(sig->group_exit_task != NULL);

641

(sig->group_exit_task != NULL);

642

}

642

}

643

644

/*

644

/*

645

* Some day this will be a full-fledged user tracking system..

645

* Some day this will be a full-fledged user tracking system..

646

*/

646

*/

647

struct user_struct {

647

struct user_struct {

648

atomic_t __count; /* reference count */

648

atomic_t __count; /* reference count */

649

atomic_t processes; /* How many processes does this user have? */

649

atomic_t processes; /* How many processes does this user have? */

650

atomic_t files; /* How many open files does this user have? */

650

atomic_t files; /* How many open files does this user have? */

651

atomic_t sigpending; /* How many pending signals does this user have? */

651

atomic_t sigpending; /* How many pending signals does this user have? */

652

#ifdef CONFIG_INOTIFY_USER

652

#ifdef CONFIG_INOTIFY_USER

653

atomic_t inotify_watches; /* How many inotify watches does this user have? */

653

atomic_t inotify_watches; /* How many inotify watches does this user have? */

654

atomic_t inotify_devs; /* How many inotify devs does this user have opened? */

654

atomic_t inotify_devs; /* How many inotify devs does this user have opened? */

655

#endif

655

#endif

656

#ifdef CONFIG_FANOTIFY

656

#ifdef CONFIG_FANOTIFY

657

atomic_t fanotify_listeners;

657

atomic_t fanotify_listeners;

658

#endif

658

#endif

659

#ifdef CONFIG_EPOLL

659

#ifdef CONFIG_EPOLL

660

atomic_long_t epoll_watches; /* The number of file descriptors currently watched */

660

atomic_long_t epoll_watches; /* The number of file descriptors currently watched */

661

#endif

661

#endif

662

#ifdef CONFIG_POSIX_MQUEUE

662

#ifdef CONFIG_POSIX_MQUEUE

663

/* protected by mq_lock */

663

/* protected by mq_lock */

664

unsigned long mq_bytes; /* How many bytes can be allocated to mqueue? */

664

unsigned long mq_bytes; /* How many bytes can be allocated to mqueue? */

665

#endif

665

#endif

666

unsigned long locked_shm; /* How many pages of mlocked shm ? */

666

unsigned long locked_shm; /* How many pages of mlocked shm ? */

667

668

#ifdef CONFIG_KEYS

668

#ifdef CONFIG_KEYS

669

struct key *uid_keyring; /* UID specific keyring */

669

struct key *uid_keyring; /* UID specific keyring */

670

struct key *session_keyring; /* UID's default session keyring */

670

struct key *session_keyring; /* UID's default session keyring */

671

#endif

671

#endif

672

673

/* Hash table maintenance information */

673

/* Hash table maintenance information */

674

struct hlist_node uidhash_node;

674

struct hlist_node uidhash_node;

675

kuid_t uid;

675

kuid_t uid;

676

677

#ifdef CONFIG_PERF_EVENTS

677

#ifdef CONFIG_PERF_EVENTS

678

atomic_long_t locked_vm;

678

atomic_long_t locked_vm;

679

#endif

679

#endif

680

};

680

};

681

682

extern int uids_sysfs_init(void);

682

extern int uids_sysfs_init(void);

683

684

extern struct user_struct *find_user(kuid_t);

684

extern struct user_struct *find_user(kuid_t);

685

686

extern struct user_struct root_user;

686

extern struct user_struct root_user;

687

#define INIT_USER (&root_user)

687

#define INIT_USER (&root_user)

688

689

690

struct backing_dev_info;

690

struct backing_dev_info;

691

struct reclaim_state;

691

struct reclaim_state;

692

693

#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)

693

#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)

694

struct sched_info {

694

struct sched_info {

695

/* cumulative counters */

695

/* cumulative counters */

696

unsigned long pcount; /* # of times run on this cpu */

696

unsigned long pcount; /* # of times run on this cpu */

697

unsigned long long run_delay; /* time spent waiting on a runqueue */

697

unsigned long long run_delay; /* time spent waiting on a runqueue */

698

699

/* timestamps */

699

/* timestamps */

700

unsigned long long last_arrival,/* when we last ran on a cpu */

700

unsigned long long last_arrival,/* when we last ran on a cpu */

701

last_queued; /* when we were last queued to run */

701

last_queued; /* when we were last queued to run */

702

};

702

};

703

#endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */

703

#endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */

704

705

#ifdef CONFIG_TASK_DELAY_ACCT

705

#ifdef CONFIG_TASK_DELAY_ACCT

706

struct task_delay_info {

706

struct task_delay_info {

707

spinlock_t lock;

707

spinlock_t lock;

708

unsigned int flags; /* Private per-task flags */

708

unsigned int flags; /* Private per-task flags */

709

710

/* For each stat XXX, add following, aligned appropriately

710

/* For each stat XXX, add following, aligned appropriately

711

*

711

*

712

* struct timespec XXX_start, XXX_end;

712

* struct timespec XXX_start, XXX_end;

713

* u64 XXX_delay;

713

* u64 XXX_delay;

714

* u32 XXX_count;

714

* u32 XXX_count;

715

*

715

*

716

* Atomicity of updates to XXX_delay, XXX_count protected by

716

* Atomicity of updates to XXX_delay, XXX_count protected by

717

* single lock above (split into XXX_lock if contention is an issue).

717

* single lock above (split into XXX_lock if contention is an issue).

718

*/

718

*/

719

720

/*

720

/*

721

* XXX_count is incremented on every XXX operation, the delay

721

* XXX_count is incremented on every XXX operation, the delay

722

* associated with the operation is added to XXX_delay.

722

* associated with the operation is added to XXX_delay.

723

* XXX_delay contains the accumulated delay time in nanoseconds.

723

* XXX_delay contains the accumulated delay time in nanoseconds.

724

*/

724

*/

725

struct timespec blkio_start, blkio_end; /* Shared by blkio, swapin */

725

struct timespec blkio_start, blkio_end; /* Shared by blkio, swapin */

726

u64 blkio_delay; /* wait for sync block io completion */

726

u64 blkio_delay; /* wait for sync block io completion */

727

u64 swapin_delay; /* wait for swapin block io completion */

727

u64 swapin_delay; /* wait for swapin block io completion */

728

u32 blkio_count; /* total count of the number of sync block */

728

u32 blkio_count; /* total count of the number of sync block */

729

/* io operations performed */

729

/* io operations performed */

730

u32 swapin_count; /* total count of the number of swapin block */

730

u32 swapin_count; /* total count of the number of swapin block */

731

/* io operations performed */

731

/* io operations performed */

732

733

struct timespec freepages_start, freepages_end;

733

struct timespec freepages_start, freepages_end;

734

u64 freepages_delay; /* wait for memory reclaim */

734

u64 freepages_delay; /* wait for memory reclaim */

735

u32 freepages_count; /* total count of memory reclaim */

735

u32 freepages_count; /* total count of memory reclaim */

736

};

736

};

737

#endif /* CONFIG_TASK_DELAY_ACCT */

737

#endif /* CONFIG_TASK_DELAY_ACCT */

738

739

static inline int sched_info_on(void)

739

static inline int sched_info_on(void)

740

{

740

{

741

#ifdef CONFIG_SCHEDSTATS

741

#ifdef CONFIG_SCHEDSTATS

742

return 1;

742

return 1;

743

#elif defined(CONFIG_TASK_DELAY_ACCT)

743

#elif defined(CONFIG_TASK_DELAY_ACCT)

744

extern int delayacct_on;

744

extern int delayacct_on;

745

return delayacct_on;

745

return delayacct_on;

746

#else

746

#else

747

return 0;

747

return 0;

748

#endif

748

#endif

749

}

749

}

750

751

enum cpu_idle_type {

751

enum cpu_idle_type {

752

CPU_IDLE,

752

CPU_IDLE,

753

CPU_NOT_IDLE,

753

CPU_NOT_IDLE,

754

CPU_NEWLY_IDLE,

754

CPU_NEWLY_IDLE,

755

CPU_MAX_IDLE_TYPES

755

CPU_MAX_IDLE_TYPES

756

};

756

};

757

758

/*

758

/*

759

* Increase resolution of cpu_power calculations

759

* Increase resolution of cpu_power calculations

760

*/

760

*/

761

#define SCHED_POWER_SHIFT 10

761

#define SCHED_POWER_SHIFT 10

762

#define SCHED_POWER_SCALE (1L << SCHED_POWER_SHIFT)

762

#define SCHED_POWER_SCALE (1L << SCHED_POWER_SHIFT)

763

764

/*

764

/*

765

* sched-domains (multiprocessor balancing) declarations:

765

* sched-domains (multiprocessor balancing) declarations:

766

*/

766

*/

767

#ifdef CONFIG_SMP

767

#ifdef CONFIG_SMP

768

#define SD_LOAD_BALANCE 0x0001 /* Do load balancing on this domain. */

768

#define SD_LOAD_BALANCE 0x0001 /* Do load balancing on this domain. */

769

#define SD_BALANCE_NEWIDLE 0x0002 /* Balance when about to become idle */

769

#define SD_BALANCE_NEWIDLE 0x0002 /* Balance when about to become idle */

770

#define SD_BALANCE_EXEC 0x0004 /* Balance on exec */

770

#define SD_BALANCE_EXEC 0x0004 /* Balance on exec */

771

#define SD_BALANCE_FORK 0x0008 /* Balance on fork, clone */

771

#define SD_BALANCE_FORK 0x0008 /* Balance on fork, clone */

772

#define SD_BALANCE_WAKE 0x0010 /* Balance on wakeup */

772

#define SD_BALANCE_WAKE 0x0010 /* Balance on wakeup */

773

#define SD_WAKE_AFFINE 0x0020 /* Wake task to waking CPU */

773

#define SD_WAKE_AFFINE 0x0020 /* Wake task to waking CPU */

774

#define SD_SHARE_CPUPOWER 0x0080 /* Domain members share cpu power */

774

#define SD_SHARE_CPUPOWER 0x0080 /* Domain members share cpu power */

775

#define SD_SHARE_PKG_RESOURCES 0x0200 /* Domain members share cpu pkg resources */

775

#define SD_SHARE_PKG_RESOURCES 0x0200 /* Domain members share cpu pkg resources */

776

#define SD_SERIALIZE 0x0400 /* Only a single load balancing instance */

776

#define SD_SERIALIZE 0x0400 /* Only a single load balancing instance */

777

#define SD_ASYM_PACKING 0x0800 /* Place busy groups earlier in the domain */

777

#define SD_ASYM_PACKING 0x0800 /* Place busy groups earlier in the domain */

778

#define SD_PREFER_SIBLING 0x1000 /* Prefer to place tasks in a sibling domain */

778

#define SD_PREFER_SIBLING 0x1000 /* Prefer to place tasks in a sibling domain */

779

#define SD_OVERLAP 0x2000 /* sched_domains of this level overlap */

779

#define SD_OVERLAP 0x2000 /* sched_domains of this level overlap */

780

#define SD_NUMA 0x4000 /* cross-node balancing */

780

#define SD_NUMA 0x4000 /* cross-node balancing */

781

782

extern int __weak arch_sd_sibiling_asym_packing(void);

782

extern int __weak arch_sd_sibiling_asym_packing(void);

783

784

struct sched_domain_attr {

784

struct sched_domain_attr {

785

int relax_domain_level;

785

int relax_domain_level;

786

};

786

};

787

788

#define SD_ATTR_INIT (struct sched_domain_attr) { \

788

#define SD_ATTR_INIT (struct sched_domain_attr) { \

789

.relax_domain_level = -1, \

789

.relax_domain_level = -1, \

790

}

790

}

791

792

extern int sched_domain_level_max;

792

extern int sched_domain_level_max;

793

794

struct sched_group;

794

struct sched_group;

795

796

struct sched_domain {

796

struct sched_domain {

797

/* These fields must be setup */

797

/* These fields must be setup */

798

struct sched_domain *parent; /* top domain must be null terminated */

798

struct sched_domain *parent; /* top domain must be null terminated */

799

struct sched_domain *child; /* bottom domain must be null terminated */

799

struct sched_domain *child; /* bottom domain must be null terminated */

800

struct sched_group *groups; /* the balancing groups of the domain */

800

struct sched_group *groups; /* the balancing groups of the domain */

801

unsigned long min_interval; /* Minimum balance interval ms */

801

unsigned long min_interval; /* Minimum balance interval ms */

802

unsigned long max_interval; /* Maximum balance interval ms */

802

unsigned long max_interval; /* Maximum balance interval ms */

803

unsigned int busy_factor; /* less balancing by factor if busy */

803

unsigned int busy_factor; /* less balancing by factor if busy */

804

unsigned int imbalance_pct; /* No balance until over watermark */

804

unsigned int imbalance_pct; /* No balance until over watermark */

805

unsigned int cache_nice_tries; /* Leave cache hot tasks for # tries */

805

unsigned int cache_nice_tries; /* Leave cache hot tasks for # tries */

806

unsigned int busy_idx;

806

unsigned int busy_idx;

807

unsigned int idle_idx;

807

unsigned int idle_idx;

808

unsigned int newidle_idx;

808

unsigned int newidle_idx;

809

unsigned int wake_idx;

809

unsigned int wake_idx;

810

unsigned int forkexec_idx;

810

unsigned int forkexec_idx;

811

unsigned int smt_gain;

811

unsigned int smt_gain;

812

813

int nohz_idle; /* NOHZ IDLE status */

813

int nohz_idle; /* NOHZ IDLE status */

814

int flags; /* See SD_* */

814

int flags; /* See SD_* */

815

int level;

815

int level;

816

817

/* Runtime fields. */

817

/* Runtime fields. */

818

unsigned long last_balance; /* init to jiffies. units in jiffies */

818

unsigned long last_balance; /* init to jiffies. units in jiffies */

819

unsigned int balance_interval; /* initialise to 1. units in ms. */

819

unsigned int balance_interval; /* initialise to 1. units in ms. */

820

unsigned int nr_balance_failed; /* initialise to 0 */

820

unsigned int nr_balance_failed; /* initialise to 0 */

821

822

u64 last_update;

822

u64 last_update;

823

824

/* idle_balance() stats */

824

/* idle_balance() stats */

825

u64 max_newidle_lb_cost;

825

u64 max_newidle_lb_cost;

826

unsigned long next_decay_max_lb_cost;

826

unsigned long next_decay_max_lb_cost;

827

828

#ifdef CONFIG_SCHEDSTATS

828

#ifdef CONFIG_SCHEDSTATS

829

/* load_balance() stats */

829

/* load_balance() stats */

830

unsigned int lb_count[CPU_MAX_IDLE_TYPES];

830

unsigned int lb_count[CPU_MAX_IDLE_TYPES];

831

unsigned int lb_failed[CPU_MAX_IDLE_TYPES];

831

unsigned int lb_failed[CPU_MAX_IDLE_TYPES];

832

unsigned int lb_balanced[CPU_MAX_IDLE_TYPES];

832

unsigned int lb_balanced[CPU_MAX_IDLE_TYPES];

833

unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES];

833

unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES];

834

unsigned int lb_gained[CPU_MAX_IDLE_TYPES];

834

unsigned int lb_gained[CPU_MAX_IDLE_TYPES];

835

unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES];

835

unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES];

836

unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES];

836

unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES];

837

unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES];

837

unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES];

838

839

/* Active load balancing */

839

/* Active load balancing */

840

unsigned int alb_count;

840

unsigned int alb_count;

841

unsigned int alb_failed;

841

unsigned int alb_failed;

842

unsigned int alb_pushed;

842

unsigned int alb_pushed;

843

844

/* SD_BALANCE_EXEC stats */

844

/* SD_BALANCE_EXEC stats */

845

unsigned int sbe_count;

845

unsigned int sbe_count;

846

unsigned int sbe_balanced;

846

unsigned int sbe_balanced;

847

unsigned int sbe_pushed;

847

unsigned int sbe_pushed;

848

849

/* SD_BALANCE_FORK stats */

849

/* SD_BALANCE_FORK stats */

850

unsigned int sbf_count;

850

unsigned int sbf_count;

851

unsigned int sbf_balanced;

851

unsigned int sbf_balanced;

852

unsigned int sbf_pushed;

852

unsigned int sbf_pushed;

853

854

/* try_to_wake_up() stats */

854

/* try_to_wake_up() stats */

855

unsigned int ttwu_wake_remote;

855

unsigned int ttwu_wake_remote;

856

unsigned int ttwu_move_affine;

856

unsigned int ttwu_move_affine;

857

unsigned int ttwu_move_balance;

857

unsigned int ttwu_move_balance;

858

#endif

858

#endif

859

#ifdef CONFIG_SCHED_DEBUG

859

#ifdef CONFIG_SCHED_DEBUG

860

char *name;

860

char *name;

861

#endif

861

#endif

862

union {

862

union {

863

void *private; /* used during construction */

863

void *private; /* used during construction */

864

struct rcu_head rcu; /* used during destruction */

864

struct rcu_head rcu; /* used during destruction */

865

};

865

};

866

867

unsigned int span_weight;

867

unsigned int span_weight;

868

/*

868

/*

869

* Span of all CPUs in this domain.

869

* Span of all CPUs in this domain.

870

*

870

*

871

* NOTE: this field is variable length. (Allocated dynamically

871

* NOTE: this field is variable length. (Allocated dynamically

872

* by attaching extra space to the end of the structure,

872

* by attaching extra space to the end of the structure,

873

* depending on how many CPUs the kernel has booted up with)

873

* depending on how many CPUs the kernel has booted up with)

874

*/

874

*/

875

unsigned long span[0];

875

unsigned long span[0];

876

};

876

};

877

878

static inline struct cpumask *sched_domain_span(struct sched_domain *sd)

878

static inline struct cpumask *sched_domain_span(struct sched_domain *sd)

879

{

879

{

880

return to_cpumask(sd->span);

880

return to_cpumask(sd->span);

881

}

881

}

882

883

extern void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],

883

extern void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],

884

struct sched_domain_attr *dattr_new);

884

struct sched_domain_attr *dattr_new);

885

886

/* Allocate an array of sched domains, for partition_sched_domains(). */

886

/* Allocate an array of sched domains, for partition_sched_domains(). */

887

cpumask_var_t *alloc_sched_domains(unsigned int ndoms);

887

cpumask_var_t *alloc_sched_domains(unsigned int ndoms);

888

void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms);

888

void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms);

889

890

bool cpus_share_cache(int this_cpu, int that_cpu);

890

bool cpus_share_cache(int this_cpu, int that_cpu);

891

892

#else /* CONFIG_SMP */

892

#else /* CONFIG_SMP */

893

894

struct sched_domain_attr;

894

struct sched_domain_attr;

895

896

static inline void

896

static inline void

897

partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],

897

partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],

898

struct sched_domain_attr *dattr_new)

898

struct sched_domain_attr *dattr_new)

899

{

899

{

900

}

900

}

901

902

static inline bool cpus_share_cache(int this_cpu, int that_cpu)

902

static inline bool cpus_share_cache(int this_cpu, int that_cpu)

903

{

903

{

904

return true;

904

return true;

905

}

905

}

906

907

#endif /* !CONFIG_SMP */

907

#endif /* !CONFIG_SMP */

908

909

910

struct io_context; /* See blkdev.h */

910

struct io_context; /* See blkdev.h */

911

912

913

#ifdef ARCH_HAS_PREFETCH_SWITCH_STACK

913

#ifdef ARCH_HAS_PREFETCH_SWITCH_STACK

914

extern void prefetch_stack(struct task_struct *t);

914

extern void prefetch_stack(struct task_struct *t);

915

#else

915

#else

916

static inline void prefetch_stack(struct task_struct *t) { }

916

static inline void prefetch_stack(struct task_struct *t) { }

917

#endif

917

#endif

918

919

struct audit_context; /* See audit.c */

919

struct audit_context; /* See audit.c */

920

struct mempolicy;

920

struct mempolicy;

921

struct pipe_inode_info;

921

struct pipe_inode_info;

922

struct uts_namespace;

922

struct uts_namespace;

923

924

struct load_weight {

924

struct load_weight {

925

unsigned long weight, inv_weight;

925

unsigned long weight, inv_weight;

926

};

926

};

927

928

struct sched_avg {

928

struct sched_avg {

929

/*

929

/*

930

* These sums represent an infinite geometric series and so are bound

930

* These sums represent an infinite geometric series and so are bound

931

* above by 1024/(1-y). Thus we only need a u32 to store them for all

931

* above by 1024/(1-y). Thus we only need a u32 to store them for all

932

* choices of y < 1-2^(-32)*1024.

932

* choices of y < 1-2^(-32)*1024.

933

*/

933

*/

934

u32 runnable_avg_sum, runnable_avg_period;

934

u32 runnable_avg_sum, runnable_avg_period;

935

u64 last_runnable_update;

935

u64 last_runnable_update;

936

s64 decay_count;

936

s64 decay_count;

937

unsigned long load_avg_contrib;

937

unsigned long load_avg_contrib;

938

};

938

};

939

940

#ifdef CONFIG_SCHEDSTATS

940

#ifdef CONFIG_SCHEDSTATS

941

struct sched_statistics {

941

struct sched_statistics {

942

u64 wait_start;

942

u64 wait_start;

943

u64 wait_max;

943

u64 wait_max;

944

u64 wait_count;

944

u64 wait_count;

945

u64 wait_sum;

945

u64 wait_sum;

946

u64 iowait_count;

946

u64 iowait_count;

947

u64 iowait_sum;

947

u64 iowait_sum;

948

949

u64 sleep_start;

949

u64 sleep_start;

950

u64 sleep_max;

950

u64 sleep_max;

951

s64 sum_sleep_runtime;

951

s64 sum_sleep_runtime;

952

953

u64 block_start;

953

u64 block_start;

954

u64 block_max;

954

u64 block_max;

955

u64 exec_max;

955

u64 exec_max;

956

u64 slice_max;

956

u64 slice_max;

957

958

u64 nr_migrations_cold;

958

u64 nr_migrations_cold;

959

u64 nr_failed_migrations_affine;

959

u64 nr_failed_migrations_affine;

960

u64 nr_failed_migrations_running;

960

u64 nr_failed_migrations_running;

961

u64 nr_failed_migrations_hot;

961

u64 nr_failed_migrations_hot;

962

u64 nr_forced_migrations;

962

u64 nr_forced_migrations;

963

964

u64 nr_wakeups;

964

u64 nr_wakeups;

965

u64 nr_wakeups_sync;

965

u64 nr_wakeups_sync;

966

u64 nr_wakeups_migrate;

966

u64 nr_wakeups_migrate;

967

u64 nr_wakeups_local;

967

u64 nr_wakeups_local;

968

u64 nr_wakeups_remote;

968

u64 nr_wakeups_remote;

969

u64 nr_wakeups_affine;

969

u64 nr_wakeups_affine;

970

u64 nr_wakeups_affine_attempts;

970

u64 nr_wakeups_affine_attempts;

971

u64 nr_wakeups_passive;

971

u64 nr_wakeups_passive;

972

u64 nr_wakeups_idle;

972

u64 nr_wakeups_idle;

973

};

973

};

974

#endif

974

#endif

975

976

struct sched_entity {

976

struct sched_entity {

977

struct load_weight load; /* for load-balancing */

977

struct load_weight load; /* for load-balancing */

978

struct rb_node run_node;

978

struct rb_node run_node;

979

struct list_head group_node;

979

struct list_head group_node;

980

unsigned int on_rq;

980

unsigned int on_rq;

981

982

u64 exec_start;

982

u64 exec_start;

983

u64 sum_exec_runtime;

983

u64 sum_exec_runtime;

984

u64 vruntime;

984

u64 vruntime;

985

u64 prev_sum_exec_runtime;

985

u64 prev_sum_exec_runtime;

986

987

u64 nr_migrations;

987

u64 nr_migrations;

988

989

#ifdef CONFIG_SCHEDSTATS

989

#ifdef CONFIG_SCHEDSTATS

990

struct sched_statistics statistics;

990

struct sched_statistics statistics;

991

#endif

991

#endif

992

993

#ifdef CONFIG_FAIR_GROUP_SCHED

993

#ifdef CONFIG_FAIR_GROUP_SCHED

994

struct sched_entity *parent;

994

struct sched_entity *parent;

995

/* rq on which this entity is (to be) queued: */

995

/* rq on which this entity is (to be) queued: */

996

struct cfs_rq *cfs_rq;

996

struct cfs_rq *cfs_rq;

997

/* rq "owned" by this entity/group: */

997

/* rq "owned" by this entity/group: */

998

struct cfs_rq *my_q;

998

struct cfs_rq *my_q;

999

#endif

999

#endif

1000

1001

#ifdef CONFIG_SMP

1001

#ifdef CONFIG_SMP

1002

/* Per-entity load-tracking */

1002

/* Per-entity load-tracking */

1003

struct sched_avg avg;

1003

struct sched_avg avg;

1004

#endif

1004

#endif

1005

};

1005

};

1006

1007

struct sched_rt_entity {

1007

struct sched_rt_entity {

1008

struct list_head run_list;

1008

struct list_head run_list;

1009

unsigned long timeout;

1009

unsigned long timeout;

1010

unsigned long watchdog_stamp;

1010

unsigned long watchdog_stamp;

1011

unsigned int time_slice;

1011

unsigned int time_slice;

1012

1013

struct sched_rt_entity *back;

1013

struct sched_rt_entity *back;

1014

#ifdef CONFIG_RT_GROUP_SCHED

1014

#ifdef CONFIG_RT_GROUP_SCHED

1015

struct sched_rt_entity *parent;

1015

struct sched_rt_entity *parent;

1016

/* rq on which this entity is (to be) queued: */

1016

/* rq on which this entity is (to be) queued: */

1017

struct rt_rq *rt_rq;

1017

struct rt_rq *rt_rq;

1018

/* rq "owned" by this entity/group: */

1018

/* rq "owned" by this entity/group: */

1019

struct rt_rq *my_q;

1019

struct rt_rq *my_q;

1020

#endif

1020

#endif

1021

};

1021

};

1022

1023

1024

struct rcu_node;

1024

struct rcu_node;

1025

1026

enum perf_event_task_context {

1026

enum perf_event_task_context {

1027

perf_invalid_context = -1,

1027

perf_invalid_context = -1,

1028

perf_hw_context = 0,

1028

perf_hw_context = 0,

1029

perf_sw_context,

1029

perf_sw_context,

1030

perf_nr_task_contexts,

1030

perf_nr_task_contexts,

1031

};

1031

};

1032

1033

struct task_struct {

1033

struct task_struct {

1034

volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */

1034

volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */

1035

void *stack;

1035

void *stack;

1036

atomic_t usage;

1036

atomic_t usage;

1037

unsigned int flags; /* per process flags, defined below */

1037

unsigned int flags; /* per process flags, defined below */

1038

unsigned int ptrace;

1038

unsigned int ptrace;

1039

1040

#ifdef CONFIG_SMP

1040

#ifdef CONFIG_SMP

1041

struct llist_node wake_entry;

1041

struct llist_node wake_entry;

1042

int on_cpu;

1042

int on_cpu;

1043

struct task_struct *last_wakee;

1043

struct task_struct *last_wakee;

1044

unsigned long wakee_flips;

1044

unsigned long wakee_flips;

1045

unsigned long wakee_flip_decay_ts;

1045

unsigned long wakee_flip_decay_ts;

1046

1047

int wake_cpu;

1047

int wake_cpu;

1048

#endif

1048

#endif

1049

int on_rq;

1049

int on_rq;

1050

1051

int prio, static_prio, normal_prio;

1051

int prio, static_prio, normal_prio;

1052

unsigned int rt_priority;

1052

unsigned int rt_priority;

1053

const struct sched_class *sched_class;

1053

const struct sched_class *sched_class;

1054

struct sched_entity se;

1054

struct sched_entity se;

1055

struct sched_rt_entity rt;

1055

struct sched_rt_entity rt;

1056

#ifdef CONFIG_CGROUP_SCHED

1056

#ifdef CONFIG_CGROUP_SCHED

1057

struct task_group *sched_task_group;

1057

struct task_group *sched_task_group;

1058

#endif

1058

#endif

1059

1060

#ifdef CONFIG_PREEMPT_NOTIFIERS

1060

#ifdef CONFIG_PREEMPT_NOTIFIERS

1061

/* list of struct preempt_notifier: */

1061

/* list of struct preempt_notifier: */

1062

struct hlist_head preempt_notifiers;

1062

struct hlist_head preempt_notifiers;

1063

#endif

1063

#endif

1064

1065

/*

1066

* fpu_counter contains the number of consecutive context switches

1067

* that the FPU is used. If this is over a threshold, the lazy fpu

1068

* saving becomes unlazy to save the trap. This is an unsigned char

1069

* so that after 256 times the counter wraps and the behavior turns

1070

* lazy again; this to deal with bursty apps that only use FPU for

1071

* a short time

1072

*/

1073

unsigned char fpu_counter;

1074

#ifdef CONFIG_BLK_DEV_IO_TRACE

1065

#ifdef CONFIG_BLK_DEV_IO_TRACE

1075

unsigned int btrace_seq;

1066

unsigned int btrace_seq;

1076

#endif

1067

#endif

1077

1068

1078

unsigned int policy;

1069

unsigned int policy;

1079

int nr_cpus_allowed;

1070

int nr_cpus_allowed;

1080

cpumask_t cpus_allowed;

1071

cpumask_t cpus_allowed;

1081

1072

1082

#ifdef CONFIG_PREEMPT_RCU

1073

#ifdef CONFIG_PREEMPT_RCU

1083

int rcu_read_lock_nesting;

1074

int rcu_read_lock_nesting;

1084

char rcu_read_unlock_special;

1075

char rcu_read_unlock_special;

1085

struct list_head rcu_node_entry;

1076

struct list_head rcu_node_entry;

1086

#endif /* #ifdef CONFIG_PREEMPT_RCU */

1077

#endif /* #ifdef CONFIG_PREEMPT_RCU */

1087

#ifdef CONFIG_TREE_PREEMPT_RCU

1078

#ifdef CONFIG_TREE_PREEMPT_RCU

1088

struct rcu_node *rcu_blocked_node;

1079

struct rcu_node *rcu_blocked_node;

1089

#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */

1080

#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */

1090

#ifdef CONFIG_RCU_BOOST

1081

#ifdef CONFIG_RCU_BOOST

1091

struct rt_mutex *rcu_boost_mutex;

1082

struct rt_mutex *rcu_boost_mutex;

1092

#endif /* #ifdef CONFIG_RCU_BOOST */

1083

#endif /* #ifdef CONFIG_RCU_BOOST */

1093

1084

1094

#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)

1085

#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)

1095

struct sched_info sched_info;

1086

struct sched_info sched_info;

1096

#endif

1087

#endif

1097

1088

1098

struct list_head tasks;

1089

struct list_head tasks;

1099

#ifdef CONFIG_SMP

1090

#ifdef CONFIG_SMP

1100

struct plist_node pushable_tasks;

1091

struct plist_node pushable_tasks;

1101

#endif

1092

#endif

1102

1093

1103

struct mm_struct *mm, *active_mm;

1094

struct mm_struct *mm, *active_mm;

1104

#ifdef CONFIG_COMPAT_BRK

1095

#ifdef CONFIG_COMPAT_BRK

1105

unsigned brk_randomized:1;

1096

unsigned brk_randomized:1;

1106

#endif

1097

#endif

1107

#if defined(SPLIT_RSS_COUNTING)

1098

#if defined(SPLIT_RSS_COUNTING)

1108

struct task_rss_stat rss_stat;

1099

struct task_rss_stat rss_stat;

1109

#endif

1100

#endif

1110

/* task state */

1101

/* task state */

1111

int exit_state;

1102

int exit_state;

1112

int exit_code, exit_signal;

1103

int exit_code, exit_signal;

1113

int pdeath_signal; /* The signal sent when the parent dies */

1104

int pdeath_signal; /* The signal sent when the parent dies */

1114

unsigned int jobctl; /* JOBCTL_*, siglock protected */

1105

unsigned int jobctl; /* JOBCTL_*, siglock protected */

1115

1106

1116

/* Used for emulating ABI behavior of previous Linux versions */

1107

/* Used for emulating ABI behavior of previous Linux versions */

1117

unsigned int personality;

1108

unsigned int personality;

1118

1109

1119

unsigned did_exec:1;

1110

unsigned did_exec:1;

1120

unsigned in_execve:1; /* Tell the LSMs that the process is doing an

1111

unsigned in_execve:1; /* Tell the LSMs that the process is doing an

1121

* execve */

1112

* execve */

1122

unsigned in_iowait:1;

1113

unsigned in_iowait:1;

1123

1114

1124

/* task may not gain privileges */

1115

/* task may not gain privileges */

1125

unsigned no_new_privs:1;

1116

unsigned no_new_privs:1;

1126

1117

1127

/* Revert to default priority/policy when forking */

1118

/* Revert to default priority/policy when forking */

1128

unsigned sched_reset_on_fork:1;

1119

unsigned sched_reset_on_fork:1;

1129

unsigned sched_contributes_to_load:1;

1120

unsigned sched_contributes_to_load:1;

1130

1121

1131

pid_t pid;

1122

pid_t pid;

1132

pid_t tgid;

1123

pid_t tgid;

1133

1124

1134

#ifdef CONFIG_CC_STACKPROTECTOR

1125

#ifdef CONFIG_CC_STACKPROTECTOR

1135

/* Canary value for the -fstack-protector gcc feature */

1126

/* Canary value for the -fstack-protector gcc feature */

1136

unsigned long stack_canary;

1127

unsigned long stack_canary;

1137

#endif

1128

#endif

1138

/*

1129

/*

1139

* pointers to (original) parent process, youngest child, younger sibling,

1130

* pointers to (original) parent process, youngest child, younger sibling,

1140

* older sibling, respectively. (p->father can be replaced with

1131

* older sibling, respectively. (p->father can be replaced with

1141

* p->real_parent->pid)

1132

* p->real_parent->pid)

1142

*/

1133

*/

1143

struct task_struct __rcu *real_parent; /* real parent process */

1134

struct task_struct __rcu *real_parent; /* real parent process */

1144

struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */

1135

struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */

1145

/*

1136

/*

1146

* children/sibling forms the list of my natural children

1137

* children/sibling forms the list of my natural children

1147

*/

1138

*/

1148

struct list_head children; /* list of my children */

1139

struct list_head children; /* list of my children */

1149

struct list_head sibling; /* linkage in my parent's children list */

1140

struct list_head sibling; /* linkage in my parent's children list */

1150

struct task_struct *group_leader; /* threadgroup leader */

1141

struct task_struct *group_leader; /* threadgroup leader */

1151

1142

1152

/*

1143

/*

1153

* ptraced is the list of tasks this task is using ptrace on.

1144

* ptraced is the list of tasks this task is using ptrace on.

1154

* This includes both natural children and PTRACE_ATTACH targets.

1145

* This includes both natural children and PTRACE_ATTACH targets.

1155

* p->ptrace_entry is p's link on the p->parent->ptraced list.

1146

* p->ptrace_entry is p's link on the p->parent->ptraced list.

1156

*/

1147

*/

1157

struct list_head ptraced;

1148

struct list_head ptraced;

1158

struct list_head ptrace_entry;

1149

struct list_head ptrace_entry;

1159

1150

1160

/* PID/PID hash table linkage. */

1151

/* PID/PID hash table linkage. */

1161

struct pid_link pids[PIDTYPE_MAX];

1152

struct pid_link pids[PIDTYPE_MAX];

1162

struct list_head thread_group;

1153

struct list_head thread_group;

1163

1154

1164

struct completion *vfork_done; /* for vfork() */

1155

struct completion *vfork_done; /* for vfork() */

1165

int __user *set_child_tid; /* CLONE_CHILD_SETTID */

1156

int __user *set_child_tid; /* CLONE_CHILD_SETTID */

1166

int __user *clear_child_tid; /* CLONE_CHILD_CLEARTID */

1157

int __user *clear_child_tid; /* CLONE_CHILD_CLEARTID */

1167

1158

1168

cputime_t utime, stime, utimescaled, stimescaled;

1159

cputime_t utime, stime, utimescaled, stimescaled;

1169

cputime_t gtime;

1160

cputime_t gtime;

1170

#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE

1161

#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE

1171

struct cputime prev_cputime;

1162

struct cputime prev_cputime;

1172

#endif

1163

#endif

1173

#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN

1164

#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN

1174

seqlock_t vtime_seqlock;

1165

seqlock_t vtime_seqlock;

1175

unsigned long long vtime_snap;

1166

unsigned long long vtime_snap;

1176

enum {

1167

enum {

1177

VTIME_SLEEPING = 0,

1168

VTIME_SLEEPING = 0,

1178

VTIME_USER,

1169

VTIME_USER,

1179

VTIME_SYS,

1170

VTIME_SYS,

1180

} vtime_snap_whence;

1171

} vtime_snap_whence;

1181

#endif

1172

#endif

1182

unsigned long nvcsw, nivcsw; /* context switch counts */

1173

unsigned long nvcsw, nivcsw; /* context switch counts */

1183

struct timespec start_time; /* monotonic time */

1174

struct timespec start_time; /* monotonic time */

1184

struct timespec real_start_time; /* boot based time */

1175

struct timespec real_start_time; /* boot based time */

1185

/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */

1176

/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */

1186

unsigned long min_flt, maj_flt;

1177

unsigned long min_flt, maj_flt;

1187

1178

1188

struct task_cputime cputime_expires;

1179

struct task_cputime cputime_expires;

1189

struct list_head cpu_timers[3];

1180

struct list_head cpu_timers[3];

1190

1181

1191

/* process credentials */

1182

/* process credentials */

1192

const struct cred __rcu *real_cred; /* objective and real subjective task

1183

const struct cred __rcu *real_cred; /* objective and real subjective task

1193

* credentials (COW) */

1184

* credentials (COW) */

1194

const struct cred __rcu *cred; /* effective (overridable) subjective task

1185

const struct cred __rcu *cred; /* effective (overridable) subjective task

1195

* credentials (COW) */

1186

* credentials (COW) */

1196

char comm[TASK_COMM_LEN]; /* executable name excluding path

1187

char comm[TASK_COMM_LEN]; /* executable name excluding path

1197

- access with [gs]et_task_comm (which lock

1188

- access with [gs]et_task_comm (which lock

1198

it with task_lock())

1189

it with task_lock())

1199

- initialized normally by setup_new_exec */

1190

- initialized normally by setup_new_exec */

1200

/* file system info */

1191

/* file system info */

1201

int link_count, total_link_count;

1192

int link_count, total_link_count;

1202

#ifdef CONFIG_SYSVIPC

1193

#ifdef CONFIG_SYSVIPC

1203

/* ipc stuff */

1194

/* ipc stuff */

1204

struct sysv_sem sysvsem;

1195

struct sysv_sem sysvsem;

1205

#endif

1196

#endif

1206

#ifdef CONFIG_DETECT_HUNG_TASK

1197

#ifdef CONFIG_DETECT_HUNG_TASK

1207

/* hung task detection */

1198

/* hung task detection */

1208

unsigned long last_switch_count;

1199

unsigned long last_switch_count;

1209

#endif

1200

#endif

1210

/* CPU-specific state of this task */

1201

/* CPU-specific state of this task */

1211

struct thread_struct thread;

1202

struct thread_struct thread;

1212

/* filesystem information */

1203

/* filesystem information */

1213

struct fs_struct *fs;

1204

struct fs_struct *fs;

1214

/* open file information */

1205

/* open file information */

1215

struct files_struct *files;

1206

struct files_struct *files;

1216

/* namespaces */

1207

/* namespaces */

1217

struct nsproxy *nsproxy;

1208

struct nsproxy *nsproxy;

1218

/* signal handlers */

1209

/* signal handlers */

1219

struct signal_struct *signal;

1210

struct signal_struct *signal;

1220

struct sighand_struct *sighand;

1211

struct sighand_struct *sighand;

1221

1212

1222

sigset_t blocked, real_blocked;

1213

sigset_t blocked, real_blocked;

1223

sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */

1214

sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */

1224

struct sigpending pending;

1215

struct sigpending pending;

1225

1216

1226

unsigned long sas_ss_sp;

1217

unsigned long sas_ss_sp;

1227

size_t sas_ss_size;

1218

size_t sas_ss_size;

1228

int (*notifier)(void *priv);

1219

int (*notifier)(void *priv);

1229

void *notifier_data;

1220

void *notifier_data;

1230

sigset_t *notifier_mask;

1221

sigset_t *notifier_mask;

1231

struct callback_head *task_works;

1222

struct callback_head *task_works;

1232

1223

1233

struct audit_context *audit_context;

1224

struct audit_context *audit_context;

1234

#ifdef CONFIG_AUDITSYSCALL

1225

#ifdef CONFIG_AUDITSYSCALL

1235

kuid_t loginuid;

1226

kuid_t loginuid;

1236

unsigned int sessionid;

1227

unsigned int sessionid;

1237

#endif

1228

#endif

1238

struct seccomp seccomp;

1229

struct seccomp seccomp;

1239

1230

1240

/* Thread group tracking */

1231

/* Thread group tracking */

1241

u32 parent_exec_id;

1232

u32 parent_exec_id;

1242

u32 self_exec_id;

1233

u32 self_exec_id;

1243

/* Protection of (de-)allocation: mm, files, fs, tty, keyrings, mems_allowed,

1234

/* Protection of (de-)allocation: mm, files, fs, tty, keyrings, mems_allowed,

1244

* mempolicy */

1235

* mempolicy */

1245

spinlock_t alloc_lock;

1236

spinlock_t alloc_lock;

1246

1237

1247

/* Protection of the PI data structures: */

1238

/* Protection of the PI data structures: */

1248

raw_spinlock_t pi_lock;

1239

raw_spinlock_t pi_lock;

1249

1240

1250

#ifdef CONFIG_RT_MUTEXES

1241

#ifdef CONFIG_RT_MUTEXES

1251

/* PI waiters blocked on a rt_mutex held by this task */

1242

/* PI waiters blocked on a rt_mutex held by this task */

1252

struct plist_head pi_waiters;

1243

struct plist_head pi_waiters;

1253

/* Deadlock detection and priority inheritance handling */

1244

/* Deadlock detection and priority inheritance handling */

1254

struct rt_mutex_waiter *pi_blocked_on;

1245

struct rt_mutex_waiter *pi_blocked_on;

1255

#endif

1246

#endif

1256

1247

1257

#ifdef CONFIG_DEBUG_MUTEXES

1248

#ifdef CONFIG_DEBUG_MUTEXES

1258

/* mutex deadlock detection */

1249

/* mutex deadlock detection */

1259

struct mutex_waiter *blocked_on;

1250

struct mutex_waiter *blocked_on;

1260

#endif

1251

#endif

1261

#ifdef CONFIG_TRACE_IRQFLAGS

1252

#ifdef CONFIG_TRACE_IRQFLAGS

1262

unsigned int irq_events;

1253

unsigned int irq_events;

1263

unsigned long hardirq_enable_ip;

1254

unsigned long hardirq_enable_ip;

1264

unsigned long hardirq_disable_ip;

1255

unsigned long hardirq_disable_ip;

1265

unsigned int hardirq_enable_event;

1256

unsigned int hardirq_enable_event;

1266

unsigned int hardirq_disable_event;

1257

unsigned int hardirq_disable_event;

1267

int hardirqs_enabled;

1258

int hardirqs_enabled;

1268

int hardirq_context;

1259

int hardirq_context;

1269

unsigned long softirq_disable_ip;

1260

unsigned long softirq_disable_ip;

1270

unsigned long softirq_enable_ip;

1261

unsigned long softirq_enable_ip;

1271

unsigned int softirq_disable_event;

1262

unsigned int softirq_disable_event;

1272

unsigned int softirq_enable_event;

1263

unsigned int softirq_enable_event;

1273

int softirqs_enabled;

1264

int softirqs_enabled;

1274

int softirq_context;

1265

int softirq_context;

1275

#endif

1266

#endif

1276

#ifdef CONFIG_LOCKDEP

1267

#ifdef CONFIG_LOCKDEP

1277

# define MAX_LOCK_DEPTH 48UL

1268

# define MAX_LOCK_DEPTH 48UL

1278

u64 curr_chain_key;

1269

u64 curr_chain_key;

1279

int lockdep_depth;

1270

int lockdep_depth;

1280

unsigned int lockdep_recursion;

1271

unsigned int lockdep_recursion;

1281

struct held_lock held_locks[MAX_LOCK_DEPTH];

1272

struct held_lock held_locks[MAX_LOCK_DEPTH];

1282

gfp_t lockdep_reclaim_gfp;

1273

gfp_t lockdep_reclaim_gfp;

1283

#endif

1274

#endif

1284

1275

1285

/* journalling filesystem info */

1276

/* journalling filesystem info */

1286

void *journal_info;

1277

void *journal_info;

1287

1278

1288

/* stacked block device info */

1279

/* stacked block device info */

1289

struct bio_list *bio_list;

1280

struct bio_list *bio_list;

1290

1281

1291

#ifdef CONFIG_BLOCK

1282

#ifdef CONFIG_BLOCK

1292

/* stack plugging */

1283

/* stack plugging */

1293

struct blk_plug *plug;

1284

struct blk_plug *plug;

1294

#endif

1285

#endif

1295

1286

1296

/* VM state */

1287

/* VM state */

1297

struct reclaim_state *reclaim_state;

1288

struct reclaim_state *reclaim_state;

1298

1289

1299

struct backing_dev_info *backing_dev_info;

1290

struct backing_dev_info *backing_dev_info;

1300

1291

1301

struct io_context *io_context;

1292

struct io_context *io_context;

1302

1293

1303

unsigned long ptrace_message;

1294

unsigned long ptrace_message;

1304

siginfo_t *last_siginfo; /* For ptrace use. */

1295

siginfo_t *last_siginfo; /* For ptrace use. */

1305

struct task_io_accounting ioac;

1296

struct task_io_accounting ioac;

1306

#if defined(CONFIG_TASK_XACCT)

1297

#if defined(CONFIG_TASK_XACCT)

1307

u64 acct_rss_mem1; /* accumulated rss usage */

1298

u64 acct_rss_mem1; /* accumulated rss usage */

1308

u64 acct_vm_mem1; /* accumulated virtual memory usage */

1299

u64 acct_vm_mem1; /* accumulated virtual memory usage */

1309

cputime_t acct_timexpd; /* stime + utime since last update */

1300

cputime_t acct_timexpd; /* stime + utime since last update */

1310

#endif

1301

#endif

1311

#ifdef CONFIG_CPUSETS

1302

#ifdef CONFIG_CPUSETS

1312

nodemask_t mems_allowed; /* Protected by alloc_lock */

1303

nodemask_t mems_allowed; /* Protected by alloc_lock */

1313

seqcount_t mems_allowed_seq; /* Seqence no to catch updates */

1304

seqcount_t mems_allowed_seq; /* Seqence no to catch updates */

1314

int cpuset_mem_spread_rotor;

1305

int cpuset_mem_spread_rotor;

1315

int cpuset_slab_spread_rotor;

1306

int cpuset_slab_spread_rotor;

1316

#endif

1307

#endif

1317

#ifdef CONFIG_CGROUPS

1308

#ifdef CONFIG_CGROUPS

1318

/* Control Group info protected by css_set_lock */

1309

/* Control Group info protected by css_set_lock */

1319

struct css_set __rcu *cgroups;

1310

struct css_set __rcu *cgroups;

1320

/* cg_list protected by css_set_lock and tsk->alloc_lock */

1311

/* cg_list protected by css_set_lock and tsk->alloc_lock */

1321

struct list_head cg_list;

1312

struct list_head cg_list;

1322

#endif

1313

#endif

1323

#ifdef CONFIG_FUTEX

1314

#ifdef CONFIG_FUTEX

1324

struct robust_list_head __user *robust_list;

1315

struct robust_list_head __user *robust_list;

1325

#ifdef CONFIG_COMPAT

1316

#ifdef CONFIG_COMPAT

1326

struct compat_robust_list_head __user *compat_robust_list;

1317

struct compat_robust_list_head __user *compat_robust_list;

1327

#endif

1318

#endif

1328

struct list_head pi_state_list;

1319

struct list_head pi_state_list;

1329

struct futex_pi_state *pi_state_cache;

1320

struct futex_pi_state *pi_state_cache;

1330

#endif

1321

#endif

1331

#ifdef CONFIG_PERF_EVENTS

1322

#ifdef CONFIG_PERF_EVENTS

1332

struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts];

1323

struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts];

1333

struct mutex perf_event_mutex;

1324

struct mutex perf_event_mutex;

1334

struct list_head perf_event_list;

1325

struct list_head perf_event_list;

1335

#endif

1326

#endif

1336

#ifdef CONFIG_NUMA

1327

#ifdef CONFIG_NUMA

1337

struct mempolicy *mempolicy; /* Protected by alloc_lock */

1328

struct mempolicy *mempolicy; /* Protected by alloc_lock */

1338

short il_next;

1329

short il_next;

1339

short pref_node_fork;

1330

short pref_node_fork;

1340

#endif

1331

#endif

1341

#ifdef CONFIG_NUMA_BALANCING

1332

#ifdef CONFIG_NUMA_BALANCING

1342

int numa_scan_seq;

1333

int numa_scan_seq;

1343

unsigned int numa_scan_period;

1334

unsigned int numa_scan_period;

1344

unsigned int numa_scan_period_max;

1335

unsigned int numa_scan_period_max;

1345

int numa_preferred_nid;

1336

int numa_preferred_nid;

1346

int numa_migrate_deferred;

1337

int numa_migrate_deferred;

1347

unsigned long numa_migrate_retry;

1338

unsigned long numa_migrate_retry;

1348

u64 node_stamp; /* migration stamp */

1339

u64 node_stamp; /* migration stamp */

1349

struct callback_head numa_work;

1340

struct callback_head numa_work;

1350

1341

1351

struct list_head numa_entry;

1342

struct list_head numa_entry;

1352

struct numa_group *numa_group;

1343

struct numa_group *numa_group;

1353

1344

1354

/*

1345

/*

1355

* Exponential decaying average of faults on a per-node basis.

1346

* Exponential decaying average of faults on a per-node basis.

1356

* Scheduling placement decisions are made based on the these counts.

1347

* Scheduling placement decisions are made based on the these counts.

1357

* The values remain static for the duration of a PTE scan

1348

* The values remain static for the duration of a PTE scan

1358

*/

1349

*/

1359

unsigned long *numa_faults;

1350

unsigned long *numa_faults;

1360

unsigned long total_numa_faults;

1351

unsigned long total_numa_faults;

1361

1352

1362

/*

1353

/*

1363

* numa_faults_buffer records faults per node during the current

1354

* numa_faults_buffer records faults per node during the current

1364

* scan window. When the scan completes, the counts in numa_faults

1355

* scan window. When the scan completes, the counts in numa_faults

1365

* decay and these values are copied.

1356

* decay and these values are copied.

1366

*/

1357

*/

1367

unsigned long *numa_faults_buffer;

1358

unsigned long *numa_faults_buffer;

1368

1359

1369

/*

1360

/*

1370

* numa_faults_locality tracks if faults recorded during the last

1361

* numa_faults_locality tracks if faults recorded during the last

1371

* scan window were remote/local. The task scan period is adapted

1362

* scan window were remote/local. The task scan period is adapted

1372

* based on the locality of the faults with different weights

1363

* based on the locality of the faults with different weights

1373

* depending on whether they were shared or private faults

1364

* depending on whether they were shared or private faults

1374

*/

1365

*/

1375

unsigned long numa_faults_locality[2];

1366

unsigned long numa_faults_locality[2];

1376

1367

1377

unsigned long numa_pages_migrated;

1368

unsigned long numa_pages_migrated;

1378

#endif /* CONFIG_NUMA_BALANCING */

1369

#endif /* CONFIG_NUMA_BALANCING */

1379

1370

1380

struct rcu_head rcu;

1371

struct rcu_head rcu;

1381

1372

1382

/*

1373

/*

1383

* cache last used pipe for splice

1374

* cache last used pipe for splice

1384

*/

1375

*/

1385

struct pipe_inode_info *splice_pipe;

1376

struct pipe_inode_info *splice_pipe;

1386

1377

1387

struct page_frag task_frag;

1378

struct page_frag task_frag;

1388

1379

1389

#ifdef CONFIG_TASK_DELAY_ACCT

1380

#ifdef CONFIG_TASK_DELAY_ACCT

1390

struct task_delay_info *delays;

1381

struct task_delay_info *delays;

1391

#endif

1382

#endif

1392

#ifdef CONFIG_FAULT_INJECTION

1383

#ifdef CONFIG_FAULT_INJECTION

1393

int make_it_fail;

1384

int make_it_fail;

1394

#endif

1385

#endif

1395

/*

1386

/*

1396

* when (nr_dirtied >= nr_dirtied_pause), it's time to call

1387

* when (nr_dirtied >= nr_dirtied_pause), it's time to call

1397

* balance_dirty_pages() for some dirty throttling pause

1388

* balance_dirty_pages() for some dirty throttling pause

1398

*/

1389

*/

1399

int nr_dirtied;

1390

int nr_dirtied;

1400

int nr_dirtied_pause;

1391

int nr_dirtied_pause;

1401

unsigned long dirty_paused_when; /* start of a write-and-pause period */

1392

unsigned long dirty_paused_when; /* start of a write-and-pause period */

1402

1393

1403

#ifdef CONFIG_LATENCYTOP

1394

#ifdef CONFIG_LATENCYTOP

1404

int latency_record_count;

1395

int latency_record_count;

1405

struct latency_record latency_record[LT_SAVECOUNT];

1396

struct latency_record latency_record[LT_SAVECOUNT];

1406

#endif

1397

#endif

1407

/*

1398

/*

1408

* time slack values; these are used to round up poll() and

1399

* time slack values; these are used to round up poll() and

1409

* select() etc timeout values. These are in nanoseconds.

1400

* select() etc timeout values. These are in nanoseconds.

1410

*/

1401

*/

1411

unsigned long timer_slack_ns;

1402

unsigned long timer_slack_ns;

1412

unsigned long default_timer_slack_ns;

1403

unsigned long default_timer_slack_ns;

1413

1404

1414

#ifdef CONFIG_FUNCTION_GRAPH_TRACER

1405

#ifdef CONFIG_FUNCTION_GRAPH_TRACER

1415

/* Index of current stored address in ret_stack */

1406

/* Index of current stored address in ret_stack */

1416

int curr_ret_stack;

1407

int curr_ret_stack;

1417

/* Stack of return addresses for return function tracing */

1408

/* Stack of return addresses for return function tracing */

1418

struct ftrace_ret_stack *ret_stack;

1409

struct ftrace_ret_stack *ret_stack;

1419

/* time stamp for last schedule */

1410

/* time stamp for last schedule */

1420

unsigned long long ftrace_timestamp;

1411

unsigned long long ftrace_timestamp;

1421

/*

1412

/*

1422

* Number of functions that haven't been traced

1413

* Number of functions that haven't been traced

1423

* because of depth overrun.

1414

* because of depth overrun.

1424

*/

1415

*/

1425

atomic_t trace_overrun;

1416

atomic_t trace_overrun;

1426

/* Pause for the tracing */

1417

/* Pause for the tracing */

1427

atomic_t tracing_graph_pause;

1418

atomic_t tracing_graph_pause;

1428

#endif

1419

#endif

1429

#ifdef CONFIG_TRACING

1420

#ifdef CONFIG_TRACING

1430

/* state flags for use by tracers */

1421

/* state flags for use by tracers */

1431

unsigned long trace;

1422

unsigned long trace;

1432

/* bitmask and counter of trace recursion */

1423

/* bitmask and counter of trace recursion */

1433

unsigned long trace_recursion;

1424

unsigned long trace_recursion;

1434

#endif /* CONFIG_TRACING */

1425

#endif /* CONFIG_TRACING */

1435

#ifdef CONFIG_MEMCG /* memcg uses this to do batch job */

1426

#ifdef CONFIG_MEMCG /* memcg uses this to do batch job */

1436

struct memcg_batch_info {

1427

struct memcg_batch_info {

1437

int do_batch; /* incremented when batch uncharge started */

1428

int do_batch; /* incremented when batch uncharge started */

1438

struct mem_cgroup *memcg; /* target memcg of uncharge */

1429

struct mem_cgroup *memcg; /* target memcg of uncharge */

1439

unsigned long nr_pages; /* uncharged usage */

1430

unsigned long nr_pages; /* uncharged usage */

1440

unsigned long memsw_nr_pages; /* uncharged mem+swap usage */

1431

unsigned long memsw_nr_pages; /* uncharged mem+swap usage */

1441

} memcg_batch;

1432

} memcg_batch;

1442

unsigned int memcg_kmem_skip_account;

1433

unsigned int memcg_kmem_skip_account;

1443

struct memcg_oom_info {

1434

struct memcg_oom_info {

1444

struct mem_cgroup *memcg;

1435

struct mem_cgroup *memcg;

1445

gfp_t gfp_mask;

1436

gfp_t gfp_mask;

1446

int order;

1437

int order;

1447

unsigned int may_oom:1;

1438

unsigned int may_oom:1;

1448

} memcg_oom;

1439

} memcg_oom;

1449

#endif

1440

#endif

1450

#ifdef CONFIG_UPROBES

1441

#ifdef CONFIG_UPROBES

1451

struct uprobe_task *utask;

1442

struct uprobe_task *utask;

1452

#endif

1443

#endif

1453

#if defined(CONFIG_BCACHE) || defined(CONFIG_BCACHE_MODULE)

1444

#if defined(CONFIG_BCACHE) || defined(CONFIG_BCACHE_MODULE)

1454

unsigned int sequential_io;

1445

unsigned int sequential_io;

1455

unsigned int sequential_io_avg;

1446

unsigned int sequential_io_avg;

1456

#endif

1447

#endif

1457

};

1448

};

1458

1449

1459

/* Future-safe accessor for struct task_struct's cpus_allowed. */

1450

/* Future-safe accessor for struct task_struct's cpus_allowed. */

1460

#define tsk_cpus_allowed(tsk) (&(tsk)->cpus_allowed)

1451

#define tsk_cpus_allowed(tsk) (&(tsk)->cpus_allowed)

1461

1452

1462

#define TNF_MIGRATED 0x01

1453

#define TNF_MIGRATED 0x01

1463

#define TNF_NO_GROUP 0x02

1454

#define TNF_NO_GROUP 0x02

1464

#define TNF_SHARED 0x04

1455

#define TNF_SHARED 0x04

1465

#define TNF_FAULT_LOCAL 0x08

1456

#define TNF_FAULT_LOCAL 0x08

1466

1457

1467

#ifdef CONFIG_NUMA_BALANCING

1458

#ifdef CONFIG_NUMA_BALANCING

1468

extern void task_numa_fault(int last_node, int node, int pages, int flags);

1459

extern void task_numa_fault(int last_node, int node, int pages, int flags);

1469

extern pid_t task_numa_group_id(struct task_struct *p);

1460

extern pid_t task_numa_group_id(struct task_struct *p);

1470

extern void set_numabalancing_state(bool enabled);

1461

extern void set_numabalancing_state(bool enabled);

1471

extern void task_numa_free(struct task_struct *p);

1462

extern void task_numa_free(struct task_struct *p);

1472

1463

1473

extern unsigned int sysctl_numa_balancing_migrate_deferred;

1464

extern unsigned int sysctl_numa_balancing_migrate_deferred;

1474

#else

1465

#else

1475

static inline void task_numa_fault(int last_node, int node, int pages,

1466

static inline void task_numa_fault(int last_node, int node, int pages,

1476

int flags)

1467

int flags)

1477

{

1468

{

1478

}

1469

}

1479

static inline pid_t task_numa_group_id(struct task_struct *p)

1470

static inline pid_t task_numa_group_id(struct task_struct *p)

1480

{

1471

{

1481

return 0;

1472

return 0;

1482

}

1473

}

1483

static inline void set_numabalancing_state(bool enabled)

1474

static inline void set_numabalancing_state(bool enabled)

1484

{

1475

{

1485

}

1476

}

1486

static inline void task_numa_free(struct task_struct *p)

1477

static inline void task_numa_free(struct task_struct *p)

1487

{

1478

{

1488

}

1479

}

1489

#endif

1480

#endif

1490

1481

1491

static inline struct pid *task_pid(struct task_struct *task)

1482

static inline struct pid *task_pid(struct task_struct *task)

1492

{

1483

{

1493

return task->pids[PIDTYPE_PID].pid;

1484

return task->pids[PIDTYPE_PID].pid;

1494

}

1485

}

1495

1486

1496

static inline struct pid *task_tgid(struct task_struct *task)

1487

static inline struct pid *task_tgid(struct task_struct *task)

1497

{

1488

{

1498

return task->group_leader->pids[PIDTYPE_PID].pid;

1489

return task->group_leader->pids[PIDTYPE_PID].pid;

1499

}

1490

}

1500

1491

1501

/*

1492

/*

1502

* Without tasklist or rcu lock it is not safe to dereference

1493

* Without tasklist or rcu lock it is not safe to dereference

1503

* the result of task_pgrp/task_session even if task == current,

1494

* the result of task_pgrp/task_session even if task == current,

1504

* we can race with another thread doing sys_setsid/sys_setpgid.

1495

* we can race with another thread doing sys_setsid/sys_setpgid.

1505

*/

1496

*/

1506

static inline struct pid *task_pgrp(struct task_struct *task)

1497

static inline struct pid *task_pgrp(struct task_struct *task)

1507

{

1498

{

1508

return task->group_leader->pids[PIDTYPE_PGID].pid;

1499

return task->group_leader->pids[PIDTYPE_PGID].pid;

1509

}

1500

}

1510

1501

1511

static inline struct pid *task_session(struct task_struct *task)

1502

static inline struct pid *task_session(struct task_struct *task)

1512

{

1503

{

1513

return task->group_leader->pids[PIDTYPE_SID].pid;

1504

return task->group_leader->pids[PIDTYPE_SID].pid;

1514

}

1505

}

1515

1506

1516

struct pid_namespace;

1507

struct pid_namespace;

1517

1508

1518

/*

1509

/*

1519

* the helpers to get the task's different pids as they are seen

1510

* the helpers to get the task's different pids as they are seen

1520

* from various namespaces

1511

* from various namespaces

1521

*

1512

*

1522

* task_xid_nr() : global id, i.e. the id seen from the init namespace;

1513

* task_xid_nr() : global id, i.e. the id seen from the init namespace;

1523

* task_xid_vnr() : virtual id, i.e. the id seen from the pid namespace of

1514

* task_xid_vnr() : virtual id, i.e. the id seen from the pid namespace of

1524

* current.

1515

* current.

1525

* task_xid_nr_ns() : id seen from the ns specified;

1516

* task_xid_nr_ns() : id seen from the ns specified;

1526

*

1517

*

1527

* set_task_vxid() : assigns a virtual id to a task;

1518

* set_task_vxid() : assigns a virtual id to a task;

1528

*

1519

*

1529

* see also pid_nr() etc in include/linux/pid.h

1520

* see also pid_nr() etc in include/linux/pid.h

1530

*/

1521

*/

1531

pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type,

1522

pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type,

1532

struct pid_namespace *ns);

1523

struct pid_namespace *ns);

1533

1524

1534

static inline pid_t task_pid_nr(struct task_struct *tsk)

1525

static inline pid_t task_pid_nr(struct task_struct *tsk)

1535

{

1526

{

1536

return tsk->pid;

1527

return tsk->pid;

1537

}

1528

}

1538

1529

1539

static inline pid_t task_pid_nr_ns(struct task_struct *tsk,

1530

static inline pid_t task_pid_nr_ns(struct task_struct *tsk,

1540

struct pid_namespace *ns)

1531

struct pid_namespace *ns)

1541

{

1532

{

1542

return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);

1533

return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);

1543

}

1534

}

1544

1535

1545

static inline pid_t task_pid_vnr(struct task_struct *tsk)

1536

static inline pid_t task_pid_vnr(struct task_struct *tsk)

1546

{

1537

{

1547

return __task_pid_nr_ns(tsk, PIDTYPE_PID, NULL);

1538

return __task_pid_nr_ns(tsk, PIDTYPE_PID, NULL);

1548

}

1539

}

1549

1540

1550

1541

1551

static inline pid_t task_tgid_nr(struct task_struct *tsk)

1542

static inline pid_t task_tgid_nr(struct task_struct *tsk)

1552

{

1543

{

1553

return tsk->tgid;

1544

return tsk->tgid;

1554

}

1545

}

1555

1546

1556

pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);

1547

pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);

1557

1548

1558

static inline pid_t task_tgid_vnr(struct task_struct *tsk)

1549

static inline pid_t task_tgid_vnr(struct task_struct *tsk)

1559

{

1550

{

1560

return pid_vnr(task_tgid(tsk));

1551

return pid_vnr(task_tgid(tsk));

1561

}

1552

}

1562

1553

1563

1554

1564

static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk,

1555

static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk,

1565

struct pid_namespace *ns)

1556

struct pid_namespace *ns)

1566

{

1557

{

1567

return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns);

1558

return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns);

1568

}

1559

}

1569

1560

1570

static inline pid_t task_pgrp_vnr(struct task_struct *tsk)

1561

static inline pid_t task_pgrp_vnr(struct task_struct *tsk)

1571

{

1562

{

1572

return __task_pid_nr_ns(tsk, PIDTYPE_PGID, NULL);

1563

return __task_pid_nr_ns(tsk, PIDTYPE_PGID, NULL);

1573

}

1564

}

1574

1565

1575

1566

1576

static inline pid_t task_session_nr_ns(struct task_struct *tsk,

1567

static inline pid_t task_session_nr_ns(struct task_struct *tsk,

1577

struct pid_namespace *ns)

1568

struct pid_namespace *ns)

1578

{

1569

{

1579

return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns);

1570

return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns);

1580

}

1571

}

1581

1572

1582

static inline pid_t task_session_vnr(struct task_struct *tsk)

1573

static inline pid_t task_session_vnr(struct task_struct *tsk)

1583

{

1574

{

1584

return __task_pid_nr_ns(tsk, PIDTYPE_SID, NULL);

1575

return __task_pid_nr_ns(tsk, PIDTYPE_SID, NULL);

1585

}

1576

}

1586

1577

1587

/* obsolete, do not use */

1578

/* obsolete, do not use */

1588

static inline pid_t task_pgrp_nr(struct task_struct *tsk)

1579

static inline pid_t task_pgrp_nr(struct task_struct *tsk)

1589

{

1580

{

1590

return task_pgrp_nr_ns(tsk, &init_pid_ns);

1581

return task_pgrp_nr_ns(tsk, &init_pid_ns);

1591

}

1582

}

1592

1583

1593

/**

1584

/**

1594

* pid_alive - check that a task structure is not stale

1585

* pid_alive - check that a task structure is not stale

1595

* @p: Task structure to be checked.

1586

* @p: Task structure to be checked.

1596

*

1587

*

1597

* Test if a process is not yet dead (at most zombie state)

1588

* Test if a process is not yet dead (at most zombie state)

1598

* If pid_alive fails, then pointers within the task structure

1589

* If pid_alive fails, then pointers within the task structure

1599

* can be stale and must not be dereferenced.

1590

* can be stale and must not be dereferenced.

1600

*

1591

*

1601

* Return: 1 if the process is alive. 0 otherwise.

1592

* Return: 1 if the process is alive. 0 otherwise.

1602

*/

1593

*/

1603

static inline int pid_alive(struct task_struct *p)

1594

static inline int pid_alive(struct task_struct *p)

1604

{

1595

{

1605

return p->pids[PIDTYPE_PID].pid != NULL;

1596

return p->pids[PIDTYPE_PID].pid != NULL;

1606

}

1597

}

1607

1598

1608

/**

1599

/**

1609

* is_global_init - check if a task structure is init

1600

* is_global_init - check if a task structure is init

1610

* @tsk: Task structure to be checked.

1601

* @tsk: Task structure to be checked.

1611

*

1602

*

1612

* Check if a task structure is the first user space task the kernel created.

1603

* Check if a task structure is the first user space task the kernel created.

1613

*

1604

*

1614

* Return: 1 if the task structure is init. 0 otherwise.

1605

* Return: 1 if the task structure is init. 0 otherwise.

1615

*/

1606

*/

1616

static inline int is_global_init(struct task_struct *tsk)

1607

static inline int is_global_init(struct task_struct *tsk)

1617

{

1608

{

1618

return tsk->pid == 1;

1609

return tsk->pid == 1;

1619

}

1610

}

1620

1611

1621

extern struct pid *cad_pid;

1612

extern struct pid *cad_pid;

1622

1613

1623

extern void free_task(struct task_struct *tsk);

1614

extern void free_task(struct task_struct *tsk);

1624

#define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)

1615

#define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)

1625

1616

1626

extern void __put_task_struct(struct task_struct *t);

1617

extern void __put_task_struct(struct task_struct *t);

1627

1618

1628

static inline void put_task_struct(struct task_struct *t)

1619

static inline void put_task_struct(struct task_struct *t)

1629

{

1620

{

1630

if (atomic_dec_and_test(&t->usage))

1621

if (atomic_dec_and_test(&t->usage))

1631

__put_task_struct(t);

1622

__put_task_struct(t);

1632

}

1623

}

1633

1624

1634

#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN

1625

#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN

1635

extern void task_cputime(struct task_struct *t,

1626

extern void task_cputime(struct task_struct *t,

1636

cputime_t *utime, cputime_t *stime);

1627

cputime_t *utime, cputime_t *stime);

1637

extern void task_cputime_scaled(struct task_struct *t,

1628

extern void task_cputime_scaled(struct task_struct *t,

1638

cputime_t *utimescaled, cputime_t *stimescaled);

1629

cputime_t *utimescaled, cputime_t *stimescaled);

1639

extern cputime_t task_gtime(struct task_struct *t);

1630

extern cputime_t task_gtime(struct task_struct *t);

1640

#else

1631

#else

1641

static inline void task_cputime(struct task_struct *t,

1632

static inline void task_cputime(struct task_struct *t,

1642

cputime_t *utime, cputime_t *stime)

1633

cputime_t *utime, cputime_t *stime)

1643

{

1634

{

1644

if (utime)

1635

if (utime)

1645

*utime = t->utime;

1636

*utime = t->utime;

1646

if (stime)

1637

if (stime)

1647

*stime = t->stime;

1638

*stime = t->stime;

1648

}

1639

}

1649

1640

1650

static inline void task_cputime_scaled(struct task_struct *t,

1641

static inline void task_cputime_scaled(struct task_struct *t,

1651

cputime_t *utimescaled,

1642

cputime_t *utimescaled,

1652

cputime_t *stimescaled)

1643

cputime_t *stimescaled)

1653

{

1644

{

1654

if (utimescaled)

1645

if (utimescaled)

1655

*utimescaled = t->utimescaled;

1646

*utimescaled = t->utimescaled;

1656

if (stimescaled)

1647

if (stimescaled)

1657

*stimescaled = t->stimescaled;

1648

*stimescaled = t->stimescaled;

1658

}

1649

}

1659

1650

1660

static inline cputime_t task_gtime(struct task_struct *t)

1651

static inline cputime_t task_gtime(struct task_struct *t)

1661

{

1652

{

1662

return t->gtime;

1653

return t->gtime;

1663

}

1654

}

1664

#endif

1655

#endif

1665

extern void task_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);

1656

extern void task_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);

1666

extern void thread_group_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);

1657

extern void thread_group_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);

1667

1658

1668

/*

1659

/*

1669

* Per process flags

1660

* Per process flags

1670

*/

1661

*/

1671

#define PF_EXITING 0x00000004 /* getting shut down */

1662

#define PF_EXITING 0x00000004 /* getting shut down */

1672

#define PF_EXITPIDONE 0x00000008 /* pi exit done on shut down */

1663

#define PF_EXITPIDONE 0x00000008 /* pi exit done on shut down */

1673

#define PF_VCPU 0x00000010 /* I'm a virtual CPU */

1664

#define PF_VCPU 0x00000010 /* I'm a virtual CPU */

1674

#define PF_WQ_WORKER 0x00000020 /* I'm a workqueue worker */

1665

#define PF_WQ_WORKER 0x00000020 /* I'm a workqueue worker */

1675

#define PF_FORKNOEXEC 0x00000040 /* forked but didn't exec */

1666

#define PF_FORKNOEXEC 0x00000040 /* forked but didn't exec */

1676

#define PF_MCE_PROCESS 0x00000080 /* process policy on mce errors */

1667

#define PF_MCE_PROCESS 0x00000080 /* process policy on mce errors */

1677

#define PF_SUPERPRIV 0x00000100 /* used super-user privileges */

1668

#define PF_SUPERPRIV 0x00000100 /* used super-user privileges */

1678

#define PF_DUMPCORE 0x00000200 /* dumped core */

1669

#define PF_DUMPCORE 0x00000200 /* dumped core */

1679

#define PF_SIGNALED 0x00000400 /* killed by a signal */

1670

#define PF_SIGNALED 0x00000400 /* killed by a signal */

1680

#define PF_MEMALLOC 0x00000800 /* Allocating memory */

1671

#define PF_MEMALLOC 0x00000800 /* Allocating memory */

1681

#define PF_NPROC_EXCEEDED 0x00001000 /* set_user noticed that RLIMIT_NPROC was exceeded */

1672

#define PF_NPROC_EXCEEDED 0x00001000 /* set_user noticed that RLIMIT_NPROC was exceeded */

1682

#define PF_USED_MATH 0x00002000 /* if unset the fpu must be initialized before use */

1673

#define PF_USED_MATH 0x00002000 /* if unset the fpu must be initialized before use */

1683

#define PF_USED_ASYNC 0x00004000 /* used async_schedule*(), used by module init */

1674

#define PF_USED_ASYNC 0x00004000 /* used async_schedule*(), used by module init */

1684

#define PF_NOFREEZE 0x00008000 /* this thread should not be frozen */

1675

#define PF_NOFREEZE 0x00008000 /* this thread should not be frozen */

1685

#define PF_FROZEN 0x00010000 /* frozen for system suspend */

1676

#define PF_FROZEN 0x00010000 /* frozen for system suspend */

1686

#define PF_FSTRANS 0x00020000 /* inside a filesystem transaction */

1677

#define PF_FSTRANS 0x00020000 /* inside a filesystem transaction */

1687

#define PF_KSWAPD 0x00040000 /* I am kswapd */

1678

#define PF_KSWAPD 0x00040000 /* I am kswapd */

1688

#define PF_MEMALLOC_NOIO 0x00080000 /* Allocating memory without IO involved */

1679

#define PF_MEMALLOC_NOIO 0x00080000 /* Allocating memory without IO involved */

1689

#define PF_LESS_THROTTLE 0x00100000 /* Throttle me less: I clean memory */

1680

#define PF_LESS_THROTTLE 0x00100000 /* Throttle me less: I clean memory */

1690

#define PF_KTHREAD 0x00200000 /* I am a kernel thread */

1681

#define PF_KTHREAD 0x00200000 /* I am a kernel thread */

1691

#define PF_RANDOMIZE 0x00400000 /* randomize virtual address space */

1682

#define PF_RANDOMIZE 0x00400000 /* randomize virtual address space */

1692

#define PF_SWAPWRITE 0x00800000 /* Allowed to write to swap */

1683

#define PF_SWAPWRITE 0x00800000 /* Allowed to write to swap */

1693

#define PF_SPREAD_PAGE 0x01000000 /* Spread page cache over cpuset */

1684

#define PF_SPREAD_PAGE 0x01000000 /* Spread page cache over cpuset */

1694

#define PF_SPREAD_SLAB 0x02000000 /* Spread some slab caches over cpuset */

1685

#define PF_SPREAD_SLAB 0x02000000 /* Spread some slab caches over cpuset */

1695

#define PF_NO_SETAFFINITY 0x04000000 /* Userland is not allowed to meddle with cpus_allowed */

1686

#define PF_NO_SETAFFINITY 0x04000000 /* Userland is not allowed to meddle with cpus_allowed */

1696

#define PF_MCE_EARLY 0x08000000 /* Early kill for mce process policy */

1687

#define PF_MCE_EARLY 0x08000000 /* Early kill for mce process policy */

1697

#define PF_MEMPOLICY 0x10000000 /* Non-default NUMA mempolicy */

1688

#define PF_MEMPOLICY 0x10000000 /* Non-default NUMA mempolicy */

1698

#define PF_MUTEX_TESTER 0x20000000 /* Thread belongs to the rt mutex tester */

1689

#define PF_MUTEX_TESTER 0x20000000 /* Thread belongs to the rt mutex tester */

1699

#define PF_FREEZER_SKIP 0x40000000 /* Freezer should not count it as freezable */

1690

#define PF_FREEZER_SKIP 0x40000000 /* Freezer should not count it as freezable */

1700

#define PF_SUSPEND_TASK 0x80000000 /* this thread called freeze_processes and should not be frozen */

1691

#define PF_SUSPEND_TASK 0x80000000 /* this thread called freeze_processes and should not be frozen */

1701

1692

1702

/*

1693

/*

1703

* Only the _current_ task can read/write to tsk->flags, but other

1694

* Only the _current_ task can read/write to tsk->flags, but other

1704

* tasks can access tsk->flags in readonly mode for example

1695

* tasks can access tsk->flags in readonly mode for example

1705

* with tsk_used_math (like during threaded core dumping).

1696

* with tsk_used_math (like during threaded core dumping).

1706

* There is however an exception to this rule during ptrace

1697

* There is however an exception to this rule during ptrace

1707

* or during fork: the ptracer task is allowed to write to the

1698

* or during fork: the ptracer task is allowed to write to the

1708

* child->flags of its traced child (same goes for fork, the parent

1699

* child->flags of its traced child (same goes for fork, the parent

1709

* can write to the child->flags), because we're guaranteed the

1700

* can write to the child->flags), because we're guaranteed the

1710

* child is not running and in turn not changing child->flags

1701

* child is not running and in turn not changing child->flags

1711

* at the same time the parent does it.

1702

* at the same time the parent does it.

1712

*/

1703

*/

1713

#define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)

1704

#define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)

1714

#define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)

1705

#define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)

1715

#define clear_used_math() clear_stopped_child_used_math(current)

1706

#define clear_used_math() clear_stopped_child_used_math(current)

1716

#define set_used_math() set_stopped_child_used_math(current)

1707

#define set_used_math() set_stopped_child_used_math(current)

1717

#define conditional_stopped_child_used_math(condition, child) \

1708

#define conditional_stopped_child_used_math(condition, child) \

1718

do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)

1709

do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)

1719

#define conditional_used_math(condition) \

1710

#define conditional_used_math(condition) \

1720

conditional_stopped_child_used_math(condition, current)

1711

conditional_stopped_child_used_math(condition, current)

1721

#define copy_to_stopped_child_used_math(child) \

1712

#define copy_to_stopped_child_used_math(child) \

1722

do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)

1713

do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)

1723

/* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */

1714

/* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */

1724

#define tsk_used_math(p) ((p)->flags & PF_USED_MATH)

1715

#define tsk_used_math(p) ((p)->flags & PF_USED_MATH)

1725

#define used_math() tsk_used_math(current)

1716

#define used_math() tsk_used_math(current)

1726

1717

1727

/* __GFP_IO isn't allowed if PF_MEMALLOC_NOIO is set in current->flags */

1718

/* __GFP_IO isn't allowed if PF_MEMALLOC_NOIO is set in current->flags */

1728

static inline gfp_t memalloc_noio_flags(gfp_t flags)

1719

static inline gfp_t memalloc_noio_flags(gfp_t flags)

1729

{

1720

{

1730

if (unlikely(current->flags & PF_MEMALLOC_NOIO))

1721

if (unlikely(current->flags & PF_MEMALLOC_NOIO))

1731

flags &= ~__GFP_IO;

1722

flags &= ~__GFP_IO;

1732

return flags;

1723

return flags;

1733

}

1724

}

1734

1725

1735

static inline unsigned int memalloc_noio_save(void)

1726

static inline unsigned int memalloc_noio_save(void)

1736

{

1727

{

1737

unsigned int flags = current->flags & PF_MEMALLOC_NOIO;

1728

unsigned int flags = current->flags & PF_MEMALLOC_NOIO;

1738

current->flags |= PF_MEMALLOC_NOIO;

1729

current->flags |= PF_MEMALLOC_NOIO;

1739

return flags;

1730

return flags;

1740

}

1731

}

1741

1732

1742

static inline void memalloc_noio_restore(unsigned int flags)

1733

static inline void memalloc_noio_restore(unsigned int flags)

1743

{

1734

{

1744

current->flags = (current->flags & ~PF_MEMALLOC_NOIO) | flags;

1735

current->flags = (current->flags & ~PF_MEMALLOC_NOIO) | flags;

1745

}

1736

}

1746

1737

1747

/*

1738

/*

1748

* task->jobctl flags

1739

* task->jobctl flags

1749

*/

1740

*/

1750

#define JOBCTL_STOP_SIGMASK 0xffff /* signr of the last group stop */

1741

#define JOBCTL_STOP_SIGMASK 0xffff /* signr of the last group stop */

1751

1742

1752

#define JOBCTL_STOP_DEQUEUED_BIT 16 /* stop signal dequeued */

1743

#define JOBCTL_STOP_DEQUEUED_BIT 16 /* stop signal dequeued */

1753

#define JOBCTL_STOP_PENDING_BIT 17 /* task should stop for group stop */

1744

#define JOBCTL_STOP_PENDING_BIT 17 /* task should stop for group stop */

1754

#define JOBCTL_STOP_CONSUME_BIT 18 /* consume group stop count */

1745

#define JOBCTL_STOP_CONSUME_BIT 18 /* consume group stop count */

1755

#define JOBCTL_TRAP_STOP_BIT 19 /* trap for STOP */

1746

#define JOBCTL_TRAP_STOP_BIT 19 /* trap for STOP */

1756

#define JOBCTL_TRAP_NOTIFY_BIT 20 /* trap for NOTIFY */

1747

#define JOBCTL_TRAP_NOTIFY_BIT 20 /* trap for NOTIFY */

1757

#define JOBCTL_TRAPPING_BIT 21 /* switching to TRACED */

1748

#define JOBCTL_TRAPPING_BIT 21 /* switching to TRACED */

1758

#define JOBCTL_LISTENING_BIT 22 /* ptracer is listening for events */

1749

#define JOBCTL_LISTENING_BIT 22 /* ptracer is listening for events */

1759

1750

1760

#define JOBCTL_STOP_DEQUEUED (1 << JOBCTL_STOP_DEQUEUED_BIT)

1751

#define JOBCTL_STOP_DEQUEUED (1 << JOBCTL_STOP_DEQUEUED_BIT)

1761

#define JOBCTL_STOP_PENDING (1 << JOBCTL_STOP_PENDING_BIT)

1752

#define JOBCTL_STOP_PENDING (1 << JOBCTL_STOP_PENDING_BIT)

1762

#define JOBCTL_STOP_CONSUME (1 << JOBCTL_STOP_CONSUME_BIT)

1753

#define JOBCTL_STOP_CONSUME (1 << JOBCTL_STOP_CONSUME_BIT)

1763

#define JOBCTL_TRAP_STOP (1 << JOBCTL_TRAP_STOP_BIT)

1754

#define JOBCTL_TRAP_STOP (1 << JOBCTL_TRAP_STOP_BIT)

1764

#define JOBCTL_TRAP_NOTIFY (1 << JOBCTL_TRAP_NOTIFY_BIT)

1755

#define JOBCTL_TRAP_NOTIFY (1 << JOBCTL_TRAP_NOTIFY_BIT)

1765

#define JOBCTL_TRAPPING (1 << JOBCTL_TRAPPING_BIT)

1756

#define JOBCTL_TRAPPING (1 << JOBCTL_TRAPPING_BIT)

1766

#define JOBCTL_LISTENING (1 << JOBCTL_LISTENING_BIT)

1757

#define JOBCTL_LISTENING (1 << JOBCTL_LISTENING_BIT)

1767

1758

1768

#define JOBCTL_TRAP_MASK (JOBCTL_TRAP_STOP | JOBCTL_TRAP_NOTIFY)

1759

#define JOBCTL_TRAP_MASK (JOBCTL_TRAP_STOP | JOBCTL_TRAP_NOTIFY)

1769

#define JOBCTL_PENDING_MASK (JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK)

1760

#define JOBCTL_PENDING_MASK (JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK)

1770

1761

1771

extern bool task_set_jobctl_pending(struct task_struct *task,

1762

extern bool task_set_jobctl_pending(struct task_struct *task,

1772

unsigned int mask);

1763

unsigned int mask);

1773

extern void task_clear_jobctl_trapping(struct task_struct *task);

1764

extern void task_clear_jobctl_trapping(struct task_struct *task);

1774

extern void task_clear_jobctl_pending(struct task_struct *task,

1765

extern void task_clear_jobctl_pending(struct task_struct *task,

1775

unsigned int mask);

1766

unsigned int mask);

1776

1767

1777

#ifdef CONFIG_PREEMPT_RCU

1768

#ifdef CONFIG_PREEMPT_RCU

1778

1769

1779

#define RCU_READ_UNLOCK_BLOCKED (1 << 0) /* blocked while in RCU read-side. */

1770

#define RCU_READ_UNLOCK_BLOCKED (1 << 0) /* blocked while in RCU read-side. */

1780

#define RCU_READ_UNLOCK_NEED_QS (1 << 1) /* RCU core needs CPU response. */

1771

#define RCU_READ_UNLOCK_NEED_QS (1 << 1) /* RCU core needs CPU response. */

1781

1772

1782

static inline void rcu_copy_process(struct task_struct *p)

1773

static inline void rcu_copy_process(struct task_struct *p)

1783

{

1774

{

1784

p->rcu_read_lock_nesting = 0;

1775

p->rcu_read_lock_nesting = 0;

1785

p->rcu_read_unlock_special = 0;

1776

p->rcu_read_unlock_special = 0;

1786

#ifdef CONFIG_TREE_PREEMPT_RCU

1777

#ifdef CONFIG_TREE_PREEMPT_RCU

1787

p->rcu_blocked_node = NULL;

1778

p->rcu_blocked_node = NULL;

1788

#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */

1779

#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */

1789

#ifdef CONFIG_RCU_BOOST

1780

#ifdef CONFIG_RCU_BOOST

1790

p->rcu_boost_mutex = NULL;

1781

p->rcu_boost_mutex = NULL;

1791

#endif /* #ifdef CONFIG_RCU_BOOST */

1782

#endif /* #ifdef CONFIG_RCU_BOOST */

1792

INIT_LIST_HEAD(&p->rcu_node_entry);

1783

INIT_LIST_HEAD(&p->rcu_node_entry);

1793

}

1784

}

1794

1785

1795

#else

1786

#else

1796

1787

1797

static inline void rcu_copy_process(struct task_struct *p)

1788

static inline void rcu_copy_process(struct task_struct *p)

1798

{

1789

{

1799

}

1790

}

1800

1791

1801

#endif

1792

#endif

1802

1793

1803

static inline void tsk_restore_flags(struct task_struct *task,

1794

static inline void tsk_restore_flags(struct task_struct *task,

1804

unsigned long orig_flags, unsigned long flags)

1795

unsigned long orig_flags, unsigned long flags)

1805

{

1796

{

1806

task->flags &= ~flags;

1797

task->flags &= ~flags;

1807

task->flags |= orig_flags & flags;

1798

task->flags |= orig_flags & flags;

1808

}

1799

}

1809

1800

1810

#ifdef CONFIG_SMP

1801

#ifdef CONFIG_SMP

1811

extern void do_set_cpus_allowed(struct task_struct *p,

1802

extern void do_set_cpus_allowed(struct task_struct *p,

1812

const struct cpumask *new_mask);

1803

const struct cpumask *new_mask);

1813

1804

1814

extern int set_cpus_allowed_ptr(struct task_struct *p,

1805

extern int set_cpus_allowed_ptr(struct task_struct *p,

1815

const struct cpumask *new_mask);

1806

const struct cpumask *new_mask);

1816

#else

1807

#else

1817

static inline void do_set_cpus_allowed(struct task_struct *p,

1808

static inline void do_set_cpus_allowed(struct task_struct *p,

1818

const struct cpumask *new_mask)

1809

const struct cpumask *new_mask)

1819

{

1810

{

1820

}

1811

}

1821

static inline int set_cpus_allowed_ptr(struct task_struct *p,

1812

static inline int set_cpus_allowed_ptr(struct task_struct *p,

1822

const struct cpumask *new_mask)

1813

const struct cpumask *new_mask)

1823

{

1814

{

1824

if (!cpumask_test_cpu(0, new_mask))

1815

if (!cpumask_test_cpu(0, new_mask))

1825

return -EINVAL;

1816

return -EINVAL;

1826

return 0;

1817

return 0;

1827

}

1818

}

1828

#endif

1819

#endif

1829

1820

1830

#ifdef CONFIG_NO_HZ_COMMON

1821

#ifdef CONFIG_NO_HZ_COMMON

1831

void calc_load_enter_idle(void);

1822

void calc_load_enter_idle(void);

1832

void calc_load_exit_idle(void);

1823

void calc_load_exit_idle(void);

1833

#else

1824

#else

1834

static inline void calc_load_enter_idle(void) { }

1825

static inline void calc_load_enter_idle(void) { }

1835

static inline void calc_load_exit_idle(void) { }

1826

static inline void calc_load_exit_idle(void) { }

1836

#endif /* CONFIG_NO_HZ_COMMON */

1827

#endif /* CONFIG_NO_HZ_COMMON */

1837

1828

1838

#ifndef CONFIG_CPUMASK_OFFSTACK

1829

#ifndef CONFIG_CPUMASK_OFFSTACK

1839

static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)

1830

static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)

1840

{

1831

{

1841

return set_cpus_allowed_ptr(p, &new_mask);

1832

return set_cpus_allowed_ptr(p, &new_mask);

1842

}

1833

}

1843

#endif

1834

#endif

1844

1835

1845

/*

1836

/*

1846

* Do not use outside of architecture code which knows its limitations.

1837

* Do not use outside of architecture code which knows its limitations.

1847

*

1838

*

1848

* sched_clock() has no promise of monotonicity or bounded drift between

1839

* sched_clock() has no promise of monotonicity or bounded drift between

1849

* CPUs, use (which you should not) requires disabling IRQs.

1840

* CPUs, use (which you should not) requires disabling IRQs.

1850

*

1841

*

1851

* Please use one of the three interfaces below.

1842

* Please use one of the three interfaces below.

1852

*/

1843

*/

1853

extern unsigned long long notrace sched_clock(void);

1844

extern unsigned long long notrace sched_clock(void);

1854

/*

1845

/*

1855

* See the comment in kernel/sched/clock.c

1846

* See the comment in kernel/sched/clock.c

1856

*/

1847

*/

1857

extern u64 cpu_clock(int cpu);

1848

extern u64 cpu_clock(int cpu);

1858

extern u64 local_clock(void);

1849

extern u64 local_clock(void);

1859

extern u64 sched_clock_cpu(int cpu);

1850

extern u64 sched_clock_cpu(int cpu);

1860

1851

1861

1852

1862

extern void sched_clock_init(void);

1853

extern void sched_clock_init(void);

1863

1854

1864

#ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK

1855

#ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK

1865

static inline void sched_clock_tick(void)

1856

static inline void sched_clock_tick(void)

1866

{

1857

{

1867

}

1858

}

1868

1859

1869

static inline void sched_clock_idle_sleep_event(void)

1860

static inline void sched_clock_idle_sleep_event(void)

1870

{

1861

{

1871

}

1862

}

1872

1863

1873

static inline void sched_clock_idle_wakeup_event(u64 delta_ns)

1864

static inline void sched_clock_idle_wakeup_event(u64 delta_ns)

1874

{

1865

{

1875

}

1866

}

1876

#else

1867

#else

1877

/*

1868

/*

1878

* Architectures can set this to 1 if they have specified

1869

* Architectures can set this to 1 if they have specified

1879

* CONFIG_HAVE_UNSTABLE_SCHED_CLOCK in their arch Kconfig,

1870

* CONFIG_HAVE_UNSTABLE_SCHED_CLOCK in their arch Kconfig,

1880

* but then during bootup it turns out that sched_clock()

1871

* but then during bootup it turns out that sched_clock()

1881

* is reliable after all:

1872

* is reliable after all:

1882

*/

1873

*/

1883

extern int sched_clock_stable;

1874

extern int sched_clock_stable;

1884

1875

1885

extern void sched_clock_tick(void);

1876

extern void sched_clock_tick(void);

1886

extern void sched_clock_idle_sleep_event(void);

1877

extern void sched_clock_idle_sleep_event(void);

1887

extern void sched_clock_idle_wakeup_event(u64 delta_ns);

1878

extern void sched_clock_idle_wakeup_event(u64 delta_ns);

1888

#endif

1879

#endif

1889

1880

1890

#ifdef CONFIG_IRQ_TIME_ACCOUNTING

1881

#ifdef CONFIG_IRQ_TIME_ACCOUNTING

1891

/*

1882

/*

1892

* An i/f to runtime opt-in for irq time accounting based off of sched_clock.

1883

* An i/f to runtime opt-in for irq time accounting based off of sched_clock.

1893

* The reason for this explicit opt-in is not to have perf penalty with

1884

* The reason for this explicit opt-in is not to have perf penalty with

1894

* slow sched_clocks.

1885

* slow sched_clocks.

1895

*/

1886

*/

1896

extern void enable_sched_clock_irqtime(void);

1887

extern void enable_sched_clock_irqtime(void);

1897

extern void disable_sched_clock_irqtime(void);

1888

extern void disable_sched_clock_irqtime(void);

1898

#else

1889

#else

1899

static inline void enable_sched_clock_irqtime(void) {}

1890

static inline void enable_sched_clock_irqtime(void) {}

1900

static inline void disable_sched_clock_irqtime(void) {}

1891

static inline void disable_sched_clock_irqtime(void) {}

1901

#endif

1892

#endif

1902

1893

1903

extern unsigned long long

1894

extern unsigned long long

1904

task_sched_runtime(struct task_struct *task);

1895

task_sched_runtime(struct task_struct *task);

1905

1896

1906

/* sched_exec is called by processes performing an exec */

1897

/* sched_exec is called by processes performing an exec */

1907

#ifdef CONFIG_SMP

1898

#ifdef CONFIG_SMP

1908

extern void sched_exec(void);

1899

extern void sched_exec(void);

1909

#else

1900

#else

1910

#define sched_exec() {}

1901

#define sched_exec() {}

1911

#endif

1902

#endif

1912

1903

1913

extern void sched_clock_idle_sleep_event(void);

1904

extern void sched_clock_idle_sleep_event(void);

1914

extern void sched_clock_idle_wakeup_event(u64 delta_ns);

1905

extern void sched_clock_idle_wakeup_event(u64 delta_ns);

1915

1906

1916

#ifdef CONFIG_HOTPLUG_CPU

1907

#ifdef CONFIG_HOTPLUG_CPU

1917

extern void idle_task_exit(void);

1908

extern void idle_task_exit(void);

1918

#else

1909

#else

1919

static inline void idle_task_exit(void) {}

1910

static inline void idle_task_exit(void) {}

1920

#endif

1911

#endif

1921

1912

1922

#if defined(CONFIG_NO_HZ_COMMON) && defined(CONFIG_SMP)

1913

#if defined(CONFIG_NO_HZ_COMMON) && defined(CONFIG_SMP)

1923

extern void wake_up_nohz_cpu(int cpu);

1914

extern void wake_up_nohz_cpu(int cpu);

1924

#else

1915

#else

1925

static inline void wake_up_nohz_cpu(int cpu) { }

1916

static inline void wake_up_nohz_cpu(int cpu) { }

1926

#endif

1917

#endif

1927

1918

1928

#ifdef CONFIG_NO_HZ_FULL

1919

#ifdef CONFIG_NO_HZ_FULL

1929

extern bool sched_can_stop_tick(void);

1920

extern bool sched_can_stop_tick(void);

1930

extern u64 scheduler_tick_max_deferment(void);

1921

extern u64 scheduler_tick_max_deferment(void);

1931

#else

1922

#else

1932

static inline bool sched_can_stop_tick(void) { return false; }

1923

static inline bool sched_can_stop_tick(void) { return false; }

1933

#endif

1924

#endif

1934

1925

1935

#ifdef CONFIG_SCHED_AUTOGROUP

1926

#ifdef CONFIG_SCHED_AUTOGROUP

1936

extern void sched_autogroup_create_attach(struct task_struct *p);

1927

extern void sched_autogroup_create_attach(struct task_struct *p);

1937

extern void sched_autogroup_detach(struct task_struct *p);

1928

extern void sched_autogroup_detach(struct task_struct *p);

1938

extern void sched_autogroup_fork(struct signal_struct *sig);

1929

extern void sched_autogroup_fork(struct signal_struct *sig);

1939

extern void sched_autogroup_exit(struct signal_struct *sig);

1930

extern void sched_autogroup_exit(struct signal_struct *sig);

1940

#ifdef CONFIG_PROC_FS

1931

#ifdef CONFIG_PROC_FS

1941

extern void proc_sched_autogroup_show_task(struct task_struct *p, struct seq_file *m);

1932

extern void proc_sched_autogroup_show_task(struct task_struct *p, struct seq_file *m);

1942

extern int proc_sched_autogroup_set_nice(struct task_struct *p, int nice);

1933

extern int proc_sched_autogroup_set_nice(struct task_struct *p, int nice);

1943

#endif

1934

#endif

1944

#else

1935

#else

1945

static inline void sched_autogroup_create_attach(struct task_struct *p) { }

1936

static inline void sched_autogroup_create_attach(struct task_struct *p) { }

1946

static inline void sched_autogroup_detach(struct task_struct *p) { }

1937

static inline void sched_autogroup_detach(struct task_struct *p) { }

1947

static inline void sched_autogroup_fork(struct signal_struct *sig) { }

1938

static inline void sched_autogroup_fork(struct signal_struct *sig) { }

1948

static inline void sched_autogroup_exit(struct signal_struct *sig) { }

1939

static inline void sched_autogroup_exit(struct signal_struct *sig) { }

1949

#endif

1940

#endif

1950

1941

1951

extern bool yield_to(struct task_struct *p, bool preempt);

1942

extern bool yield_to(struct task_struct *p, bool preempt);

1952

extern void set_user_nice(struct task_struct *p, long nice);

1943

extern void set_user_nice(struct task_struct *p, long nice);

1953

extern int task_prio(const struct task_struct *p);

1944

extern int task_prio(const struct task_struct *p);

1954

extern int task_nice(const struct task_struct *p);

1945

extern int task_nice(const struct task_struct *p);

1955

extern int can_nice(const struct task_struct *p, const int nice);

1946

extern int can_nice(const struct task_struct *p, const int nice);

1956

extern int task_curr(const struct task_struct *p);

1947

extern int task_curr(const struct task_struct *p);

1957

extern int idle_cpu(int cpu);

1948

extern int idle_cpu(int cpu);

1958

extern int sched_setscheduler(struct task_struct *, int,

1949

extern int sched_setscheduler(struct task_struct *, int,

1959

const struct sched_param *);

1950

const struct sched_param *);

1960

extern int sched_setscheduler_nocheck(struct task_struct *, int,

1951

extern int sched_setscheduler_nocheck(struct task_struct *, int,

1961

const struct sched_param *);

1952

const struct sched_param *);

1962

extern struct task_struct *idle_task(int cpu);

1953

extern struct task_struct *idle_task(int cpu);

1963

/**

1954

/**

1964

* is_idle_task - is the specified task an idle task?

1955

* is_idle_task - is the specified task an idle task?

1965

* @p: the task in question.

1956

* @p: the task in question.

1966

*

1957

*

1967

* Return: 1 if @p is an idle task. 0 otherwise.

1958

* Return: 1 if @p is an idle task. 0 otherwise.

1968

*/

1959

*/

1969

static inline bool is_idle_task(const struct task_struct *p)

1960

static inline bool is_idle_task(const struct task_struct *p)

1970

{

1961

{

1971

return p->pid == 0;

1962

return p->pid == 0;

1972

}

1963

}

1973

extern struct task_struct *curr_task(int cpu);

1964

extern struct task_struct *curr_task(int cpu);

1974

extern void set_curr_task(int cpu, struct task_struct *p);

1965

extern void set_curr_task(int cpu, struct task_struct *p);

1975

1966

1976

void yield(void);

1967

void yield(void);

1977

1968

1978

/*

1969

/*

1979

* The default (Linux) execution domain.

1970

* The default (Linux) execution domain.

1980

*/

1971

*/

1981

extern struct exec_domain default_exec_domain;

1972

extern struct exec_domain default_exec_domain;

1982

1973

1983

union thread_union {

1974

union thread_union {

1984

struct thread_info thread_info;

1975

struct thread_info thread_info;

1985

unsigned long stack[THREAD_SIZE/sizeof(long)];

1976

unsigned long stack[THREAD_SIZE/sizeof(long)];

1986

};

1977

};

1987

1978

1988

#ifndef __HAVE_ARCH_KSTACK_END

1979

#ifndef __HAVE_ARCH_KSTACK_END

1989

static inline int kstack_end(void *addr)

1980

static inline int kstack_end(void *addr)

1990

{

1981

{

1991

/* Reliable end of stack detection:

1982

/* Reliable end of stack detection:

1992

* Some APM bios versions misalign the stack

1983

* Some APM bios versions misalign the stack

1993

*/

1984

*/

1994

return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));

1985

return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));

1995

}

1986

}

1996

#endif

1987

#endif

1997

1988

1998

extern union thread_union init_thread_union;

1989

extern union thread_union init_thread_union;

1999

extern struct task_struct init_task;

1990

extern struct task_struct init_task;

2000

1991

2001

extern struct mm_struct init_mm;

1992

extern struct mm_struct init_mm;

2002

1993

2003

extern struct pid_namespace init_pid_ns;

1994

extern struct pid_namespace init_pid_ns;

2004

1995

2005

/*

1996

/*

2006

* find a task by one of its numerical ids

1997

* find a task by one of its numerical ids

2007

*

1998

*

2008

* find_task_by_pid_ns():

1999

* find_task_by_pid_ns():

2009

* finds a task by its pid in the specified namespace

2000

* finds a task by its pid in the specified namespace

2010

* find_task_by_vpid():

2001

* find_task_by_vpid():

2011

* finds a task by its virtual pid

2002

* finds a task by its virtual pid

2012

*

2003

*

2013

* see also find_vpid() etc in include/linux/pid.h

2004

* see also find_vpid() etc in include/linux/pid.h

2014

*/

2005

*/

2015

2006

2016

extern struct task_struct *find_task_by_vpid(pid_t nr);

2007

extern struct task_struct *find_task_by_vpid(pid_t nr);

2017

extern struct task_struct *find_task_by_pid_ns(pid_t nr,

2008

extern struct task_struct *find_task_by_pid_ns(pid_t nr,

2018

struct pid_namespace *ns);

2009

struct pid_namespace *ns);

2019

2010

2020

/* per-UID process charging. */

2011

/* per-UID process charging. */

2021

extern struct user_struct * alloc_uid(kuid_t);

2012

extern struct user_struct * alloc_uid(kuid_t);

2022

static inline struct user_struct *get_uid(struct user_struct *u)

2013

static inline struct user_struct *get_uid(struct user_struct *u)

2023

{

2014

{

2024

atomic_inc(&u->__count);

2015

atomic_inc(&u->__count);

2025

return u;

2016

return u;

2026

}

2017

}

2027

extern void free_uid(struct user_struct *);

2018

extern void free_uid(struct user_struct *);

2028

2019

2029

#include <asm/current.h>

2020

#include <asm/current.h>

2030

2021

2031

extern void xtime_update(unsigned long ticks);

2022

extern void xtime_update(unsigned long ticks);

2032

2023

2033

extern int wake_up_state(struct task_struct *tsk, unsigned int state);

2024

extern int wake_up_state(struct task_struct *tsk, unsigned int state);

2034

extern int wake_up_process(struct task_struct *tsk);

2025

extern int wake_up_process(struct task_struct *tsk);

2035

extern void wake_up_new_task(struct task_struct *tsk);

2026

extern void wake_up_new_task(struct task_struct *tsk);

2036

#ifdef CONFIG_SMP

2027

#ifdef CONFIG_SMP

2037

extern void kick_process(struct task_struct *tsk);

2028

extern void kick_process(struct task_struct *tsk);

2038

#else

2029

#else

2039

static inline void kick_process(struct task_struct *tsk) { }

2030

static inline void kick_process(struct task_struct *tsk) { }

2040

#endif

2031

#endif

2041

extern void sched_fork(unsigned long clone_flags, struct task_struct *p);

2032

extern void sched_fork(unsigned long clone_flags, struct task_struct *p);

2042

extern void sched_dead(struct task_struct *p);

2033

extern void sched_dead(struct task_struct *p);

2043

2034

2044

extern void proc_caches_init(void);

2035

extern void proc_caches_init(void);

2045

extern void flush_signals(struct task_struct *);

2036

extern void flush_signals(struct task_struct *);

2046

extern void __flush_signals(struct task_struct *);

2037

extern void __flush_signals(struct task_struct *);

2047

extern void ignore_signals(struct task_struct *);

2038

extern void ignore_signals(struct task_struct *);

2048

extern void flush_signal_handlers(struct task_struct *, int force_default);

2039

extern void flush_signal_handlers(struct task_struct *, int force_default);

2049

extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);

2040

extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);

2050

2041

2051

static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)

2042

static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)

2052

{

2043

{

2053

unsigned long flags;

2044

unsigned long flags;

2054

int ret;

2045

int ret;

2055

2046

2056

spin_lock_irqsave(&tsk->sighand->siglock, flags);

2047

spin_lock_irqsave(&tsk->sighand->siglock, flags);

2057

ret = dequeue_signal(tsk, mask, info);

2048

ret = dequeue_signal(tsk, mask, info);

2058

spin_unlock_irqrestore(&tsk->sighand->siglock, flags);

2049

spin_unlock_irqrestore(&tsk->sighand->siglock, flags);

2059

2050

2060

return ret;

2051

return ret;

2061

}

2052

}

2062

2053

2063

extern void block_all_signals(int (*notifier)(void *priv), void *priv,

2054

extern void block_all_signals(int (*notifier)(void *priv), void *priv,

2064

sigset_t *mask);

2055

sigset_t *mask);

2065

extern void unblock_all_signals(void);

2056

extern void unblock_all_signals(void);

2066

extern void release_task(struct task_struct * p);

2057

extern void release_task(struct task_struct * p);

2067

extern int send_sig_info(int, struct siginfo *, struct task_struct *);

2058

extern int send_sig_info(int, struct siginfo *, struct task_struct *);

2068

extern int force_sigsegv(int, struct task_struct *);

2059

extern int force_sigsegv(int, struct task_struct *);

2069

extern int force_sig_info(int, struct siginfo *, struct task_struct *);

2060

extern int force_sig_info(int, struct siginfo *, struct task_struct *);

2070

extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);

2061

extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);

2071

extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);

2062

extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);

2072

extern int kill_pid_info_as_cred(int, struct siginfo *, struct pid *,

2063

extern int kill_pid_info_as_cred(int, struct siginfo *, struct pid *,

2073

const struct cred *, u32);

2064

const struct cred *, u32);

2074

extern int kill_pgrp(struct pid *pid, int sig, int priv);

2065

extern int kill_pgrp(struct pid *pid, int sig, int priv);

2075

extern int kill_pid(struct pid *pid, int sig, int priv);

2066

extern int kill_pid(struct pid *pid, int sig, int priv);

2076

extern int kill_proc_info(int, struct siginfo *, pid_t);

2067

extern int kill_proc_info(int, struct siginfo *, pid_t);

2077

extern __must_check bool do_notify_parent(struct task_struct *, int);

2068

extern __must_check bool do_notify_parent(struct task_struct *, int);

2078

extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);

2069

extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);

2079

extern void force_sig(int, struct task_struct *);

2070

extern void force_sig(int, struct task_struct *);

2080

extern int send_sig(int, struct task_struct *, int);

2071

extern int send_sig(int, struct task_struct *, int);

2081

extern int zap_other_threads(struct task_struct *p);

2072

extern int zap_other_threads(struct task_struct *p);

2082

extern struct sigqueue *sigqueue_alloc(void);

2073

extern struct sigqueue *sigqueue_alloc(void);

2083

extern void sigqueue_free(struct sigqueue *);

2074

extern void sigqueue_free(struct sigqueue *);

2084

extern int send_sigqueue(struct sigqueue *, struct task_struct *, int group);

2075

extern int send_sigqueue(struct sigqueue *, struct task_struct *, int group);

2085

extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);

2076

extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);

2086

2077

2087

static inline void restore_saved_sigmask(void)

2078

static inline void restore_saved_sigmask(void)

2088

{

2079

{

2089

if (test_and_clear_restore_sigmask())

2080

if (test_and_clear_restore_sigmask())

2090

__set_current_blocked(&current->saved_sigmask);

2081

__set_current_blocked(&current->saved_sigmask);

2091

}

2082

}

2092

2083

2093

static inline sigset_t *sigmask_to_save(void)

2084

static inline sigset_t *sigmask_to_save(void)

2094

{

2085

{

2095

sigset_t *res = &current->blocked;

2086

sigset_t *res = &current->blocked;

2096

if (unlikely(test_restore_sigmask()))

2087

if (unlikely(test_restore_sigmask()))

2097

res = &current->saved_sigmask;

2088

res = &current->saved_sigmask;

2098

return res;

2089

return res;

2099

}

2090

}

2100

2091

2101

static inline int kill_cad_pid(int sig, int priv)

2092

static inline int kill_cad_pid(int sig, int priv)

2102

{

2093

{

2103

return kill_pid(cad_pid, sig, priv);

2094

return kill_pid(cad_pid, sig, priv);

2104

}

2095

}

2105

2096

2106

/* These can be the second arg to send_sig_info/send_group_sig_info. */

2097

/* These can be the second arg to send_sig_info/send_group_sig_info. */

2107

#define SEND_SIG_NOINFO ((struct siginfo *) 0)

2098

#define SEND_SIG_NOINFO ((struct siginfo *) 0)

2108

#define SEND_SIG_PRIV ((struct siginfo *) 1)

2099

#define SEND_SIG_PRIV ((struct siginfo *) 1)

2109

#define SEND_SIG_FORCED ((struct siginfo *) 2)

2100

#define SEND_SIG_FORCED ((struct siginfo *) 2)

2110

2101

2111

/*

2102

/*

2112

* True if we are on the alternate signal stack.

2103

* True if we are on the alternate signal stack.

2113

*/

2104

*/

2114

static inline int on_sig_stack(unsigned long sp)

2105

static inline int on_sig_stack(unsigned long sp)

2115

{

2106

{

2116

#ifdef CONFIG_STACK_GROWSUP

2107

#ifdef CONFIG_STACK_GROWSUP

2117

return sp >= current->sas_ss_sp &&

2108

return sp >= current->sas_ss_sp &&

2118

sp - current->sas_ss_sp < current->sas_ss_size;

2109

sp - current->sas_ss_sp < current->sas_ss_size;

2119

#else

2110

#else

2120

return sp > current->sas_ss_sp &&

2111

return sp > current->sas_ss_sp &&

2121

sp - current->sas_ss_sp <= current->sas_ss_size;

2112

sp - current->sas_ss_sp <= current->sas_ss_size;

2122

#endif

2113

#endif

2123

}

2114

}

2124

2115

2125

static inline int sas_ss_flags(unsigned long sp)

2116

static inline int sas_ss_flags(unsigned long sp)

2126

{

2117

{

2127

return (current->sas_ss_size == 0 ? SS_DISABLE

2118

return (current->sas_ss_size == 0 ? SS_DISABLE

2128

: on_sig_stack(sp) ? SS_ONSTACK : 0);

2119

: on_sig_stack(sp) ? SS_ONSTACK : 0);

2129

}

2120

}

2130

2121

2131

static inline unsigned long sigsp(unsigned long sp, struct ksignal *ksig)

2122

static inline unsigned long sigsp(unsigned long sp, struct ksignal *ksig)

2132

{

2123

{

2133

if (unlikely((ksig->ka.sa.sa_flags & SA_ONSTACK)) && ! sas_ss_flags(sp))

2124

if (unlikely((ksig->ka.sa.sa_flags & SA_ONSTACK)) && ! sas_ss_flags(sp))

2134

#ifdef CONFIG_STACK_GROWSUP

2125

#ifdef CONFIG_STACK_GROWSUP

2135

return current->sas_ss_sp;

2126

return current->sas_ss_sp;

2136

#else

2127

#else

2137

return current->sas_ss_sp + current->sas_ss_size;

2128

return current->sas_ss_sp + current->sas_ss_size;

2138

#endif

2129

#endif

2139

return sp;

2130

return sp;

2140

}

2131

}

2141

2132

2142

/*

2133

/*

2143

* Routines for handling mm_structs

2134

* Routines for handling mm_structs

2144

*/

2135

*/

2145

extern struct mm_struct * mm_alloc(void);

2136

extern struct mm_struct * mm_alloc(void);

2146

2137

2147

/* mmdrop drops the mm and the page tables */

2138

/* mmdrop drops the mm and the page tables */

2148

extern void __mmdrop(struct mm_struct *);

2139

extern void __mmdrop(struct mm_struct *);

2149

static inline void mmdrop(struct mm_struct * mm)

2140

static inline void mmdrop(struct mm_struct * mm)

2150

{

2141

{

2151

if (unlikely(atomic_dec_and_test(&mm->mm_count)))

2142

if (unlikely(atomic_dec_and_test(&mm->mm_count)))

2152

__mmdrop(mm);

2143

__mmdrop(mm);

2153

}

2144

}

2154

2145

2155

/* mmput gets rid of the mappings and all user-space */

2146

/* mmput gets rid of the mappings and all user-space */

2156

extern void mmput(struct mm_struct *);

2147

extern void mmput(struct mm_struct *);

2157

/* Grab a reference to a task's mm, if it is not already going away */

2148

/* Grab a reference to a task's mm, if it is not already going away */

2158

extern struct mm_struct *get_task_mm(struct task_struct *task);

2149

extern struct mm_struct *get_task_mm(struct task_struct *task);

2159

/*

2150

/*

2160

* Grab a reference to a task's mm, if it is not already going away

2151

* Grab a reference to a task's mm, if it is not already going away

2161

* and ptrace_may_access with the mode parameter passed to it

2152

* and ptrace_may_access with the mode parameter passed to it

2162

* succeeds.

2153

* succeeds.

2163

*/

2154

*/

2164

extern struct mm_struct *mm_access(struct task_struct *task, unsigned int mode);

2155

extern struct mm_struct *mm_access(struct task_struct *task, unsigned int mode);

2165

/* Remove the current tasks stale references to the old mm_struct */

2156

/* Remove the current tasks stale references to the old mm_struct */

2166

extern void mm_release(struct task_struct *, struct mm_struct *);

2157

extern void mm_release(struct task_struct *, struct mm_struct *);

2167

/* Allocate a new mm structure and copy contents from tsk->mm */

2158

/* Allocate a new mm structure and copy contents from tsk->mm */

2168

extern struct mm_struct *dup_mm(struct task_struct *tsk);

2159

extern struct mm_struct *dup_mm(struct task_struct *tsk);

2169

2160

2170

extern int copy_thread(unsigned long, unsigned long, unsigned long,

2161

extern int copy_thread(unsigned long, unsigned long, unsigned long,

2171

struct task_struct *);

2162

struct task_struct *);

2172

extern void flush_thread(void);

2163

extern void flush_thread(void);

2173

extern void exit_thread(void);

2164

extern void exit_thread(void);

2174

2165

2175

extern void exit_files(struct task_struct *);

2166

extern void exit_files(struct task_struct *);

2176

extern void __cleanup_sighand(struct sighand_struct *);

2167

extern void __cleanup_sighand(struct sighand_struct *);

2177

2168

2178

extern void exit_itimers(struct signal_struct *);

2169

extern void exit_itimers(struct signal_struct *);

2179

extern void flush_itimer_signals(void);

2170

extern void flush_itimer_signals(void);

2180

2171

2181

extern void do_group_exit(int);

2172

extern void do_group_exit(int);

2182

2173

2183

extern int allow_signal(int);

2174

extern int allow_signal(int);

2184

extern int disallow_signal(int);

2175

extern int disallow_signal(int);

2185

2176

2186

extern int do_execve(const char *,

2177

extern int do_execve(const char *,

2187

const char __user * const __user *,

2178

const char __user * const __user *,

2188

const char __user * const __user *);

2179

const char __user * const __user *);

2189

extern long do_fork(unsigned long, unsigned long, unsigned long, int __user *, int __user *);

2180

extern long do_fork(unsigned long, unsigned long, unsigned long, int __user *, int __user *);

2190

struct task_struct *fork_idle(int);

2181

struct task_struct *fork_idle(int);

2191

extern pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);

2182

extern pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);

2192

2183

2193

extern void set_task_comm(struct task_struct *tsk, char *from);

2184

extern void set_task_comm(struct task_struct *tsk, char *from);

2194

extern char *get_task_comm(char *to, struct task_struct *tsk);

2185

extern char *get_task_comm(char *to, struct task_struct *tsk);

2195

2186

2196

#ifdef CONFIG_SMP

2187

#ifdef CONFIG_SMP

2197

void scheduler_ipi(void);

2188

void scheduler_ipi(void);

2198

extern unsigned long wait_task_inactive(struct task_struct *, long match_state);

2189

extern unsigned long wait_task_inactive(struct task_struct *, long match_state);

2199

#else

2190

#else

2200

static inline void scheduler_ipi(void) { }

2191

static inline void scheduler_ipi(void) { }

2201

static inline unsigned long wait_task_inactive(struct task_struct *p,

2192

static inline unsigned long wait_task_inactive(struct task_struct *p,

2202

long match_state)

2193

long match_state)

2203

{

2194

{

2204

return 1;

2195

return 1;

2205

}

2196

}

2206

#endif

2197

#endif

2207

2198

2208

#define next_task(p) \

2199

#define next_task(p) \

2209

list_entry_rcu((p)->tasks.next, struct task_struct, tasks)

2200

list_entry_rcu((p)->tasks.next, struct task_struct, tasks)

2210

2201

2211

#define for_each_process(p) \

2202

#define for_each_process(p) \

2212

for (p = &init_task ; (p = next_task(p)) != &init_task ; )

2203

for (p = &init_task ; (p = next_task(p)) != &init_task ; )

2213

2204

2214

extern bool current_is_single_threaded(void);

2205

extern bool current_is_single_threaded(void);

2215

2206

2216

/*

2207

/*

2217

* Careful: do_each_thread/while_each_thread is a double loop so

2208

* Careful: do_each_thread/while_each_thread is a double loop so

2218

* 'break' will not work as expected - use goto instead.

2209

* 'break' will not work as expected - use goto instead.

2219

*/

2210

*/

2220

#define do_each_thread(g, t) \

2211

#define do_each_thread(g, t) \

2221

for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do

2212

for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do

2222

2213

2223

#define while_each_thread(g, t) \

2214

#define while_each_thread(g, t) \

2224

while ((t = next_thread(t)) != g)

2215

while ((t = next_thread(t)) != g)

2225

2216

2226

static inline int get_nr_threads(struct task_struct *tsk)

2217

static inline int get_nr_threads(struct task_struct *tsk)

2227

{

2218

{

2228

return tsk->signal->nr_threads;

2219

return tsk->signal->nr_threads;

2229

}

2220

}

2230

2221

2231

static inline bool thread_group_leader(struct task_struct *p)

2222

static inline bool thread_group_leader(struct task_struct *p)

2232

{

2223

{

2233

return p->exit_signal >= 0;

2224

return p->exit_signal >= 0;

2234

}

2225

}

2235

2226

2236

/* Do to the insanities of de_thread it is possible for a process

2227

/* Do to the insanities of de_thread it is possible for a process

2237

* to have the pid of the thread group leader without actually being

2228

* to have the pid of the thread group leader without actually being

2238

* the thread group leader. For iteration through the pids in proc

2229

* the thread group leader. For iteration through the pids in proc

2239

* all we care about is that we have a task with the appropriate

2230

* all we care about is that we have a task with the appropriate

2240

* pid, we don't actually care if we have the right task.

2231

* pid, we don't actually care if we have the right task.

2241

*/

2232

*/

2242

static inline bool has_group_leader_pid(struct task_struct *p)

2233

static inline bool has_group_leader_pid(struct task_struct *p)

2243

{

2234

{

2244

return task_pid(p) == p->signal->leader_pid;

2235

return task_pid(p) == p->signal->leader_pid;

2245

}

2236

}

2246

2237

2247

static inline

2238

static inline

2248

bool same_thread_group(struct task_struct *p1, struct task_struct *p2)

2239

bool same_thread_group(struct task_struct *p1, struct task_struct *p2)

2249

{

2240

{

2250

return p1->signal == p2->signal;

2241

return p1->signal == p2->signal;

2251

}

2242

}

2252

2243

2253

static inline struct task_struct *next_thread(const struct task_struct *p)

2244

static inline struct task_struct *next_thread(const struct task_struct *p)

2254

{

2245

{

2255

return list_entry_rcu(p->thread_group.next,

2246

return list_entry_rcu(p->thread_group.next,

2256

struct task_struct, thread_group);

2247

struct task_struct, thread_group);

2257

}

2248

}

2258

2249

2259

static inline int thread_group_empty(struct task_struct *p)

2250

static inline int thread_group_empty(struct task_struct *p)

2260

{

2251

{

2261

return list_empty(&p->thread_group);

2252

return list_empty(&p->thread_group);

2262

}

2253

}

2263

2254

2264

#define delay_group_leader(p) \

2255

#define delay_group_leader(p) \

2265

(thread_group_leader(p) && !thread_group_empty(p))

2256

(thread_group_leader(p) && !thread_group_empty(p))

2266

2257

2267

/*

2258

/*

2268

* Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring

2259

* Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring

2269

* subscriptions and synchronises with wait4(). Also used in procfs. Also

2260

* subscriptions and synchronises with wait4(). Also used in procfs. Also

2270

* pins the final release of task.io_context. Also protects ->cpuset and

2261

* pins the final release of task.io_context. Also protects ->cpuset and

2271

* ->cgroup.subsys[]. And ->vfork_done.

2262

* ->cgroup.subsys[]. And ->vfork_done.

2272

*

2263

*

2273

* Nests both inside and outside of read_lock(&tasklist_lock).

2264

* Nests both inside and outside of read_lock(&tasklist_lock).

2274

* It must not be nested with write_lock_irq(&tasklist_lock),

2265

* It must not be nested with write_lock_irq(&tasklist_lock),

2275

* neither inside nor outside.

2266

* neither inside nor outside.

2276

*/

2267

*/

2277

static inline void task_lock(struct task_struct *p)

2268

static inline void task_lock(struct task_struct *p)

2278

{

2269

{

2279

spin_lock(&p->alloc_lock);

2270

spin_lock(&p->alloc_lock);

2280

}

2271

}

2281

2272

2282

static inline void task_unlock(struct task_struct *p)

2273

static inline void task_unlock(struct task_struct *p)

2283

{

2274

{

2284

spin_unlock(&p->alloc_lock);

2275

spin_unlock(&p->alloc_lock);

2285

}

2276

}

2286

2277

2287

extern struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,

2278

extern struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,

2288

unsigned long *flags);

2279

unsigned long *flags);

2289

2280

2290

static inline struct sighand_struct *lock_task_sighand(struct task_struct *tsk,

2281

static inline struct sighand_struct *lock_task_sighand(struct task_struct *tsk,

2291

unsigned long *flags)

2282

unsigned long *flags)

2292

{

2283

{

2293

struct sighand_struct *ret;

2284

struct sighand_struct *ret;

2294

2285

2295

ret = __lock_task_sighand(tsk, flags);

2286

ret = __lock_task_sighand(tsk, flags);

2296

(void)__cond_lock(&tsk->sighand->siglock, ret);

2287

(void)__cond_lock(&tsk->sighand->siglock, ret);

2297

return ret;

2288

return ret;

2298

}

2289

}

2299

2290

2300

static inline void unlock_task_sighand(struct task_struct *tsk,

2291

static inline void unlock_task_sighand(struct task_struct *tsk,

2301

unsigned long *flags)

2292

unsigned long *flags)

2302

{

2293

{

2303

spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);

2294

spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);

2304

}

2295

}

2305

2296

2306

#ifdef CONFIG_CGROUPS

2297

#ifdef CONFIG_CGROUPS

2307

static inline void threadgroup_change_begin(struct task_struct *tsk)

2298

static inline void threadgroup_change_begin(struct task_struct *tsk)

2308

{

2299

{

2309

down_read(&tsk->signal->group_rwsem);

2300

down_read(&tsk->signal->group_rwsem);

2310

}

2301

}

2311

static inline void threadgroup_change_end(struct task_struct *tsk)

2302

static inline void threadgroup_change_end(struct task_struct *tsk)

2312

{

2303

{

2313

up_read(&tsk->signal->group_rwsem);

2304

up_read(&tsk->signal->group_rwsem);

2314

}

2305

}

2315

2306

2316

/**

2307

/**

2317

* threadgroup_lock - lock threadgroup

2308

* threadgroup_lock - lock threadgroup

2318

* @tsk: member task of the threadgroup to lock

2309

* @tsk: member task of the threadgroup to lock

2319

*

2310

*

2320

* Lock the threadgroup @tsk belongs to. No new task is allowed to enter

2311

* Lock the threadgroup @tsk belongs to. No new task is allowed to enter

2321

* and member tasks aren't allowed to exit (as indicated by PF_EXITING) or

2312

* and member tasks aren't allowed to exit (as indicated by PF_EXITING) or

2322

* change ->group_leader/pid. This is useful for cases where the threadgroup

2313

* change ->group_leader/pid. This is useful for cases where the threadgroup

2323

* needs to stay stable across blockable operations.

2314

* needs to stay stable across blockable operations.

2324

*

2315

*

2325

* fork and exit paths explicitly call threadgroup_change_{begin|end}() for

2316

* fork and exit paths explicitly call threadgroup_change_{begin|end}() for

2326

* synchronization. While held, no new task will be added to threadgroup

2317

* synchronization. While held, no new task will be added to threadgroup

2327

* and no existing live task will have its PF_EXITING set.

2318

* and no existing live task will have its PF_EXITING set.

2328

*

2319

*

2329

* de_thread() does threadgroup_change_{begin|end}() when a non-leader

2320

* de_thread() does threadgroup_change_{begin|end}() when a non-leader

2330

* sub-thread becomes a new leader.

2321

* sub-thread becomes a new leader.

2331

*/

2322

*/

2332

static inline void threadgroup_lock(struct task_struct *tsk)

2323

static inline void threadgroup_lock(struct task_struct *tsk)

2333

{

2324

{

2334

down_write(&tsk->signal->group_rwsem);

2325

down_write(&tsk->signal->group_rwsem);

2335

}

2326

}

2336

2327

2337

/**

2328

/**

2338

* threadgroup_unlock - unlock threadgroup

2329

* threadgroup_unlock - unlock threadgroup

2339

* @tsk: member task of the threadgroup to unlock

2330

* @tsk: member task of the threadgroup to unlock

2340

*

2331

*

2341

* Reverse threadgroup_lock().

2332

* Reverse threadgroup_lock().

2342

*/

2333

*/

2343

static inline void threadgroup_unlock(struct task_struct *tsk)

2334

static inline void threadgroup_unlock(struct task_struct *tsk)

2344

{

2335

{

2345

up_write(&tsk->signal->group_rwsem);

2336

up_write(&tsk->signal->group_rwsem);

2346

}

2337

}

2347

#else

2338

#else

2348

static inline void threadgroup_change_begin(struct task_struct *tsk) {}

2339

static inline void threadgroup_change_begin(struct task_struct *tsk) {}

2349

static inline void threadgroup_change_end(struct task_struct *tsk) {}

2340

static inline void threadgroup_change_end(struct task_struct *tsk) {}

2350

static inline void threadgroup_lock(struct task_struct *tsk) {}

2341

static inline void threadgroup_lock(struct task_struct *tsk) {}

2351

static inline void threadgroup_unlock(struct task_struct *tsk) {}

2342

static inline void threadgroup_unlock(struct task_struct *tsk) {}

2352

#endif

2343

#endif

2353

2344

2354

#ifndef __HAVE_THREAD_FUNCTIONS

2345

#ifndef __HAVE_THREAD_FUNCTIONS

2355

2346

2356

#define task_thread_info(task) ((struct thread_info *)(task)->stack)

2347

#define task_thread_info(task) ((struct thread_info *)(task)->stack)

2357

#define task_stack_page(task) ((task)->stack)

2348

#define task_stack_page(task) ((task)->stack)

2358

2349

2359

static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)

2350

static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)

2360

{

2351

{

2361

*task_thread_info(p) = *task_thread_info(org);

2352

*task_thread_info(p) = *task_thread_info(org);

2362

task_thread_info(p)->task = p;

2353

task_thread_info(p)->task = p;

2363

}

2354

}

2364

2355

2365

static inline unsigned long *end_of_stack(struct task_struct *p)

2356

static inline unsigned long *end_of_stack(struct task_struct *p)

2366

{

2357

{

2367

return (unsigned long *)(task_thread_info(p) + 1);

2358

return (unsigned long *)(task_thread_info(p) + 1);

2368

}

2359

}

2369

2360

2370

#endif

2361

#endif

2371

2362

2372

static inline int object_is_on_stack(void *obj)

2363

static inline int object_is_on_stack(void *obj)

2373

{

2364

{

2374

void *stack = task_stack_page(current);

2365

void *stack = task_stack_page(current);

2375

2366

2376

return (obj >= stack) && (obj < (stack + THREAD_SIZE));

2367

return (obj >= stack) && (obj < (stack + THREAD_SIZE));

2377

}

2368

}

2378

2369

2379

extern void thread_info_cache_init(void);

2370

extern void thread_info_cache_init(void);

2380

2371

2381

#ifdef CONFIG_DEBUG_STACK_USAGE

2372

#ifdef CONFIG_DEBUG_STACK_USAGE

2382

static inline unsigned long stack_not_used(struct task_struct *p)

2373

static inline unsigned long stack_not_used(struct task_struct *p)

2383

{

2374

{

2384

unsigned long *n = end_of_stack(p);

2375

unsigned long *n = end_of_stack(p);

2385

2376

2386

do { /* Skip over canary */

2377

do { /* Skip over canary */

2387

n++;

2378

n++;

2388

} while (!*n);

2379

} while (!*n);

2389

2380

2390

return (unsigned long)n - (unsigned long)end_of_stack(p);

2381

return (unsigned long)n - (unsigned long)end_of_stack(p);

2391

}

2382

}

2392

#endif

2383

#endif

2393

2384

2394

/* set thread flags in other task's structures

2385

/* set thread flags in other task's structures

2395

* - see asm/thread_info.h for TIF_xxxx flags available

2386

* - see asm/thread_info.h for TIF_xxxx flags available

2396

*/

2387

*/

2397

static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)

2388

static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)

2398

{

2389

{

2399

set_ti_thread_flag(task_thread_info(tsk), flag);

2390

set_ti_thread_flag(task_thread_info(tsk), flag);

2400

}

2391

}

2401

2392

2402

static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)

2393

static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)

2403

{

2394

{

2404

clear_ti_thread_flag(task_thread_info(tsk), flag);

2395

clear_ti_thread_flag(task_thread_info(tsk), flag);

2405

}

2396

}

2406

2397

2407

static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)

2398

static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)

2408

{

2399

{

2409

return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);

2400

return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);

2410

}

2401

}

2411

2402

2412

static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)

2403

static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)

2413

{

2404

{

2414

return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);

2405

return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);

2415

}

2406

}

2416

2407

2417

static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)

2408

static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)

2418

{

2409

{

2419

return test_ti_thread_flag(task_thread_info(tsk), flag);

2410

return test_ti_thread_flag(task_thread_info(tsk), flag);

2420

}

2411

}

2421

2412

2422

static inline void set_tsk_need_resched(struct task_struct *tsk)

2413

static inline void set_tsk_need_resched(struct task_struct *tsk)

2423

{

2414

{

2424

set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);

2415

set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);

2425

}

2416

}

2426

2417

2427

static inline void clear_tsk_need_resched(struct task_struct *tsk)

2418

static inline void clear_tsk_need_resched(struct task_struct *tsk)

2428

{

2419

{

2429

clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);

2420

clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);

2430

}

2421

}

2431

2422

2432

static inline int test_tsk_need_resched(struct task_struct *tsk)

2423

static inline int test_tsk_need_resched(struct task_struct *tsk)

2433

{

2424

{

2434

return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED));

2425

return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED));

2435

}

2426

}

2436

2427

2437

static inline int restart_syscall(void)

2428

static inline int restart_syscall(void)

2438

{

2429

{

2439

set_tsk_thread_flag(current, TIF_SIGPENDING);

2430

set_tsk_thread_flag(current, TIF_SIGPENDING);

2440

return -ERESTARTNOINTR;

2431

return -ERESTARTNOINTR;

2441

}

2432

}

2442

2433

2443

static inline int signal_pending(struct task_struct *p)

2434

static inline int signal_pending(struct task_struct *p)

2444

{

2435

{

2445

return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));

2436

return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));

2446

}

2437

}

2447

2438

2448

static inline int __fatal_signal_pending(struct task_struct *p)

2439

static inline int __fatal_signal_pending(struct task_struct *p)

2449

{

2440

{

2450

return unlikely(sigismember(&p->pending.signal, SIGKILL));

2441

return unlikely(sigismember(&p->pending.signal, SIGKILL));

2451

}

2442

}

2452

2443

2453

static inline int fatal_signal_pending(struct task_struct *p)

2444

static inline int fatal_signal_pending(struct task_struct *p)

2454

{

2445

{

2455

return signal_pending(p) && __fatal_signal_pending(p);

2446

return signal_pending(p) && __fatal_signal_pending(p);

2456

}

2447

}

2457

2448

2458

static inline int signal_pending_state(long state, struct task_struct *p)

2449

static inline int signal_pending_state(long state, struct task_struct *p)

2459

{

2450

{

2460

if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))

2451

if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))

2461

return 0;

2452

return 0;

2462

if (!signal_pending(p))

2453

if (!signal_pending(p))

2463

return 0;

2454

return 0;

2464

2455

2465

return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);

2456

return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);

2466

}

2457

}

2467

2458

2468

/*

2459

/*

2469

* cond_resched() and cond_resched_lock(): latency reduction via

2460

* cond_resched() and cond_resched_lock(): latency reduction via

2470

* explicit rescheduling in places that are safe. The return

2461

* explicit rescheduling in places that are safe. The return

2471

* value indicates whether a reschedule was done in fact.

2462

* value indicates whether a reschedule was done in fact.

2472

* cond_resched_lock() will drop the spinlock before scheduling,

2463

* cond_resched_lock() will drop the spinlock before scheduling,

2473

* cond_resched_softirq() will enable bhs before scheduling.

2464

* cond_resched_softirq() will enable bhs before scheduling.

2474

*/

2465

*/

2475

extern int _cond_resched(void);

2466

extern int _cond_resched(void);

2476

2467

2477

#define cond_resched() ({ \

2468

#define cond_resched() ({ \

2478

__might_sleep(__FILE__, __LINE__, 0); \

2469

__might_sleep(__FILE__, __LINE__, 0); \

2479

_cond_resched(); \

2470

_cond_resched(); \

2480

})

2471

})

2481

2472

2482

extern int __cond_resched_lock(spinlock_t *lock);

2473

extern int __cond_resched_lock(spinlock_t *lock);

2483

2474

2484

#ifdef CONFIG_PREEMPT_COUNT

2475

#ifdef CONFIG_PREEMPT_COUNT

2485

#define PREEMPT_LOCK_OFFSET PREEMPT_OFFSET

2476

#define PREEMPT_LOCK_OFFSET PREEMPT_OFFSET

2486

#else

2477

#else

2487

#define PREEMPT_LOCK_OFFSET 0

2478

#define PREEMPT_LOCK_OFFSET 0

2488

#endif

2479

#endif

2489

2480

2490

#define cond_resched_lock(lock) ({ \

2481

#define cond_resched_lock(lock) ({ \

2491

__might_sleep(__FILE__, __LINE__, PREEMPT_LOCK_OFFSET); \

2482

__might_sleep(__FILE__, __LINE__, PREEMPT_LOCK_OFFSET); \

2492

__cond_resched_lock(lock); \

2483

__cond_resched_lock(lock); \

2493

})

2484

})

2494

2485

2495

extern int __cond_resched_softirq(void);

2486

extern int __cond_resched_softirq(void);

2496

2487

2497

#define cond_resched_softirq() ({ \

2488

#define cond_resched_softirq() ({ \

2498

__might_sleep(__FILE__, __LINE__, SOFTIRQ_DISABLE_OFFSET); \

2489

__might_sleep(__FILE__, __LINE__, SOFTIRQ_DISABLE_OFFSET); \

2499

__cond_resched_softirq(); \

2490

__cond_resched_softirq(); \

2500

})

2491

})

2501

2492

2502

static inline void cond_resched_rcu(void)

2493

static inline void cond_resched_rcu(void)

2503

{

2494

{

2504

#if defined(CONFIG_DEBUG_ATOMIC_SLEEP) || !defined(CONFIG_PREEMPT_RCU)

2495

#if defined(CONFIG_DEBUG_ATOMIC_SLEEP) || !defined(CONFIG_PREEMPT_RCU)

2505

rcu_read_unlock();

2496

rcu_read_unlock();

2506

cond_resched();

2497

cond_resched();

2507

rcu_read_lock();

2498

rcu_read_lock();

2508

#endif

2499

#endif

2509

}

2500

}

2510

2501

2511

/*

2502

/*

2512

* Does a critical section need to be broken due to another

2503

* Does a critical section need to be broken due to another

2513

* task waiting?: (technically does not depend on CONFIG_PREEMPT,

2504

* task waiting?: (technically does not depend on CONFIG_PREEMPT,

2514

* but a general need for low latency)

2505

* but a general need for low latency)

2515

*/

2506

*/

2516

static inline int spin_needbreak(spinlock_t *lock)

2507

static inline int spin_needbreak(spinlock_t *lock)

2517

{

2508

{

2518

#ifdef CONFIG_PREEMPT

2509

#ifdef CONFIG_PREEMPT

2519

return spin_is_contended(lock);

2510

return spin_is_contended(lock);

2520

#else

2511

#else

2521

return 0;

2512

return 0;

2522

#endif

2513

#endif

2523

}

2514

}

2524

2515

2525

/*

2516

/*

2526

* Idle thread specific functions to determine the need_resched

2517

* Idle thread specific functions to determine the need_resched

2527

* polling state. We have two versions, one based on TS_POLLING in

2518

* polling state. We have two versions, one based on TS_POLLING in

2528

* thread_info.status and one based on TIF_POLLING_NRFLAG in

2519

* thread_info.status and one based on TIF_POLLING_NRFLAG in

2529

* thread_info.flags

2520

* thread_info.flags

2530

*/

2521

*/

2531

#ifdef TS_POLLING

2522

#ifdef TS_POLLING

2532

static inline int tsk_is_polling(struct task_struct *p)

2523

static inline int tsk_is_polling(struct task_struct *p)

2533

{

2524

{

2534

return task_thread_info(p)->status & TS_POLLING;

2525

return task_thread_info(p)->status & TS_POLLING;

2535

}

2526

}

2536

static inline void __current_set_polling(void)

2527

static inline void __current_set_polling(void)

2537

{

2528

{

2538

current_thread_info()->status |= TS_POLLING;

2529

current_thread_info()->status |= TS_POLLING;

2539

}

2530

}

2540

2531

2541

static inline bool __must_check current_set_polling_and_test(void)

2532

static inline bool __must_check current_set_polling_and_test(void)

2542

{

2533

{

2543

__current_set_polling();

2534

__current_set_polling();

2544

2535

2545

/*

2536

/*

2546

* Polling state must be visible before we test NEED_RESCHED,

2537

* Polling state must be visible before we test NEED_RESCHED,

2547

* paired by resched_task()

2538

* paired by resched_task()

2548

*/

2539

*/

2549

smp_mb();

2540

smp_mb();

2550

2541

2551

return unlikely(tif_need_resched());

2542

return unlikely(tif_need_resched());

2552

}

2543

}

2553

2544

2554

static inline void __current_clr_polling(void)

2545

static inline void __current_clr_polling(void)

2555

{

2546

{

2556

current_thread_info()->status &= ~TS_POLLING;

2547

current_thread_info()->status &= ~TS_POLLING;

2557

}

2548

}

2558

2549

2559

static inline bool __must_check current_clr_polling_and_test(void)

2550

static inline bool __must_check current_clr_polling_and_test(void)

2560

{

2551

{

2561

__current_clr_polling();

2552

__current_clr_polling();

2562

2553

2563

/*

2554

/*

2564

* Polling state must be visible before we test NEED_RESCHED,

2555

* Polling state must be visible before we test NEED_RESCHED,

2565

* paired by resched_task()

2556

* paired by resched_task()

2566

*/

2557

*/

2567

smp_mb();

2558

smp_mb();

2568

2559

2569

return unlikely(tif_need_resched());

2560

return unlikely(tif_need_resched());

2570

}

2561

}

2571

#elif defined(TIF_POLLING_NRFLAG)

2562

#elif defined(TIF_POLLING_NRFLAG)

2572

static inline int tsk_is_polling(struct task_struct *p)

2563

static inline int tsk_is_polling(struct task_struct *p)

2573

{

2564

{

2574

return test_tsk_thread_flag(p, TIF_POLLING_NRFLAG);

2565

return test_tsk_thread_flag(p, TIF_POLLING_NRFLAG);

2575

}

2566

}

2576

2567

2577

static inline void __current_set_polling(void)

2568

static inline void __current_set_polling(void)

2578

{

2569

{

2579

set_thread_flag(TIF_POLLING_NRFLAG);

2570

set_thread_flag(TIF_POLLING_NRFLAG);

2580

}

2571

}

2581

2572

2582

static inline bool __must_check current_set_polling_and_test(void)

2573

static inline bool __must_check current_set_polling_and_test(void)

2583

{

2574

{

2584

__current_set_polling();

2575

__current_set_polling();

2585

2576

2586

/*

2577

/*

2587

* Polling state must be visible before we test NEED_RESCHED,

2578

* Polling state must be visible before we test NEED_RESCHED,

2588

* paired by resched_task()

2579

* paired by resched_task()

2589

*

2580

*

2590

* XXX: assumes set/clear bit are identical barrier wise.

2581

* XXX: assumes set/clear bit are identical barrier wise.

2591

*/

2582

*/

2592

smp_mb__after_clear_bit();

2583

smp_mb__after_clear_bit();

2593

2584

2594

return unlikely(tif_need_resched());

2585

return unlikely(tif_need_resched());

2595

}

2586

}

2596

2587

2597

static inline void __current_clr_polling(void)

2588

static inline void __current_clr_polling(void)

2598

{

2589

{

2599

clear_thread_flag(TIF_POLLING_NRFLAG);

2590

clear_thread_flag(TIF_POLLING_NRFLAG);

2600

}

2591

}

2601

2592

2602

static inline bool __must_check current_clr_polling_and_test(void)

2593

static inline bool __must_check current_clr_polling_and_test(void)

2603

{

2594

{

2604

__current_clr_polling();

2595

__current_clr_polling();

2605

2596

2606

/*

2597

/*

2607

* Polling state must be visible before we test NEED_RESCHED,

2598

* Polling state must be visible before we test NEED_RESCHED,

2608

* paired by resched_task()

2599

* paired by resched_task()

2609

*/

2600

*/

2610

smp_mb__after_clear_bit();

2601

smp_mb__after_clear_bit();

2611

2602

2612

return unlikely(tif_need_resched());

2603

return unlikely(tif_need_resched());

2613

}

2604

}

2614

2605

2615

#else

2606

#else

2616

static inline int tsk_is_polling(struct task_struct *p) { return 0; }

2607

static inline int tsk_is_polling(struct task_struct *p) { return 0; }

2617

static inline void __current_set_polling(void) { }

2608

static inline void __current_set_polling(void) { }

2618

static inline void __current_clr_polling(void) { }

2609

static inline void __current_clr_polling(void) { }

2619

2610

2620

static inline bool __must_check current_set_polling_and_test(void)

2611

static inline bool __must_check current_set_polling_and_test(void)

2621

{

2612

{

2622

return unlikely(tif_need_resched());

2613

return unlikely(tif_need_resched());

2623

}

2614

}

2624

static inline bool __must_check current_clr_polling_and_test(void)

2615

static inline bool __must_check current_clr_polling_and_test(void)

2625

{

2616

{

2626

return unlikely(tif_need_resched());

2617

return unlikely(tif_need_resched());

2627

}

2618

}

2628

#endif

2619

#endif

2629

2620

2630

static __always_inline bool need_resched(void)

2621

static __always_inline bool need_resched(void)

2631

{

2622

{

2632

return unlikely(tif_need_resched());

2623

return unlikely(tif_need_resched());

2633

}

2624

}

2634

2625

2635

/*

2626

/*

2636

* Thread group CPU time accounting.

2627

* Thread group CPU time accounting.

2637

*/

2628

*/

2638

void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);

2629

void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);

2639

void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times);

2630

void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times);

2640

2631

2641

static inline void thread_group_cputime_init(struct signal_struct *sig)

2632

static inline void thread_group_cputime_init(struct signal_struct *sig)

2642

{

2633

{

2643

raw_spin_lock_init(&sig->cputimer.lock);

2634

raw_spin_lock_init(&sig->cputimer.lock);

2644

}

2635

}

2645

2636

2646

/*

2637

/*

2647

* Reevaluate whether the task has signals pending delivery.

2638

* Reevaluate whether the task has signals pending delivery.

2648

* Wake the task if so.

2639

* Wake the task if so.

2649

* This is required every time the blocked sigset_t changes.

2640

* This is required every time the blocked sigset_t changes.

2650

* callers must hold sighand->siglock.

2641

* callers must hold sighand->siglock.

2651

*/

2642

*/

2652

extern void recalc_sigpending_and_wake(struct task_struct *t);

2643

extern void recalc_sigpending_and_wake(struct task_struct *t);

2653

extern void recalc_sigpending(void);

2644

extern void recalc_sigpending(void);

2654

2645

2655

extern void signal_wake_up_state(struct task_struct *t, unsigned int state);

2646

extern void signal_wake_up_state(struct task_struct *t, unsigned int state);

2656

2647

2657

static inline void signal_wake_up(struct task_struct *t, bool resume)

2648

static inline void signal_wake_up(struct task_struct *t, bool resume)

2658

{

2649

{

2659

signal_wake_up_state(t, resume ? TASK_WAKEKILL : 0);

2650

signal_wake_up_state(t, resume ? TASK_WAKEKILL : 0);

2660

}

2651

}

2661

static inline void ptrace_signal_wake_up(struct task_struct *t, bool resume)

2652

static inline void ptrace_signal_wake_up(struct task_struct *t, bool resume)

2662

{

2653

{

2663

signal_wake_up_state(t, resume ? __TASK_TRACED : 0);

2654

signal_wake_up_state(t, resume ? __TASK_TRACED : 0);

2664

}

2655

}

2665

2656

2666

/*

2657

/*

2667

* Wrappers for p->thread_info->cpu access. No-op on UP.

2658

* Wrappers for p->thread_info->cpu access. No-op on UP.

2668

*/

2659

*/

2669

#ifdef CONFIG_SMP

2660

#ifdef CONFIG_SMP

2670

2661

2671

static inline unsigned int task_cpu(const struct task_struct *p)

2662

static inline unsigned int task_cpu(const struct task_struct *p)

2672

{

2663

{

2673

return task_thread_info(p)->cpu;

2664

return task_thread_info(p)->cpu;

2674

}

2665

}

2675

2666

2676

static inline int task_node(const struct task_struct *p)

2667

static inline int task_node(const struct task_struct *p)

2677

{

2668

{

2678

return cpu_to_node(task_cpu(p));

2669

return cpu_to_node(task_cpu(p));

2679

}

2670

}

2680

2671

2681

extern void set_task_cpu(struct task_struct *p, unsigned int cpu);

2672

extern void set_task_cpu(struct task_struct *p, unsigned int cpu);

2682

2673

2683

#else

2674

#else

2684

2675

2685

static inline unsigned int task_cpu(const struct task_struct *p)

2676

static inline unsigned int task_cpu(const struct task_struct *p)

2686

{

2677

{

2687

return 0;

2678

return 0;

2688

}

2679

}

2689

2680

2690

static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)

2681

static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)

2691

{

2682

{

2692

}

2683

}

2693

2684

2694

#endif /* CONFIG_SMP */

2685

#endif /* CONFIG_SMP */

2695

2686

2696

extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);

2687

extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);

2697

extern long sched_getaffinity(pid_t pid, struct cpumask *mask);

2688

extern long sched_getaffinity(pid_t pid, struct cpumask *mask);

2698

2689

2699

#ifdef CONFIG_CGROUP_SCHED

2690

#ifdef CONFIG_CGROUP_SCHED

2700

extern struct task_group root_task_group;

2691

extern struct task_group root_task_group;

2701

#endif /* CONFIG_CGROUP_SCHED */

2692

#endif /* CONFIG_CGROUP_SCHED */

2702

2693

2703

extern int task_can_switch_user(struct user_struct *up,

2694

extern int task_can_switch_user(struct user_struct *up,

2704

struct task_struct *tsk);

2695

struct task_struct *tsk);

2705

2696

2706

#ifdef CONFIG_TASK_XACCT

2697

#ifdef CONFIG_TASK_XACCT

2707

static inline void add_rchar(struct task_struct *tsk, ssize_t amt)

2698

static inline void add_rchar(struct task_struct *tsk, ssize_t amt)

2708

{

2699

{

2709

tsk->ioac.rchar += amt;

2700

tsk->ioac.rchar += amt;

2710

}

2701

}

2711

2702

2712

static inline void add_wchar(struct task_struct *tsk, ssize_t amt)

2703

static inline void add_wchar(struct task_struct *tsk, ssize_t amt)

2713

{

2704

{

2714

tsk->ioac.wchar += amt;

2705

tsk->ioac.wchar += amt;

2715

}

2706

}

2716

2707

2717

static inline void inc_syscr(struct task_struct *tsk)

2708

static inline void inc_syscr(struct task_struct *tsk)

2718

{

2709

{

2719

tsk->ioac.syscr++;

2710

tsk->ioac.syscr++;

2720

}

2711

}

2721

2712

2722

static inline void inc_syscw(struct task_struct *tsk)

2713

static inline void inc_syscw(struct task_struct *tsk)

2723

{

2714

{

2724

tsk->ioac.syscw++;

2715

tsk->ioac.syscw++;

2725

}

2716

}

2726

#else

2717

#else

2727

static inline void add_rchar(struct task_struct *tsk, ssize_t amt)

2718

static inline void add_rchar(struct task_struct *tsk, ssize_t amt)

2728

{

2719

{

2729

}

2720

}

2730

2721

2731

static inline void add_wchar(struct task_struct *tsk, ssize_t amt)

2722

static inline void add_wchar(struct task_struct *tsk, ssize_t amt)

2732

{

2723

{

2733

}

2724

}

2734

2725

2735

static inline void inc_syscr(struct task_struct *tsk)

2726

static inline void inc_syscr(struct task_struct *tsk)

2736

{

2727

{

2737

}

2728

}

2738

2729

2739

static inline void inc_syscw(struct task_struct *tsk)

2730

static inline void inc_syscw(struct task_struct *tsk)

2740

{

2731

{

2741

}

2732

}

2742

#endif

2733

#endif

2743

2734

2744

#ifndef TASK_SIZE_OF

2735

#ifndef TASK_SIZE_OF

2745

#define TASK_SIZE_OF(tsk) TASK_SIZE

2736

#define TASK_SIZE_OF(tsk) TASK_SIZE

2746

#endif

2737

#endif

2747

2738

2748

#ifdef CONFIG_MM_OWNER

2739

#ifdef CONFIG_MM_OWNER

2749

extern void mm_update_next_owner(struct mm_struct *mm);

2740

extern void mm_update_next_owner(struct mm_struct *mm);

2750

extern void mm_init_owner(struct mm_struct *mm, struct task_struct *p);

2741

extern void mm_init_owner(struct mm_struct *mm, struct task_struct *p);

2751

#else

2742

#else

2752

static inline void mm_update_next_owner(struct mm_struct *mm)

2743

static inline void mm_update_next_owner(struct mm_struct *mm)

2753

{

2744

{

2754

}

2745

}

2755

2746

2756

static inline void mm_init_owner(struct mm_struct *mm, struct task_struct *p)

2747

static inline void mm_init_owner(struct mm_struct *mm, struct task_struct *p)

2757

{

2748

{

2758

}

2749

}

2759

#endif /* CONFIG_MM_OWNER */

2750

#endif /* CONFIG_MM_OWNER */

2760

2751

2761

static inline unsigned long task_rlimit(const struct task_struct *tsk,

2752

static inline unsigned long task_rlimit(const struct task_struct *tsk,

2762

unsigned int limit)

2753

unsigned int limit)

2763

{

2754

{

2764

return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_cur);

2755

return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_cur);

2765

}

2756

}

2766

2757

2767

static inline unsigned long task_rlimit_max(const struct task_struct *tsk,

2758

static inline unsigned long task_rlimit_max(const struct task_struct *tsk,

2768

unsigned int limit)

2759

unsigned int limit)

2769

{

2760

{

2770

return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_max);

2761

return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_max);

2771

}

2762

}

2772

2763

2773

static inline unsigned long rlimit(unsigned int limit)

2764

static inline unsigned long rlimit(unsigned int limit)

2774

{

2765

{

2775

return task_rlimit(current, limit);

2766

return task_rlimit(current, limit);

2776

}

2767

}

2777

2768

2778

static inline unsigned long rlimit_max(unsigned int limit)

2769

static inline unsigned long rlimit_max(unsigned int limit)

2779

{

2770

{

2780

return task_rlimit_max(current, limit);

2771

return task_rlimit_max(current, limit);

2781

}

2772

}

2782

2773

2783

#endif

2774

#endif

2784

2775

GITLAB

sched: remove ARCH specific fpu_counter from task_struct

 #ifndef _LINUX_SCHED_H
 #define _LINUX_SCHED_H
 #include <uapi/linux/sched.h>
 struct sched_param {
 	int sched_priority;
 };
 #include <asm/param.h>	/* for HZ */
 #include <linux/capability.h>
 #include <linux/threads.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/timex.h>
 #include <linux/jiffies.h>
 #include <linux/rbtree.h>
 #include <linux/thread_info.h>
 #include <linux/cpumask.h>
 #include <linux/errno.h>
 #include <linux/nodemask.h>
 #include <linux/mm_types.h>
 #include <linux/preempt.h>
 #include <asm/page.h>
 #include <asm/ptrace.h>
 #include <asm/cputime.h>
 #include <linux/smp.h>
 #include <linux/sem.h>
 #include <linux/signal.h>
 #include <linux/compiler.h>
 #include <linux/completion.h>
 #include <linux/pid.h>
 #include <linux/percpu.h>
 #include <linux/topology.h>
 #include <linux/proportions.h>
 #include <linux/seccomp.h>
 #include <linux/rcupdate.h>
 #include <linux/rculist.h>
 #include <linux/rtmutex.h>
 #include <linux/time.h>
 #include <linux/param.h>
 #include <linux/resource.h>
 #include <linux/timer.h>
 #include <linux/hrtimer.h>
 #include <linux/task_io_accounting.h>
 #include <linux/latencytop.h>
 #include <linux/cred.h>
 #include <linux/llist.h>
 #include <linux/uidgid.h>
 #include <linux/gfp.h>
 #include <asm/processor.h>
 struct exec_domain;
 struct futex_pi_state;
 struct robust_list_head;
 struct bio_list;
 struct fs_struct;
 struct perf_event_context;
 struct blk_plug;
 /*
  * List of flags we want to share for kernel threads,
  * if only because they are not used by them anyway.
  */
 #define CLONE_KERNEL	(CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
 /*
  * These are the constant used to fake the fixed-point load-average
  * counting. Some notes:
  *  - 11 bit fractions expand to 22 bits by the multiplies: this gives
  *    a load-average precision of 10 bits integer + 11 bits fractional
  *  - if you want to count load-averages more often, you need more
  *    precision, or rounding will get you. With 2-second counting freq,
  *    the EXP_n values would be 1981, 2034 and 2043 if still using only
  *    11 bit fractions.
  */
 extern unsigned long avenrun[];		/* Load averages */
 extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift);
 #define FSHIFT		11		/* nr of bits of precision */
 #define FIXED_1		(1<<FSHIFT)	/* 1.0 as fixed-point */
 #define LOAD_FREQ	(5*HZ+1)	/* 5 sec intervals */
 #define EXP_1		1884		/* 1/exp(5sec/1min) as fixed-point */
 #define EXP_5		2014		/* 1/exp(5sec/5min) */
 #define EXP_15		2037		/* 1/exp(5sec/15min) */
 #define CALC_LOAD(load,exp,n) \
 	load *= exp; \
 	load += n*(FIXED_1-exp); \
 	load >>= FSHIFT;
 extern unsigned long total_forks;
 extern int nr_threads;
 DECLARE_PER_CPU(unsigned long, process_counts);
 extern int nr_processes(void);
 extern unsigned long nr_running(void);
 extern unsigned long nr_iowait(void);
 extern unsigned long nr_iowait_cpu(int cpu);
 extern unsigned long this_cpu_load(void);
 extern void calc_global_load(unsigned long ticks);
 extern void update_cpu_load_nohz(void);
 extern unsigned long get_parent_ip(unsigned long addr);
 extern void dump_cpu_task(int cpu);
 struct seq_file;
 struct cfs_rq;
 struct task_group;
 #ifdef CONFIG_SCHED_DEBUG
 extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);
 extern void proc_sched_set_task(struct task_struct *p);
 extern void
 print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
 #endif
 /*
  * Task state bitmask. NOTE! These bits are also
  * encoded in fs/proc/array.c: get_task_state().
  *
  * We have two separate sets of flags: task->state
  * is about runnability, while task->exit_state are
  * about the task exiting. Confusing, but this way
  * modifying one set can't modify the other one by
  * mistake.
  */
 #define TASK_RUNNING		0
 #define TASK_INTERRUPTIBLE	1
 #define TASK_UNINTERRUPTIBLE	2
 #define __TASK_STOPPED		4
 #define __TASK_TRACED		8
 /* in tsk->exit_state */
 #define EXIT_ZOMBIE		16
 #define EXIT_DEAD		32
 /* in tsk->state again */
 #define TASK_DEAD		64
 #define TASK_WAKEKILL		128
 #define TASK_WAKING		256
 #define TASK_PARKED		512
 #define TASK_STATE_MAX		1024
 #define TASK_STATE_TO_CHAR_STR "RSDTtZXxKWP"
 extern char ___assert_task_state[1 - 2*!!(
 		sizeof(TASK_STATE_TO_CHAR_STR)-1 != ilog2(TASK_STATE_MAX)+1)];
 /* Convenience macros for the sake of set_task_state */
 #define TASK_KILLABLE		(TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
 #define TASK_STOPPED		(TASK_WAKEKILL | __TASK_STOPPED)
 #define TASK_TRACED		(TASK_WAKEKILL | __TASK_TRACED)
 /* Convenience macros for the sake of wake_up */
 #define TASK_NORMAL		(TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)
 #define TASK_ALL		(TASK_NORMAL | __TASK_STOPPED | __TASK_TRACED)
 /* get_task_state() */
 #define TASK_REPORT		(TASK_RUNNING | TASK_INTERRUPTIBLE | \
 				 TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \
 				 __TASK_TRACED)
 #define task_is_traced(task)	((task->state & __TASK_TRACED) != 0)
 #define task_is_stopped(task)	((task->state & __TASK_STOPPED) != 0)
 #define task_is_dead(task)	((task)->exit_state != 0)
 #define task_is_stopped_or_traced(task)	\
 			((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)
 #define task_contributes_to_load(task)	\
 				((task->state & TASK_UNINTERRUPTIBLE) != 0 && \
 				 (task->flags & PF_FROZEN) == 0)
 #define __set_task_state(tsk, state_value)		\
 	do { (tsk)->state = (state_value); } while (0)
 #define set_task_state(tsk, state_value)		\
 	set_mb((tsk)->state, (state_value))
 /*
  * set_current_state() includes a barrier so that the write of current->state
  * is correctly serialised wrt the caller's subsequent test of whether to
  * actually sleep:
  *
  *	set_current_state(TASK_UNINTERRUPTIBLE);
  *	if (do_i_need_to_sleep())
  *		schedule();
  *
  * If the caller does not need such serialisation then use __set_current_state()
  */
 #define __set_current_state(state_value)			\
 	do { current->state = (state_value); } while (0)
 #define set_current_state(state_value)		\
 	set_mb(current->state, (state_value))
 /* Task command name length */
 #define TASK_COMM_LEN 16
 #include <linux/spinlock.h>
 /*
  * This serializes "schedule()" and also protects
  * the run-queue from deletions/modifications (but
  * _adding_ to the beginning of the run-queue has
  * a separate lock).
  */
 extern rwlock_t tasklist_lock;
 extern spinlock_t mmlist_lock;
 struct task_struct;
 #ifdef CONFIG_PROVE_RCU
 extern int lockdep_tasklist_lock_is_held(void);
 #endif /* #ifdef CONFIG_PROVE_RCU */
 extern void sched_init(void);
 extern void sched_init_smp(void);
 extern asmlinkage void schedule_tail(struct task_struct *prev);
 extern void init_idle(struct task_struct *idle, int cpu);
 extern void init_idle_bootup_task(struct task_struct *idle);
 extern int runqueue_is_locked(int cpu);
 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
 extern void nohz_balance_enter_idle(int cpu);
 extern void set_cpu_sd_state_idle(void);
 extern int get_nohz_timer_target(void);
 #else
 static inline void nohz_balance_enter_idle(int cpu) { }
 static inline void set_cpu_sd_state_idle(void) { }
 #endif
 /*
  * Only dump TASK_* tasks. (0 for all tasks)
  */
 extern void show_state_filter(unsigned long state_filter);
 static inline void show_state(void)
 {
 	show_state_filter(0);
 }
 extern void show_regs(struct pt_regs *);
 /*
  * TASK is a pointer to the task whose backtrace we want to see (or NULL for current
  * task), SP is the stack pointer of the first frame that should be shown in the back
  * trace (or NULL if the entire call-chain of the task should be shown).
  */
 extern void show_stack(struct task_struct *task, unsigned long *sp);
 void io_schedule(void);
 long io_schedule_timeout(long timeout);
 extern void cpu_init (void);
 extern void trap_init(void);
 extern void update_process_times(int user);
 extern void scheduler_tick(void);
 extern void sched_show_task(struct task_struct *p);
 #ifdef CONFIG_LOCKUP_DETECTOR
 extern void touch_softlockup_watchdog(void);
 extern void touch_softlockup_watchdog_sync(void);
 extern void touch_all_softlockup_watchdogs(void);
 extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,
 				  void __user *buffer,
 				  size_t *lenp, loff_t *ppos);
 extern unsigned int  softlockup_panic;
 void lockup_detector_init(void);
 #else
 static inline void touch_softlockup_watchdog(void)
 {
 }
 static inline void touch_softlockup_watchdog_sync(void)
 {
 }
 static inline void touch_all_softlockup_watchdogs(void)
 {
 }
 static inline void lockup_detector_init(void)
 {
 }
 #endif
 /* Attach to any functions which should be ignored in wchan output. */
 #define __sched		__attribute__((__section__(".sched.text")))
 /* Linker adds these: start and end of __sched functions */
 extern char __sched_text_start[], __sched_text_end[];
 /* Is this address in the __sched functions? */
 extern int in_sched_functions(unsigned long addr);
 #define	MAX_SCHEDULE_TIMEOUT	LONG_MAX
 extern signed long schedule_timeout(signed long timeout);
 extern signed long schedule_timeout_interruptible(signed long timeout);
 extern signed long schedule_timeout_killable(signed long timeout);
 extern signed long schedule_timeout_uninterruptible(signed long timeout);
 asmlinkage void schedule(void);
 extern void schedule_preempt_disabled(void);
 struct nsproxy;
 struct user_namespace;
 #ifdef CONFIG_MMU
 extern void arch_pick_mmap_layout(struct mm_struct *mm);
 extern unsigned long
 arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
 		       unsigned long, unsigned long);
 extern unsigned long
 arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
 			  unsigned long len, unsigned long pgoff,
 			  unsigned long flags);
 #else
 static inline void arch_pick_mmap_layout(struct mm_struct *mm) {}
 #endif
 extern void set_dumpable(struct mm_struct *mm, int value);
 extern int get_dumpable(struct mm_struct *mm);
 /* mm flags */
 /* dumpable bits */
 #define MMF_DUMPABLE      0  /* core dump is permitted */
 #define MMF_DUMP_SECURELY 1  /* core file is readable only by root */
 #define MMF_DUMPABLE_BITS 2
 #define MMF_DUMPABLE_MASK ((1 << MMF_DUMPABLE_BITS) - 1)
 /* coredump filter bits */
 #define MMF_DUMP_ANON_PRIVATE	2
 #define MMF_DUMP_ANON_SHARED	3
 #define MMF_DUMP_MAPPED_PRIVATE	4
 #define MMF_DUMP_MAPPED_SHARED	5
 #define MMF_DUMP_ELF_HEADERS	6
 #define MMF_DUMP_HUGETLB_PRIVATE 7
 #define MMF_DUMP_HUGETLB_SHARED  8
 #define MMF_DUMP_FILTER_SHIFT	MMF_DUMPABLE_BITS
 #define MMF_DUMP_FILTER_BITS	7
 #define MMF_DUMP_FILTER_MASK \
 	(((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)
 #define MMF_DUMP_FILTER_DEFAULT \
 	((1 << MMF_DUMP_ANON_PRIVATE) |	(1 << MMF_DUMP_ANON_SHARED) |\
 	 (1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)
 #ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS
 # define MMF_DUMP_MASK_DEFAULT_ELF	(1 << MMF_DUMP_ELF_HEADERS)
 #else
 # define MMF_DUMP_MASK_DEFAULT_ELF	0
 #endif
 					/* leave room for more dump flags */
 #define MMF_VM_MERGEABLE	16	/* KSM may merge identical pages */
 #define MMF_VM_HUGEPAGE		17	/* set when VM_HUGEPAGE is set on vma */
 #define MMF_EXE_FILE_CHANGED	18	/* see prctl_set_mm_exe_file() */
 #define MMF_HAS_UPROBES		19	/* has uprobes */
 #define MMF_RECALC_UPROBES	20	/* MMF_HAS_UPROBES can be wrong */
 #define MMF_INIT_MASK		(MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK)
 struct sighand_struct {
 	atomic_t		count;
 	struct k_sigaction	action[_NSIG];
 	spinlock_t		siglock;
 	wait_queue_head_t	signalfd_wqh;
 };
 struct pacct_struct {
 	int			ac_flag;
 	long			ac_exitcode;
 	unsigned long		ac_mem;
 	cputime_t		ac_utime, ac_stime;
 	unsigned long		ac_minflt, ac_majflt;
 };
 struct cpu_itimer {
 	cputime_t expires;
 	cputime_t incr;
 	u32 error;
 	u32 incr_error;
 };
 /**
  * struct cputime - snaphsot of system and user cputime
  * @utime: time spent in user mode
  * @stime: time spent in system mode
  *
  * Gathers a generic snapshot of user and system time.
  */
 struct cputime {
 	cputime_t utime;
 	cputime_t stime;
 };
 /**
  * struct task_cputime - collected CPU time counts
  * @utime:		time spent in user mode, in &cputime_t units
  * @stime:		time spent in kernel mode, in &cputime_t units
  * @sum_exec_runtime:	total time spent on the CPU, in nanoseconds
  *
  * This is an extension of struct cputime that includes the total runtime
  * spent by the task from the scheduler point of view.
  *
  * As a result, this structure groups together three kinds of CPU time
  * that are tracked for threads and thread groups.  Most things considering
  * CPU time want to group these counts together and treat all three
  * of them in parallel.
  */
 struct task_cputime {
 	cputime_t utime;
 	cputime_t stime;
 	unsigned long long sum_exec_runtime;
 };
 /* Alternate field names when used to cache expirations. */
 #define prof_exp	stime
 #define virt_exp	utime
 #define sched_exp	sum_exec_runtime
 #define INIT_CPUTIME	\
 	(struct task_cputime) {					\
 		.utime = 0,					\
 		.stime = 0,					\
 		.sum_exec_runtime = 0,				\
 	}
 #define PREEMPT_ENABLED		(PREEMPT_NEED_RESCHED)
 #ifdef CONFIG_PREEMPT_COUNT
 #define PREEMPT_DISABLED	(1 + PREEMPT_ENABLED)
 #else
 #define PREEMPT_DISABLED	PREEMPT_ENABLED
 #endif
 /*
  * Disable preemption until the scheduler is running.
  * Reset by start_kernel()->sched_init()->init_idle().
  *
  * We include PREEMPT_ACTIVE to avoid cond_resched() from working
  * before the scheduler is active -- see should_resched().
  */
 #define INIT_PREEMPT_COUNT	(PREEMPT_DISABLED + PREEMPT_ACTIVE)
 /**
  * struct thread_group_cputimer - thread group interval timer counts
  * @cputime:		thread group interval timers.
  * @running:		non-zero when there are timers running and
  * 			@cputime receives updates.
  * @lock:		lock for fields in this struct.
  *
  * This structure contains the version of task_cputime, above, that is
  * used for thread group CPU timer calculations.
  */
 struct thread_group_cputimer {
 	struct task_cputime cputime;
 	int running;
 	raw_spinlock_t lock;
 };
 #include <linux/rwsem.h>
 struct autogroup;
 /*
  * NOTE! "signal_struct" does not have its own
  * locking, because a shared signal_struct always
  * implies a shared sighand_struct, so locking
  * sighand_struct is always a proper superset of
  * the locking of signal_struct.
  */
 struct signal_struct {
 	atomic_t		sigcnt;
 	atomic_t		live;
 	int			nr_threads;
 	wait_queue_head_t	wait_chldexit;	/* for wait4() */
 	/* current thread group signal load-balancing target: */
 	struct task_struct	*curr_target;
 	/* shared signal handling: */
 	struct sigpending	shared_pending;
 	/* thread group exit support */
 	int			group_exit_code;
 	/* overloaded:
 	 * - notify group_exit_task when ->count is equal to notify_count
 	 * - everyone except group_exit_task is stopped during signal delivery
 	 *   of fatal signals, group_exit_task processes the signal.
 	 */
 	int			notify_count;
 	struct task_struct	*group_exit_task;
 	/* thread group stop support, overloads group_exit_code too */
 	int			group_stop_count;
 	unsigned int		flags; /* see SIGNAL_* flags below */
 	/*
 	 * PR_SET_CHILD_SUBREAPER marks a process, like a service
 	 * manager, to re-parent orphan (double-forking) child processes
 	 * to this process instead of 'init'. The service manager is
 	 * able to receive SIGCHLD signals and is able to investigate
 	 * the process until it calls wait(). All children of this
 	 * process will inherit a flag if they should look for a
 	 * child_subreaper process at exit.
 	 */
 	unsigned int		is_child_subreaper:1;
 	unsigned int		has_child_subreaper:1;
 	/* POSIX.1b Interval Timers */
 	int			posix_timer_id;
 	struct list_head	posix_timers;
 	/* ITIMER_REAL timer for the process */
 	struct hrtimer real_timer;
 	struct pid *leader_pid;
 	ktime_t it_real_incr;
 	/*
 	 * ITIMER_PROF and ITIMER_VIRTUAL timers for the process, we use
 	 * CPUCLOCK_PROF and CPUCLOCK_VIRT for indexing array as these
 	 * values are defined to 0 and 1 respectively
 	 */
 	struct cpu_itimer it[2];
 	/*
 	 * Thread group totals for process CPU timers.
 	 * See thread_group_cputimer(), et al, for details.
 	 */
 	struct thread_group_cputimer cputimer;
 	/* Earliest-expiration cache. */
 	struct task_cputime cputime_expires;
 	struct list_head cpu_timers[3];
 	struct pid *tty_old_pgrp;
 	/* boolean value for session group leader */
 	int leader;
 	struct tty_struct *tty; /* NULL if no tty */
 #ifdef CONFIG_SCHED_AUTOGROUP
 	struct autogroup *autogroup;
 #endif
 	/*
 	 * Cumulative resource counters for dead threads in the group,
 	 * and for reaped dead child processes forked by this group.
 	 * Live threads maintain their own counters and add to these
 	 * in __exit_signal, except for the group leader.
 	 */
 	cputime_t utime, stime, cutime, cstime;
 	cputime_t gtime;
 	cputime_t cgtime;
 #ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
 	struct cputime prev_cputime;
 #endif
 	unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
 	unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
 	unsigned long inblock, oublock, cinblock, coublock;
 	unsigned long maxrss, cmaxrss;
 	struct task_io_accounting ioac;
 	/*
 	 * Cumulative ns of schedule CPU time fo dead threads in the
 	 * group, not including a zombie group leader, (This only differs
 	 * from jiffies_to_ns(utime + stime) if sched_clock uses something
 	 * other than jiffies.)
 	 */
 	unsigned long long sum_sched_runtime;
 	/*
 	 * We don't bother to synchronize most readers of this at all,
 	 * because there is no reader checking a limit that actually needs
 	 * to get both rlim_cur and rlim_max atomically, and either one
 	 * alone is a single word that can safely be read normally.
 	 * getrlimit/setrlimit use task_lock(current->group_leader) to
 	 * protect this instead of the siglock, because they really
 	 * have no need to disable irqs.
 	 */
 	struct rlimit rlim[RLIM_NLIMITS];
 #ifdef CONFIG_BSD_PROCESS_ACCT
 	struct pacct_struct pacct;	/* per-process accounting information */
 #endif
 #ifdef CONFIG_TASKSTATS
 	struct taskstats *stats;
 #endif
 #ifdef CONFIG_AUDIT
 	unsigned audit_tty;
 	unsigned audit_tty_log_passwd;
 	struct tty_audit_buf *tty_audit_buf;
 #endif
 #ifdef CONFIG_CGROUPS
 	/*
 	 * group_rwsem prevents new tasks from entering the threadgroup and
 	 * member tasks from exiting,a more specifically, setting of
 	 * PF_EXITING.  fork and exit paths are protected with this rwsem
 	 * using threadgroup_change_begin/end().  Users which require
 	 * threadgroup to remain stable should use threadgroup_[un]lock()
 	 * which also takes care of exec path.  Currently, cgroup is the
 	 * only user.
 	 */
 	struct rw_semaphore group_rwsem;
 #endif
 	oom_flags_t oom_flags;
 	short oom_score_adj;		/* OOM kill score adjustment */
 	short oom_score_adj_min;	/* OOM kill score adjustment min value.
 					 * Only settable by CAP_SYS_RESOURCE. */
 	struct mutex cred_guard_mutex;	/* guard against foreign influences on
 					 * credential calculations
 					 * (notably. ptrace) */
 };
 /*
  * Bits in flags field of signal_struct.
  */
 #define SIGNAL_STOP_STOPPED	0x00000001 /* job control stop in effect */
 #define SIGNAL_STOP_CONTINUED	0x00000002 /* SIGCONT since WCONTINUED reap */
 #define SIGNAL_GROUP_EXIT	0x00000004 /* group exit in progress */
 #define SIGNAL_GROUP_COREDUMP	0x00000008 /* coredump in progress */
 /*
  * Pending notifications to parent.
  */
 #define SIGNAL_CLD_STOPPED	0x00000010
 #define SIGNAL_CLD_CONTINUED	0x00000020
 #define SIGNAL_CLD_MASK		(SIGNAL_CLD_STOPPED|SIGNAL_CLD_CONTINUED)
 #define SIGNAL_UNKILLABLE	0x00000040 /* for init: ignore fatal signals */
 /* If true, all threads except ->group_exit_task have pending SIGKILL */
 static inline int signal_group_exit(const struct signal_struct *sig)
 {
 	return	(sig->flags & SIGNAL_GROUP_EXIT) ||
 		(sig->group_exit_task != NULL);
 }
 /*
  * Some day this will be a full-fledged user tracking system..
  */
 struct user_struct {
 	atomic_t __count;	/* reference count */
 	atomic_t processes;	/* How many processes does this user have? */
 	atomic_t files;		/* How many open files does this user have? */
 	atomic_t sigpending;	/* How many pending signals does this user have? */
 #ifdef CONFIG_INOTIFY_USER
 	atomic_t inotify_watches; /* How many inotify watches does this user have? */
 	atomic_t inotify_devs;	/* How many inotify devs does this user have opened? */
 #endif
 #ifdef CONFIG_FANOTIFY
 	atomic_t fanotify_listeners;
 #endif
 #ifdef CONFIG_EPOLL
 	atomic_long_t epoll_watches; /* The number of file descriptors currently watched */
 #endif
 #ifdef CONFIG_POSIX_MQUEUE
 	/* protected by mq_lock	*/
 	unsigned long mq_bytes;	/* How many bytes can be allocated to mqueue? */
 #endif
 	unsigned long locked_shm; /* How many pages of mlocked shm ? */
 #ifdef CONFIG_KEYS
 	struct key *uid_keyring;	/* UID specific keyring */
 	struct key *session_keyring;	/* UID's default session keyring */
 #endif
 	/* Hash table maintenance information */
 	struct hlist_node uidhash_node;
 	kuid_t uid;
 #ifdef CONFIG_PERF_EVENTS
 	atomic_long_t locked_vm;
 #endif
 };
 extern int uids_sysfs_init(void);
 extern struct user_struct *find_user(kuid_t);
 extern struct user_struct root_user;
 #define INIT_USER (&root_user)
 struct backing_dev_info;
 struct reclaim_state;
 #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
 struct sched_info {
 	/* cumulative counters */
 	unsigned long pcount;	      /* # of times run on this cpu */
 	unsigned long long run_delay; /* time spent waiting on a runqueue */
 	/* timestamps */
 	unsigned long long last_arrival,/* when we last ran on a cpu */
 			   last_queued;	/* when we were last queued to run */
 };
 #endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */
 #ifdef CONFIG_TASK_DELAY_ACCT
 struct task_delay_info {
 	spinlock_t	lock;
 	unsigned int	flags;	/* Private per-task flags */
 	/* For each stat XXX, add following, aligned appropriately
 	 *
 	 * struct timespec XXX_start, XXX_end;
 	 * u64 XXX_delay;
 	 * u32 XXX_count;
 	 *
 	 * Atomicity of updates to XXX_delay, XXX_count protected by
 	 * single lock above (split into XXX_lock if contention is an issue).
 	 */
 	/*
 	 * XXX_count is incremented on every XXX operation, the delay
 	 * associated with the operation is added to XXX_delay.
 	 * XXX_delay contains the accumulated delay time in nanoseconds.
 	 */
 	struct timespec blkio_start, blkio_end;	/* Shared by blkio, swapin */
 	u64 blkio_delay;	/* wait for sync block io completion */
 	u64 swapin_delay;	/* wait for swapin block io completion */
 	u32 blkio_count;	/* total count of the number of sync block */
 				/* io operations performed */
 	u32 swapin_count;	/* total count of the number of swapin block */
 				/* io operations performed */
 	struct timespec freepages_start, freepages_end;
 	u64 freepages_delay;	/* wait for memory reclaim */
 	u32 freepages_count;	/* total count of memory reclaim */
 };
 #endif	/* CONFIG_TASK_DELAY_ACCT */
 static inline int sched_info_on(void)
 {
 #ifdef CONFIG_SCHEDSTATS
 	return 1;
 #elif defined(CONFIG_TASK_DELAY_ACCT)
 	extern int delayacct_on;
 	return delayacct_on;
 #else
 	return 0;
 #endif
 }
 enum cpu_idle_type {
 	CPU_IDLE,
 	CPU_NOT_IDLE,
 	CPU_NEWLY_IDLE,
 	CPU_MAX_IDLE_TYPES
 };
 /*
  * Increase resolution of cpu_power calculations
  */
 #define SCHED_POWER_SHIFT	10
 #define SCHED_POWER_SCALE	(1L << SCHED_POWER_SHIFT)
 /*
  * sched-domains (multiprocessor balancing) declarations:
  */
 #ifdef CONFIG_SMP
 #define SD_LOAD_BALANCE		0x0001	/* Do load balancing on this domain. */
 #define SD_BALANCE_NEWIDLE	0x0002	/* Balance when about to become idle */
 #define SD_BALANCE_EXEC		0x0004	/* Balance on exec */
 #define SD_BALANCE_FORK		0x0008	/* Balance on fork, clone */
 #define SD_BALANCE_WAKE		0x0010  /* Balance on wakeup */
 #define SD_WAKE_AFFINE		0x0020	/* Wake task to waking CPU */
 #define SD_SHARE_CPUPOWER	0x0080	/* Domain members share cpu power */
 #define SD_SHARE_PKG_RESOURCES	0x0200	/* Domain members share cpu pkg resources */
 #define SD_SERIALIZE		0x0400	/* Only a single load balancing instance */
 #define SD_ASYM_PACKING		0x0800  /* Place busy groups earlier in the domain */
 #define SD_PREFER_SIBLING	0x1000	/* Prefer to place tasks in a sibling domain */
 #define SD_OVERLAP		0x2000	/* sched_domains of this level overlap */
 #define SD_NUMA			0x4000	/* cross-node balancing */
 extern int __weak arch_sd_sibiling_asym_packing(void);
 struct sched_domain_attr {
 	int relax_domain_level;
 };
 #define SD_ATTR_INIT	(struct sched_domain_attr) {	\
 	.relax_domain_level = -1,			\
 }
 extern int sched_domain_level_max;
 struct sched_group;
 struct sched_domain {
 	/* These fields must be setup */
 	struct sched_domain *parent;	/* top domain must be null terminated */
 	struct sched_domain *child;	/* bottom domain must be null terminated */
 	struct sched_group *groups;	/* the balancing groups of the domain */
 	unsigned long min_interval;	/* Minimum balance interval ms */
 	unsigned long max_interval;	/* Maximum balance interval ms */
 	unsigned int busy_factor;	/* less balancing by factor if busy */
 	unsigned int imbalance_pct;	/* No balance until over watermark */
 	unsigned int cache_nice_tries;	/* Leave cache hot tasks for # tries */
 	unsigned int busy_idx;
 	unsigned int idle_idx;
 	unsigned int newidle_idx;
 	unsigned int wake_idx;
 	unsigned int forkexec_idx;
 	unsigned int smt_gain;
 	int nohz_idle;			/* NOHZ IDLE status */
 	int flags;			/* See SD_* */
 	int level;
 	/* Runtime fields. */
 	unsigned long last_balance;	/* init to jiffies. units in jiffies */
 	unsigned int balance_interval;	/* initialise to 1. units in ms. */
 	unsigned int nr_balance_failed; /* initialise to 0 */
 	u64 last_update;
 	/* idle_balance() stats */
 	u64 max_newidle_lb_cost;
 	unsigned long next_decay_max_lb_cost;
 #ifdef CONFIG_SCHEDSTATS
 	/* load_balance() stats */
 	unsigned int lb_count[CPU_MAX_IDLE_TYPES];
 	unsigned int lb_failed[CPU_MAX_IDLE_TYPES];
 	unsigned int lb_balanced[CPU_MAX_IDLE_TYPES];
 	unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES];
 	unsigned int lb_gained[CPU_MAX_IDLE_TYPES];
 	unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES];
 	unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES];
 	unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES];
 	/* Active load balancing */
 	unsigned int alb_count;
 	unsigned int alb_failed;
 	unsigned int alb_pushed;
 	/* SD_BALANCE_EXEC stats */
 	unsigned int sbe_count;
 	unsigned int sbe_balanced;
 	unsigned int sbe_pushed;
 	/* SD_BALANCE_FORK stats */
 	unsigned int sbf_count;
 	unsigned int sbf_balanced;
 	unsigned int sbf_pushed;
 	/* try_to_wake_up() stats */
 	unsigned int ttwu_wake_remote;
 	unsigned int ttwu_move_affine;
 	unsigned int ttwu_move_balance;
 #endif
 #ifdef CONFIG_SCHED_DEBUG
 	char *name;
 #endif
 	union {
 		void *private;		/* used during construction */
 		struct rcu_head rcu;	/* used during destruction */
 	};
 	unsigned int span_weight;
 	/*
 	 * Span of all CPUs in this domain.
 	 *
 	 * NOTE: this field is variable length. (Allocated dynamically
 	 * by attaching extra space to the end of the structure,
 	 * depending on how many CPUs the kernel has booted up with)
 	 */
 	unsigned long span[0];
 };
 static inline struct cpumask *sched_domain_span(struct sched_domain *sd)
 {
 	return to_cpumask(sd->span);
 }
 extern void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
 				    struct sched_domain_attr *dattr_new);
 /* Allocate an array of sched domains, for partition_sched_domains(). */
 cpumask_var_t *alloc_sched_domains(unsigned int ndoms);
 void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms);
 bool cpus_share_cache(int this_cpu, int that_cpu);
 #else /* CONFIG_SMP */
 struct sched_domain_attr;
 static inline void
 partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
 			struct sched_domain_attr *dattr_new)
 {
 }
 static inline bool cpus_share_cache(int this_cpu, int that_cpu)
 {
 	return true;
 }
 #endif	/* !CONFIG_SMP */
 struct io_context;			/* See blkdev.h */
 #ifdef ARCH_HAS_PREFETCH_SWITCH_STACK
 extern void prefetch_stack(struct task_struct *t);
 #else
 static inline void prefetch_stack(struct task_struct *t) { }
 #endif
 struct audit_context;		/* See audit.c */
 struct mempolicy;
 struct pipe_inode_info;
 struct uts_namespace;
 struct load_weight {
 	unsigned long weight, inv_weight;
 };
 struct sched_avg {
 	/*
 	 * These sums represent an infinite geometric series and so are bound
 	 * above by 1024/(1-y).  Thus we only need a u32 to store them for all
 	 * choices of y < 1-2^(-32)*1024.
 	 */
 	u32 runnable_avg_sum, runnable_avg_period;
 	u64 last_runnable_update;
 	s64 decay_count;
 	unsigned long load_avg_contrib;
 };
 #ifdef CONFIG_SCHEDSTATS
 struct sched_statistics {
 	u64			wait_start;
 	u64			wait_max;
 	u64			wait_count;
 	u64			wait_sum;
 	u64			iowait_count;
 	u64			iowait_sum;
 	u64			sleep_start;
 	u64			sleep_max;
 	s64			sum_sleep_runtime;
 	u64			block_start;
 	u64			block_max;
 	u64			exec_max;
 	u64			slice_max;
 	u64			nr_migrations_cold;
 	u64			nr_failed_migrations_affine;
 	u64			nr_failed_migrations_running;
 	u64			nr_failed_migrations_hot;
 	u64			nr_forced_migrations;
 	u64			nr_wakeups;
 	u64			nr_wakeups_sync;
 	u64			nr_wakeups_migrate;
 	u64			nr_wakeups_local;
 	u64			nr_wakeups_remote;
 	u64			nr_wakeups_affine;
 	u64			nr_wakeups_affine_attempts;
 	u64			nr_wakeups_passive;
 	u64			nr_wakeups_idle;
 };
 #endif
 struct sched_entity {
 	struct load_weight	load;		/* for load-balancing */
 	struct rb_node		run_node;
 	struct list_head	group_node;
 	unsigned int		on_rq;
 	u64			exec_start;
 	u64			sum_exec_runtime;
 	u64			vruntime;
 	u64			prev_sum_exec_runtime;
 	u64			nr_migrations;
 #ifdef CONFIG_SCHEDSTATS
 	struct sched_statistics statistics;
 #endif
 #ifdef CONFIG_FAIR_GROUP_SCHED
 	struct sched_entity	*parent;
 	/* rq on which this entity is (to be) queued: */
 	struct cfs_rq		*cfs_rq;
 	/* rq "owned" by this entity/group: */
 	struct cfs_rq		*my_q;
 #endif
 #ifdef CONFIG_SMP
 	/* Per-entity load-tracking */
 	struct sched_avg	avg;
 #endif
 };
 struct sched_rt_entity {
 	struct list_head run_list;
 	unsigned long timeout;
 	unsigned long watchdog_stamp;
 	unsigned int time_slice;
 	struct sched_rt_entity *back;
 #ifdef CONFIG_RT_GROUP_SCHED
 	struct sched_rt_entity	*parent;
 	/* rq on which this entity is (to be) queued: */
 	struct rt_rq		*rt_rq;
 	/* rq "owned" by this entity/group: */
 	struct rt_rq		*my_q;
 #endif
 };
 struct rcu_node;
 enum perf_event_task_context {
 	perf_invalid_context = -1,
 	perf_hw_context = 0,
 	perf_sw_context,
 	perf_nr_task_contexts,
 };
 struct task_struct {
 	volatile long state;	/* -1 unrunnable, 0 runnable, >0 stopped */
 	void *stack;
 	atomic_t usage;
 	unsigned int flags;	/* per process flags, defined below */
 	unsigned int ptrace;
 #ifdef CONFIG_SMP
 	struct llist_node wake_entry;
 	int on_cpu;
 	struct task_struct *last_wakee;
 	unsigned long wakee_flips;
 	unsigned long wakee_flip_decay_ts;
 	int wake_cpu;
 #endif
 	int on_rq;
 	int prio, static_prio, normal_prio;
 	unsigned int rt_priority;
 	const struct sched_class *sched_class;
 	struct sched_entity se;
 	struct sched_rt_entity rt;
 #ifdef CONFIG_CGROUP_SCHED
 	struct task_group *sched_task_group;
 #endif
 #ifdef CONFIG_PREEMPT_NOTIFIERS
 	/* list of struct preempt_notifier: */
 	struct hlist_head preempt_notifiers;
 #endif
-	/*
-	 * fpu_counter contains the number of consecutive context switches
-	 * that the FPU is used. If this is over a threshold, the lazy fpu
-	 * saving becomes unlazy to save the trap. This is an unsigned char
-	 * so that after 256 times the counter wraps and the behavior turns
-	 * lazy again; this to deal with bursty apps that only use FPU for
-	 * a short time
-	 */
-	unsigned char fpu_counter;
 #ifdef CONFIG_BLK_DEV_IO_TRACE
 	unsigned int btrace_seq;
 #endif
 	unsigned int policy;
 	int nr_cpus_allowed;
 	cpumask_t cpus_allowed;
 #ifdef CONFIG_PREEMPT_RCU
 	int rcu_read_lock_nesting;
 	char rcu_read_unlock_special;
 	struct list_head rcu_node_entry;
 #endif /* #ifdef CONFIG_PREEMPT_RCU */
 #ifdef CONFIG_TREE_PREEMPT_RCU
 	struct rcu_node *rcu_blocked_node;
 #endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
 #ifdef CONFIG_RCU_BOOST
 	struct rt_mutex *rcu_boost_mutex;
 #endif /* #ifdef CONFIG_RCU_BOOST */
 #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
 	struct sched_info sched_info;
 #endif
 	struct list_head tasks;
 #ifdef CONFIG_SMP
 	struct plist_node pushable_tasks;
 #endif
 	struct mm_struct *mm, *active_mm;
 #ifdef CONFIG_COMPAT_BRK
 	unsigned brk_randomized:1;
 #endif
 #if defined(SPLIT_RSS_COUNTING)
 	struct task_rss_stat	rss_stat;
 #endif
 /* task state */
 	int exit_state;
 	int exit_code, exit_signal;
 	int pdeath_signal;  /*  The signal sent when the parent dies  */
 	unsigned int jobctl;	/* JOBCTL_*, siglock protected */
 	/* Used for emulating ABI behavior of previous Linux versions */
 	unsigned int personality;
 	unsigned did_exec:1;
 	unsigned in_execve:1;	/* Tell the LSMs that the process is doing an
 				 * execve */
 	unsigned in_iowait:1;
 	/* task may not gain privileges */
 	unsigned no_new_privs:1;
 	/* Revert to default priority/policy when forking */
 	unsigned sched_reset_on_fork:1;
 	unsigned sched_contributes_to_load:1;
 	pid_t pid;
 	pid_t tgid;
 #ifdef CONFIG_CC_STACKPROTECTOR
 	/* Canary value for the -fstack-protector gcc feature */
 	unsigned long stack_canary;
 #endif
 	/*
 	 * pointers to (original) parent process, youngest child, younger sibling,
 	 * older sibling, respectively.  (p->father can be replaced with
 	 * p->real_parent->pid)
 	 */
 	struct task_struct __rcu *real_parent; /* real parent process */
 	struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */
 	/*
 	 * children/sibling forms the list of my natural children
 	 */
 	struct list_head children;	/* list of my children */
 	struct list_head sibling;	/* linkage in my parent's children list */
 	struct task_struct *group_leader;	/* threadgroup leader */
 	/*
 	 * ptraced is the list of tasks this task is using ptrace on.
 	 * This includes both natural children and PTRACE_ATTACH targets.
 	 * p->ptrace_entry is p's link on the p->parent->ptraced list.
 	 */
 	struct list_head ptraced;
 	struct list_head ptrace_entry;
 	/* PID/PID hash table linkage. */
 	struct pid_link pids[PIDTYPE_MAX];
 	struct list_head thread_group;
 	struct completion *vfork_done;		/* for vfork() */
 	int __user *set_child_tid;		/* CLONE_CHILD_SETTID */
 	int __user *clear_child_tid;		/* CLONE_CHILD_CLEARTID */
 	cputime_t utime, stime, utimescaled, stimescaled;
 	cputime_t gtime;
 #ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
 	struct cputime prev_cputime;
 #endif
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
 	seqlock_t vtime_seqlock;
 	unsigned long long vtime_snap;
 	enum {
 		VTIME_SLEEPING = 0,
 		VTIME_USER,
 		VTIME_SYS,
 	} vtime_snap_whence;
 #endif
 	unsigned long nvcsw, nivcsw; /* context switch counts */
 	struct timespec start_time; 		/* monotonic time */
 	struct timespec real_start_time;	/* boot based time */
 /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
 	unsigned long min_flt, maj_flt;
 	struct task_cputime cputime_expires;
 	struct list_head cpu_timers[3];
 /* process credentials */
 	const struct cred __rcu *real_cred; /* objective and real subjective task
 					 * credentials (COW) */
 	const struct cred __rcu *cred;	/* effective (overridable) subjective task
 					 * credentials (COW) */
 	char comm[TASK_COMM_LEN]; /* executable name excluding path
 				     - access with [gs]et_task_comm (which lock
 				       it with task_lock())
 				     - initialized normally by setup_new_exec */
 /* file system info */
 	int link_count, total_link_count;
 #ifdef CONFIG_SYSVIPC
 /* ipc stuff */
 	struct sysv_sem sysvsem;
 #endif
 #ifdef CONFIG_DETECT_HUNG_TASK
 /* hung task detection */
 	unsigned long last_switch_count;
 #endif
 /* CPU-specific state of this task */
 	struct thread_struct thread;
 /* filesystem information */
 	struct fs_struct *fs;
 /* open file information */
 	struct files_struct *files;
 /* namespaces */
 	struct nsproxy *nsproxy;
 /* signal handlers */
 	struct signal_struct *signal;
 	struct sighand_struct *sighand;
 	sigset_t blocked, real_blocked;
 	sigset_t saved_sigmask;	/* restored if set_restore_sigmask() was used */
 	struct sigpending pending;
 	unsigned long sas_ss_sp;
 	size_t sas_ss_size;
 	int (*notifier)(void *priv);
 	void *notifier_data;
 	sigset_t *notifier_mask;
 	struct callback_head *task_works;
 	struct audit_context *audit_context;
 #ifdef CONFIG_AUDITSYSCALL
 	kuid_t loginuid;
 	unsigned int sessionid;
 #endif
 	struct seccomp seccomp;
 /* Thread group tracking */
    	u32 parent_exec_id;
    	u32 self_exec_id;
 /* Protection of (de-)allocation: mm, files, fs, tty, keyrings, mems_allowed,
  * mempolicy */
 	spinlock_t alloc_lock;
 	/* Protection of the PI data structures: */
 	raw_spinlock_t pi_lock;
 #ifdef CONFIG_RT_MUTEXES
 	/* PI waiters blocked on a rt_mutex held by this task */
 	struct plist_head pi_waiters;
 	/* Deadlock detection and priority inheritance handling */
 	struct rt_mutex_waiter *pi_blocked_on;
 #endif
 #ifdef CONFIG_DEBUG_MUTEXES
 	/* mutex deadlock detection */
 	struct mutex_waiter *blocked_on;
 #endif
 #ifdef CONFIG_TRACE_IRQFLAGS
 	unsigned int irq_events;
 	unsigned long hardirq_enable_ip;
 	unsigned long hardirq_disable_ip;
 	unsigned int hardirq_enable_event;
 	unsigned int hardirq_disable_event;
 	int hardirqs_enabled;
 	int hardirq_context;
 	unsigned long softirq_disable_ip;
 	unsigned long softirq_enable_ip;
 	unsigned int softirq_disable_event;
 	unsigned int softirq_enable_event;
 	int softirqs_enabled;
 	int softirq_context;
 #endif
 #ifdef CONFIG_LOCKDEP
 # define MAX_LOCK_DEPTH 48UL
 	u64 curr_chain_key;
 	int lockdep_depth;
 	unsigned int lockdep_recursion;
 	struct held_lock held_locks[MAX_LOCK_DEPTH];
 	gfp_t lockdep_reclaim_gfp;
 #endif
 /* journalling filesystem info */
 	void *journal_info;
 /* stacked block device info */
 	struct bio_list *bio_list;
 #ifdef CONFIG_BLOCK
 /* stack plugging */
 	struct blk_plug *plug;
 #endif
 /* VM state */
 	struct reclaim_state *reclaim_state;
 	struct backing_dev_info *backing_dev_info;
 	struct io_context *io_context;
 	unsigned long ptrace_message;
 	siginfo_t *last_siginfo; /* For ptrace use.  */
 	struct task_io_accounting ioac;
 #if defined(CONFIG_TASK_XACCT)
 	u64 acct_rss_mem1;	/* accumulated rss usage */
 	u64 acct_vm_mem1;	/* accumulated virtual memory usage */
 	cputime_t acct_timexpd;	/* stime + utime since last update */
 #endif
 #ifdef CONFIG_CPUSETS
 	nodemask_t mems_allowed;	/* Protected by alloc_lock */
 	seqcount_t mems_allowed_seq;	/* Seqence no to catch updates */
 	int cpuset_mem_spread_rotor;
 	int cpuset_slab_spread_rotor;
 #endif
 #ifdef CONFIG_CGROUPS
 	/* Control Group info protected by css_set_lock */
 	struct css_set __rcu *cgroups;
 	/* cg_list protected by css_set_lock and tsk->alloc_lock */
 	struct list_head cg_list;
 #endif
 #ifdef CONFIG_FUTEX
 	struct robust_list_head __user *robust_list;
 #ifdef CONFIG_COMPAT
 	struct compat_robust_list_head __user *compat_robust_list;
 #endif
 	struct list_head pi_state_list;
 	struct futex_pi_state *pi_state_cache;
 #endif
 #ifdef CONFIG_PERF_EVENTS
 	struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts];
 	struct mutex perf_event_mutex;
 	struct list_head perf_event_list;
 #endif
 #ifdef CONFIG_NUMA
 	struct mempolicy *mempolicy;	/* Protected by alloc_lock */
 	short il_next;
 	short pref_node_fork;
 #endif
 #ifdef CONFIG_NUMA_BALANCING
 	int numa_scan_seq;
 	unsigned int numa_scan_period;
 	unsigned int numa_scan_period_max;
 	int numa_preferred_nid;
 	int numa_migrate_deferred;
 	unsigned long numa_migrate_retry;
 	u64 node_stamp;			/* migration stamp  */
 	struct callback_head numa_work;
 	struct list_head numa_entry;
 	struct numa_group *numa_group;
 	/*
 	 * Exponential decaying average of faults on a per-node basis.
 	 * Scheduling placement decisions are made based on the these counts.
 	 * The values remain static for the duration of a PTE scan
 	 */
 	unsigned long *numa_faults;
 	unsigned long total_numa_faults;
 	/*
 	 * numa_faults_buffer records faults per node during the current
 	 * scan window. When the scan completes, the counts in numa_faults
 	 * decay and these values are copied.
 	 */
 	unsigned long *numa_faults_buffer;
 	/*
 	 * numa_faults_locality tracks if faults recorded during the last
 	 * scan window were remote/local. The task scan period is adapted
 	 * based on the locality of the faults with different weights
 	 * depending on whether they were shared or private faults
 	 */
 	unsigned long numa_faults_locality[2];
 	unsigned long numa_pages_migrated;
 #endif /* CONFIG_NUMA_BALANCING */
 	struct rcu_head rcu;
 	/*
 	 * cache last used pipe for splice
 	 */
 	struct pipe_inode_info *splice_pipe;
 	struct page_frag task_frag;
 #ifdef	CONFIG_TASK_DELAY_ACCT
 	struct task_delay_info *delays;
 #endif
 #ifdef CONFIG_FAULT_INJECTION
 	int make_it_fail;
 #endif
 	/*
 	 * when (nr_dirtied >= nr_dirtied_pause), it's time to call
 	 * balance_dirty_pages() for some dirty throttling pause
 	 */
 	int nr_dirtied;
 	int nr_dirtied_pause;
 	unsigned long dirty_paused_when; /* start of a write-and-pause period */
 #ifdef CONFIG_LATENCYTOP
 	int latency_record_count;
 	struct latency_record latency_record[LT_SAVECOUNT];
 #endif
 	/*
 	 * time slack values; these are used to round up poll() and
 	 * select() etc timeout values. These are in nanoseconds.
 	 */
 	unsigned long timer_slack_ns;
 	unsigned long default_timer_slack_ns;
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 	/* Index of current stored address in ret_stack */
 	int curr_ret_stack;
 	/* Stack of return addresses for return function tracing */
 	struct ftrace_ret_stack	*ret_stack;
 	/* time stamp for last schedule */
 	unsigned long long ftrace_timestamp;
 	/*
 	 * Number of functions that haven't been traced
 	 * because of depth overrun.
 	 */
 	atomic_t trace_overrun;
 	/* Pause for the tracing */
 	atomic_t tracing_graph_pause;
 #endif
 #ifdef CONFIG_TRACING
 	/* state flags for use by tracers */
 	unsigned long trace;
 	/* bitmask and counter of trace recursion */
 	unsigned long trace_recursion;
 #endif /* CONFIG_TRACING */
 #ifdef CONFIG_MEMCG /* memcg uses this to do batch job */
 	struct memcg_batch_info {
 		int do_batch;	/* incremented when batch uncharge started */
 		struct mem_cgroup *memcg; /* target memcg of uncharge */
 		unsigned long nr_pages;	/* uncharged usage */
 		unsigned long memsw_nr_pages; /* uncharged mem+swap usage */
 	} memcg_batch;
 	unsigned int memcg_kmem_skip_account;
 	struct memcg_oom_info {
 		struct mem_cgroup *memcg;
 		gfp_t gfp_mask;
 		int order;
 		unsigned int may_oom:1;
 	} memcg_oom;
 #endif
 #ifdef CONFIG_UPROBES
 	struct uprobe_task *utask;
 #endif
 #if defined(CONFIG_BCACHE) || defined(CONFIG_BCACHE_MODULE)
 	unsigned int	sequential_io;
 	unsigned int	sequential_io_avg;
 #endif
 };
 /* Future-safe accessor for struct task_struct's cpus_allowed. */
 #define tsk_cpus_allowed(tsk) (&(tsk)->cpus_allowed)
 #define TNF_MIGRATED	0x01
 #define TNF_NO_GROUP	0x02
 #define TNF_SHARED	0x04
 #define TNF_FAULT_LOCAL	0x08
 #ifdef CONFIG_NUMA_BALANCING
 extern void task_numa_fault(int last_node, int node, int pages, int flags);
 extern pid_t task_numa_group_id(struct task_struct *p);
 extern void set_numabalancing_state(bool enabled);
 extern void task_numa_free(struct task_struct *p);
 extern unsigned int sysctl_numa_balancing_migrate_deferred;
 #else
 static inline void task_numa_fault(int last_node, int node, int pages,
 				   int flags)
 {
 }
 static inline pid_t task_numa_group_id(struct task_struct *p)
 {
 	return 0;
 }
 static inline void set_numabalancing_state(bool enabled)
 {
 }
 static inline void task_numa_free(struct task_struct *p)
 {
 }
 #endif
 static inline struct pid *task_pid(struct task_struct *task)
 {
 	return task->pids[PIDTYPE_PID].pid;
 }
 static inline struct pid *task_tgid(struct task_struct *task)
 {
 	return task->group_leader->pids[PIDTYPE_PID].pid;
 }
 /*
  * Without tasklist or rcu lock it is not safe to dereference
  * the result of task_pgrp/task_session even if task == current,
  * we can race with another thread doing sys_setsid/sys_setpgid.
  */
 static inline struct pid *task_pgrp(struct task_struct *task)
 {
 	return task->group_leader->pids[PIDTYPE_PGID].pid;
 }
 static inline struct pid *task_session(struct task_struct *task)
 {
 	return task->group_leader->pids[PIDTYPE_SID].pid;
 }
 struct pid_namespace;
 /*
  * the helpers to get the task's different pids as they are seen
  * from various namespaces
  *
  * task_xid_nr()     : global id, i.e. the id seen from the init namespace;
  * task_xid_vnr()    : virtual id, i.e. the id seen from the pid namespace of
  *                     current.
  * task_xid_nr_ns()  : id seen from the ns specified;
  *
  * set_task_vxid()   : assigns a virtual id to a task;
  *
  * see also pid_nr() etc in include/linux/pid.h
  */
 pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type,
 			struct pid_namespace *ns);
 static inline pid_t task_pid_nr(struct task_struct *tsk)
 {
 	return tsk->pid;
 }
 static inline pid_t task_pid_nr_ns(struct task_struct *tsk,
 					struct pid_namespace *ns)
 {
 	return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);
 }
 static inline pid_t task_pid_vnr(struct task_struct *tsk)
 {
 	return __task_pid_nr_ns(tsk, PIDTYPE_PID, NULL);
 }
 static inline pid_t task_tgid_nr(struct task_struct *tsk)
 {
 	return tsk->tgid;
 }
 pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
 static inline pid_t task_tgid_vnr(struct task_struct *tsk)
 {
 	return pid_vnr(task_tgid(tsk));
 }
 static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk,
 					struct pid_namespace *ns)
 {
 	return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns);
 }
 static inline pid_t task_pgrp_vnr(struct task_struct *tsk)
 {
 	return __task_pid_nr_ns(tsk, PIDTYPE_PGID, NULL);
 }
 static inline pid_t task_session_nr_ns(struct task_struct *tsk,
 					struct pid_namespace *ns)
 {
 	return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns);
 }
 static inline pid_t task_session_vnr(struct task_struct *tsk)
 {
 	return __task_pid_nr_ns(tsk, PIDTYPE_SID, NULL);
 }
 /* obsolete, do not use */
 static inline pid_t task_pgrp_nr(struct task_struct *tsk)
 {
 	return task_pgrp_nr_ns(tsk, &init_pid_ns);
 }
 /**
  * pid_alive - check that a task structure is not stale
  * @p: Task structure to be checked.
  *
  * Test if a process is not yet dead (at most zombie state)
  * If pid_alive fails, then pointers within the task structure
  * can be stale and must not be dereferenced.
  *
  * Return: 1 if the process is alive. 0 otherwise.
  */
 static inline int pid_alive(struct task_struct *p)
 {
 	return p->pids[PIDTYPE_PID].pid != NULL;
 }
 /**
  * is_global_init - check if a task structure is init
  * @tsk: Task structure to be checked.
  *
  * Check if a task structure is the first user space task the kernel created.
  *
  * Return: 1 if the task structure is init. 0 otherwise.
  */
 static inline int is_global_init(struct task_struct *tsk)
 {
 	return tsk->pid == 1;
 }
 extern struct pid *cad_pid;
 extern void free_task(struct task_struct *tsk);
 #define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
 extern void __put_task_struct(struct task_struct *t);
 static inline void put_task_struct(struct task_struct *t)
 {
 	if (atomic_dec_and_test(&t->usage))
 		__put_task_struct(t);
 }
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
 extern void task_cputime(struct task_struct *t,
 			 cputime_t *utime, cputime_t *stime);
 extern void task_cputime_scaled(struct task_struct *t,
 				cputime_t *utimescaled, cputime_t *stimescaled);
 extern cputime_t task_gtime(struct task_struct *t);
 #else
 static inline void task_cputime(struct task_struct *t,
 				cputime_t *utime, cputime_t *stime)
 {
 	if (utime)
 		*utime = t->utime;
 	if (stime)
 		*stime = t->stime;
 }
 static inline void task_cputime_scaled(struct task_struct *t,
 				       cputime_t *utimescaled,
 				       cputime_t *stimescaled)
 {
 	if (utimescaled)
 		*utimescaled = t->utimescaled;
 	if (stimescaled)
 		*stimescaled = t->stimescaled;
 }
 static inline cputime_t task_gtime(struct task_struct *t)
 {
 	return t->gtime;
 }
 #endif
 extern void task_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);
 extern void thread_group_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);
 /*
  * Per process flags
  */
 #define PF_EXITING	0x00000004	/* getting shut down */
 #define PF_EXITPIDONE	0x00000008	/* pi exit done on shut down */
 #define PF_VCPU		0x00000010	/* I'm a virtual CPU */
 #define PF_WQ_WORKER	0x00000020	/* I'm a workqueue worker */
 #define PF_FORKNOEXEC	0x00000040	/* forked but didn't exec */
 #define PF_MCE_PROCESS  0x00000080      /* process policy on mce errors */
 #define PF_SUPERPRIV	0x00000100	/* used super-user privileges */
 #define PF_DUMPCORE	0x00000200	/* dumped core */
 #define PF_SIGNALED	0x00000400	/* killed by a signal */
 #define PF_MEMALLOC	0x00000800	/* Allocating memory */
 #define PF_NPROC_EXCEEDED 0x00001000	/* set_user noticed that RLIMIT_NPROC was exceeded */
 #define PF_USED_MATH	0x00002000	/* if unset the fpu must be initialized before use */
 #define PF_USED_ASYNC	0x00004000	/* used async_schedule*(), used by module init */
 #define PF_NOFREEZE	0x00008000	/* this thread should not be frozen */
 #define PF_FROZEN	0x00010000	/* frozen for system suspend */
 #define PF_FSTRANS	0x00020000	/* inside a filesystem transaction */
 #define PF_KSWAPD	0x00040000	/* I am kswapd */
 #define PF_MEMALLOC_NOIO 0x00080000	/* Allocating memory without IO involved */
 #define PF_LESS_THROTTLE 0x00100000	/* Throttle me less: I clean memory */
 #define PF_KTHREAD	0x00200000	/* I am a kernel thread */
 #define PF_RANDOMIZE	0x00400000	/* randomize virtual address space */
 #define PF_SWAPWRITE	0x00800000	/* Allowed to write to swap */
 #define PF_SPREAD_PAGE	0x01000000	/* Spread page cache over cpuset */
 #define PF_SPREAD_SLAB	0x02000000	/* Spread some slab caches over cpuset */
 #define PF_NO_SETAFFINITY 0x04000000	/* Userland is not allowed to meddle with cpus_allowed */
 #define PF_MCE_EARLY    0x08000000      /* Early kill for mce process policy */
 #define PF_MEMPOLICY	0x10000000	/* Non-default NUMA mempolicy */
 #define PF_MUTEX_TESTER	0x20000000	/* Thread belongs to the rt mutex tester */
 #define PF_FREEZER_SKIP	0x40000000	/* Freezer should not count it as freezable */
 #define PF_SUSPEND_TASK 0x80000000      /* this thread called freeze_processes and should not be frozen */
 /*
  * Only the _current_ task can read/write to tsk->flags, but other
  * tasks can access tsk->flags in readonly mode for example
  * with tsk_used_math (like during threaded core dumping).
  * There is however an exception to this rule during ptrace
  * or during fork: the ptracer task is allowed to write to the
  * child->flags of its traced child (same goes for fork, the parent
  * can write to the child->flags), because we're guaranteed the
  * child is not running and in turn not changing child->flags
  * at the same time the parent does it.
  */
 #define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)
 #define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)
 #define clear_used_math() clear_stopped_child_used_math(current)
 #define set_used_math() set_stopped_child_used_math(current)
 #define conditional_stopped_child_used_math(condition, child) \
 	do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)
 #define conditional_used_math(condition) \
 	conditional_stopped_child_used_math(condition, current)
 #define copy_to_stopped_child_used_math(child) \
 	do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)
 /* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */
 #define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
 #define used_math() tsk_used_math(current)
 /* __GFP_IO isn't allowed if PF_MEMALLOC_NOIO is set in current->flags */
 static inline gfp_t memalloc_noio_flags(gfp_t flags)
 {
 	if (unlikely(current->flags & PF_MEMALLOC_NOIO))
 		flags &= ~__GFP_IO;
 	return flags;
 }
 static inline unsigned int memalloc_noio_save(void)
 {
 	unsigned int flags = current->flags & PF_MEMALLOC_NOIO;
 	current->flags |= PF_MEMALLOC_NOIO;
 	return flags;
 }
 static inline void memalloc_noio_restore(unsigned int flags)
 {
 	current->flags = (current->flags & ~PF_MEMALLOC_NOIO) | flags;
 }
 /*
  * task->jobctl flags
  */
 #define JOBCTL_STOP_SIGMASK	0xffff	/* signr of the last group stop */
 #define JOBCTL_STOP_DEQUEUED_BIT 16	/* stop signal dequeued */
 #define JOBCTL_STOP_PENDING_BIT	17	/* task should stop for group stop */
 #define JOBCTL_STOP_CONSUME_BIT	18	/* consume group stop count */
 #define JOBCTL_TRAP_STOP_BIT	19	/* trap for STOP */
 #define JOBCTL_TRAP_NOTIFY_BIT	20	/* trap for NOTIFY */
 #define JOBCTL_TRAPPING_BIT	21	/* switching to TRACED */
 #define JOBCTL_LISTENING_BIT	22	/* ptracer is listening for events */
 #define JOBCTL_STOP_DEQUEUED	(1 << JOBCTL_STOP_DEQUEUED_BIT)
 #define JOBCTL_STOP_PENDING	(1 << JOBCTL_STOP_PENDING_BIT)
 #define JOBCTL_STOP_CONSUME	(1 << JOBCTL_STOP_CONSUME_BIT)
 #define JOBCTL_TRAP_STOP	(1 << JOBCTL_TRAP_STOP_BIT)
 #define JOBCTL_TRAP_NOTIFY	(1 << JOBCTL_TRAP_NOTIFY_BIT)
 #define JOBCTL_TRAPPING		(1 << JOBCTL_TRAPPING_BIT)
 #define JOBCTL_LISTENING	(1 << JOBCTL_LISTENING_BIT)
 #define JOBCTL_TRAP_MASK	(JOBCTL_TRAP_STOP | JOBCTL_TRAP_NOTIFY)
 #define JOBCTL_PENDING_MASK	(JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK)
 extern bool task_set_jobctl_pending(struct task_struct *task,
 				    unsigned int mask);
 extern void task_clear_jobctl_trapping(struct task_struct *task);
 extern void task_clear_jobctl_pending(struct task_struct *task,
 				      unsigned int mask);
 #ifdef CONFIG_PREEMPT_RCU
 #define RCU_READ_UNLOCK_BLOCKED (1 << 0) /* blocked while in RCU read-side. */
 #define RCU_READ_UNLOCK_NEED_QS (1 << 1) /* RCU core needs CPU response. */
 static inline void rcu_copy_process(struct task_struct *p)
 {
 	p->rcu_read_lock_nesting = 0;
 	p->rcu_read_unlock_special = 0;
 #ifdef CONFIG_TREE_PREEMPT_RCU
 	p->rcu_blocked_node = NULL;
 #endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
 #ifdef CONFIG_RCU_BOOST
 	p->rcu_boost_mutex = NULL;
 #endif /* #ifdef CONFIG_RCU_BOOST */
 	INIT_LIST_HEAD(&p->rcu_node_entry);
 }
 #else
 static inline void rcu_copy_process(struct task_struct *p)
 {
 }
 #endif
 static inline void tsk_restore_flags(struct task_struct *task,
 				unsigned long orig_flags, unsigned long flags)
 {
 	task->flags &= ~flags;
 	task->flags |= orig_flags & flags;
 }
 #ifdef CONFIG_SMP
 extern void do_set_cpus_allowed(struct task_struct *p,
 			       const struct cpumask *new_mask);
 extern int set_cpus_allowed_ptr(struct task_struct *p,
 				const struct cpumask *new_mask);
 #else
 static inline void do_set_cpus_allowed(struct task_struct *p,
 				      const struct cpumask *new_mask)
 {
 }
 static inline int set_cpus_allowed_ptr(struct task_struct *p,
 				       const struct cpumask *new_mask)
 {
 	if (!cpumask_test_cpu(0, new_mask))
 		return -EINVAL;
 	return 0;
 }
 #endif
 #ifdef CONFIG_NO_HZ_COMMON
 void calc_load_enter_idle(void);
 void calc_load_exit_idle(void);
 #else
 static inline void calc_load_enter_idle(void) { }
 static inline void calc_load_exit_idle(void) { }
 #endif /* CONFIG_NO_HZ_COMMON */
 #ifndef CONFIG_CPUMASK_OFFSTACK
 static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
 {
 	return set_cpus_allowed_ptr(p, &new_mask);
 }
 #endif
 /*
  * Do not use outside of architecture code which knows its limitations.
  *
  * sched_clock() has no promise of monotonicity or bounded drift between
  * CPUs, use (which you should not) requires disabling IRQs.
  *
  * Please use one of the three interfaces below.
  */
 extern unsigned long long notrace sched_clock(void);
 /*
  * See the comment in kernel/sched/clock.c
  */
 extern u64 cpu_clock(int cpu);
 extern u64 local_clock(void);
 extern u64 sched_clock_cpu(int cpu);
 extern void sched_clock_init(void);
 #ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
 static inline void sched_clock_tick(void)
 {
 }
 static inline void sched_clock_idle_sleep_event(void)
 {
 }
 static inline void sched_clock_idle_wakeup_event(u64 delta_ns)
 {
 }
 #else
 /*
  * Architectures can set this to 1 if they have specified
  * CONFIG_HAVE_UNSTABLE_SCHED_CLOCK in their arch Kconfig,
  * but then during bootup it turns out that sched_clock()
  * is reliable after all:
  */
 extern int sched_clock_stable;
 extern void sched_clock_tick(void);
 extern void sched_clock_idle_sleep_event(void);
 extern void sched_clock_idle_wakeup_event(u64 delta_ns);
 #endif
 #ifdef CONFIG_IRQ_TIME_ACCOUNTING
 /*
  * An i/f to runtime opt-in for irq time accounting based off of sched_clock.
  * The reason for this explicit opt-in is not to have perf penalty with
  * slow sched_clocks.
  */
 extern void enable_sched_clock_irqtime(void);
 extern void disable_sched_clock_irqtime(void);
 #else
 static inline void enable_sched_clock_irqtime(void) {}
 static inline void disable_sched_clock_irqtime(void) {}
 #endif
 extern unsigned long long
 task_sched_runtime(struct task_struct *task);
 /* sched_exec is called by processes performing an exec */
 #ifdef CONFIG_SMP
 extern void sched_exec(void);
 #else
 #define sched_exec()   {}
 #endif
 extern void sched_clock_idle_sleep_event(void);
 extern void sched_clock_idle_wakeup_event(u64 delta_ns);
 #ifdef CONFIG_HOTPLUG_CPU
 extern void idle_task_exit(void);
 #else
 static inline void idle_task_exit(void) {}
 #endif
 #if defined(CONFIG_NO_HZ_COMMON) && defined(CONFIG_SMP)
 extern void wake_up_nohz_cpu(int cpu);
 #else
 static inline void wake_up_nohz_cpu(int cpu) { }
 #endif
 #ifdef CONFIG_NO_HZ_FULL
 extern bool sched_can_stop_tick(void);
 extern u64 scheduler_tick_max_deferment(void);
 #else
 static inline bool sched_can_stop_tick(void) { return false; }
 #endif
 #ifdef CONFIG_SCHED_AUTOGROUP
 extern void sched_autogroup_create_attach(struct task_struct *p);
 extern void sched_autogroup_detach(struct task_struct *p);
 extern void sched_autogroup_fork(struct signal_struct *sig);
 extern void sched_autogroup_exit(struct signal_struct *sig);
 #ifdef CONFIG_PROC_FS
 extern void proc_sched_autogroup_show_task(struct task_struct *p, struct seq_file *m);
 extern int proc_sched_autogroup_set_nice(struct task_struct *p, int nice);
 #endif
 #else
 static inline void sched_autogroup_create_attach(struct task_struct *p) { }
 static inline void sched_autogroup_detach(struct task_struct *p) { }
 static inline void sched_autogroup_fork(struct signal_struct *sig) { }
 static inline void sched_autogroup_exit(struct signal_struct *sig) { }
 #endif
 extern bool yield_to(struct task_struct *p, bool preempt);
 extern void set_user_nice(struct task_struct *p, long nice);
 extern int task_prio(const struct task_struct *p);
 extern int task_nice(const struct task_struct *p);
 extern int can_nice(const struct task_struct *p, const int nice);
 extern int task_curr(const struct task_struct *p);
 extern int idle_cpu(int cpu);
 extern int sched_setscheduler(struct task_struct *, int,
 			      const struct sched_param *);
 extern int sched_setscheduler_nocheck(struct task_struct *, int,
 				      const struct sched_param *);
 extern struct task_struct *idle_task(int cpu);
 /**
  * is_idle_task - is the specified task an idle task?
  * @p: the task in question.
  *
  * Return: 1 if @p is an idle task. 0 otherwise.
  */
 static inline bool is_idle_task(const struct task_struct *p)
 {
 	return p->pid == 0;
 }
 extern struct task_struct *curr_task(int cpu);
 extern void set_curr_task(int cpu, struct task_struct *p);
 void yield(void);
 /*
  * The default (Linux) execution domain.
  */
 extern struct exec_domain	default_exec_domain;
 union thread_union {
 	struct thread_info thread_info;
 	unsigned long stack[THREAD_SIZE/sizeof(long)];
 };
 #ifndef __HAVE_ARCH_KSTACK_END
 static inline int kstack_end(void *addr)
 {
 	/* Reliable end of stack detection:
 	 * Some APM bios versions misalign the stack
 	 */
 	return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));
 }
 #endif
 extern union thread_union init_thread_union;
 extern struct task_struct init_task;
 extern struct   mm_struct init_mm;
 extern struct pid_namespace init_pid_ns;
 /*
  * find a task by one of its numerical ids
  *
  * find_task_by_pid_ns():
  *      finds a task by its pid in the specified namespace
  * find_task_by_vpid():
  *      finds a task by its virtual pid
  *
  * see also find_vpid() etc in include/linux/pid.h
  */
 extern struct task_struct *find_task_by_vpid(pid_t nr);
 extern struct task_struct *find_task_by_pid_ns(pid_t nr,
 		struct pid_namespace *ns);
 /* per-UID process charging. */
 extern struct user_struct * alloc_uid(kuid_t);
 static inline struct user_struct *get_uid(struct user_struct *u)
 {
 	atomic_inc(&u->__count);
 	return u;
 }
 extern void free_uid(struct user_struct *);
 #include <asm/current.h>
 extern void xtime_update(unsigned long ticks);
 extern int wake_up_state(struct task_struct *tsk, unsigned int state);
 extern int wake_up_process(struct task_struct *tsk);
 extern void wake_up_new_task(struct task_struct *tsk);
 #ifdef CONFIG_SMP
  extern void kick_process(struct task_struct *tsk);
 #else
  static inline void kick_process(struct task_struct *tsk) { }
 #endif
 extern void sched_fork(unsigned long clone_flags, struct task_struct *p);
 extern void sched_dead(struct task_struct *p);
 extern void proc_caches_init(void);
 extern void flush_signals(struct task_struct *);
 extern void __flush_signals(struct task_struct *);
 extern void ignore_signals(struct task_struct *);
 extern void flush_signal_handlers(struct task_struct *, int force_default);
 extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
 static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
 {
 	unsigned long flags;
 	int ret;
 	spin_lock_irqsave(&tsk->sighand->siglock, flags);
 	ret = dequeue_signal(tsk, mask, info);
 	spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
 	return ret;
 }
 extern void block_all_signals(int (*notifier)(void *priv), void *priv,
 			      sigset_t *mask);
 extern void unblock_all_signals(void);
 extern void release_task(struct task_struct * p);
 extern int send_sig_info(int, struct siginfo *, struct task_struct *);
 extern int force_sigsegv(int, struct task_struct *);
 extern int force_sig_info(int, struct siginfo *, struct task_struct *);
 extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
 extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
 extern int kill_pid_info_as_cred(int, struct siginfo *, struct pid *,
 				const struct cred *, u32);
 extern int kill_pgrp(struct pid *pid, int sig, int priv);
 extern int kill_pid(struct pid *pid, int sig, int priv);
 extern int kill_proc_info(int, struct siginfo *, pid_t);
 extern __must_check bool do_notify_parent(struct task_struct *, int);
 extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);
 extern void force_sig(int, struct task_struct *);
 extern int send_sig(int, struct task_struct *, int);
 extern int zap_other_threads(struct task_struct *p);
 extern struct sigqueue *sigqueue_alloc(void);
 extern void sigqueue_free(struct sigqueue *);
 extern int send_sigqueue(struct sigqueue *,  struct task_struct *, int group);
 extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
 static inline void restore_saved_sigmask(void)
 {
 	if (test_and_clear_restore_sigmask())
 		__set_current_blocked(&current->saved_sigmask);
 }
 static inline sigset_t *sigmask_to_save(void)
 {
 	sigset_t *res = &current->blocked;
 	if (unlikely(test_restore_sigmask()))
 		res = &current->saved_sigmask;
 	return res;
 }
 static inline int kill_cad_pid(int sig, int priv)
 {
 	return kill_pid(cad_pid, sig, priv);
 }
 /* These can be the second arg to send_sig_info/send_group_sig_info.  */
 #define SEND_SIG_NOINFO ((struct siginfo *) 0)
 #define SEND_SIG_PRIV	((struct siginfo *) 1)
 #define SEND_SIG_FORCED	((struct siginfo *) 2)
 /*
  * True if we are on the alternate signal stack.
  */
 static inline int on_sig_stack(unsigned long sp)
 {
 #ifdef CONFIG_STACK_GROWSUP
 	return sp >= current->sas_ss_sp &&
 		sp - current->sas_ss_sp < current->sas_ss_size;
 #else
 	return sp > current->sas_ss_sp &&
 		sp - current->sas_ss_sp <= current->sas_ss_size;
 #endif
 }
 static inline int sas_ss_flags(unsigned long sp)
 {
 	return (current->sas_ss_size == 0 ? SS_DISABLE
 		: on_sig_stack(sp) ? SS_ONSTACK : 0);
 }
 static inline unsigned long sigsp(unsigned long sp, struct ksignal *ksig)
 {
 	if (unlikely((ksig->ka.sa.sa_flags & SA_ONSTACK)) && ! sas_ss_flags(sp))
 #ifdef CONFIG_STACK_GROWSUP
 		return current->sas_ss_sp;
 #else
 		return current->sas_ss_sp + current->sas_ss_size;
 #endif
 	return sp;
 }
 /*
  * Routines for handling mm_structs
  */
 extern struct mm_struct * mm_alloc(void);
 /* mmdrop drops the mm and the page tables */
 extern void __mmdrop(struct mm_struct *);
 static inline void mmdrop(struct mm_struct * mm)
 {
 	if (unlikely(atomic_dec_and_test(&mm->mm_count)))
 		__mmdrop(mm);
 }
 /* mmput gets rid of the mappings and all user-space */
 extern void mmput(struct mm_struct *);
 /* Grab a reference to a task's mm, if it is not already going away */
 extern struct mm_struct *get_task_mm(struct task_struct *task);
 /*
  * Grab a reference to a task's mm, if it is not already going away
  * and ptrace_may_access with the mode parameter passed to it
  * succeeds.
  */
 extern struct mm_struct *mm_access(struct task_struct *task, unsigned int mode);
 /* Remove the current tasks stale references to the old mm_struct */
 extern void mm_release(struct task_struct *, struct mm_struct *);
 /* Allocate a new mm structure and copy contents from tsk->mm */
 extern struct mm_struct *dup_mm(struct task_struct *tsk);
 extern int copy_thread(unsigned long, unsigned long, unsigned long,
 			struct task_struct *);
 extern void flush_thread(void);
 extern void exit_thread(void);
 extern void exit_files(struct task_struct *);
 extern void __cleanup_sighand(struct sighand_struct *);
 extern void exit_itimers(struct signal_struct *);
 extern void flush_itimer_signals(void);
 extern void do_group_exit(int);
 extern int allow_signal(int);
 extern int disallow_signal(int);
 extern int do_execve(const char *,
 		     const char __user * const __user *,
 		     const char __user * const __user *);
 extern long do_fork(unsigned long, unsigned long, unsigned long, int __user *, int __user *);
 struct task_struct *fork_idle(int);
 extern pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
 extern void set_task_comm(struct task_struct *tsk, char *from);
 extern char *get_task_comm(char *to, struct task_struct *tsk);
 #ifdef CONFIG_SMP
 void scheduler_ipi(void);
 extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
 #else
 static inline void scheduler_ipi(void) { }
 static inline unsigned long wait_task_inactive(struct task_struct *p,
 					       long match_state)
 {
 	return 1;
 }
 #endif
 #define next_task(p) \
 	list_entry_rcu((p)->tasks.next, struct task_struct, tasks)
 #define for_each_process(p) \
 	for (p = &init_task ; (p = next_task(p)) != &init_task ; )
 extern bool current_is_single_threaded(void);
 /*
  * Careful: do_each_thread/while_each_thread is a double loop so
  *          'break' will not work as expected - use goto instead.
  */
 #define do_each_thread(g, t) \
 	for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do
 #define while_each_thread(g, t) \
 	while ((t = next_thread(t)) != g)
 static inline int get_nr_threads(struct task_struct *tsk)
 {
 	return tsk->signal->nr_threads;
 }
 static inline bool thread_group_leader(struct task_struct *p)
 {
 	return p->exit_signal >= 0;
 }
 /* Do to the insanities of de_thread it is possible for a process
  * to have the pid of the thread group leader without actually being
  * the thread group leader.  For iteration through the pids in proc
  * all we care about is that we have a task with the appropriate
  * pid, we don't actually care if we have the right task.
  */
 static inline bool has_group_leader_pid(struct task_struct *p)
 {
 	return task_pid(p) == p->signal->leader_pid;
 }
 static inline
 bool same_thread_group(struct task_struct *p1, struct task_struct *p2)
 {
 	return p1->signal == p2->signal;
 }
 static inline struct task_struct *next_thread(const struct task_struct *p)
 {
 	return list_entry_rcu(p->thread_group.next,
 			      struct task_struct, thread_group);
 }
 static inline int thread_group_empty(struct task_struct *p)
 {
 	return list_empty(&p->thread_group);
 }
 #define delay_group_leader(p) \
 		(thread_group_leader(p) && !thread_group_empty(p))
 /*
  * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
  * subscriptions and synchronises with wait4().  Also used in procfs.  Also
  * pins the final release of task.io_context.  Also protects ->cpuset and
  * ->cgroup.subsys[]. And ->vfork_done.
  *
  * Nests both inside and outside of read_lock(&tasklist_lock).
  * It must not be nested with write_lock_irq(&tasklist_lock),
  * neither inside nor outside.
  */
 static inline void task_lock(struct task_struct *p)
 {
 	spin_lock(&p->alloc_lock);
 }
 static inline void task_unlock(struct task_struct *p)
 {
 	spin_unlock(&p->alloc_lock);
 }
 extern struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
 							unsigned long *flags);
 static inline struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
 						       unsigned long *flags)
 {
 	struct sighand_struct *ret;
 	ret = __lock_task_sighand(tsk, flags);
 	(void)__cond_lock(&tsk->sighand->siglock, ret);
 	return ret;
 }
 static inline void unlock_task_sighand(struct task_struct *tsk,
 						unsigned long *flags)
 {
 	spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
 }
 #ifdef CONFIG_CGROUPS
 static inline void threadgroup_change_begin(struct task_struct *tsk)
 {
 	down_read(&tsk->signal->group_rwsem);
 }
 static inline void threadgroup_change_end(struct task_struct *tsk)
 {
 	up_read(&tsk->signal->group_rwsem);
 }
 /**
  * threadgroup_lock - lock threadgroup
  * @tsk: member task of the threadgroup to lock
  *
  * Lock the threadgroup @tsk belongs to.  No new task is allowed to enter
  * and member tasks aren't allowed to exit (as indicated by PF_EXITING) or
  * change ->group_leader/pid.  This is useful for cases where the threadgroup
  * needs to stay stable across blockable operations.
  *
  * fork and exit paths explicitly call threadgroup_change_{begin|end}() for
  * synchronization.  While held, no new task will be added to threadgroup
  * and no existing live task will have its PF_EXITING set.
  *
  * de_thread() does threadgroup_change_{begin|end}() when a non-leader
  * sub-thread becomes a new leader.
  */
 static inline void threadgroup_lock(struct task_struct *tsk)
 {
 	down_write(&tsk->signal->group_rwsem);
 }
 /**
  * threadgroup_unlock - unlock threadgroup
  * @tsk: member task of the threadgroup to unlock
  *
  * Reverse threadgroup_lock().
  */
 static inline void threadgroup_unlock(struct task_struct *tsk)
 {
 	up_write(&tsk->signal->group_rwsem);
 }
 #else
 static inline void threadgroup_change_begin(struct task_struct *tsk) {}
 static inline void threadgroup_change_end(struct task_struct *tsk) {}
 static inline void threadgroup_lock(struct task_struct *tsk) {}
 static inline void threadgroup_unlock(struct task_struct *tsk) {}
 #endif
 #ifndef __HAVE_THREAD_FUNCTIONS
 #define task_thread_info(task)	((struct thread_info *)(task)->stack)
 #define task_stack_page(task)	((task)->stack)
 static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
 {
 	*task_thread_info(p) = *task_thread_info(org);
 	task_thread_info(p)->task = p;
 }
 static inline unsigned long *end_of_stack(struct task_struct *p)
 {
 	return (unsigned long *)(task_thread_info(p) + 1);
 }
 #endif
 static inline int object_is_on_stack(void *obj)
 {
 	void *stack = task_stack_page(current);
 	return (obj >= stack) && (obj < (stack + THREAD_SIZE));
 }
 extern void thread_info_cache_init(void);
 #ifdef CONFIG_DEBUG_STACK_USAGE
 static inline unsigned long stack_not_used(struct task_struct *p)
 {
 	unsigned long *n = end_of_stack(p);
 	do { 	/* Skip over canary */
 		n++;
 	} while (!*n);
 	return (unsigned long)n - (unsigned long)end_of_stack(p);
 }
 #endif
 /* set thread flags in other task's structures
  * - see asm/thread_info.h for TIF_xxxx flags available
  */
 static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
 {
 	set_ti_thread_flag(task_thread_info(tsk), flag);
 }
 static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
 {
 	clear_ti_thread_flag(task_thread_info(tsk), flag);
 }
 static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
 {
 	return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);
 }
 static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
 {
 	return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
 }
 static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
 {
 	return test_ti_thread_flag(task_thread_info(tsk), flag);
 }
 static inline void set_tsk_need_resched(struct task_struct *tsk)
 {
 	set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
 }
 static inline void clear_tsk_need_resched(struct task_struct *tsk)
 {
 	clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
 }
 static inline int test_tsk_need_resched(struct task_struct *tsk)
 {
 	return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED));
 }
 static inline int restart_syscall(void)
 {
 	set_tsk_thread_flag(current, TIF_SIGPENDING);
 	return -ERESTARTNOINTR;
 }
 static inline int signal_pending(struct task_struct *p)
 {
 	return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
 }
 static inline int __fatal_signal_pending(struct task_struct *p)
 {
 	return unlikely(sigismember(&p->pending.signal, SIGKILL));
 }
 static inline int fatal_signal_pending(struct task_struct *p)
 {
 	return signal_pending(p) && __fatal_signal_pending(p);
 }
 static inline int signal_pending_state(long state, struct task_struct *p)
 {
 	if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))
 		return 0;
 	if (!signal_pending(p))
 		return 0;
 	return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);
 }
 /*
  * cond_resched() and cond_resched_lock(): latency reduction via
  * explicit rescheduling in places that are safe. The return
  * value indicates whether a reschedule was done in fact.
  * cond_resched_lock() will drop the spinlock before scheduling,
  * cond_resched_softirq() will enable bhs before scheduling.
  */
 extern int _cond_resched(void);
 #define cond_resched() ({			\
 	__might_sleep(__FILE__, __LINE__, 0);	\
 	_cond_resched();			\
 })
 extern int __cond_resched_lock(spinlock_t *lock);
 #ifdef CONFIG_PREEMPT_COUNT
 #define PREEMPT_LOCK_OFFSET	PREEMPT_OFFSET
 #else
 #define PREEMPT_LOCK_OFFSET	0
 #endif
 #define cond_resched_lock(lock) ({				\
 	__might_sleep(__FILE__, __LINE__, PREEMPT_LOCK_OFFSET);	\
 	__cond_resched_lock(lock);				\
 })
 extern int __cond_resched_softirq(void);
 #define cond_resched_softirq() ({					\
 	__might_sleep(__FILE__, __LINE__, SOFTIRQ_DISABLE_OFFSET);	\
 	__cond_resched_softirq();					\
 })
 static inline void cond_resched_rcu(void)
 {
 #if defined(CONFIG_DEBUG_ATOMIC_SLEEP) || !defined(CONFIG_PREEMPT_RCU)
 	rcu_read_unlock();
 	cond_resched();
 	rcu_read_lock();
 #endif
 }
 /*
  * Does a critical section need to be broken due to another
  * task waiting?: (technically does not depend on CONFIG_PREEMPT,
  * but a general need for low latency)
  */
 static inline int spin_needbreak(spinlock_t *lock)
 {
 #ifdef CONFIG_PREEMPT
 	return spin_is_contended(lock);
 #else
 	return 0;
 #endif
 }
 /*
  * Idle thread specific functions to determine the need_resched
  * polling state. We have two versions, one based on TS_POLLING in
  * thread_info.status and one based on TIF_POLLING_NRFLAG in
  * thread_info.flags
  */
 #ifdef TS_POLLING
 static inline int tsk_is_polling(struct task_struct *p)
 {
 	return task_thread_info(p)->status & TS_POLLING;
 }
 static inline void __current_set_polling(void)
 {
 	current_thread_info()->status |= TS_POLLING;
 }
 static inline bool __must_check current_set_polling_and_test(void)
 {
 	__current_set_polling();
 	/*
 	 * Polling state must be visible before we test NEED_RESCHED,
 	 * paired by resched_task()
 	 */
 	smp_mb();
 	return unlikely(tif_need_resched());
 }
 static inline void __current_clr_polling(void)
 {
 	current_thread_info()->status &= ~TS_POLLING;
 }
 static inline bool __must_check current_clr_polling_and_test(void)
 {
 	__current_clr_polling();
 	/*
 	 * Polling state must be visible before we test NEED_RESCHED,
 	 * paired by resched_task()
 	 */
 	smp_mb();
 	return unlikely(tif_need_resched());
 }
 #elif defined(TIF_POLLING_NRFLAG)
 static inline int tsk_is_polling(struct task_struct *p)
 {
 	return test_tsk_thread_flag(p, TIF_POLLING_NRFLAG);
 }
 static inline void __current_set_polling(void)
 {
 	set_thread_flag(TIF_POLLING_NRFLAG);
 }
 static inline bool __must_check current_set_polling_and_test(void)
 {
 	__current_set_polling();
 	/*
 	 * Polling state must be visible before we test NEED_RESCHED,
 	 * paired by resched_task()
 	 *
 	 * XXX: assumes set/clear bit are identical barrier wise.
 	 */
 	smp_mb__after_clear_bit();
 	return unlikely(tif_need_resched());
 }
 static inline void __current_clr_polling(void)
 {
 	clear_thread_flag(TIF_POLLING_NRFLAG);
 }
 static inline bool __must_check current_clr_polling_and_test(void)
 {
 	__current_clr_polling();
 	/*
 	 * Polling state must be visible before we test NEED_RESCHED,
 	 * paired by resched_task()
 	 */
 	smp_mb__after_clear_bit();
 	return unlikely(tif_need_resched());
 }
 #else
 static inline int tsk_is_polling(struct task_struct *p) { return 0; }
 static inline void __current_set_polling(void) { }
 static inline void __current_clr_polling(void) { }
 static inline bool __must_check current_set_polling_and_test(void)
 {
 	return unlikely(tif_need_resched());
 }
 static inline bool __must_check current_clr_polling_and_test(void)
 {
 	return unlikely(tif_need_resched());
 }
 #endif
 static __always_inline bool need_resched(void)
 {
 	return unlikely(tif_need_resched());
 }
 /*
  * Thread group CPU time accounting.
  */
 void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);
 void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times);
 static inline void thread_group_cputime_init(struct signal_struct *sig)
 {
 	raw_spin_lock_init(&sig->cputimer.lock);
 }
 /*
  * Reevaluate whether the task has signals pending delivery.
  * Wake the task if so.
  * This is required every time the blocked sigset_t changes.
  * callers must hold sighand->siglock.
  */
 extern void recalc_sigpending_and_wake(struct task_struct *t);
 extern void recalc_sigpending(void);
 extern void signal_wake_up_state(struct task_struct *t, unsigned int state);
 static inline void signal_wake_up(struct task_struct *t, bool resume)
 {
 	signal_wake_up_state(t, resume ? TASK_WAKEKILL : 0);
 }
 static inline void ptrace_signal_wake_up(struct task_struct *t, bool resume)
 {
 	signal_wake_up_state(t, resume ? __TASK_TRACED : 0);
 }
 /*
  * Wrappers for p->thread_info->cpu access. No-op on UP.
  */
 #ifdef CONFIG_SMP
 static inline unsigned int task_cpu(const struct task_struct *p)
 {
 	return task_thread_info(p)->cpu;
 }
 static inline int task_node(const struct task_struct *p)
 {
 	return cpu_to_node(task_cpu(p));
 }
 extern void set_task_cpu(struct task_struct *p, unsigned int cpu);
 #else
 static inline unsigned int task_cpu(const struct task_struct *p)
 {
 	return 0;
 }
 static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
 {
 }
 #endif /* CONFIG_SMP */
 extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
 extern long sched_getaffinity(pid_t pid, struct cpumask *mask);
 #ifdef CONFIG_CGROUP_SCHED
 extern struct task_group root_task_group;
 #endif /* CONFIG_CGROUP_SCHED */
 extern int task_can_switch_user(struct user_struct *up,
 					struct task_struct *tsk);
 #ifdef CONFIG_TASK_XACCT
 static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
 {
 	tsk->ioac.rchar += amt;
 }
 static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
 {
 	tsk->ioac.wchar += amt;
 }
 static inline void inc_syscr(struct task_struct *tsk)
 {
 	tsk->ioac.syscr++;
 }
 static inline void inc_syscw(struct task_struct *tsk)
 {
 	tsk->ioac.syscw++;
 }
 #else
 static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
 {
 }
 static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
 {
 }
 static inline void inc_syscr(struct task_struct *tsk)
 {
 }
 static inline void inc_syscw(struct task_struct *tsk)
 {
 }
 #endif
 #ifndef TASK_SIZE_OF
 #define TASK_SIZE_OF(tsk)	TASK_SIZE
 #endif
 #ifdef CONFIG_MM_OWNER
 extern void mm_update_next_owner(struct mm_struct *mm);
 extern void mm_init_owner(struct mm_struct *mm, struct task_struct *p);
 #else
 static inline void mm_update_next_owner(struct mm_struct *mm)
 {
 }
 static inline void mm_init_owner(struct mm_struct *mm, struct task_struct *p)
 {
 }
 #endif /* CONFIG_MM_OWNER */
 static inline unsigned long task_rlimit(const struct task_struct *tsk,
 		unsigned int limit)
 {
 	return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_cur);
 }
 static inline unsigned long task_rlimit_max(const struct task_struct *tsk,
 		unsigned int limit)
 {
 	return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_max);
 }
 static inline unsigned long rlimit(unsigned int limit)
 {
 	return task_rlimit(current, limit);
 }
 static inline unsigned long rlimit_max(unsigned int limit)
 {
 	return task_rlimit_max(current, limit);
 }
 #endif