linux-imx

// SPDX-License-Identifier: GPL-2.0

#include <linux/kernel.h>

#include <linux/syscalls.h>

#include <linux/fdtable.h>

#include <linux/string.h>

#include <linux/random.h>

#include <linux/module.h>

#include <linux/ptrace.h>

#include <linux/init.h>

#include <linux/errno.h>

#include <linux/cache.h>

#include <linux/bug.h>

#include <linux/err.h>

#include <linux/kcmp.h>

#include <linux/capability.h>

#include <linux/list.h>

#include <linux/eventpoll.h>

#include <linux/file.h>

​

#include <asm/unistd.h>

​

/*

 * We don't expose the real in-memory order of objects for security reasons.

 * But still the comparison results should be suitable for sorting. So we

 * obfuscate kernel pointers values and compare the production instead.

 *

 * The obfuscation is done in two steps. First we xor the kernel pointer with

 * a random value, which puts pointer into a new position in a reordered space.

 * Secondly we multiply the xor production with a large odd random number to

 * permute its bits even more (the odd multiplier guarantees that the product

 * is unique ever after the high bits are truncated, since any odd number is

 * relative prime to 2^n).

 *

 * Note also that the obfuscation itself is invisible to userspace and if needed

 * it can be changed to an alternate scheme.

 */

static unsigned long cookies[KCMP_TYPES][2] __read_mostly;

​

static long kptr_obfuscate(long v, int type)

{

    return (v ^ cookies[type][0]) * cookies[type][1];

}

​

/*

 * 0 - equal, i.e. v1 = v2

 * 1 - less than, i.e. v1 < v2

 * 2 - greater than, i.e. v1 > v2

 * 3 - not equal but ordering unavailable (reserved for future)

 */

static int kcmp_ptr(void *v1, void *v2, enum kcmp_type type)

{

    long t1, t2;

​

    t1 = kptr_obfuscate((long)v1, type);

    t2 = kptr_obfuscate((long)v2, type);

​

    return (t1 < t2) | ((t1 > t2) << 1);

}

​

/* The caller must have pinned the task */

static struct file *

get_file_raw_ptr(struct task_struct *task, unsigned int idx)

{

    struct file *file = NULL;

​

    task_lock(task);

    rcu_read_lock();

​

    if (task->files)

        file = fcheck_files(task->files, idx);

​

    rcu_read_unlock();

    task_unlock(task);

​

    return file;

}

​

static void kcmp_unlock(struct mutex *m1, struct mutex *m2)

{

    if (likely(m2 != m1))

        mutex_unlock(m2);

    mutex_unlock(m1);

}

​

static int kcmp_lock(struct mutex *m1, struct mutex *m2)

{

    int err;

​

    if (m2 > m1)

        swap(m1, m2);

​

    err = mutex_lock_killable(m1);