1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#include <linux/sched.h>
23#include <linux/slab.h>
24#include <linux/user_namespace.h>
25#include <linux/nsproxy.h>
26#include "ecryptfs_kernel.h"
27
28static LIST_HEAD(ecryptfs_msg_ctx_free_list);
29static LIST_HEAD(ecryptfs_msg_ctx_alloc_list);
30static struct mutex ecryptfs_msg_ctx_lists_mux;
31
32static struct hlist_head *ecryptfs_daemon_hash;
33struct mutex ecryptfs_daemon_hash_mux;
34static int ecryptfs_hash_bits;
35#define ecryptfs_current_euid_hash(uid) \
36 hash_long((unsigned long)from_kuid(&init_user_ns, current_euid()), ecryptfs_hash_bits)
37
38static u32 ecryptfs_msg_counter;
39static struct ecryptfs_msg_ctx *ecryptfs_msg_ctx_arr;
40
41
42
43
44
45
46
47
48
49
50
51static int ecryptfs_acquire_free_msg_ctx(struct ecryptfs_msg_ctx **msg_ctx)
52{
53 struct list_head *p;
54 int rc;
55
56 if (list_empty(&ecryptfs_msg_ctx_free_list)) {
57 printk(KERN_WARNING "%s: The eCryptfs free "
58 "context list is empty. It may be helpful to "
59 "specify the ecryptfs_message_buf_len "
60 "parameter to be greater than the current "
61 "value of [%d]\n", __func__, ecryptfs_message_buf_len);
62 rc = -ENOMEM;
63 goto out;
64 }
65 list_for_each(p, &ecryptfs_msg_ctx_free_list) {
66 *msg_ctx = list_entry(p, struct ecryptfs_msg_ctx, node);
67 if (mutex_trylock(&(*msg_ctx)->mux)) {
68 (*msg_ctx)->task = current;
69 rc = 0;
70 goto out;
71 }
72 }
73 rc = -ENOMEM;
74out:
75 return rc;
76}
77
78
79
80
81
82
83
84static void ecryptfs_msg_ctx_free_to_alloc(struct ecryptfs_msg_ctx *msg_ctx)
85{
86 list_move(&msg_ctx->node, &ecryptfs_msg_ctx_alloc_list);
87 msg_ctx->state = ECRYPTFS_MSG_CTX_STATE_PENDING;
88 msg_ctx->counter = ++ecryptfs_msg_counter;
89}
90
91
92
93
94
95
96
97void ecryptfs_msg_ctx_alloc_to_free(struct ecryptfs_msg_ctx *msg_ctx)
98{
99 list_move(&(msg_ctx->node), &ecryptfs_msg_ctx_free_list);
100 kfree(msg_ctx->msg);
101 msg_ctx->msg = NULL;
102 msg_ctx->state = ECRYPTFS_MSG_CTX_STATE_FREE;
103}
104
105
106
107
108
109
110
111
112
113
114
115int ecryptfs_find_daemon_by_euid(struct ecryptfs_daemon **daemon)
116{
117 int rc;
118
119 hlist_for_each_entry(*daemon,
120 &ecryptfs_daemon_hash[ecryptfs_current_euid_hash()],
121 euid_chain) {
122 if (uid_eq((*daemon)->file->f_cred->euid, current_euid())) {
123 rc = 0;
124 goto out;
125 }
126 }
127 rc = -EINVAL;
128out:
129 return rc;
130}
131
132
133
134
135
136
137
138
139
140
141
142int
143ecryptfs_spawn_daemon(struct ecryptfs_daemon **daemon, struct file *file)
144{
145 int rc = 0;
146
147 (*daemon) = kzalloc(sizeof(**daemon), GFP_KERNEL);
148 if (!(*daemon)) {
149 rc = -ENOMEM;
150 printk(KERN_ERR "%s: Failed to allocate [%zd] bytes of "
151 "GFP_KERNEL memory\n", __func__, sizeof(**daemon));
152 goto out;
153 }
154 (*daemon)->file = file;
155 mutex_init(&(*daemon)->mux);
156 INIT_LIST_HEAD(&(*daemon)->msg_ctx_out_queue);
157 init_waitqueue_head(&(*daemon)->wait);
158 (*daemon)->num_queued_msg_ctx = 0;
159 hlist_add_head(&(*daemon)->euid_chain,
160 &ecryptfs_daemon_hash[ecryptfs_current_euid_hash()]);
161out:
162 return rc;
163}
164
165
166
167
168
169
170
171int ecryptfs_exorcise_daemon(struct ecryptfs_daemon *daemon)
172{
173 struct ecryptfs_msg_ctx *msg_ctx, *msg_ctx_tmp;
174 int rc = 0;
175
176 mutex_lock(&daemon->mux);
177 if ((daemon->flags & ECRYPTFS_DAEMON_IN_READ)
178 || (daemon->flags & ECRYPTFS_DAEMON_IN_POLL)) {
179 rc = -EBUSY;
180 mutex_unlock(&daemon->mux);
181 goto out;
182 }
183 list_for_each_entry_safe(msg_ctx, msg_ctx_tmp,
184 &daemon->msg_ctx_out_queue, daemon_out_list) {
185 list_del(&msg_ctx->daemon_out_list);
186 daemon->num_queued_msg_ctx--;
187 printk(KERN_WARNING "%s: Warning: dropping message that is in "
188 "the out queue of a dying daemon\n", __func__);
189 ecryptfs_msg_ctx_alloc_to_free(msg_ctx);
190 }
191 hlist_del(&daemon->euid_chain);
192 mutex_unlock(&daemon->mux);
193 kzfree(daemon);
194out:
195 return rc;
196}
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220int ecryptfs_process_response(struct ecryptfs_daemon *daemon,
221 struct ecryptfs_message *msg, u32 seq)
222{
223 struct ecryptfs_msg_ctx *msg_ctx;
224 size_t msg_size;
225 int rc;
226
227 if (msg->index >= ecryptfs_message_buf_len) {
228 rc = -EINVAL;
229 printk(KERN_ERR "%s: Attempt to reference "
230 "context buffer at index [%d]; maximum "
231 "allowable is [%d]\n", __func__, msg->index,
232 (ecryptfs_message_buf_len - 1));
233 goto out;
234 }
235 msg_ctx = &ecryptfs_msg_ctx_arr[msg->index];
236 mutex_lock(&msg_ctx->mux);
237 if (msg_ctx->state != ECRYPTFS_MSG_CTX_STATE_PENDING) {
238 rc = -EINVAL;
239 printk(KERN_WARNING "%s: Desired context element is not "
240 "pending a response\n", __func__);
241 goto unlock;
242 } else if (msg_ctx->counter != seq) {
243 rc = -EINVAL;
244 printk(KERN_WARNING "%s: Invalid message sequence; "
245 "expected [%d]; received [%d]\n", __func__,
246 msg_ctx->counter, seq);
247 goto unlock;
248 }
249 msg_size = (sizeof(*msg) + msg->data_len);
250 msg_ctx->msg = kmalloc(msg_size, GFP_KERNEL);
251 if (!msg_ctx->msg) {
252 rc = -ENOMEM;
253 printk(KERN_ERR "%s: Failed to allocate [%zd] bytes of "
254 "GFP_KERNEL memory\n", __func__, msg_size);
255 goto unlock;
256 }
257 memcpy(msg_ctx->msg, msg, msg_size);
258 msg_ctx->state = ECRYPTFS_MSG_CTX_STATE_DONE;
259 wake_up_process(msg_ctx->task);
260 rc = 0;
261unlock:
262 mutex_unlock(&msg_ctx->mux);
263out:
264 return rc;
265}
266
267
268
269
270
271
272
273
274
275
276
277static int
278ecryptfs_send_message_locked(char *data, int data_len, u8 msg_type,
279 struct ecryptfs_msg_ctx **msg_ctx)
280{
281 struct ecryptfs_daemon *daemon;
282 int rc;
283
284 rc = ecryptfs_find_daemon_by_euid(&daemon);
285 if (rc) {
286 rc = -ENOTCONN;
287 goto out;
288 }
289 mutex_lock(&ecryptfs_msg_ctx_lists_mux);
290 rc = ecryptfs_acquire_free_msg_ctx(msg_ctx);
291 if (rc) {
292 mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
293 printk(KERN_WARNING "%s: Could not claim a free "
294 "context element\n", __func__);
295 goto out;
296 }
297 ecryptfs_msg_ctx_free_to_alloc(*msg_ctx);
298 mutex_unlock(&(*msg_ctx)->mux);
299 mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
300 rc = ecryptfs_send_miscdev(data, data_len, *msg_ctx, msg_type, 0,
301 daemon);
302 if (rc)
303 printk(KERN_ERR "%s: Error attempting to send message to "
304 "userspace daemon; rc = [%d]\n", __func__, rc);
305out:
306 return rc;
307}
308
309
310
311
312
313
314
315
316
317
318
319int ecryptfs_send_message(char *data, int data_len,
320 struct ecryptfs_msg_ctx **msg_ctx)
321{
322 int rc;
323
324 mutex_lock(&ecryptfs_daemon_hash_mux);
325 rc = ecryptfs_send_message_locked(data, data_len, ECRYPTFS_MSG_REQUEST,
326 msg_ctx);
327 mutex_unlock(&ecryptfs_daemon_hash_mux);
328 return rc;
329}
330
331
332
333
334
335
336
337
338
339
340
341
342int ecryptfs_wait_for_response(struct ecryptfs_msg_ctx *msg_ctx,
343 struct ecryptfs_message **msg)
344{
345 signed long timeout = ecryptfs_message_wait_timeout * HZ;
346 int rc = 0;
347
348sleep:
349 timeout = schedule_timeout_interruptible(timeout);
350 mutex_lock(&ecryptfs_msg_ctx_lists_mux);
351 mutex_lock(&msg_ctx->mux);
352 if (msg_ctx->state != ECRYPTFS_MSG_CTX_STATE_DONE) {
353 if (timeout) {
354 mutex_unlock(&msg_ctx->mux);
355 mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
356 goto sleep;
357 }
358 rc = -ENOMSG;
359 } else {
360 *msg = msg_ctx->msg;
361 msg_ctx->msg = NULL;
362 }
363 ecryptfs_msg_ctx_alloc_to_free(msg_ctx);
364 mutex_unlock(&msg_ctx->mux);
365 mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
366 return rc;
367}
368
369int __init ecryptfs_init_messaging(void)
370{
371 int i;
372 int rc = 0;
373
374 if (ecryptfs_number_of_users > ECRYPTFS_MAX_NUM_USERS) {
375 ecryptfs_number_of_users = ECRYPTFS_MAX_NUM_USERS;
376 printk(KERN_WARNING "%s: Specified number of users is "
377 "too large, defaulting to [%d] users\n", __func__,
378 ecryptfs_number_of_users);
379 }
380 mutex_init(&ecryptfs_daemon_hash_mux);
381 mutex_lock(&ecryptfs_daemon_hash_mux);
382 ecryptfs_hash_bits = 1;
383 while (ecryptfs_number_of_users >> ecryptfs_hash_bits)
384 ecryptfs_hash_bits++;
385 ecryptfs_daemon_hash = kmalloc((sizeof(struct hlist_head)
386 * (1 << ecryptfs_hash_bits)),
387 GFP_KERNEL);
388 if (!ecryptfs_daemon_hash) {
389 rc = -ENOMEM;
390 printk(KERN_ERR "%s: Failed to allocate memory\n", __func__);
391 mutex_unlock(&ecryptfs_daemon_hash_mux);
392 goto out;
393 }
394 for (i = 0; i < (1 << ecryptfs_hash_bits); i++)
395 INIT_HLIST_HEAD(&ecryptfs_daemon_hash[i]);
396 mutex_unlock(&ecryptfs_daemon_hash_mux);
397 ecryptfs_msg_ctx_arr = kmalloc((sizeof(struct ecryptfs_msg_ctx)
398 * ecryptfs_message_buf_len),
399 GFP_KERNEL);
400 if (!ecryptfs_msg_ctx_arr) {
401 rc = -ENOMEM;
402 printk(KERN_ERR "%s: Failed to allocate memory\n", __func__);
403 goto out;
404 }
405 mutex_init(&ecryptfs_msg_ctx_lists_mux);
406 mutex_lock(&ecryptfs_msg_ctx_lists_mux);
407 ecryptfs_msg_counter = 0;
408 for (i = 0; i < ecryptfs_message_buf_len; i++) {
409 INIT_LIST_HEAD(&ecryptfs_msg_ctx_arr[i].node);
410 INIT_LIST_HEAD(&ecryptfs_msg_ctx_arr[i].daemon_out_list);
411 mutex_init(&ecryptfs_msg_ctx_arr[i].mux);
412 mutex_lock(&ecryptfs_msg_ctx_arr[i].mux);
413 ecryptfs_msg_ctx_arr[i].index = i;
414 ecryptfs_msg_ctx_arr[i].state = ECRYPTFS_MSG_CTX_STATE_FREE;
415 ecryptfs_msg_ctx_arr[i].counter = 0;
416 ecryptfs_msg_ctx_arr[i].task = NULL;
417 ecryptfs_msg_ctx_arr[i].msg = NULL;
418 list_add_tail(&ecryptfs_msg_ctx_arr[i].node,
419 &ecryptfs_msg_ctx_free_list);
420 mutex_unlock(&ecryptfs_msg_ctx_arr[i].mux);
421 }
422 mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
423 rc = ecryptfs_init_ecryptfs_miscdev();
424 if (rc)
425 ecryptfs_release_messaging();
426out:
427 return rc;
428}
429
430void ecryptfs_release_messaging(void)
431{
432 if (ecryptfs_msg_ctx_arr) {
433 int i;
434
435 mutex_lock(&ecryptfs_msg_ctx_lists_mux);
436 for (i = 0; i < ecryptfs_message_buf_len; i++) {
437 mutex_lock(&ecryptfs_msg_ctx_arr[i].mux);
438 if (ecryptfs_msg_ctx_arr[i].msg)
439 kfree(ecryptfs_msg_ctx_arr[i].msg);
440 mutex_unlock(&ecryptfs_msg_ctx_arr[i].mux);
441 }
442 kfree(ecryptfs_msg_ctx_arr);
443 mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
444 }
445 if (ecryptfs_daemon_hash) {
446 struct ecryptfs_daemon *daemon;
447 int i;
448
449 mutex_lock(&ecryptfs_daemon_hash_mux);
450 for (i = 0; i < (1 << ecryptfs_hash_bits); i++) {
451 int rc;
452
453 hlist_for_each_entry(daemon,
454 &ecryptfs_daemon_hash[i],
455 euid_chain) {
456 rc = ecryptfs_exorcise_daemon(daemon);
457 if (rc)
458 printk(KERN_ERR "%s: Error whilst "
459 "attempting to destroy daemon; "
460 "rc = [%d]. Dazed and confused, "
461 "but trying to continue.\n",
462 __func__, rc);
463 }
464 }
465 kfree(ecryptfs_daemon_hash);
466 mutex_unlock(&ecryptfs_daemon_hash_mux);
467 }
468 ecryptfs_destroy_ecryptfs_miscdev();
469 return;
470}
471