arch/alpha/kernel/traps.c

127

if (((long) stack & (THREAD_SIZE-1)) == 0)

arch/arc/include/asm/entry-compact.h

377

bic \reg, sp, (THREAD_SIZE - 1)

arch/arc/include/asm/entry.h

70

add2 \out, \out, (THREAD_SIZE)/4

arch/arc/include/asm/processor.h

41

((struct pt_regs *)(THREAD_SIZE + (void *)task_stack_page(p)) - 1)

arch/arc/include/asm/ptrace.h

137

unsigned long pg_start = (sp & ~(THREAD_SIZE - 1)); \

arch/arc/include/asm/ptrace.h

138

(struct pt_regs *)(pg_start + THREAD_SIZE) - 1; \

arch/arc/include/asm/thread_info.h

62

return (struct thread_info *)(sp & ~(THREAD_SIZE - 1));

arch/arc/include/asm/unwind.h

70

#define STACK_LIMIT(ptr) (((ptr) - 1) & ~(THREAD_SIZE - 1))

arch/arc/kernel/kprobes.c

18

(unsigned long)current_thread_info() + THREAD_SIZE - (addr))

arch/arc/kernel/ptrace.c

388

return (addr & ~(THREAD_SIZE - 1)) ==

arch/arc/kernel/ptrace.c

389

(kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1));

arch/arm/include/asm/ptrace.h

165

((current_stack_pointer | (THREAD_SIZE - 1)) - 7) - 1; \

arch/arm/include/asm/stacktrace.h

34

return delta < THREAD_SIZE;

arch/arm/include/asm/thread_info.h

26

#define THREAD_START_SP (THREAD_SIZE - 8)

arch/arm/include/asm/thread_info.h

29

#define THREAD_ALIGN (2 * THREAD_SIZE)

arch/arm/include/asm/thread_info.h

31

#define THREAD_ALIGN THREAD_SIZE

arch/arm/kernel/irq.c

64

stack = __vmalloc_node(THREAD_SIZE, THREAD_ALIGN,

arch/arm/kernel/irq.c

70

per_cpu(irq_stack_ptr, cpu) = &stack[THREAD_SIZE];

arch/arm/kernel/process.c

293

frame.sp >= stack_page + THREAD_SIZE ||

arch/arm/kernel/ptrace.c

132

return ((addr & ~(THREAD_SIZE - 1)) ==

arch/arm/kernel/ptrace.c

133

(kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1)));

arch/arm/kernel/smp.c

377

: "r" (task_stack_page(current) + THREAD_SIZE - 8),

arch/arm/kernel/stacktrace.c

64

high = ALIGN(low, THREAD_SIZE);

arch/arm/kernel/stacktrace.c

98

if ((unsigned long)&regs[1] > ALIGN(frame->sp, THREAD_SIZE))

arch/arm/kernel/traps.c

294

ALIGN(regs->ARM_sp - THREAD_SIZE, THREAD_ALIGN)

arch/arm/kernel/traps.c

295

+ THREAD_SIZE);

arch/arm/kernel/traps.c

73

end > ALIGN(frame, THREAD_SIZE)) {

arch/arm/kernel/traps.c

933

tsk_stk, tsk_stk + THREAD_SIZE);

arch/arm/kernel/traps.c

936

irq_stk - THREAD_SIZE, irq_stk);

arch/arm/kernel/traps.c

94

if (in_entry_text(from) && end <= ALIGN(frame, THREAD_SIZE))

arch/arm/kernel/unwind.c

414

ctrl.sp_high = ALIGN(sp_low - THREAD_SIZE, THREAD_ALIGN)

arch/arm/kernel/unwind.c

415

+ THREAD_SIZE;

arch/arm/kernel/unwind.c

492

ctrl.sp_high = ALIGN(frame->fp, THREAD_SIZE);

arch/arm64/include/asm/memory.h

138

#define THREAD_ALIGN (2 * THREAD_SIZE)

arch/arm64/include/asm/memory.h

140

#define IRQ_STACK_SIZE THREAD_SIZE

arch/arm64/include/asm/processor.h

384

((struct pt_regs *)(THREAD_SIZE + task_stack_page(p)) - 1)

arch/arm64/include/asm/stacktrace.h

111

unsigned long low = high - THREAD_SIZE;

arch/arm64/include/asm/stacktrace.h

45

unsigned long high = low + THREAD_SIZE;

arch/arm64/kernel/efi.c

243

static_assert(THREAD_SIZE >= SZ_8K);

arch/arm64/kernel/efi.c

252

