Merge master.kernel.org:/pub/scm/linux/kernel/git/lethal/sh-2.6
[linux-2.6] / fs / ecryptfs / messaging.c
1 /**
2  * eCryptfs: Linux filesystem encryption layer
3  *
4  * Copyright (C) 2004-2006 International Business Machines Corp.
5  *   Author(s): Michael A. Halcrow <mhalcrow@us.ibm.com>
6  *              Tyler Hicks <tyhicks@ou.edu>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License version
10  * 2 as published by the Free Software Foundation.
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 "ecryptfs_kernel.h"
24
25 static LIST_HEAD(ecryptfs_msg_ctx_free_list);
26 static LIST_HEAD(ecryptfs_msg_ctx_alloc_list);
27 static struct mutex ecryptfs_msg_ctx_lists_mux;
28
29 static struct hlist_head *ecryptfs_daemon_id_hash;
30 static struct mutex ecryptfs_daemon_id_hash_mux;
31 static int ecryptfs_hash_buckets;
32 #define ecryptfs_uid_hash(uid) \
33         hash_long((unsigned long)uid, ecryptfs_hash_buckets)
34
35 static unsigned int ecryptfs_msg_counter;
36 static struct ecryptfs_msg_ctx *ecryptfs_msg_ctx_arr;
37
38 /**
39  * ecryptfs_acquire_free_msg_ctx
40  * @msg_ctx: The context that was acquired from the free list
41  *
42  * Acquires a context element from the free list and locks the mutex
43  * on the context.  Returns zero on success; non-zero on error or upon
44  * failure to acquire a free context element.  Be sure to lock the
45  * list mutex before calling.
46  */
47 static int ecryptfs_acquire_free_msg_ctx(struct ecryptfs_msg_ctx **msg_ctx)
48 {
49         struct list_head *p;
50         int rc;
51
52         if (list_empty(&ecryptfs_msg_ctx_free_list)) {
53                 ecryptfs_printk(KERN_WARNING, "The eCryptfs free "
54                                 "context list is empty.  It may be helpful to "
55                                 "specify the ecryptfs_message_buf_len "
56                                 "parameter to be greater than the current "
57                                 "value of [%d]\n", ecryptfs_message_buf_len);
58                 rc = -ENOMEM;
59                 goto out;
60         }
61         list_for_each(p, &ecryptfs_msg_ctx_free_list) {
62                 *msg_ctx = list_entry(p, struct ecryptfs_msg_ctx, node);
63                 if (mutex_trylock(&(*msg_ctx)->mux)) {
64                         (*msg_ctx)->task = current;
65                         rc = 0;
66                         goto out;
67                 }
68         }
69         rc = -ENOMEM;
70 out:
71         return rc;
72 }
73
74 /**
75  * ecryptfs_msg_ctx_free_to_alloc
76  * @msg_ctx: The context to move from the free list to the alloc list
77  *
78  * Be sure to lock the list mutex and the context mutex before
79  * calling.
80  */
81 static void ecryptfs_msg_ctx_free_to_alloc(struct ecryptfs_msg_ctx *msg_ctx)
82 {
83         list_move(&msg_ctx->node, &ecryptfs_msg_ctx_alloc_list);
84         msg_ctx->state = ECRYPTFS_MSG_CTX_STATE_PENDING;
85         msg_ctx->counter = ++ecryptfs_msg_counter;
86 }
87
88 /**
89  * ecryptfs_msg_ctx_alloc_to_free
90  * @msg_ctx: The context to move from the alloc list to the free list
91  *
92  * Be sure to lock the list mutex and the context mutex before
93  * calling.
94  */
95 static void ecryptfs_msg_ctx_alloc_to_free(struct ecryptfs_msg_ctx *msg_ctx)
96 {
97         list_move(&(msg_ctx->node), &ecryptfs_msg_ctx_free_list);
98         if (msg_ctx->msg)
99                 kfree(msg_ctx->msg);
100         msg_ctx->state = ECRYPTFS_MSG_CTX_STATE_FREE;
101 }
102
103 /**
104  * ecryptfs_find_daemon_id
105  * @uid: The user id which maps to the desired daemon id
106  * @id: If return value is zero, points to the desired daemon id
107  *      pointer
108  *
109  * Search the hash list for the given user id.  Returns zero if the
110  * user id exists in the list; non-zero otherwise.  The daemon id hash
111  * mutex should be held before calling this function.
112  */
113 static int ecryptfs_find_daemon_id(uid_t uid, struct ecryptfs_daemon_id **id)
114 {
115         struct hlist_node *elem;
116         int rc;
117
118         hlist_for_each_entry(*id, elem,
119                              &ecryptfs_daemon_id_hash[ecryptfs_uid_hash(uid)],
120                              id_chain) {
121                 if ((*id)->uid == uid) {
122                         rc = 0;
123                         goto out;
124                 }
125         }
126         rc = -EINVAL;
127 out:
128         return rc;
129 }
130
131 static int ecryptfs_send_raw_message(unsigned int transport, u16 msg_type,
132                                      pid_t pid)
133 {
134         int rc;
135
136         switch(transport) {
137         case ECRYPTFS_TRANSPORT_NETLINK:
138                 rc = ecryptfs_send_netlink(NULL, 0, NULL, msg_type, 0, pid);
139                 break;
140         case ECRYPTFS_TRANSPORT_CONNECTOR:
141         case ECRYPTFS_TRANSPORT_RELAYFS:
142         default:
143                 rc = -ENOSYS;
144         }
145         return rc;
146 }
147
148 /**
149  * ecryptfs_process_helo
150  * @transport: The underlying transport (netlink, etc.)
151  * @uid: The user ID owner of the message
152  * @pid: The process ID for the userspace program that sent the
153  *       message
154  *
155  * Adds the uid and pid values to the daemon id hash.  If a uid
156  * already has a daemon pid registered, the daemon will be
157  * unregistered before the new daemon id is put into the hash list.
158  * Returns zero after adding a new daemon id to the hash list;
159  * non-zero otherwise.
160  */
161 int ecryptfs_process_helo(unsigned int transport, uid_t uid, pid_t pid)
162 {
163         struct ecryptfs_daemon_id *new_id;
164         struct ecryptfs_daemon_id *old_id;
165         int rc;
166
167         mutex_lock(&ecryptfs_daemon_id_hash_mux);
168         new_id = kmalloc(sizeof(*new_id), GFP_KERNEL);
169         if (!new_id) {
170                 rc = -ENOMEM;
171                 ecryptfs_printk(KERN_ERR, "Failed to allocate memory; unable "
172                                 "to register daemon [%d] for user [%d]\n",
173                                 pid, uid);
174                 goto unlock;
175         }
176         if (!ecryptfs_find_daemon_id(uid, &old_id)) {
177                 printk(KERN_WARNING "Received request from user [%d] "
178                        "to register daemon [%d]; unregistering daemon "
179                        "[%d]\n", uid, pid, old_id->pid);
180                 hlist_del(&old_id->id_chain);
181                 rc = ecryptfs_send_raw_message(transport, ECRYPTFS_NLMSG_QUIT,
182                                                old_id->pid);
183                 if (rc)
184                         printk(KERN_WARNING "Failed to send QUIT "
185                                "message to daemon [%d]; rc = [%d]\n",
186                                old_id->pid, rc);
187                 kfree(old_id);
188         }
189         new_id->uid = uid;
190         new_id->pid = pid;
191         hlist_add_head(&new_id->id_chain,
192                        &ecryptfs_daemon_id_hash[ecryptfs_uid_hash(uid)]);
193         rc = 0;
194 unlock:
195         mutex_unlock(&ecryptfs_daemon_id_hash_mux);
196         return rc;
197 }
198
199 /**
200  * ecryptfs_process_quit
201  * @uid: The user ID owner of the message
202  * @pid: The process ID for the userspace program that sent the
203  *       message
204  *
205  * Deletes the corresponding daemon id for the given uid and pid, if
206  * it is the registered that is requesting the deletion. Returns zero
207  * after deleting the desired daemon id; non-zero otherwise.
208  */
209 int ecryptfs_process_quit(uid_t uid, pid_t pid)
210 {
211         struct ecryptfs_daemon_id *id;
212         int rc;
213
214         mutex_lock(&ecryptfs_daemon_id_hash_mux);
215         if (ecryptfs_find_daemon_id(uid, &id)) {
216                 rc = -EINVAL;
217                 ecryptfs_printk(KERN_ERR, "Received request from user [%d] to "
218                                 "unregister unrecognized daemon [%d]\n", uid,
219                                 pid);
220                 goto unlock;
221         }
222         if (id->pid != pid) {
223                 rc = -EINVAL;
224                 ecryptfs_printk(KERN_WARNING, "Received request from user [%d] "
225                                 "with pid [%d] to unregister daemon [%d]\n",
226                                 uid, pid, id->pid);
227                 goto unlock;
228         }
229         hlist_del(&id->id_chain);
230         kfree(id);
231         rc = 0;
232 unlock:
233         mutex_unlock(&ecryptfs_daemon_id_hash_mux);
234         return rc;
235 }
236
237 /**
238  * ecryptfs_process_reponse
239  * @msg: The ecryptfs message received; the caller should sanity check
240  *       msg->data_len
241  * @pid: The process ID of the userspace application that sent the
242  *       message
243  * @seq: The sequence number of the message
244  *
245  * Processes a response message after sending a operation request to
246  * userspace. Returns zero upon delivery to desired context element;
247  * non-zero upon delivery failure or error.
248  */
249 int ecryptfs_process_response(struct ecryptfs_message *msg, uid_t uid,
250                               pid_t pid, u32 seq)
251 {
252         struct ecryptfs_daemon_id *id;
253         struct ecryptfs_msg_ctx *msg_ctx;
254         int msg_size;
255         int rc;
256
257         if (msg->index >= ecryptfs_message_buf_len) {
258                 rc = -EINVAL;
259                 ecryptfs_printk(KERN_ERR, "Attempt to reference "
260                                 "context buffer at index [%d]; maximum "
261                                 "allowable is [%d]\n", msg->index,
262                                 (ecryptfs_message_buf_len - 1));
263                 goto out;
264         }
265         msg_ctx = &ecryptfs_msg_ctx_arr[msg->index];
266         mutex_lock(&msg_ctx->mux);
267         if (ecryptfs_find_daemon_id(msg_ctx->task->euid, &id)) {
268                 rc = -EBADMSG;
269                 ecryptfs_printk(KERN_WARNING, "User [%d] received a "
270                                 "message response from process [%d] but does "
271                                 "not have a registered daemon\n",
272                                 msg_ctx->task->euid, pid);
273                 goto wake_up;
274         }
275         if (msg_ctx->task->euid != uid) {
276                 rc = -EBADMSG;
277                 ecryptfs_printk(KERN_WARNING, "Received message from user "
278                                 "[%d]; expected message from user [%d]\n",
279                                 uid, msg_ctx->task->euid);
280                 goto unlock;
281         }
282         if (id->pid != pid) {
283                 rc = -EBADMSG;
284                 ecryptfs_printk(KERN_ERR, "User [%d] received a "
285                                 "message response from an unrecognized "
286                                 "process [%d]\n", msg_ctx->task->euid, pid);
287                 goto unlock;
288         }
289         if (msg_ctx->state != ECRYPTFS_MSG_CTX_STATE_PENDING) {
290                 rc = -EINVAL;
291                 ecryptfs_printk(KERN_WARNING, "Desired context element is not "
292                                 "pending a response\n");
293                 goto unlock;
294         } else if (msg_ctx->counter != seq) {
295                 rc = -EINVAL;
296                 ecryptfs_printk(KERN_WARNING, "Invalid message sequence; "
297                                 "expected [%d]; received [%d]\n",
298                                 msg_ctx->counter, seq);
299                 goto unlock;
300         }
301         msg_size = sizeof(*msg) + msg->data_len;
302         msg_ctx->msg = kmalloc(msg_size, GFP_KERNEL);
303         if (!msg_ctx->msg) {
304                 rc = -ENOMEM;
305                 ecryptfs_printk(KERN_ERR, "Failed to allocate memory\n");
306                 goto unlock;
307         }
308         memcpy(msg_ctx->msg, msg, msg_size);
309         msg_ctx->state = ECRYPTFS_MSG_CTX_STATE_DONE;
310         rc = 0;
311 wake_up:
312         wake_up_process(msg_ctx->task);
313 unlock:
314         mutex_unlock(&msg_ctx->mux);
315 out:
316         return rc;
317 }
318
319 /**
320  * ecryptfs_send_message
321  * @transport: The transport over which to send the message (i.e.,
322  *             netlink)
323  * @data: The data to send
324  * @data_len: The length of data
325  * @msg_ctx: The message context allocated for the send
326  */
327 int ecryptfs_send_message(unsigned int transport, char *data, int data_len,
328                           struct ecryptfs_msg_ctx **msg_ctx)
329 {
330         struct ecryptfs_daemon_id *id;
331         int rc;
332
333         mutex_lock(&ecryptfs_daemon_id_hash_mux);
334         if (ecryptfs_find_daemon_id(current->euid, &id)) {
335                 mutex_unlock(&ecryptfs_daemon_id_hash_mux);
336                 rc = -ENOTCONN;
337                 ecryptfs_printk(KERN_ERR, "User [%d] does not have a daemon "
338                                 "registered\n", current->euid);
339                 goto out;
340         }
341         mutex_unlock(&ecryptfs_daemon_id_hash_mux);
342         mutex_lock(&ecryptfs_msg_ctx_lists_mux);
343         rc = ecryptfs_acquire_free_msg_ctx(msg_ctx);
344         if (rc) {
345                 mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
346                 ecryptfs_printk(KERN_WARNING, "Could not claim a free "
347                                 "context element\n");
348                 goto out;
349         }
350         ecryptfs_msg_ctx_free_to_alloc(*msg_ctx);
351         mutex_unlock(&(*msg_ctx)->mux);
352         mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
353         switch (transport) {
354         case ECRYPTFS_TRANSPORT_NETLINK:
355                 rc = ecryptfs_send_netlink(data, data_len, *msg_ctx,
356                                            ECRYPTFS_NLMSG_REQUEST, 0, id->pid);
357                 break;
358         case ECRYPTFS_TRANSPORT_CONNECTOR:
359         case ECRYPTFS_TRANSPORT_RELAYFS:
360         default:
361                 rc = -ENOSYS;
362         }
363         if (rc) {
364                 printk(KERN_ERR "Error attempting to send message to userspace "
365                        "daemon; rc = [%d]\n", rc);
366         }
367 out:
368         return rc;
369 }
370
371 /**
372  * ecryptfs_wait_for_response
373  * @msg_ctx: The context that was assigned when sending a message
374  * @msg: The incoming message from userspace; not set if rc != 0
375  *
376  * Sleeps until awaken by ecryptfs_receive_message or until the amount
377  * of time exceeds ecryptfs_message_wait_timeout.  If zero is
378  * returned, msg will point to a valid message from userspace; a
379  * non-zero value is returned upon failure to receive a message or an
380  * error occurs.
381  */
382 int ecryptfs_wait_for_response(struct ecryptfs_msg_ctx *msg_ctx,
383                                struct ecryptfs_message **msg)
384 {
385         signed long timeout = ecryptfs_message_wait_timeout * HZ;
386         int rc = 0;
387
388 sleep:
389         timeout = schedule_timeout_interruptible(timeout);
390         mutex_lock(&ecryptfs_msg_ctx_lists_mux);
391         mutex_lock(&msg_ctx->mux);
392         if (msg_ctx->state != ECRYPTFS_MSG_CTX_STATE_DONE) {
393                 if (timeout) {
394                         mutex_unlock(&msg_ctx->mux);
395                         mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
396                         goto sleep;
397                 }
398                 rc = -ENOMSG;
399         } else {
400                 *msg = msg_ctx->msg;
401                 msg_ctx->msg = NULL;
402         }
403         ecryptfs_msg_ctx_alloc_to_free(msg_ctx);
404         mutex_unlock(&msg_ctx->mux);
405         mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
406         return rc;
407 }
408
409 int ecryptfs_init_messaging(unsigned int transport)
410 {
411         int i;
412         int rc = 0;
413
414         if (ecryptfs_number_of_users > ECRYPTFS_MAX_NUM_USERS) {
415                 ecryptfs_number_of_users = ECRYPTFS_MAX_NUM_USERS;
416                 ecryptfs_printk(KERN_WARNING, "Specified number of users is "
417                                 "too large, defaulting to [%d] users\n",
418                                 ecryptfs_number_of_users);
419         }
420         mutex_init(&ecryptfs_daemon_id_hash_mux);
421         mutex_lock(&ecryptfs_daemon_id_hash_mux);
422         ecryptfs_hash_buckets = 0;
423         while (ecryptfs_number_of_users >> ++ecryptfs_hash_buckets);
424         ecryptfs_daemon_id_hash = kmalloc(sizeof(struct hlist_head)
425                                           * ecryptfs_hash_buckets, GFP_KERNEL);
426         if (!ecryptfs_daemon_id_hash) {
427                 rc = -ENOMEM;
428                 ecryptfs_printk(KERN_ERR, "Failed to allocate memory\n");
429                 goto out;
430         }
431         for (i = 0; i < ecryptfs_hash_buckets; i++)
432                 INIT_HLIST_HEAD(&ecryptfs_daemon_id_hash[i]);
433         mutex_unlock(&ecryptfs_daemon_id_hash_mux);
434
435         ecryptfs_msg_ctx_arr = kmalloc((sizeof(struct ecryptfs_msg_ctx)
436                                       * ecryptfs_message_buf_len), GFP_KERNEL);
437         if (!ecryptfs_msg_ctx_arr) {
438                 rc = -ENOMEM;
439                 ecryptfs_printk(KERN_ERR, "Failed to allocate memory\n");
440                 goto out;
441         }
442         mutex_init(&ecryptfs_msg_ctx_lists_mux);
443         mutex_lock(&ecryptfs_msg_ctx_lists_mux);
444         ecryptfs_msg_counter = 0;
445         for (i = 0; i < ecryptfs_message_buf_len; i++) {
446                 INIT_LIST_HEAD(&ecryptfs_msg_ctx_arr[i].node);
447                 mutex_init(&ecryptfs_msg_ctx_arr[i].mux);
448                 mutex_lock(&ecryptfs_msg_ctx_arr[i].mux);
449                 ecryptfs_msg_ctx_arr[i].index = i;
450                 ecryptfs_msg_ctx_arr[i].state = ECRYPTFS_MSG_CTX_STATE_FREE;
451                 ecryptfs_msg_ctx_arr[i].counter = 0;
452                 ecryptfs_msg_ctx_arr[i].task = NULL;
453                 ecryptfs_msg_ctx_arr[i].msg = NULL;
454                 list_add_tail(&ecryptfs_msg_ctx_arr[i].node,
455                               &ecryptfs_msg_ctx_free_list);
456                 mutex_unlock(&ecryptfs_msg_ctx_arr[i].mux);
457         }
458         mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
459         switch(transport) {
460         case ECRYPTFS_TRANSPORT_NETLINK:
461                 rc = ecryptfs_init_netlink();
462                 if (rc)
463                         ecryptfs_release_messaging(transport);
464                 break;
465         case ECRYPTFS_TRANSPORT_CONNECTOR:
466         case ECRYPTFS_TRANSPORT_RELAYFS:
467         default:
468                 rc = -ENOSYS;
469         }
470 out:
471         return rc;
472 }
473
474 void ecryptfs_release_messaging(unsigned int transport)
475 {
476         if (ecryptfs_msg_ctx_arr) {
477                 int i;
478
479                 mutex_lock(&ecryptfs_msg_ctx_lists_mux);
480                 for (i = 0; i < ecryptfs_message_buf_len; i++) {
481                         mutex_lock(&ecryptfs_msg_ctx_arr[i].mux);
482                         if (ecryptfs_msg_ctx_arr[i].msg)
483                                 kfree(ecryptfs_msg_ctx_arr[i].msg);
484                         mutex_unlock(&ecryptfs_msg_ctx_arr[i].mux);
485                 }
486                 kfree(ecryptfs_msg_ctx_arr);
487                 mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
488         }
489         if (ecryptfs_daemon_id_hash) {
490                 struct hlist_node *elem;
491                 struct ecryptfs_daemon_id *id;
492                 int i;
493
494                 mutex_lock(&ecryptfs_daemon_id_hash_mux);
495                 for (i = 0; i < ecryptfs_hash_buckets; i++) {
496                         hlist_for_each_entry(id, elem,
497                                              &ecryptfs_daemon_id_hash[i],
498                                              id_chain) {
499                                 hlist_del(elem);
500                                 kfree(id);
501                         }
502                 }
503                 kfree(ecryptfs_daemon_id_hash);
504                 mutex_unlock(&ecryptfs_daemon_id_hash_mux);
505         }
506         switch(transport) {
507         case ECRYPTFS_TRANSPORT_NETLINK:
508                 ecryptfs_release_netlink();
509                 break;
510         case ECRYPTFS_TRANSPORT_CONNECTOR:
511         case ECRYPTFS_TRANSPORT_RELAYFS:
512         default:
513                 break;
514         }
515         return;
516 }