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}
160