p = arch_alloc_vmap_stack(THREAD_SIZE, NUMA_NO_NODE);

arch/arm64/kernel/efi.c

260

efi_rt_stack_top = p + THREAD_SIZE;

arch/arm64/kernel/ptrace.c

124

return ((addr & ~(THREAD_SIZE - 1)) ==

arch/arm64/kernel/ptrace.c

125

(kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1))) ||

arch/arm64/kernel/traps.c

916

tsk_stk, tsk_stk + THREAD_SIZE);

arch/csky/include/asm/page.h

13

#define THREAD_MASK (~(THREAD_SIZE - 1))

arch/csky/include/asm/processor.h

81

((struct pt_regs *)(THREAD_SIZE + task_stack_page(p)) - 1)

arch/csky/include/asm/ptrace.h

19

({ (struct pt_regs *)((char *)current_thread_info() + THREAD_SIZE) - 1; })

arch/csky/include/asm/thread_info.h

51

return (struct thread_info *)(sp & ~(THREAD_SIZE - 1));

arch/csky/kernel/perf_callchain.c

16

unsigned long high = low + THREAD_SIZE;

arch/csky/kernel/ptrace.c

277

return (addr & ~(THREAD_SIZE - 1)) ==

arch/csky/kernel/ptrace.c

278

(kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1));

arch/csky/kernel/smp.c

208

(unsigned int) task_stack_page(tidle) + THREAD_SIZE - 8;

arch/csky/kernel/stacktrace.c

46

high = ALIGN(sp, THREAD_SIZE);

arch/hexagon/include/asm/processor.h

58

((struct pt_regs *)(task_stack_page(task) + THREAD_SIZE) - 1)

arch/hexagon/include/asm/ptrace.h

19

((unsigned long)current_thread_info() + THREAD_SIZE) - 1)

arch/hexagon/kernel/asm-offsets.c

68

DEFINE(_THREAD_SIZE, THREAD_SIZE);

arch/hexagon/kernel/process.c

137

fp >= (THREAD_SIZE - 8 + stack_page))

arch/hexagon/kernel/process.c

63

childregs = (struct pt_regs *) (((unsigned long) ti + THREAD_SIZE) -

arch/hexagon/kernel/smp.c

134

thread_ptr = thread_ptr & ~(THREAD_SIZE-1);

arch/hexagon/kernel/smp.c

182

stack_start = ((void *) thread) + THREAD_SIZE;

arch/hexagon/kernel/stacktrace.c

30

high = low + THREAD_SIZE;

arch/hexagon/kernel/traps.c

116

high = low + THREAD_SIZE - 8;

arch/loongarch/include/asm/irq.h

11

#define IRQ_STACK_SIZE THREAD_SIZE

arch/loongarch/include/asm/processor.h

202

THREAD_SIZE - sizeof(struct pt_regs))

arch/loongarch/include/asm/ptrace.h

176

(struct pt_regs *)((sp | (THREAD_SIZE - 1)) + 1) - 1; \

arch/loongarch/include/asm/ptrace.h

87

return ((addr & ~(THREAD_SIZE - 1)) ==

arch/loongarch/include/asm/ptrace.h

88

(kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1)));

arch/loongarch/include/asm/stacktrace.h

36

return !(((unsigned long)(current->stack) ^ current_stack_pointer) & ~(THREAD_SIZE - 1));

arch/loongarch/include/asm/thread_info.h

60

#define THREAD_MASK (THREAD_SIZE - 1UL)

arch/loongarch/include/asm/thread_info.h

61

#define THREAD_SIZE_ORDER ilog2(THREAD_SIZE / PAGE_SIZE)

arch/loongarch/kernel/asm-offsets.c

93

DEFINE(_THREAD_SIZE, THREAD_SIZE);

arch/loongarch/kernel/process.c

178

childksp = (unsigned long)task_stack_page(p) + THREAD_SIZE;

arch/loongarch/kernel/process.c

283

unsigned long end = begin + THREAD_SIZE;

arch/m68k/include/asm/entry.h

231

andl #-THREAD_SIZE,\reg

arch/m68k/include/asm/entry.h

255

"andw #-"STR(THREAD_SIZE)","#tmp"\n\t" \

arch/m68k/include/asm/ptrace.h

18

(struct pt_regs *)((char *)current_thread_info() + THREAD_SIZE) - 1

arch/m68k/include/asm/thread_info.h

51

: "di" (~(THREAD_SIZE-1))

arch/m68k/kernel/process.c

152

frame = (struct fork_frame *) (task_stack_page(p) + THREAD_SIZE) - 1;

