forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
229 lines
4.8 KiB
229 lines
4.8 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
|
|
#include <linux/prctl.h> |
|
#include "sched.h" |
|
|
|
/* |
|
* A simple wrapper around refcount. An allocated sched_core_cookie's |
|
* address is used to compute the cookie of the task. |
|
*/ |
|
struct sched_core_cookie { |
|
refcount_t refcnt; |
|
}; |
|
|
|
unsigned long sched_core_alloc_cookie(void) |
|
{ |
|
struct sched_core_cookie *ck = kmalloc(sizeof(*ck), GFP_KERNEL); |
|
if (!ck) |
|
return 0; |
|
|
|
refcount_set(&ck->refcnt, 1); |
|
sched_core_get(); |
|
|
|
return (unsigned long)ck; |
|
} |
|
|
|
void sched_core_put_cookie(unsigned long cookie) |
|
{ |
|
struct sched_core_cookie *ptr = (void *)cookie; |
|
|
|
if (ptr && refcount_dec_and_test(&ptr->refcnt)) { |
|
kfree(ptr); |
|
sched_core_put(); |
|
} |
|
} |
|
|
|
unsigned long sched_core_get_cookie(unsigned long cookie) |
|
{ |
|
struct sched_core_cookie *ptr = (void *)cookie; |
|
|
|
if (ptr) |
|
refcount_inc(&ptr->refcnt); |
|
|
|
return cookie; |
|
} |
|
|
|
/* |
|
* sched_core_update_cookie - replace the cookie on a task |
|
* @p: the task to update |
|
* @cookie: the new cookie |
|
* |
|
* Effectively exchange the task cookie; caller is responsible for lifetimes on |
|
* both ends. |
|
* |
|
* Returns: the old cookie |
|
*/ |
|
unsigned long sched_core_update_cookie(struct task_struct *p, unsigned long cookie) |
|
{ |
|
unsigned long old_cookie; |
|
struct rq_flags rf; |
|
struct rq *rq; |
|
bool enqueued; |
|
|
|
rq = task_rq_lock(p, &rf); |
|
|
|
/* |
|
* Since creating a cookie implies sched_core_get(), and we cannot set |
|
* a cookie until after we've created it, similarly, we cannot destroy |
|
* a cookie until after we've removed it, we must have core scheduling |
|
* enabled here. |
|
*/ |
|
SCHED_WARN_ON((p->core_cookie || cookie) && !sched_core_enabled(rq)); |
|
|
|
enqueued = sched_core_enqueued(p); |
|
if (enqueued) |
|
sched_core_dequeue(rq, p); |
|
|
|
old_cookie = p->core_cookie; |
|
p->core_cookie = cookie; |
|
|
|
if (enqueued) |
|
sched_core_enqueue(rq, p); |
|
|
|
/* |
|
* If task is currently running, it may not be compatible anymore after |
|
* the cookie change, so enter the scheduler on its CPU to schedule it |
|
* away. |
|
*/ |
|
if (task_running(rq, p)) |
|
resched_curr(rq); |
|
|
|
task_rq_unlock(rq, p, &rf); |
|
|
|
return old_cookie; |
|
} |
|
|
|
static unsigned long sched_core_clone_cookie(struct task_struct *p) |
|
{ |
|
unsigned long cookie, flags; |
|
|
|
raw_spin_lock_irqsave(&p->pi_lock, flags); |
|
cookie = sched_core_get_cookie(p->core_cookie); |
|
raw_spin_unlock_irqrestore(&p->pi_lock, flags); |
|
|
|
return cookie; |
|
} |
|
|
|
void sched_core_fork(struct task_struct *p) |
|
{ |
|
RB_CLEAR_NODE(&p->core_node); |
|
p->core_cookie = sched_core_clone_cookie(current); |
|
} |
|
|
|
void sched_core_free(struct task_struct *p) |
|
{ |
|
sched_core_put_cookie(p->core_cookie); |
|
} |
|
|
|
static void __sched_core_set(struct task_struct *p, unsigned long cookie) |
|
{ |
|
cookie = sched_core_get_cookie(cookie); |
|
cookie = sched_core_update_cookie(p, cookie); |
|
sched_core_put_cookie(cookie); |
|
} |
|
|
|
/* Called from prctl interface: PR_SCHED_CORE */ |
|
int sched_core_share_pid(unsigned int cmd, pid_t pid, enum pid_type type, |
|
unsigned long uaddr) |
|
{ |
|
unsigned long cookie = 0, id = 0; |
|
struct task_struct *task, *p; |
|
struct pid *grp; |
|
int err = 0; |
|
|
|
if (!static_branch_likely(&sched_smt_present)) |
|
return -ENODEV; |
|
|
|
if (type > PIDTYPE_PGID || cmd >= PR_SCHED_CORE_MAX || pid < 0 || |
|
(cmd != PR_SCHED_CORE_GET && uaddr)) |
|
return -EINVAL; |
|
|
|
rcu_read_lock(); |
|
if (pid == 0) { |
|
task = current; |
|
} else { |
|
task = find_task_by_vpid(pid); |
|
if (!task) { |
|
rcu_read_unlock(); |
|
return -ESRCH; |
|
} |
|
} |
|
get_task_struct(task); |
|
rcu_read_unlock(); |
|
|
|
/* |
|
* Check if this process has the right to modify the specified |
|
* process. Use the regular "ptrace_may_access()" checks. |
|
*/ |
|
if (!ptrace_may_access(task, PTRACE_MODE_READ_REALCREDS)) { |
|
err = -EPERM; |
|
goto out; |
|
} |
|
|
|
switch (cmd) { |
|
case PR_SCHED_CORE_GET: |
|
if (type != PIDTYPE_PID || uaddr & 7) { |
|
err = -EINVAL; |
|
goto out; |
|
} |
|
cookie = sched_core_clone_cookie(task); |
|
if (cookie) { |
|
/* XXX improve ? */ |
|
ptr_to_hashval((void *)cookie, &id); |
|
} |
|
err = put_user(id, (u64 __user *)uaddr); |
|
goto out; |
|
|
|
case PR_SCHED_CORE_CREATE: |
|
cookie = sched_core_alloc_cookie(); |
|
if (!cookie) { |
|
err = -ENOMEM; |
|
goto out; |
|
} |
|
break; |
|
|
|
case PR_SCHED_CORE_SHARE_TO: |
|
cookie = sched_core_clone_cookie(current); |
|
break; |
|
|
|
case PR_SCHED_CORE_SHARE_FROM: |
|
if (type != PIDTYPE_PID) { |
|
err = -EINVAL; |
|
goto out; |
|
} |
|
cookie = sched_core_clone_cookie(task); |
|
__sched_core_set(current, cookie); |
|
goto out; |
|
|
|
default: |
|
err = -EINVAL; |
|
goto out; |
|
}; |
|
|
|
if (type == PIDTYPE_PID) { |
|
__sched_core_set(task, cookie); |
|
goto out; |
|
} |
|
|
|
read_lock(&tasklist_lock); |
|
grp = task_pid_type(task, type); |
|
|
|
do_each_pid_thread(grp, type, p) { |
|
if (!ptrace_may_access(p, PTRACE_MODE_READ_REALCREDS)) { |
|
err = -EPERM; |
|
goto out_tasklist; |
|
} |
|
} while_each_pid_thread(grp, type, p); |
|
|
|
do_each_pid_thread(grp, type, p) { |
|
__sched_core_set(p, cookie); |
|
} while_each_pid_thread(grp, type, p); |
|
out_tasklist: |
|
read_unlock(&tasklist_lock); |
|
|
|
out: |
|
sched_core_put_cookie(cookie); |
|
put_task_struct(task); |
|
return err; |
|
} |
|
|
|
|