imamnurby/smpl_train_seed8 huggingface dataset:
--- initial
+++ final
@@ -1,19 +1,19 @@
 static int cpu_clock_sample_group(const clockid_t which_clock, struct task_struct *p, unsigned long long *sample) {
-  struct task_cputime cputime;
+  struct task_cputime_t cputime;
   switch (CPUCLOCK_WHICH(which_clock)) {
   default: return -EINVAL;
   case CPUCLOCK_PROF:
-    thread_group_cputime(p, &cputime);
+    thread_group_cputime_t(p, &cputime);
     *sample = cputime_to_expires(cputime.utime + cputime.stime);
     break;
   case CPUCLOCK_VIRT:
-    thread_group_cputime(p, &cputime);
+    thread_group_cputime_t(p, &cputime);
     *sample = cputime_to_expires(cputime.utime);
     break;
   case CPUCLOCK_SCHED:
-    thread_group_cputime(p, &cputime);
+    thread_group_cputime_t(p, &cputime);
     *sample = cputime.sum_exec_runtime;
     break;
   }
   return 0;
 }<sep>@@
identifier cputime;
expression p;
@@

-	struct task_cputime cputime;
+	struct task_cputime_t cputime;
 <...
-		thread_group_cputime(p, &cputime);
+		thread_group_cputime_t(p, &cputime);
 ...>
--- initial
+++ final
@@ -1,11 +1,11 @@
 static int cpu_timer_sample_group(const clockid_t which_clock, struct task_struct *p, unsigned long long *sample) {
-  struct task_cputime cputime;
+  struct task_cputime_t cputime;
   thread_group_cputimer(p, &cputime);
   switch (CPUCLOCK_WHICH(which_clock)) {
   default: return -EINVAL;
   case CPUCLOCK_PROF: *sample = cputime_to_expires(cputime.utime + cputime.stime); break;
   case CPUCLOCK_VIRT: *sample = cputime_to_expires(cputime.utime); break;
   case CPUCLOCK_SCHED: *sample = cputime.sum_exec_runtime; break;
   }
   return 0;
 }<sep>@@
identifier cputime;
expression p;
@@

-	struct task_cputime cputime;
+	struct task_cputime_t cputime;
 <...
-		thread_group_cputime(p, &cputime);
+		thread_group_cputime_t(p, &cputime);
 ...>
--- initial
+++ final
@@ -1,30 +1,30 @@
 static inline int fastpath_timer_check(struct task_struct *tsk) {
   struct signal_struct *sig;
   if (!task_cputime_zero(&tsk->cputime_expires)) {
-    struct task_cputime task_sample;
-    task_cputime(tsk, &task_sample.utime, &task_sample.stime);
+    struct task_cputime_t task_sample;
+    task_cputime_t(tsk, &task_sample.utime, &task_sample.stime);
     task_sample.sum_exec_runtime = tsk->se.sum_exec_runtime;
     if (task_cputime_expired(&task_sample, &tsk->cputime_expires)) return 1;
   }
   sig = tsk->signal;
   /*
    * Check if thread group timers expired when the cputimer is
    * running and no other thread in the group is already checking
    * for thread group cputimers. These fields are read without the
    * sighand lock. However, this is fine because this is meant to
    * be a fastpath heuristic to determine whether we should try to
    * acquire the sighand lock to check/handle timers.
    *
    * In the worst case scenario, if 'running' or 'checking_timer' gets
    * set but the current thread doesn't see the change yet, we'll wait
    * until the next thread in the group gets a scheduler interrupt to
    * handle the timer. This isn't an issue in practice because these
    * types of delays with signals actually getting sent are expected.
    */
   if (READ_ONCE(sig->cputimer.running) && !READ_ONCE(sig->cputimer.checking_timer)) {
-    struct task_cputime group_sample;
+    struct task_cputime_t group_sample;
     sample_cputime_atomic(&group_sample, &sig->cputimer.cputime_atomic);
     if (task_cputime_expired(&group_sample, &sig->cputime_expires)) return 1;
   }
   return 0;
 }<sep>@@
expression e1,e2,e3;
@@
-       task_cputime
+       task_cputime_t
		(e1,e2,e3)