arch/m68k/kernel/traps.c

817

addr = (unsigned long)stack + THREAD_SIZE - 1;

arch/m68k/kernel/traps.c

818

endstack = (unsigned long *)(addr & -THREAD_SIZE);

arch/m68k/kernel/traps.c

944

endstack = (unsigned long *)(((unsigned long)stack + THREAD_SIZE - 1) & -THREAD_SIZE);

arch/microblaze/include/asm/processor.h

24

(((struct pt_regs *)(THREAD_SIZE + task_stack_page(tsk))) - 1)

arch/microblaze/include/asm/thread_info.h

85

return (struct thread_info *)(sp & ~(THREAD_SIZE-1));

arch/microblaze/kernel/traps.c

50

words_to_show = (THREAD_SIZE - (fp & (THREAD_SIZE - 1))) >> 2;

arch/mips/include/asm/irq.h

19

#define IRQ_STACK_SIZE THREAD_SIZE

arch/mips/include/asm/processor.h

364

THREAD_SIZE - 32 - sizeof(struct pt_regs))

arch/mips/include/asm/ptrace.h

100

return ((addr & ~(THREAD_SIZE - 1)) ==

arch/mips/include/asm/ptrace.h

101

(kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1)));

arch/mips/include/asm/ptrace.h

177

(struct pt_regs *)((sp | (THREAD_SIZE - 1)) + 1 - 32) - 1; \

arch/mips/include/asm/thread_info.h

101

#define STACK_WARN (THREAD_SIZE / 8)

arch/mips/include/asm/thread_info.h

99

#define THREAD_MASK (THREAD_SIZE - 1UL)

arch/mips/kernel/asm-offsets.c

113

DEFINE(_THREAD_SIZE, THREAD_SIZE);

arch/mips/kernel/perf_event.c

54

sp <= stack_page + THREAD_SIZE - 32)

arch/mips/kernel/process.c

117

childksp = (unsigned long)task_stack_page(p) + THREAD_SIZE - 32;

arch/mips/kernel/process.c

567

high = stack_page + THREAD_SIZE - 32;

arch/mips/kernel/stacktrace.c

49

sp <= stack_page + THREAD_SIZE - 32)

arch/nios2/include/asm/entry.h

30

addi r24, r24, THREAD_SIZE-PT_REGS_SIZE

arch/nios2/include/asm/processor.h

67

((struct pt_regs *)(THREAD_SIZE + task_stack_page(p)) - 1)

arch/nios2/include/asm/ptrace.h

74

((struct pt_regs *)((unsigned long)current_thread_info() + THREAD_SIZE)\

arch/nios2/include/asm/thread_info.h

62

return (struct thread_info *)(sp & ~(THREAD_SIZE - 1));

arch/nios2/kernel/process.c

171

(int)(((unsigned long) current) + THREAD_SIZE));

arch/openrisc/include/asm/processor.h

58

#define user_regs(thread_info) (((struct pt_regs *)((unsigned long)(thread_info) + THREAD_SIZE - STACK_FRAME_OVERHEAD)) - 1)

arch/openrisc/kernel/process.c

173

unsigned long sp = (unsigned long)task_stack_page(p) + THREAD_SIZE;

arch/openrisc/kernel/ptrace.c

236

return (addr & ~(THREAD_SIZE - 1)) ==

arch/openrisc/kernel/ptrace.c

237

(kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1));

arch/parisc/kernel/irq.c

399

if (likely(stack_usage <= THREAD_SIZE))

arch/parisc/kernel/irq.c

427

if (likely(stack_usage < (THREAD_SIZE - STACK_MARGIN)))

arch/parisc/kernel/irq.c

432

current->comm, sp, stack_start, stack_start + THREAD_SIZE);

arch/parisc/kernel/ptrace.c

770

return ((addr & ~(THREAD_SIZE - 1)) ==

arch/parisc/kernel/ptrace.c

771

(kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1)));

arch/parisc/kernel/unwind.c

310

>= THREAD_SIZE) {

arch/powerpc/include/asm/ptrace.h

234

((struct pt_regs *)((unsigned long)task_stack_page(current) + THREAD_SIZE) - 1)

arch/powerpc/include/asm/ptrace.h

376

return ((addr & ~(THREAD_SIZE - 1)) ==

arch/powerpc/include/asm/ptrace.h

377

(kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1)));

arch/powerpc/kernel/head_32.h

150

addi r1, r1, THREAD_SIZE - INT_FRAME_SIZE

arch/powerpc/kernel/head_32.h

205

