// SPDX-License-Identifier: GPL-2.0
  /*
   * This code fills the used part of the kernel stack with a poison value
   * before returning to userspace. It's part of the STACKLEAK feature
   * ported from grsecurity/PaX.
   *
   * Author: Alexander Popov <alex.popov@linux.com>
   *
   * STACKLEAK reduces the information which kernel stack leak bugs can
   * reveal and blocks some uninitialized stack variable attacks.
   */
  
  #include <linux/stackleak.h>

  #include <linux/kprobes.h>

  #ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE
  #include <linux/jump_label.h>
  #include <linux/sysctl.h>
  
  static DEFINE_STATIC_KEY_FALSE(stack_erasing_bypass);
  
  int stack_erasing_sysctl(struct ctl_table *table, int write,

  			void *buffer, size_t *lenp, loff_t *ppos)

  {
  	int ret = 0;
  	int state = !static_branch_unlikely(&stack_erasing_bypass);
  	int prev_state = state;
  
  	table->data = &state;
  	table->maxlen = sizeof(int);
  	ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
  	state = !!state;
  	if (ret || !write || state == prev_state)
  		return ret;
  
  	if (state)
  		static_branch_disable(&stack_erasing_bypass);
  	else
  		static_branch_enable(&stack_erasing_bypass);
  
  	pr_warn("stackleak: kernel stack erasing is %s
  ",
  					state ? "enabled" : "disabled");
  	return ret;
  }
  
  #define skip_erasing()	static_branch_unlikely(&stack_erasing_bypass)
  #else
  #define skip_erasing()	false
  #endif /* CONFIG_STACKLEAK_RUNTIME_DISABLE */

  asmlinkage void notrace stackleak_erase(void)

  {
  	/* It would be nice not to have 'kstack_ptr' and 'boundary' on stack */
  	unsigned long kstack_ptr = current->lowest_stack;
  	unsigned long boundary = (unsigned long)end_of_stack(current);
  	unsigned int poison_count = 0;
  	const unsigned int depth = STACKLEAK_SEARCH_DEPTH / sizeof(unsigned long);

  	if (skip_erasing())
  		return;

  	/* Check that 'lowest_stack' value is sane */
  	if (unlikely(kstack_ptr - boundary >= THREAD_SIZE))
  		kstack_ptr = boundary;
  
  	/* Search for the poison value in the kernel stack */
  	while (kstack_ptr > boundary && poison_count <= depth) {
  		if (*(unsigned long *)kstack_ptr == STACKLEAK_POISON)
  			poison_count++;
  		else
  			poison_count = 0;
  
  		kstack_ptr -= sizeof(unsigned long);
  	}
  
  	/*
  	 * One 'long int' at the bottom of the thread stack is reserved and
  	 * should not be poisoned (see CONFIG_SCHED_STACK_END_CHECK=y).
  	 */
  	if (kstack_ptr == boundary)
  		kstack_ptr += sizeof(unsigned long);

  #ifdef CONFIG_STACKLEAK_METRICS
  	current->prev_lowest_stack = kstack_ptr;
  #endif

  	/*
  	 * Now write the poison value to the kernel stack. Start from
  	 * 'kstack_ptr' and move up till the new 'boundary'. We assume that
  	 * the stack pointer doesn't change when we write poison.
  	 */
  	if (on_thread_stack())
  		boundary = current_stack_pointer;
  	else
  		boundary = current_top_of_stack();
  
  	while (kstack_ptr < boundary) {
  		*(unsigned long *)kstack_ptr = STACKLEAK_POISON;
  		kstack_ptr += sizeof(unsigned long);
  	}
  
  	/* Reset the 'lowest_stack' value for the next syscall */
  	current->lowest_stack = current_top_of_stack() - THREAD_SIZE/64;
  }

  NOKPROBE_SYMBOL(stackleak_erase);

  void __used __no_caller_saved_registers notrace stackleak_track_stack(void)

  {

  	unsigned long sp = current_stack_pointer;

  
  	/*
  	 * Having CONFIG_STACKLEAK_TRACK_MIN_SIZE larger than
  	 * STACKLEAK_SEARCH_DEPTH makes the poison search in
  	 * stackleak_erase() unreliable. Let's prevent that.
  	 */
  	BUILD_BUG_ON(CONFIG_STACKLEAK_TRACK_MIN_SIZE > STACKLEAK_SEARCH_DEPTH);

  	/* 'lowest_stack' should be aligned on the register width boundary */
  	sp = ALIGN(sp, sizeof(unsigned long));

  	if (sp < current->lowest_stack &&
  	    sp >= (unsigned long)task_stack_page(current) +
  						sizeof(unsigned long)) {
  		current->lowest_stack = sp;
  	}
  }
  EXPORT_SYMBOL(stackleak_track_stack);