@@
identifier cputime;
expression p;
@@

-	struct task_cputime cputime;
+	struct task_cputime_t cputime;
 <...
-		thread_group_cputime(p, &cputime);
+		thread_group_cputime_t(p, &cputime);
 ...>
--- initial
+++ final
@@ -1,5 +1,5 @@
 static inline unsigned long long prof_ticks(struct task_struct *p) {
   cputime_t utime, stime;
-  task_cputime(p, &utime, &stime);
+  task_cputime_t(p, &utime, &stime);
   return cputime_to_expires(utime + stime);
 }<sep>@@
expression e1,e2,e3;
@@
-       task_cputime
+       task_cputime_t
		(e1,e2,e3)
--- initial
+++ final
@@ -1,5 +1,5 @@
-static inline void sample_cputime_atomic(struct task_cputime *times, struct task_cputime_atomic *atomic_times) {
+static inline void sample_cputime_atomic(struct task_cputime_t *times, struct task_cputime_atomic *atomic_times) {
   times->utime = atomic64_read(&atomic_times->utime);
   times->stime = atomic64_read(&atomic_times->stime);
   times->sum_exec_runtime = atomic64_read(&atomic_times->sum_exec_runtime);
 }<sep>@@
identifier cputime,f;
expression p;
@@

f(...,
-	struct task_cputime *cputime
+	struct task_cputime_t *cputime
,...) {
 <...
-		thread_group_cputime(p, cputime);
+		thread_group_cputime_t(p, cputime);
 ...>
}
--- initial
+++ final
@@ -1,6 +1,6 @@
-static inline int task_cputime_expired(const struct task_cputime *sample, const struct task_cputime *expires) {
+static inline int task_cputime_expired(const struct task_cputime_t *sample, const struct task_cputime_t *expires) {
   if (expires->utime && sample->utime >= expires->utime) return 1;
   if (expires->stime && sample->utime + sample->stime >= expires->stime) return 1;
   if (expires->sum_exec_runtime != 0 && sample->sum_exec_runtime >= expires->sum_exec_runtime) return 1;
   return 0;
 }<sep>@@
identifier cputime,f;
expression p;
@@

f(...,
-	struct task_cputime *cputime
+	struct task_cputime_t *cputime
,...) {
 <...
-		thread_group_cputime(p, cputime);
+		thread_group_cputime_t(p, cputime);
 ...>
}
--- initial
+++ final
@@ -1,4 +1,4 @@
-static inline int task_cputime_zero(const struct task_cputime *cputime) {
+static inline int task_cputime_zero(const struct task_cputime_t *cputime) {
   if (!cputime->utime && !cputime->stime && !cputime->sum_exec_runtime) return 1;
   return 0;
 }<sep>@@
identifier cputime,f;
expression p;
@@

f(...,
-	struct task_cputime *cputime
+	struct task_cputime_t *cputime
,...) {
 <...
-		thread_group_cputime(p, cputime);
+		thread_group_cputime_t(p, cputime);
 ...>
}
--- initial
+++ final
@@ -1,23 +1,23 @@
-void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times) {
+void thread_group_cputimer(struct task_struct *tsk, struct task_cputime_t *times) {
   struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;
-  struct task_cputime sum;
+  struct task_cputime_t sum;
   /* Check if cputimer isn't running. This is accessed without locking. */
   if (!READ_ONCE(cputimer->running)) {
     /*
      * The POSIX timer interface allows for absolute time expiry
      * values through the TIMER_ABSTIME flag, therefore we have
      * to synchronize the timer to the clock every time we start it.
      */
-    thread_group_cputime(tsk, &sum);
+    thread_group_cputime_t(tsk, &sum);
     update_gt_cputime(&cputimer->cputime_atomic, &sum);
     /*
      * We're setting cputimer->running without a lock. Ensure
      * this only gets written to in one operation. We set
      * running after update_gt_cputime() as a small optimization,
      * but barriers are not required because update_gt_cputime()
      * can handle concurrent updates.
      */
     WRITE_ONCE(cputimer->running, true);
   }
   sample_cputime_atomic(times, &cputimer->cputime_atomic);
 }<sep>@@
identifier cputime;
expression p;
@@

-	struct task_cputime cputime;
+	struct task_cputime_t cputime;
 <...
-		thread_group_cputime(p, &cputime);
+		thread_group_cputime_t(p, &cputime);
 ...>

@@
identifier cputime,f;
expression p;
@@

f(...,
-	struct task_cputime *cputime
+	struct task_cputime_t *cputime
,...) {
 <...
-		thread_group_cputime(p, cputime);
+		thread_group_cputime_t(p, cputime);
 ...>
}
--- initial
+++ final
@@ -1,5 +1,5 @@
-static void update_gt_cputime(struct task_cputime_atomic *cputime_atomic, struct task_cputime *sum) {
+static void update_gt_cputime(struct task_cputime_atomic *cputime_atomic, struct task_cputime_t *sum) {
   __update_gt_cputime(&cputime_atomic->utime, sum->utime);
   __update_gt_cputime(&cputime_atomic->stime, sum->stime);
   __update_gt_cputime(&cputime_atomic->sum_exec_runtime, sum->sum_exec_runtime);
 }<sep>@@
identifier cputime,f;
expression p;
@@

f(...,
-	struct task_cputime *cputime
+	struct task_cputime_t *cputime
,...) {
 <...
-		thread_group_cputime(p, cputime);
+		thread_group_cputime_t(p, cputime);
 ...>
}
--- initial
+++ final
@@ -1,5 +1,5 @@
 static inline unsigned long long virt_ticks(struct task_struct *p) {
   cputime_t utime, stime;
-  task_cputime(p, &utime, &stime);
+  task_cputime_t(p, &utime, &stime);
   return cputime_to_expires(utime);
 }<sep>@@
expression e1,e2,e3;
@@
-       task_cputime
+       task_cputime_t
		(e1,e2,e3)
--- initial
+++ final
@@ -1,72 +1,72 @@
 bool do_notify_parent(struct task_struct *tsk, int sig) {
   struct siginfo info;
   unsigned long flags;
   struct sighand_struct *psig;
   bool autoreap = false;
   cputime_t utime, stime;
   BUG_ON(sig == -1);
   /* do_notify_parent_cldstop should have been called instead.  */
   BUG_ON(task_is_stopped_or_traced(tsk));
   BUG_ON(!tsk->ptrace && (tsk->group_leader != tsk || !thread_group_empty(tsk)));
   if (sig != SIGCHLD) {
     /*
      * This is only possible if parent == real_parent.
      * Check if it has changed security domain.
      */
     if (tsk->parent_exec_id != tsk->parent->self_exec_id) sig = SIGCHLD;
   }
   info.si_signo = sig;
   info.si_errno = 0;
   /*
    * We are under tasklist_lock here so our parent is tied to
    * us and cannot change.
    *
    * task_active_pid_ns will always return the same pid namespace
    * until a task passes through release_task.
    *
    * write_lock() currently calls preempt_disable() which is the
    * same as rcu_read_lock(), but according to Oleg, this is not
    * correct to rely on this
    */
   rcu_read_lock();
   info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
   info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns), task_uid(tsk));
   rcu_read_unlock();
-  task_cputime(tsk, &utime, &stime);
+  task_cputime_t(tsk, &utime, &stime);
   info.si_utime = cputime_to_clock_t(utime + tsk->signal->utime);
   info.si_stime = cputime_to_clock_t(stime + tsk->signal->stime);
   info.si_status = tsk->exit_code & 0x7f;
   if (tsk->exit_code & 0x80)
     info.si_code = CLD_DUMPED;
   else if (tsk->exit_code & 0x7f)
     info.si_code = CLD_KILLED;
   else {
     info.si_code = CLD_EXITED;
     info.si_status = tsk->exit_code >> 8;
   }
   psig = tsk->parent->sighand;
   spin_lock_irqsave(&psig->siglock, flags);
   if (!tsk->ptrace && sig == SIGCHLD && (psig->action[SIGCHLD - 1].sa.sa_handler == SIG_IGN || (psig->action[SIGCHLD - 1].sa.sa_flags & SA_NOCLDWAIT))) {
     /*
      * We are exiting and our parent doesn't care.  POSIX.1
      * defines special semantics for setting SIGCHLD to SIG_IGN
      * or setting the SA_NOCLDWAIT flag: we should be reaped
      * automatically and not left for our parent's wait4 call.
      * Rather than having the parent do it as a magic kind of
      * signal handler, we just set this to tell do_exit that we
      * can be cleaned up without becoming a zombie.  Note that
      * we still call __wake_up_parent in this case, because a
      * blocked sys_wait4 might now return -ECHILD.
      *
      * Whether we send SIGCHLD or not for SA_NOCLDWAIT
      * is implementation-defined: we do (if you don't want
      * it, just use SIG_IGN instead).
      */
     autoreap = true;
     if (psig->action[SIGCHLD - 1].sa.sa_handler == SIG_IGN) sig = 0;
   }
   if (valid_signal(sig) && sig) __group_send_sig_info(sig, &info, tsk->parent);
   __wake_up_parent(tsk, tsk->parent);
   spin_unlock_irqrestore(&psig->siglock, flags);
   return autoreap;
 }<sep>@@
expression e1,e2,e3;
@@
-       task_cputime
+       task_cputime_t
		(e1,e2,e3)
--- initial
+++ final
@@ -1,40 +1,40 @@
 static void do_notify_parent_cldstop(struct task_struct *tsk, bool for_ptracer, int why) {
   struct siginfo info;
   unsigned long flags;
   struct task_struct *parent;
   struct sighand_struct *sighand;
   cputime_t utime, stime;
   if (for_ptracer) {
     parent = tsk->parent;
   } else {
     tsk = tsk->group_leader;
     parent = tsk->real_parent;
   }
   info.si_signo = SIGCHLD;
   info.si_errno = 0;
   /*
    * see comment in do_notify_parent() about the following 4 lines
    */
   rcu_read_lock();
   info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
   info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
   rcu_read_unlock();
-  task_cputime(tsk, &utime, &stime);
+  task_cputime_t(tsk, &utime, &stime);
   info.si_utime = cputime_to_clock_t(utime);
   info.si_stime = cputime_to_clock_t(stime);
   info.si_code = why;
   switch (why) {
   case CLD_CONTINUED: info.si_status = SIGCONT; break;
   case CLD_STOPPED: info.si_status = tsk->signal->group_exit_code & 0x7f; break;
   case CLD_TRAPPED: info.si_status = tsk->exit_code & 0x7f; break;
   default: BUG();
   }
   sighand = parent->sighand;
   spin_lock_irqsave(&sighand->siglock, flags);
   if (sighand->action[SIGCHLD - 1].sa.sa_handler != SIG_IGN && !(sighand->action[SIGCHLD - 1].sa.sa_flags & SA_NOCLDSTOP)) __group_send_sig_info(SIGCHLD, &info, parent);
   /*
    * Even if SIGCHLD is not generated, we must wake up wait4 calls.
    */
   __wake_up_parent(tsk, parent);
   spin_unlock_irqrestore(&sighand->siglock, flags);
 }<sep>@@
expression e1,e2,e3;
@@
-       task_cputime
+       task_cputime_t
		(e1,e2,e3)
--- initial
+++ final
@@ -1,8 +1,8 @@
 void acct_update_integrals(struct task_struct *tsk) {
   cputime_t utime, stime;
   unsigned long flags;
   local_irq_save(flags);
-  task_cputime(tsk, &utime, &stime);
+  task_cputime_t(tsk, &utime, &stime);
   __acct_update_integrals(tsk, utime, stime);
   local_irq_restore(flags);
 }<sep>@@
expression e1,e2,e3;
@@
-       task_cputime
+       task_cputime_t
		(e1,e2,e3)
--- initial
+++ final
@@ -1,39 +1,39 @@
 void bacct_add_tsk(struct user_namespace *user_ns, struct pid_namespace *pid_ns, struct taskstats *stats, struct task_struct *tsk) {
   const struct cred *tcred;
   cputime_t utime, stime, utimescaled, stimescaled;
   u64 delta;
   BUILD_BUG_ON(TS_COMM_LEN < TASK_COMM_LEN);
   /* calculate task elapsed time in nsec */
   delta = ktime_get_ns() - tsk->start_time;
   /* Convert to micro seconds */
   do_div(delta, NSEC_PER_USEC);
   stats->ac_etime = delta;
   /* Convert to seconds for btime */
   do_div(delta, USEC_PER_SEC);
   stats->ac_btime = get_seconds() - delta;
   if (thread_group_leader(tsk)) {
     stats->ac_exitcode = tsk->exit_code;
     if (tsk->flags & PF_FORKNOEXEC) stats->ac_flag |= AFORK;
   }
   if (tsk->flags & PF_SUPERPRIV) stats->ac_flag |= ASU;
   if (tsk->flags & PF_DUMPCORE) stats->ac_flag |= ACORE;
   if (tsk->flags & PF_SIGNALED) stats->ac_flag |= AXSIG;
   stats->ac_nice = task_nice(tsk);
   stats->ac_sched = tsk->policy;
   stats->ac_pid = task_pid_nr_ns(tsk, pid_ns);
   rcu_read_lock();
   tcred = __task_cred(tsk);
   stats->ac_uid = from_kuid_munged(user_ns, tcred->uid);
   stats->ac_gid = from_kgid_munged(user_ns, tcred->gid);
   stats->ac_ppid = pid_alive(tsk) ? task_tgid_nr_ns(rcu_dereference(tsk->real_parent), pid_ns) : 0;
   rcu_read_unlock();
-  task_cputime(tsk, &utime, &stime);
+  task_cputime_t(tsk, &utime, &stime);
   stats->ac_utime = cputime_to_usecs(utime);
   stats->ac_stime = cputime_to_usecs(stime);
-  task_cputime_scaled(tsk, &utimescaled, &stimescaled);
+  task_cputime_t_scaled(tsk, &utimescaled, &stimescaled);
   stats->ac_utimescaled = cputime_to_usecs(utimescaled);
   stats->ac_stimescaled = cputime_to_usecs(stimescaled);
   stats->ac_minflt = tsk->min_flt;
   stats->ac_majflt = tsk->maj_flt;
   strncpy(stats->ac_comm, tsk->comm, sizeof(stats->ac_comm));
 }<sep>@@
expression e1,e2,e3;
@@
-       task_cputime
+       task_cputime_t
		(e1,e2,e3)

@@
expression e1,e2,e3;
@@
-       task_cputime_scaled
+       task_cputime_t_scaled
		(e1,e2,e3)
--- initial
+++ final
@@ -1,7 +1,7 @@
 static struct rq *__migrate_task(struct rq *rq, struct task_struct *p, int dest_cpu) {
   if (unlikely(!cpu_active(dest_cpu))) return rq;
   /* Affinity changed (again). */
-  if (!cpumask_test_cpu(dest_cpu, tsk_cpus_allowed(p))) return rq;
+  if (!cpumask_test_cpu(dest_cpu, &p->cpus_allowed)) return rq;
   rq = move_queued_task(rq, p, dest_cpu);
   return rq;
 }<sep>@@
expression current;
@@
-       tsk_cpus_allowed(current)
+       &current->cpus_allowed
--- initial
+++ final
@@ -1,22 +1,22 @@
 int migrate_swap(struct task_struct *cur, struct task_struct *p) {
   struct migration_swap_arg arg;
   int ret = -EINVAL;
   arg = (struct migration_swap_arg){
       .src_task = cur,
       .src_cpu = task_cpu(cur),
       .dst_task = p,
       .dst_cpu = task_cpu(p),
   };
   if (arg.src_cpu == arg.dst_cpu) goto out;
   /*
    * These three tests are all lockless; this is OK since all of them
    * will be re-checked with proper locks held further down the line.
    */
   if (!cpu_active(arg.src_cpu) || !cpu_active(arg.dst_cpu)) goto out;
-  if (!cpumask_test_cpu(arg.dst_cpu, tsk_cpus_allowed(arg.src_task))) goto out;
-  if (!cpumask_test_cpu(arg.src_cpu, tsk_cpus_allowed(arg.dst_task))) goto out;
+  if (!cpumask_test_cpu(arg.dst_cpu, &arg.src_task->cpus_allowed)) goto out;
+  if (!cpumask_test_cpu(arg.src_cpu, &arg.dst_task->cpus_allowed)) goto out;
   trace_sched_swap_numa(cur, arg.src_cpu, p, arg.dst_cpu);
   ret = stop_two_cpus(arg.dst_cpu, arg.src_cpu, migrate_swap_stop, &arg);
 out:
   return ret;
 }<sep>@@
expression current;
@@
-       tsk_cpus_allowed(current)
+       &current->cpus_allowed
--- initial
+++ final
@@ -1,22 +1,22 @@
 static int migrate_swap_stop(void *data) {
   struct migration_swap_arg *arg = data;
   struct rq *src_rq, *dst_rq;
   int ret = -EAGAIN;
   if (!cpu_active(arg->src_cpu) || !cpu_active(arg->dst_cpu)) return -EAGAIN;
   src_rq = cpu_rq(arg->src_cpu);
   dst_rq = cpu_rq(arg->dst_cpu);
   double_raw_lock(&arg->src_task->pi_lock, &arg->dst_task->pi_lock);
   double_rq_lock(src_rq, dst_rq);
   if (task_cpu(arg->dst_task) != arg->dst_cpu) goto unlock;
   if (task_cpu(arg->src_task) != arg->src_cpu) goto unlock;
-  if (!cpumask_test_cpu(arg->dst_cpu, tsk_cpus_allowed(arg->src_task))) goto unlock;
-  if (!cpumask_test_cpu(arg->src_cpu, tsk_cpus_allowed(arg->dst_task))) goto unlock;
+  if (!cpumask_test_cpu(arg->dst_cpu, &arg->src_task->cpus_allowed)) goto unlock;
+  if (!cpumask_test_cpu(arg->src_cpu, &arg->dst_task->cpus_allowed)) goto unlock;
   __migrate_swap_task(arg->src_task, arg->dst_cpu);
   __migrate_swap_task(arg->dst_task, arg->src_cpu);
   ret = 0;
 unlock:
   double_rq_unlock(src_rq, dst_rq);
   raw_spin_unlock(&arg->dst_task->pi_lock);
   raw_spin_unlock(&arg->src_task->pi_lock);
   return ret;
 }<sep>@@
expression current;
@@
-       tsk_cpus_allowed(current)
+       &current->cpus_allowed
--- initial
+++ final
@@ -1,9 +1,9 @@
 int migrate_task_to(struct task_struct *p, int target_cpu) {
   struct migration_arg arg = {p, target_cpu};
   int curr_cpu = task_cpu(p);
   if (curr_cpu == target_cpu) return 0;
-  if (!cpumask_test_cpu(target_cpu, tsk_cpus_allowed(p))) return -EINVAL;
+  if (!cpumask_test_cpu(target_cpu, &p->cpus_allowed)) return -EINVAL;
   /* TODO: This is not properly updating schedstats */
   trace_sched_move_numa(p, curr_cpu, target_cpu);
   return stop_one_cpu(curr_cpu, migration_cpu_stop, &arg);
 }<sep>@@
expression current;
@@
-       tsk_cpus_allowed(current)
+       &current->cpus_allowed
--- initial
+++ final
@@ -1,52 +1,52 @@
 static int select_fallback_rq(int cpu, struct task_struct *p) {
   int nid = cpu_to_node(cpu);
   const struct cpumask *nodemask = NULL;
   enum { cpuset, possible, fail } state = cpuset;
   int dest_cpu;
   /*
    * If the node that the CPU is on has been offlined, cpu_to_node()
    * will return -1. There is no CPU on the node, and we should
    * select the CPU on the other node.
    */
   if (nid != -1) {
     nodemask = cpumask_of_node(nid);
     /* Look for allowed, online CPU in same node. */
     for_each_cpu(dest_cpu, nodemask) {
       if (!cpu_active(dest_cpu)) continue;
-      if (cpumask_test_cpu(dest_cpu, tsk_cpus_allowed(p))) return dest_cpu;
+      if (cpumask_test_cpu(dest_cpu, &p->cpus_allowed)) return dest_cpu;
     }
   }
   for (;;) {
     /* Any allowed, online CPU? */
-    for_each_cpu(dest_cpu, tsk_cpus_allowed(p)) {
+    for_each_cpu(dest_cpu, &p->cpus_allowed) {
       if (!(p->flags & PF_KTHREAD) && !cpu_active(dest_cpu)) continue;
       if (!cpu_online(dest_cpu)) continue;
       goto out;
     }
     /* No more Mr. Nice Guy. */
     switch (state) {
     case cpuset:
       if (IS_ENABLED(CONFIG_CPUSETS)) {
         cpuset_cpus_allowed_fallback(p);
         state = possible;
         break;
       }
       /* Fall-through */
     case possible:
       do_set_cpus_allowed(p, cpu_possible_mask);
       state = fail;
       break;
     case fail: BUG(); break;
     }
   }
 out:
   if (state != cpuset) {
     /*
      * Don't tell them about moving exiting tasks or
      * kernel threads (both mm NULL), since they never
      * leave kernel.
      */
     if (p->mm && printk_ratelimit()) { printk_deferred("process %d (%s) no longer affine to cpu%d\n", task_pid_nr(p), p->comm, cpu); }
   }
   return dest_cpu;
 }<sep>@@
expression current;
@@
-       tsk_cpus_allowed(current)
+       &current->cpus_allowed
--- initial
+++ final
@@ -1,19 +1,19 @@
 static inline int select_task_rq(struct task_struct *p, int cpu, int sd_flags, int wake_flags) {
   lockdep_assert_held(&p->pi_lock);
   if (tsk_nr_cpus_allowed(p) > 1)
     cpu = p->sched_class->select_task_rq(p, cpu, sd_flags, wake_flags);
   else
-    cpu = cpumask_any(tsk_cpus_allowed(p));
+    cpu = cpumask_any(&p->cpus_allowed);
   /*
    * In order not to call set_task_cpu() on a blocking task we need
    * to rely on ttwu() to place the task on a valid ->cpus_allowed
    * CPU.
    *
    * Since this is common to all placement strategies, this lives here.
    *
    * [ this allows ->select_task() to simply return task_cpu(p) and
    *   not worry about this generic constraint ]
    */
-  if (unlikely(!cpumask_test_cpu(cpu, tsk_cpus_allowed(p)) || !cpu_online(cpu))) cpu = select_fallback_rq(task_cpu(p), p);
+  if (unlikely(!cpumask_test_cpu(cpu, &p->cpus_allowed) || !cpu_online(cpu))) cpu = select_fallback_rq(task_cpu(p), p);
   return cpu;
 }<sep>@@
expression current;
@@
-       tsk_cpus_allowed(current)
+       &current->cpus_allowed
--- initial
+++ final
@@ -1,14 +1,14 @@
 int cpudl_find(struct cpudl *cp, struct task_struct *p, struct cpumask *later_mask) {
   int best_cpu = -1;
   const struct sched_dl_entity *dl_se = &p->dl;
-  if (later_mask && cpumask_and(later_mask, cp->free_cpus, tsk_cpus_allowed(p))) {
+  if (later_mask && cpumask_and(later_mask, cp->free_cpus, &p->cpus_allowed)) {
     best_cpu = cpumask_any(later_mask);
     goto out;
-  } else if (cpumask_test_cpu(cpudl_maximum(cp), tsk_cpus_allowed(p)) && dl_time_before(dl_se->deadline, cp->elements[0].dl)) {
+  } else if (cpumask_test_cpu(cpudl_maximum(cp), &p->cpus_allowed) && dl_time_before(dl_se->deadline, cp->elements[0].dl)) {
     best_cpu = cpudl_maximum(cp);
     if (later_mask) cpumask_set_cpu(best_cpu, later_mask);
   }
 out:
   WARN_ON(best_cpu != -1 && !cpu_present(best_cpu));
   return best_cpu;
 }<sep>@@
expression current;
@@
-       tsk_cpus_allowed(current)
+       &current->cpus_allowed