addi r1, r1, THREAD_SIZE - INT_FRAME_SIZE

arch/powerpc/kernel/head_32.h

43

addi r1, r1, THREAD_SIZE - INT_FRAME_SIZE

arch/powerpc/kernel/head_booke.h

141

ALLOC_STACK_FRAME(r1, THREAD_SIZE - INT_FRAME_SIZE)

arch/powerpc/kernel/head_booke.h

176

addi r8,r8,THREAD_SIZE - INT_FRAME_SIZE;

arch/powerpc/kernel/head_booke.h

181

addi r8,r8,THREAD_SIZE - INT_FRAME_SIZE;

arch/powerpc/kernel/head_booke.h

208

addi r11,r11,THREAD_SIZE - INT_FRAME_SIZE; /* allocate stack frame */\

arch/powerpc/kernel/head_booke.h

64

ALLOC_STACK_FRAME(r11, THREAD_SIZE); \

arch/powerpc/kernel/irq.c

193

sp &= THREAD_SIZE - 1;

arch/powerpc/kernel/irq.c

196

if (unlikely(sp < THREAD_SIZE / 4)) {

arch/powerpc/kernel/irq.c

217

[sp] "b" (sp), [offset] "i" (THREAD_SIZE - STACK_FRAME_MIN_SIZE),

arch/powerpc/kernel/irq.c

275

[sp] "b" (sp), [offset] "i" (THREAD_SIZE - STACK_FRAME_MIN_SIZE),

arch/powerpc/kernel/irq.c

290

cursp = (void *)(current_stack_pointer & ~(THREAD_SIZE - 1));

arch/powerpc/kernel/irq.c

309

return __vmalloc_node(THREAD_SIZE, THREAD_ALIGN, THREADINFO_GFP,

arch/powerpc/kernel/process.c

1609

struct pt_regs *regs = task_stack_page(current) + THREAD_SIZE;

arch/powerpc/kernel/process.c

1741

unsigned long sp = (unsigned long)task_stack_page(p) + THREAD_SIZE;

arch/powerpc/kernel/process.c

2138

if (sp >= stack_page && sp <= stack_page + THREAD_SIZE - nbytes)

arch/powerpc/kernel/process.c

2142

if (sp >= stack_page && sp <= stack_page + THREAD_SIZE - nbytes)

arch/powerpc/kernel/process.c

2166

stack_page = (unsigned long)paca_ptrs[cpu]->emergency_sp - THREAD_SIZE;

arch/powerpc/kernel/process.c

2167

if (sp >= stack_page && sp <= stack_page + THREAD_SIZE - nbytes)

arch/powerpc/kernel/process.c

2171

stack_page = (unsigned long)paca_ptrs[cpu]->nmi_emergency_sp - THREAD_SIZE;

arch/powerpc/kernel/process.c

2172

if (sp >= stack_page && sp <= stack_page + THREAD_SIZE - nbytes)

arch/powerpc/kernel/process.c

2175

stack_page = (unsigned long)paca_ptrs[cpu]->mc_emergency_sp - THREAD_SIZE;

arch/powerpc/kernel/process.c

2176

if (sp >= stack_page && sp <= stack_page + THREAD_SIZE - nbytes)

arch/powerpc/kernel/process.c

2192

stack_page = (unsigned long)emergency_ctx[cpu] - THREAD_SIZE;

arch/powerpc/kernel/process.c

2193

if (sp >= stack_page && sp <= stack_page + THREAD_SIZE - nbytes)

arch/powerpc/kernel/process.c

2209

if (sp < THREAD_SIZE)

arch/powerpc/kernel/process.c

2212

if (sp >= stack_page && sp <= stack_page + THREAD_SIZE - nbytes)

arch/powerpc/kernel/process.c

2272

if ((unsigned long)(regs + 1) != stack_page + THREAD_SIZE)

arch/powerpc/kernel/setup_32.c

143

return memblock_alloc_or_panic(THREAD_SIZE, THREAD_ALIGN);

arch/powerpc/kernel/setup_64.c

189

(THREAD_SIZE/2);

arch/powerpc/kernel/setup_64.c

715

ptr = memblock_alloc_try_nid(THREAD_SIZE, THREAD_ALIGN,

arch/powerpc/kernel/setup_64.c

750

paca_ptrs[i]->crit_kstack = sp + THREAD_SIZE;

arch/powerpc/kernel/setup_64.c

754

paca_ptrs[i]->dbg_kstack = sp + THREAD_SIZE;

arch/powerpc/kernel/setup_64.c

758

paca_ptrs[i]->mc_kstack = sp + THREAD_SIZE;

arch/powerpc/kernel/setup_64.c

802

paca_ptrs[i]->emergency_sp = alloc_stack(limit, i) + THREAD_SIZE;

arch/powerpc/kernel/setup_64.c

806

paca_ptrs[i]->nmi_emergency_sp = alloc_stack(limit, i) + THREAD_SIZE;

arch/powerpc/kernel/setup_64.c

809

paca_ptrs[i]->mc_emergency_sp = alloc_stack(mce_limit, i) + THREAD_SIZE;

arch/powerpc/kernel/smp.c

1285

THREAD_SIZE - STACK_FRAME_MIN_SIZE;

arch/powerpc/kernel/stacktrace.c

76

stack_end = stack_page + THREAD_SIZE;

arch/powerpc/perf/callchain.c

38

if ((sp & ~(THREAD_SIZE - 1)) != (prev_sp & ~(THREAD_SIZE - 1)))

arch/powerpc/xmon/xmon.c

2680

printf(" %-*s = 0x%016llx\n", 25, "kstack_base", p->kstack & ~(THREAD_SIZE - 1));

arch/riscv/include/asm/processor.h

142

((struct pt_regs *)(task_stack_page(tsk) + THREAD_SIZE \

arch/riscv/include/asm/stacktrace.h

21

return !(((unsigned long)(current->stack) ^ current_stack_pointer) & ~(THREAD_SIZE - 1));

arch/riscv/include/asm/thread_info.h

30

#define THREAD_ALIGN (2 * THREAD_SIZE)

arch/riscv/include/asm/thread_info.h

32

#define THREAD_ALIGN THREAD_SIZE

arch/riscv/include/asm/thread_info.h

38

#define IRQ_STACK_SIZE THREAD_SIZE

arch/riscv/kernel/ptrace.c

516

return (addr & ~(THREAD_SIZE - 1)) ==

arch/riscv/kernel/ptrace.c

517

(kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1));

arch/riscv/kernel/stacktrace.c

43

high = ALIGN(sp, THREAD_SIZE);

arch/riscv/kernel/traps.c

490

tsk_stk, tsk_stk + THREAD_SIZE);

arch/s390/boot/startup.c

336

BUILD_BUG_ON(!IS_ALIGNED(TEXT_OFFSET, THREAD_SIZE));

arch/s390/boot/startup.c

337

BUILD_BUG_ON(!IS_ALIGNED(__NO_KASLR_START_KERNEL, THREAD_SIZE));

arch/s390/boot/startup.c

377

slots = DIV_ROUND_UP(kaslr_len - kernel_size, THREAD_SIZE);

arch/s390/boot/startup.c

380

kernel_end = vmax - pos * THREAD_SIZE;

arch/s390/boot/startup.c

381

kernel_start = round_down(kernel_end - kernel_size, THREAD_SIZE);

arch/s390/boot/startup.c

386

kernel_start = round_down(vmax - kernel_size, THREAD_SIZE);

arch/s390/include/asm/kprobes.h

48

(((unsigned long)task_stack_page(current)) + THREAD_SIZE - (ADDR))) \

arch/s390/include/asm/kprobes.h

50

: (((unsigned long)task_stack_page(current)) + THREAD_SIZE - (ADDR)))

arch/s390/include/asm/processor.h

252

(task_stack_page(tsk) + THREAD_SIZE) - 1)

