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