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