arch/s390/include/asm/processor.h

274

return !((ksp ^ current_stack_pointer) & ~(THREAD_SIZE - 1));

arch/s390/include/asm/ptrace.h

269

return (addr & ~(THREAD_SIZE - 1)) == (ksp & ~(THREAD_SIZE - 1));

arch/s390/include/asm/thread_info.h

25

#define STACK_INIT_OFFSET (THREAD_SIZE - STACK_FRAME_OVERHEAD - __PT_SIZE)

arch/s390/kernel/dumpstack.c

47

if (sp < stack || sp >= stack + THREAD_SIZE)

arch/s390/kernel/dumpstack.c

51

info->end = stack + THREAD_SIZE;

arch/s390/kernel/irq.c

117

return ((get_lowcore()->async_stack ^ frame) & ~(THREAD_SIZE - 1)) == 0;

arch/s390/kernel/setup.c

367

stack = __vmalloc_node(THREAD_SIZE, THREAD_SIZE, THREADINFO_GFP,

arch/s390/kernel/setup.c

382

stack = (unsigned long)memblock_alloc_or_panic(THREAD_SIZE, THREAD_SIZE);

arch/sh/include/asm/kprobes.h

19

(((unsigned long)current_thread_info()) + THREAD_SIZE - (ADDR))) \

