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 16 struct 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 23 static 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 31 static 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 */ 42 static 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 } 68 out: 69 return 0; 70 } 71 72 int __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 89 void 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 */ 117 int 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); 157 out: 158 return rc; 159 } 160