cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

kthread.c (4382B)

      1// SPDX-License-Identifier: GPL-2.0-or-later
      2/*
      3 * eCryptfs: Linux filesystem encryption layer
      4 *
      5 * Copyright (C) 2008 International Business Machines Corp.
      6 *   Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
      7 */
      8
      9#include <linux/kthread.h>
     10#include <linux/freezer.h>
     11#include <linux/slab.h>
     12#include <linux/wait.h>
     13#include <linux/mount.h>
     14#include "ecryptfs_kernel.h"
     15
     16struct ecryptfs_open_req {
     17	struct file **lower_file;
     18	struct path path;
     19	struct completion done;
     20	struct list_head kthread_ctl_list;
     21};
     22
     23static struct ecryptfs_kthread_ctl {
     24#define ECRYPTFS_KTHREAD_ZOMBIE 0x00000001
     25	u32 flags;
     26	struct mutex mux;
     27	struct list_head req_list;
     28	wait_queue_head_t wait;
     29} ecryptfs_kthread_ctl;
     30
     31static struct task_struct *ecryptfs_kthread;
     32
     33/**
     34 * ecryptfs_threadfn
     35 * @ignored: ignored
     36 *
     37 * The eCryptfs kernel thread that has the responsibility of getting
     38 * the lower file with RW permissions.
     39 *
     40 * Returns zero on success; non-zero otherwise
     41 */
     42static int ecryptfs_threadfn(void *ignored)
     43{
     44	set_freezable();
     45	while (1)  {
     46		struct ecryptfs_open_req *req;
     47
     48		wait_event_freezable(
     49			ecryptfs_kthread_ctl.wait,
     50			(!list_empty(&ecryptfs_kthread_ctl.req_list)
     51			 || kthread_should_stop()));
     52		mutex_lock(&ecryptfs_kthread_ctl.mux);
     53		if (ecryptfs_kthread_ctl.flags & ECRYPTFS_KTHREAD_ZOMBIE) {
     54			mutex_unlock(&ecryptfs_kthread_ctl.mux);
     55			goto out;
     56		}
     57		while (!list_empty(&ecryptfs_kthread_ctl.req_list)) {
     58			req = list_first_entry(&ecryptfs_kthread_ctl.req_list,
     59					       struct ecryptfs_open_req,
     60					       kthread_ctl_list);
     61			list_del(&req->kthread_ctl_list);
     62			*req->lower_file = dentry_open(&req->path,
     63				(O_RDWR | O_LARGEFILE), current_cred());
     64			complete(&req->done);
     65		}
     66		mutex_unlock(&ecryptfs_kthread_ctl.mux);
     67	}
     68out:
     69	return 0;
     70}
     71
     72int __init ecryptfs_init_kthread(void)
     73{
     74	int rc = 0;
     75
     76	mutex_init(&ecryptfs_kthread_ctl.mux);
     77	init_waitqueue_head(&ecryptfs_kthread_ctl.wait);
     78	INIT_LIST_HEAD(&ecryptfs_kthread_ctl.req_list);
     79	ecryptfs_kthread = kthread_run(&ecryptfs_threadfn, NULL,
     80				       "ecryptfs-kthread");
     81	if (IS_ERR(ecryptfs_kthread)) {
     82		rc = PTR_ERR(ecryptfs_kthread);
     83		printk(KERN_ERR "%s: Failed to create kernel thread; rc = [%d]"
     84		       "\n", __func__, rc);
     85	}
     86	return rc;
     87}
     88
     89void ecryptfs_destroy_kthread(void)
     90{
     91	struct ecryptfs_open_req *req, *tmp;
     92
     93	mutex_lock(&ecryptfs_kthread_ctl.mux);
     94	ecryptfs_kthread_ctl.flags |= ECRYPTFS_KTHREAD_ZOMBIE;
     95	list_for_each_entry_safe(req, tmp, &ecryptfs_kthread_ctl.req_list,
     96				 kthread_ctl_list) {
     97		list_del(&req->kthread_ctl_list);
     98		*req->lower_file = ERR_PTR(-EIO);
     99		complete(&req->done);
    100	}
    101	mutex_unlock(&ecryptfs_kthread_ctl.mux);
    102	kthread_stop(ecryptfs_kthread);
    103	wake_up(&ecryptfs_kthread_ctl.wait);
    104}
    105
    106/**
    107 * ecryptfs_privileged_open
    108 * @lower_file: Result of dentry_open by root on lower dentry
    109 * @lower_dentry: Lower dentry for file to open
    110 * @lower_mnt: Lower vfsmount for file to open
    111 * @cred: credential to use for this call
    112 *
    113 * This function gets a r/w file opened against the lower dentry.
    114 *
    115 * Returns zero on success; non-zero otherwise
    116 */
    117int ecryptfs_privileged_open(struct file **lower_file,
    118			     struct dentry *lower_dentry,
    119			     struct vfsmount *lower_mnt,
    120			     const struct cred *cred)
    121{
    122	struct ecryptfs_open_req req;
    123	int flags = O_LARGEFILE;
    124	int rc = 0;
    125
    126	init_completion(&req.done);
    127	req.lower_file = lower_file;
    128	req.path.dentry = lower_dentry;
    129	req.path.mnt = lower_mnt;
    130
    131	/* Corresponding dput() and mntput() are done when the
    132	 * lower file is fput() when all eCryptfs files for the inode are
    133	 * released. */
    134	flags |= IS_RDONLY(d_inode(lower_dentry)) ? O_RDONLY : O_RDWR;
    135	(*lower_file) = dentry_open(&req.path, flags, cred);
    136	if (!IS_ERR(*lower_file))
    137		goto out;
    138	if ((flags & O_ACCMODE) == O_RDONLY) {
    139		rc = PTR_ERR((*lower_file));
    140		goto out;
    141	}
    142	mutex_lock(&ecryptfs_kthread_ctl.mux);
    143	if (ecryptfs_kthread_ctl.flags & ECRYPTFS_KTHREAD_ZOMBIE) {
    144		rc = -EIO;
    145		mutex_unlock(&ecryptfs_kthread_ctl.mux);
    146		printk(KERN_ERR "%s: We are in the middle of shutting down; "
    147		       "aborting privileged request to open lower file\n",
    148			__func__);
    149		goto out;
    150	}
    151	list_add_tail(&req.kthread_ctl_list, &ecryptfs_kthread_ctl.req_list);
    152	mutex_unlock(&ecryptfs_kthread_ctl.mux);
    153	wake_up(&ecryptfs_kthread_ctl.wait);
    154	wait_for_completion(&req.done);
    155	if (IS_ERR(*lower_file))
    156		rc = PTR_ERR(*lower_file);
    157out:
    158	return rc;
    159}