arch/sh/include/asm/kprobes.h

21

: (((unsigned long)current_thread_info()) + THREAD_SIZE - (ADDR)))

arch/sh/include/asm/ptrace.h

127

((struct pt_regs *) (task_stack_page(task) + THREAD_SIZE) - 1)

arch/sh/include/asm/ptrace.h

96

return ((addr & ~(THREAD_SIZE - 1)) ==

arch/sh/include/asm/ptrace.h

97

(kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1)));

arch/sh/include/asm/thread_info.h

47

#define STACK_WARN (THREAD_SIZE >> 3)

arch/sh/include/asm/thread_info.h

78

: "1" (~(THREAD_SIZE - 1))

arch/sh/kernel/dumpstack.c

153

dump_mem("Stack: ", loglvl, stack, THREAD_SIZE +

arch/sh/kernel/dumpstack.c

96

((unsigned long)sp & (~(THREAD_SIZE - 1)));

arch/sh/kernel/irq.c

127

irqctx = (union irq_ctx *)&hardirq_stack[cpu * THREAD_SIZE];

arch/sh/kernel/irq.c

135

irqctx = (union irq_ctx *)&softirq_stack[cpu * THREAD_SIZE];

arch/sh/kernel/irq.c

63

u32 stack[THREAD_SIZE/sizeof(u32)];

arch/sh/kernel/irq.c

69

static char softirq_stack[NR_CPUS * THREAD_SIZE] __page_aligned_bss;

arch/sh/kernel/irq.c

70

static char hardirq_stack[NR_CPUS * THREAD_SIZE] __page_aligned_bss;

arch/sh/kernel/traps.c

44

THREAD_SIZE + (unsigned long)task_stack_page(current));

arch/sparc/include/asm/processor_32.h

52

.kregs = (struct pt_regs *)(init_stack+THREAD_SIZE)-1 \

arch/sparc/include/asm/ptrace.h

141

((struct pt_regs *)((unsigned long)current_thread_info() + THREAD_SIZE) - 1)

arch/sparc/include/asm/ptrace.h

38

((struct pt_regs *)((unsigned long)current_thread_info() + THREAD_SIZE) - 1)

arch/sparc/include/asm/thread_info_64.h

119

.kregs = (struct pt_regs *)(init_stack+THREAD_SIZE)-1 \

arch/sparc/kernel/irq_64.c

858

sp += THREAD_SIZE - 192 - STACK_BIAS;

arch/sparc/kernel/kstack.h

20

sp <= (base + THREAD_SIZE - sizeof(struct sparc_stackf)))

arch/sparc/kernel/kstack.h

26

sp <= (base + THREAD_SIZE - sizeof(struct sparc_stackf)))

arch/sparc/kernel/kstack.h

30

sp <= (base + THREAD_SIZE - sizeof(struct sparc_stackf)))

arch/sparc/kernel/kstack.h

43

addr <= (base + THREAD_SIZE - sizeof(*regs)))

arch/sparc/kernel/kstack.h

49

addr <= (base + THREAD_SIZE - sizeof(*regs)))

arch/sparc/kernel/kstack.h

53

addr <= (base + THREAD_SIZE - sizeof(*regs)))

arch/sparc/kernel/kstack.h

71

orig_sp > (sp + THREAD_SIZE)) {

arch/sparc/kernel/kstack.h

72

sp += THREAD_SIZE - 192 - STACK_BIAS;

arch/sparc/kernel/process_32.c

288

new_stack = task_stack_page(p) + THREAD_SIZE;

arch/sparc/kernel/process_64.c

584

(THREAD_SIZE - child_stack_sz));

arch/sparc/kernel/ptrace_64.c

1154

return ((addr & ~(THREAD_SIZE - 1)) ==

arch/sparc/kernel/ptrace_64.c

1155

(ksp & ~(THREAD_SIZE - 1)));

arch/sparc/kernel/setup_64.c

609

softirq_stack[i] = memblock_alloc_node(THREAD_SIZE,

arch/sparc/kernel/setup_64.c

610

THREAD_SIZE, node);

arch/sparc/kernel/setup_64.c

613

__func__, THREAD_SIZE, THREAD_SIZE, node);

arch/sparc/kernel/setup_64.c

614

hardirq_stack[i] = memblock_alloc_node(THREAD_SIZE,

arch/sparc/kernel/setup_64.c

615

THREAD_SIZE, node);

