Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : #ifndef __INCLUDE_LINUX_OOM_H
       3             : #define __INCLUDE_LINUX_OOM_H
       4             : 
       5             : 
       6             : #include <linux/sched/signal.h>
       7             : #include <linux/types.h>
       8             : #include <linux/nodemask.h>
       9             : #include <uapi/linux/oom.h>
      10             : #include <linux/sched/coredump.h> /* MMF_* */
      11             : #include <linux/mm.h> /* VM_FAULT* */
      12             : 
      13             : struct zonelist;
      14             : struct notifier_block;
      15             : struct mem_cgroup;
      16             : struct task_struct;
      17             : 
      18             : enum oom_constraint {
      19             :         CONSTRAINT_NONE,
      20             :         CONSTRAINT_CPUSET,
      21             :         CONSTRAINT_MEMORY_POLICY,
      22             :         CONSTRAINT_MEMCG,
      23             : };
      24             : 
      25             : /*
      26             :  * Details of the page allocation that triggered the oom killer that are used to
      27             :  * determine what should be killed.
      28             :  */
      29             : struct oom_control {
      30             :         /* Used to determine cpuset */
      31             :         struct zonelist *zonelist;
      32             : 
      33             :         /* Used to determine mempolicy */
      34             :         nodemask_t *nodemask;
      35             : 
      36             :         /* Memory cgroup in which oom is invoked, or NULL for global oom */
      37             :         struct mem_cgroup *memcg;
      38             : 
      39             :         /* Used to determine cpuset and node locality requirement */
      40             :         const gfp_t gfp_mask;
      41             : 
      42             :         /*
      43             :          * order == -1 means the oom kill is required by sysrq, otherwise only
      44             :          * for display purposes.
      45             :          */
      46             :         const int order;
      47             : 
      48             :         /* Used by oom implementation, do not set */
      49             :         unsigned long totalpages;
      50             :         struct task_struct *chosen;
      51             :         long chosen_points;
      52             : 
      53             :         /* Used to print the constraint info. */
      54             :         enum oom_constraint constraint;
      55             : };
      56             : 
      57             : extern struct mutex oom_lock;
      58             : extern struct mutex oom_adj_mutex;
      59             : 
      60             : static inline void set_current_oom_origin(void)
      61             : {
      62           0 :         current->signal->oom_flag_origin = true;
      63             : }
      64             : 
      65             : static inline void clear_current_oom_origin(void)
      66             : {
      67           0 :         current->signal->oom_flag_origin = false;
      68             : }
      69             : 
      70             : static inline bool oom_task_origin(const struct task_struct *p)
      71             : {
      72           0 :         return p->signal->oom_flag_origin;
      73             : }
      74             : 
      75             : static inline bool tsk_is_oom_victim(struct task_struct * tsk)
      76             : {
      77           0 :         return tsk->signal->oom_mm;
      78             : }
      79             : 
      80             : /*
      81             :  * Checks whether a page fault on the given mm is still reliable.
      82             :  * This is no longer true if the oom reaper started to reap the
      83             :  * address space which is reflected by MMF_UNSTABLE flag set in
      84             :  * the mm. At that moment any !shared mapping would lose the content
      85             :  * and could cause a memory corruption (zero pages instead of the
      86             :  * original content).
      87             :  *
      88             :  * User should call this before establishing a page table entry for
      89             :  * a !shared mapping and under the proper page table lock.
      90             :  *
      91             :  * Return 0 when the PF is safe VM_FAULT_SIGBUS otherwise.
      92             :  */
      93             : static inline vm_fault_t check_stable_address_space(struct mm_struct *mm)
      94             : {
      95           0 :         if (unlikely(test_bit(MMF_UNSTABLE, &mm->flags)))
      96             :                 return VM_FAULT_SIGBUS;
      97             :         return 0;
      98             : }
      99             : 
     100             : long oom_badness(struct task_struct *p,
     101             :                 unsigned long totalpages);
     102             : 
     103             : extern bool out_of_memory(struct oom_control *oc);
     104             : 
     105             : extern void exit_oom_victim(void);
     106             : 
     107             : extern int register_oom_notifier(struct notifier_block *nb);
     108             : extern int unregister_oom_notifier(struct notifier_block *nb);
     109             : 
     110             : extern bool oom_killer_disable(signed long timeout);
     111             : extern void oom_killer_enable(void);
     112             : 
     113             : extern struct task_struct *find_lock_task_mm(struct task_struct *p);
     114             : 
     115             : #endif /* _INCLUDE_LINUX_OOM_H */