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, pid_t pid, u32 seq)
 247 {
 248         struct ecryptfs_daemon_id *id;
 249         struct ecryptfs_msg_ctx *msg_ctx;
 250         int msg_size;
 251         int rc;
 252
 253         if (msg->index >= ecryptfs_message_buf_len) {
 254                 rc = -EINVAL;
 255                 ecryptfs_printk(KERN_ERR, "Attempt to reference "
 256                                 "context buffer at index [%d]; maximum "
 257                                 "allowable is [%d]\n", msg->index,
 258                                 (ecryptfs_message_buf_len - 1));
 259                 goto out;
 260         }
 261         msg_ctx = &ecryptfs_msg_ctx_arr[msg->index];
 262         mutex_lock(&msg_ctx->mux);
 263         if (ecryptfs_find_daemon_id(msg_ctx->task->euid, &id)) {
 264                 rc = -EBADMSG;
 265                 ecryptfs_printk(KERN_WARNING, "User [%d] received a "
 266                                 "message response from process [%d] but does "
 267                                 "not have a registered daemon\n",
 268                                 msg_ctx->task->euid, pid);
 269                 goto wake_up;
 270         }
 271         if (id->pid != pid) {
 272                 rc = -EBADMSG;
 273                 ecryptfs_printk(KERN_ERR, "User [%d] received a "
 274                                 "message response from an unrecognized "
 275                                 "process [%d]\n", msg_ctx->task->euid, pid);
 276                 goto unlock;
 277         }
 278         if (msg_ctx->state != ECRYPTFS_MSG_CTX_STATE_PENDING) {
 279                 rc = -EINVAL;
 280                 ecryptfs_printk(KERN_WARNING, "Desired context element is not "
 281                                 "pending a response\n");
 282                 goto unlock;
 283         } else if (msg_ctx->counter != seq) {
 284                 rc = -EINVAL;
 285                 ecryptfs_printk(KERN_WARNING, "Invalid message sequence; "
 286                                 "expected [%d]; received [%d]\n",
 287                                 msg_ctx->counter, seq);
 288                 goto unlock;
 289         }
 290         msg_size = sizeof(*msg) + msg->data_len;
 291         msg_ctx->msg = kmalloc(msg_size, GFP_KERNEL);
 292         if (!msg_ctx->msg) {
 293                 rc = -ENOMEM;
 294                 ecryptfs_printk(KERN_ERR, "Failed to allocate memory\n");
 295                 goto unlock;
 296         }
 297         memcpy(msg_ctx->msg, msg, msg_size);
 298         msg_ctx->state = ECRYPTFS_MSG_CTX_STATE_DONE;
 299         rc = 0;
 300 wake_up:
 301         wake_up_process(msg_ctx->task);
 302 unlock:
 303         mutex_unlock(&msg_ctx->mux);
 304 out:
 305         return rc;
 306 }
 307
 308 /**
 309  * ecryptfs_send_message
 310  * @transport: The transport over which to send the message (i.e.,
 311  *             netlink)
 312  * @data: The data to send
 313  * @data_len: The length of data
 314  * @msg_ctx: The message context allocated for the send
 315  */
 316 int ecryptfs_send_message(unsigned int transport, char *data, int data_len,
 317                           struct ecryptfs_msg_ctx **msg_ctx)
 318 {
 319         struct ecryptfs_daemon_id *id;
 320         int rc;
 321
 322         mutex_lock(&ecryptfs_daemon_id_hash_mux);
 323         if (ecryptfs_find_daemon_id(current->euid, &id)) {
 324                 mutex_unlock(&ecryptfs_daemon_id_hash_mux);
 325                 rc = -ENOTCONN;
 326                 ecryptfs_printk(KERN_ERR, "User [%d] does not have a daemon "
 327                                 "registered\n", current->euid);
 328                 goto out;
 329         }
 330         mutex_unlock(&ecryptfs_daemon_id_hash_mux);
 331         mutex_lock(&ecryptfs_msg_ctx_lists_mux);
 332         rc = ecryptfs_acquire_free_msg_ctx(msg_ctx);
 333         if (rc) {
 334                 mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
 335                 ecryptfs_printk(KERN_WARNING, "Could not claim a free "
 336                                 "context element\n");
 337                 goto out;
 338         }
 339         ecryptfs_msg_ctx_free_to_alloc(*msg_ctx);
 340         mutex_unlock(&(*msg_ctx)->mux);
 341         mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
 342         switch (transport) {
 343         case ECRYPTFS_TRANSPORT_NETLINK:
 344                 rc = ecryptfs_send_netlink(data, data_len, *msg_ctx,
 345                                            ECRYPTFS_NLMSG_REQUEST, 0, id->pid);
 346                 break;
 347         case ECRYPTFS_TRANSPORT_CONNECTOR:
 348         case ECRYPTFS_TRANSPORT_RELAYFS:
 349         default:
 350                 rc = -ENOSYS;
 351         }
 352         if (rc) {
 353                 printk(KERN_ERR "Error attempting to send message to userspace "
 354                        "daemon; rc = [%d]\n", rc);
 355         }
 356 out:
 357         return rc;
 358 }
 359
 360 /**
 361  * ecryptfs_wait_for_response
 362  * @msg_ctx: The context that was assigned when sending a message
 363  * @msg: The incoming message from userspace; not set if rc != 0
 364  *
 365  * Sleeps until awaken by ecryptfs_receive_message or until the amount
 366  * of time exceeds ecryptfs_message_wait_timeout.  If zero is
 367  * returned, msg will point to a valid message from userspace; a
 368  * non-zero value is returned upon failure to receive a message or an
 369  * error occurs.
 370  */
 371 int ecryptfs_wait_for_response(struct ecryptfs_msg_ctx *msg_ctx,
 372                                struct ecryptfs_message **msg)
 373 {
 374         signed long timeout = ecryptfs_message_wait_timeout * HZ;
 375         int rc = 0;
 376
 377 sleep:
 378         timeout = schedule_timeout_interruptible(timeout);
 379         mutex_lock(&ecryptfs_msg_ctx_lists_mux);
 380         mutex_lock(&msg_ctx->mux);
 381         if (msg_ctx->state != ECRYPTFS_MSG_CTX_STATE_DONE) {
 382                 if (timeout) {
 383                         mutex_unlock(&msg_ctx->mux);
 384                         mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
 385                         goto sleep;
 386                 }
 387                 rc = -ENOMSG;
 388         } else {
 389                 *msg = msg_ctx->msg;
 390                 msg_ctx->msg = NULL;
 391         }
 392         ecryptfs_msg_ctx_alloc_to_free(msg_ctx);
 393         mutex_unlock(&msg_ctx->mux);
 394         mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
 395         return rc;
 396 }
 397
 398 int ecryptfs_init_messaging(unsigned int transport)
 399 {
 400         int i;
 401         int rc = 0;
 402
 403         if (ecryptfs_number_of_users > ECRYPTFS_MAX_NUM_USERS) {
 404                 ecryptfs_number_of_users = ECRYPTFS_MAX_NUM_USERS;
 405                 ecryptfs_printk(KERN_WARNING, "Specified number of users is "
 406                                 "too large, defaulting to [%d] users\n",
 407                                 ecryptfs_number_of_users);
 408         }
 409         mutex_init(&ecryptfs_daemon_id_hash_mux);
 410         mutex_lock(&ecryptfs_daemon_id_hash_mux);
 411         ecryptfs_hash_buckets = 0;
 412         while (ecryptfs_number_of_users >> ++ecryptfs_hash_buckets);
 413         ecryptfs_daemon_id_hash = kmalloc(sizeof(struct hlist_head)
 414                                           * ecryptfs_hash_buckets, GFP_KERNEL);
 415         if (!ecryptfs_daemon_id_hash) {
 416                 rc = -ENOMEM;
 417                 ecryptfs_printk(KERN_ERR, "Failed to allocate memory\n");
 418                 goto out;
 419         }
 420         for (i = 0; i < ecryptfs_hash_buckets; i++)
 421                 INIT_HLIST_HEAD(&ecryptfs_daemon_id_hash[i]);
 422         mutex_unlock(&ecryptfs_daemon_id_hash_mux);
 423
 424         ecryptfs_msg_ctx_arr = kmalloc((sizeof(struct ecryptfs_msg_ctx)
 425                                       * ecryptfs_message_buf_len), GFP_KERNEL);
 426         if (!ecryptfs_msg_ctx_arr) {
 427                 rc = -ENOMEM;
 428                 ecryptfs_printk(KERN_ERR, "Failed to allocate memory\n");
 429                 goto out;
 430         }
 431         mutex_init(&ecryptfs_msg_ctx_lists_mux);
 432         mutex_lock(&ecryptfs_msg_ctx_lists_mux);
 433         ecryptfs_msg_counter = 0;
 434         for (i = 0; i < ecryptfs_message_buf_len; i++) {
 435                 INIT_LIST_HEAD(&ecryptfs_msg_ctx_arr[i].node);
 436                 mutex_init(&ecryptfs_msg_ctx_arr[i].mux);
 437                 mutex_lock(&ecryptfs_msg_ctx_arr[i].mux);
 438                 ecryptfs_msg_ctx_arr[i].index = i;
 439                 ecryptfs_msg_ctx_arr[i].state = ECRYPTFS_MSG_CTX_STATE_FREE;
 440                 ecryptfs_msg_ctx_arr[i].counter = 0;
 441                 ecryptfs_msg_ctx_arr[i].task = NULL;
 442                 ecryptfs_msg_ctx_arr[i].msg = NULL;
 443                 list_add_tail(&ecryptfs_msg_ctx_arr[i].node,
 444                               &ecryptfs_msg_ctx_free_list);
 445                 mutex_unlock(&ecryptfs_msg_ctx_arr[i].mux);
 446         }
 447         mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
 448         switch(transport) {
 449         case ECRYPTFS_TRANSPORT_NETLINK:
 450                 rc = ecryptfs_init_netlink();
 451                 if (rc)
 452                         ecryptfs_release_messaging(transport);
 453                 break;
 454         case ECRYPTFS_TRANSPORT_CONNECTOR:
 455         case ECRYPTFS_TRANSPORT_RELAYFS:
 456         default:
 457                 rc = -ENOSYS;
 458         }
 459 out:
 460         return rc;
 461 }
 462
 463 void ecryptfs_release_messaging(unsigned int transport)
 464 {
 465         if (ecryptfs_msg_ctx_arr) {
 466                 int i;
 467
 468                 mutex_lock(&ecryptfs_msg_ctx_lists_mux);
 469                 for (i = 0; i < ecryptfs_message_buf_len; i++) {
 470                         mutex_lock(&ecryptfs_msg_ctx_arr[i].mux);
 471                         if (ecryptfs_msg_ctx_arr[i].msg)
 472                                 kfree(ecryptfs_msg_ctx_arr[i].msg);
 473                         mutex_unlock(&ecryptfs_msg_ctx_arr[i].mux);
 474                 }
 475                 kfree(ecryptfs_msg_ctx_arr);
 476                 mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
 477         }
 478         if (ecryptfs_daemon_id_hash) {
 479                 struct hlist_node *elem;
 480                 struct ecryptfs_daemon_id *id;
 481                 int i;
 482
 483                 mutex_lock(&ecryptfs_daemon_id_hash_mux);
 484                 for (i = 0; i < ecryptfs_hash_buckets; i++) {
 485                         hlist_for_each_entry(id, elem,
 486                                              &ecryptfs_daemon_id_hash[i],
 487                                              id_chain) {
 488                                 hlist_del(elem);
 489                                 kfree(id);
 490                         }
 491                 }
 492                 kfree(ecryptfs_daemon_id_hash);
 493                 mutex_unlock(&ecryptfs_daemon_id_hash_mux);
 494         }
 495         switch(transport) {
 496         case ECRYPTFS_TRANSPORT_NETLINK:
 497                 ecryptfs_release_netlink();
 498                 break;
 499         case ECRYPTFS_TRANSPORT_CONNECTOR:
 500         case ECRYPTFS_TRANSPORT_RELAYFS:
 501         default:
 502                 break;
 503         }
 504         return;
 505 }