arch/sparc/kernel/setup_64.c

618

__func__, THREAD_SIZE, THREAD_SIZE, node);

arch/um/include/linux/smp-internal.h

15

extern char cpu_irqstacks[NR_CPUS][THREAD_SIZE] __aligned(THREAD_SIZE);

arch/um/kernel/asm-offsets.c

28

DEFINE(UM_THREAD_SIZE, THREAD_SIZE);

arch/um/kernel/process.c

297

while (sp < stack_page + THREAD_SIZE) {

arch/um/kernel/skas/process.c

30

char cpu_irqstacks[NR_CPUS][THREAD_SIZE] __aligned(THREAD_SIZE);

arch/um/kernel/skas/process.c

35

set_sigstack(cpu_irqstacks[0], THREAD_SIZE);

arch/um/kernel/smp.c

144

set_sigstack(&cpu_irqstacks[cpu], THREAD_SIZE);

arch/um/kernel/stacktrace.c

29

while (((long) sp & (THREAD_SIZE-1)) != 0) {

arch/x86/include/asm/fred.h

101

unsigned long rsp0 = (unsigned long) task_stack_page(current) + THREAD_SIZE;

arch/x86/include/asm/page_32_types.h

25

#define IRQ_STACK_SIZE THREAD_SIZE

arch/x86/include/asm/processor.h

562

current_stack_pointer) < THREAD_SIZE;

arch/x86/include/asm/processor.h

651

__ptr += THREAD_SIZE - TOP_OF_KERNEL_STACK_PADDING; \

arch/x86/include/asm/ptrace.h

362

return ((addr & ~(THREAD_SIZE - 1)) == (regs->sp & ~(THREAD_SIZE - 1)));

arch/x86/include/asm/thread_info.h

141

#define STACK_WARN (THREAD_SIZE/8)

arch/x86/kernel/dumpstack.c

34

unsigned long *end = task_stack_page(task) + THREAD_SIZE;

arch/x86/kernel/dumpstack_32.c

41

unsigned long *end = begin + (THREAD_SIZE / sizeof(long));

arch/x86/kernel/dumpstack_32.c

66

unsigned long *end = begin + (THREAD_SIZE / sizeof(long));

arch/x86/kernel/irq_32.c

34

unsigned long sp = current_stack_pointer & (THREAD_SIZE - 1);

arch/x86/kernel/irq_32.c

66

return (void *)(current_stack_pointer & ~(THREAD_SIZE - 1));

arch/x86/kernel/process_32.c

200

THREAD_SIZE);

arch/xtensa/kernel/irq.c

42

sp &= THREAD_SIZE - 1;

arch/xtensa/kernel/process.c

388

sp >= (stack_page + THREAD_SIZE) ||

arch/xtensa/kernel/stacktrace.c

128

sp_start = a1 & ~(THREAD_SIZE - 1);

arch/xtensa/kernel/stacktrace.c

129

sp_end = sp_start + THREAD_SIZE;

arch/xtensa/kernel/stacktrace.c

178

sp_end = ALIGN(a1, THREAD_SIZE);

arch/xtensa/kernel/traps.c

614

