psi: Move PF_MEMSTALL out of task->flags

The task->flags is a 32-bits flag, in which 31 bits have already been
consumed. So it is hardly to introduce other new per process flag.
Currently there're still enough spaces in the bit-field section of
task_struct, so we can define the memstall state as a single bit in
task_struct instead.
This patch also removes an out-of-date comment pointed by Matthew.

Suggested-by: Johannes Weiner <hannes@cmpxchg.org>
Signed-off-by: Yafang Shao <laoar.shao@gmail.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Johannes Weiner <hannes@cmpxchg.org>
Link: https://lkml.kernel.org/r/1584408485-1921-1-git-send-email-laoar.shao@gmail.com

diff --git a/include/linux/sched.h b/include/linux/sched.h
index 2e9199bf947b0a68b60438dbbf810026ac0d0ca1..09bddd9e69a292cc6dc0bb77e498bb0f8b22a245 100644 (file)
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -785,9 +785,12 @@ struct task_struct {
        unsigned                        frozen:1;
 #endif
 #ifdef CONFIG_BLK_CGROUP
-       /* to be used once the psi infrastructure lands upstream. */
        unsigned                        use_memdelay:1;
 #endif
+#ifdef CONFIG_PSI
+       /* Stalled due to lack of memory */
+       unsigned                        in_memstall:1;
+#endif
 
        unsigned long                   atomic_flags; /* Flags requiring atomic access. */
 
@@ -1480,7 +1483,6 @@ extern struct pid *cad_pid;
 #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_MEMSTALL            0x01000000      /* Stalled due to lack of memory */
 #define PF_UMH                 0x02000000      /* I'm an Usermodehelper process */
 #define PF_NO_SETAFFINITY      0x04000000      /* Userland is not allowed to meddle with cpus_mask */
 #define PF_MCE_EARLY           0x08000000      /* Early kill for mce process policy */

diff --git a/kernel/sched/psi.c b/kernel/sched/psi.c
index 955a124bae817156fa06af439f776c1ef3af3024..8f45cdb6463b88d87ddac3af0150ff1730e18c9e 100644 (file)
--- a/kernel/sched/psi.c
+++ b/kernel/sched/psi.c
@@ -865,17 +865,17 @@ void psi_memstall_enter(unsigned long *flags)
        if (static_branch_likely(&psi_disabled))
                return;
 
-       *flags = current->flags & PF_MEMSTALL;
+       *flags = current->in_memstall;
        if (*flags)
                return;
        /*
-        * PF_MEMSTALL setting & accounting needs to be atomic wrt
+        * in_memstall setting & accounting needs to be atomic wrt
         * changes to the task's scheduling state, otherwise we can
         * race with CPU migration.
         */
        rq = this_rq_lock_irq(&rf);
 
-       current->flags |= PF_MEMSTALL;
+       current->in_memstall = 1;
        psi_task_change(current, 0, TSK_MEMSTALL);
 
        rq_unlock_irq(rq, &rf);
@@ -898,13 +898,13 @@ void psi_memstall_leave(unsigned long *flags)
        if (*flags)
                return;
        /*
-        * PF_MEMSTALL clearing & accounting needs to be atomic wrt
+        * in_memstall clearing & accounting needs to be atomic wrt
         * changes to the task's scheduling state, otherwise we could
         * race with CPU migration.
         */
        rq = this_rq_lock_irq(&rf);
 
-       current->flags &= ~PF_MEMSTALL;
+       current->in_memstall = 0;
        psi_task_change(current, TSK_MEMSTALL, 0);
 
        rq_unlock_irq(rq, &rf);
@@ -970,7 +970,7 @@ void cgroup_move_task(struct task_struct *task, struct css_set *to)
        } else if (task->in_iowait)
                task_flags = TSK_IOWAIT;
 
-       if (task->flags & PF_MEMSTALL)
+       if (task->in_memstall)
                task_flags |= TSK_MEMSTALL;
 
        if (task_flags)

diff --git a/kernel/sched/stats.h b/kernel/sched/stats.h
index 1339f5bfe513ebbbefec3b0e324ad14edda026d5..33d0daf83842a1a8ae8a9548c4a0e81f5dc1d9fb 100644 (file)
--- a/kernel/sched/stats.h
+++ b/kernel/sched/stats.h
@@ -70,7 +70,7 @@ static inline void psi_enqueue(struct task_struct *p, bool wakeup)
                return;
 
        if (!wakeup || p->sched_psi_wake_requeue) {
-               if (p->flags & PF_MEMSTALL)
+               if (p->in_memstall)
                        set |= TSK_MEMSTALL;
                if (p->sched_psi_wake_requeue)
                        p->sched_psi_wake_requeue = 0;
@@ -90,7 +90,7 @@ static inline void psi_dequeue(struct task_struct *p, bool sleep)
                return;
 
        if (!sleep) {
-               if (p->flags & PF_MEMSTALL)
+               if (p->in_memstall)
                        clear |= TSK_MEMSTALL;
        } else {
                /*
@@ -117,14 +117,14 @@ static inline void psi_ttwu_dequeue(struct task_struct *p)
         * deregister its sleep-persistent psi states from the old
         * queue, and let psi_enqueue() know it has to requeue.
         */
-       if (unlikely(p->in_iowait || (p->flags & PF_MEMSTALL))) {
+       if (unlikely(p->in_iowait || p->in_memstall)) {
                struct rq_flags rf;
                struct rq *rq;
                int clear = 0;
 
                if (p->in_iowait)
                        clear |= TSK_IOWAIT;
-               if (p->flags & PF_MEMSTALL)
+               if (p->in_memstall)
                        clear |= TSK_MEMSTALL;
 
                rq = __task_rq_lock(p, &rf);
@@ -149,7 +149,7 @@ static inline void psi_task_tick(struct rq *rq)
        if (static_branch_likely(&psi_disabled))
                return;
 
-       if (unlikely(rq->curr->flags & PF_MEMSTALL))
+       if (unlikely(rq->curr->in_memstall))
                psi_memstall_tick(rq->curr, cpu_of(rq));
 }
 #else /* CONFIG_PSI */