sf.len = min((-(size_t)sp) & (THREAD_SIZE - STACK_DUMP_ENTRY_SIZE),

drivers/misc/lkdtm/bugs.c

35

#define REC_STACK_SIZE (THREAD_SIZE / 8UL)

drivers/misc/lkdtm/bugs.c

37

#define REC_NUM_DEFAULT ((THREAD_SIZE / REC_STACK_SIZE) * 2)

drivers/misc/lkdtm/bugs.c

666

const unsigned char *ptr = stack + THREAD_SIZE;

drivers/misc/lkdtm/kstack_erase.c

107

task_stack_base + THREAD_SIZE - task_stack_high,

drivers/misc/lkdtm/usercopy.c

71

bad_stack = task_stack_page(current) + THREAD_SIZE;

fs/proc/base.c

3295

unsigned long prev_depth = THREAD_SIZE -

fs/proc/base.c

3296

(task->prev_lowest_stack & (THREAD_SIZE - 1));

fs/proc/base.c

3297

unsigned long depth = THREAD_SIZE -

fs/proc/base.c

3298

(task->lowest_stack & (THREAD_SIZE - 1));

include/asm-generic/vmlinux.lds.h

431

. = __start_init_stack + THREAD_SIZE; \

include/linux/ftrace.h

271

if (((unsigned long)(stackp + nth) & ~(THREAD_SIZE - 1)) ==

include/linux/ftrace.h

272

((unsigned long)stackp & ~(THREAD_SIZE - 1)))

include/linux/sched.h

1955

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

include/linux/sched.h

1962

extern unsigned long init_stack[THREAD_SIZE / sizeof(unsigned long)];

include/linux/sched/task_stack.h

114

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

include/linux/sched/task_stack.h

31

return (unsigned long *)((unsigned long)task->stack + THREAD_SIZE) - 1;

include/linux/sched/task_stack.h

59

return (unsigned long *)((unsigned long)task_thread_info(p) + THREAD_SIZE) - 1;

include/linux/sched/task_stack.h

94

return (obj >= stack) && (obj < (stack + THREAD_SIZE));

include/linux/thread_info.h

92

#define THREAD_ALIGN THREAD_SIZE

include/linux/vm_event_item.h

169

#if THREAD_SIZE > 1024

include/linux/vm_event_item.h

172

#if THREAD_SIZE > 2048

include/linux/vm_event_item.h

175

#if THREAD_SIZE > 4096

include/linux/vm_event_item.h

178

#if THREAD_SIZE > 8192

include/linux/vm_event_item.h

181

#if THREAD_SIZE > 16384

include/linux/vm_event_item.h

184

#if THREAD_SIZE > 32768

include/linux/vm_event_item.h

187

#if THREAD_SIZE > 65536

init/main.c

810

# if THREAD_SIZE >= PAGE_SIZE

kernel/exit.c

812

#if THREAD_SIZE > 1024

kernel/exit.c

816

#if THREAD_SIZE > 2048

kernel/exit.c

820

#if THREAD_SIZE > 4096

kernel/exit.c

824

#if THREAD_SIZE > 8192

kernel/exit.c

828

#if THREAD_SIZE > 16384

kernel/exit.c

832

#if THREAD_SIZE > 32768

kernel/exit.c

836

#if THREAD_SIZE > 65536

kernel/exit.c

846

static int lowest_to_date = THREAD_SIZE;

kernel/exit.c

850

kstack_histogram(THREAD_SIZE - free);

kernel/fork.c

315

BUG_ON(vm_area->nr_pages != THREAD_SIZE / PAGE_SIZE);

kernel/fork.c

317

for (i = 0; i < THREAD_SIZE / PAGE_SIZE; i++) {

kernel/fork.c

343

kasan_unpoison_range(vm_area->addr, THREAD_SIZE);

kernel/fork.c

348

memset(stack, 0, THREAD_SIZE);

kernel/fork.c

355

stack = __vmalloc_node(THREAD_SIZE, THREAD_ALIGN,

kernel/fork.c

392

#if THREAD_SIZE >= PAGE_SIZE

kernel/fork.c

458

THREAD_SIZE, THREAD_SIZE, 0, 0,

kernel/fork.c

459

THREAD_SIZE, NULL);

kernel/fork.c

487

for (i = 0; i < THREAD_SIZE / PAGE_SIZE; i++)

kernel/fork.c

495

account * (THREAD_SIZE / 1024));

kernel/fork.c

508

for (i = 0; i < THREAD_SIZE / PAGE_SIZE; i++)

kernel/fork.c

821

(u64) THREAD_SIZE * 8UL);

kernel/trace/trace_probe.c

940

#define PARAM_MAX_STACK (THREAD_SIZE / sizeof(unsigned long))

kernel/trace/trace_stack.c

162

this_size = ((unsigned long)stack) & (THREAD_SIZE-1);

kernel/trace/trace_stack.c

163

this_size = THREAD_SIZE - this_size;

kernel/trace/trace_stack.c

214

(((unsigned long)start & ~(THREAD_SIZE-1)) + THREAD_SIZE);

mm/kasan/common.c

111

kasan_unpoison(base, THREAD_SIZE, false);

mm/kasan/common.c

122

void *base = (void *)((unsigned long)watermark & ~(THREAD_SIZE - 1));

mm/kmemleak.c

1787

scan_block(stack, stack + THREAD_SIZE, NULL);

mm/usercopy.c

40

const void * const stackend = stack + THREAD_SIZE;

mm/vmstat.c

1467

#if THREAD_SIZE > 1024

mm/vmstat.c

1470

#if THREAD_SIZE > 2048

mm/vmstat.c

1473

#if THREAD_SIZE > 4096

mm/vmstat.c

1476

#if THREAD_SIZE > 8192

mm/vmstat.c

1479

#if THREAD_SIZE > 16384

mm/vmstat.c

1482

#if THREAD_SIZE > 32768

mm/vmstat.c

1485

#if THREAD_SIZE > 65536