Blame view
fs/ecryptfs/miscdev.c
15.7 KB
8bf2debd5
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
/** * eCryptfs: Linux filesystem encryption layer * * Copyright (C) 2008 International Business Machines Corp. * Author(s): Michael A. Halcrow <mhalcrow@us.ibm.com> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License version * 2 as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA * 02111-1307, USA. */ #include <linux/fs.h> #include <linux/hash.h> #include <linux/random.h> #include <linux/miscdevice.h> #include <linux/poll.h> |
5a0e3ad6a
|
27 |
#include <linux/slab.h> |
8bf2debd5
|
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
#include <linux/wait.h> #include <linux/module.h> #include "ecryptfs_kernel.h" static atomic_t ecryptfs_num_miscdev_opens; /** * ecryptfs_miscdev_poll * @file: dev file (ignored) * @pt: dev poll table (ignored) * * Returns the poll mask */ static unsigned int ecryptfs_miscdev_poll(struct file *file, poll_table *pt) { struct ecryptfs_daemon *daemon; unsigned int mask = 0; |
4eea03539
|
46 |
uid_t euid = current_euid(); |
8bf2debd5
|
47 48 49 50 |
int rc; mutex_lock(&ecryptfs_daemon_hash_mux); /* TODO: Just use file->private_data? */ |
18b6e0414
|
51 |
rc = ecryptfs_find_daemon_by_euid(&daemon, euid, current_user_ns()); |
8bf2debd5
|
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 |
BUG_ON(rc || !daemon); mutex_lock(&daemon->mux); mutex_unlock(&ecryptfs_daemon_hash_mux); if (daemon->flags & ECRYPTFS_DAEMON_ZOMBIE) { printk(KERN_WARNING "%s: Attempt to poll on zombified " "daemon ", __func__); goto out_unlock_daemon; } if (daemon->flags & ECRYPTFS_DAEMON_IN_READ) goto out_unlock_daemon; if (daemon->flags & ECRYPTFS_DAEMON_IN_POLL) goto out_unlock_daemon; daemon->flags |= ECRYPTFS_DAEMON_IN_POLL; mutex_unlock(&daemon->mux); poll_wait(file, &daemon->wait, pt); mutex_lock(&daemon->mux); if (!list_empty(&daemon->msg_ctx_out_queue)) mask |= POLLIN | POLLRDNORM; out_unlock_daemon: daemon->flags &= ~ECRYPTFS_DAEMON_IN_POLL; mutex_unlock(&daemon->mux); return mask; } /** * ecryptfs_miscdev_open * @inode: inode of miscdev handle (ignored) * @file: file for miscdev handle (ignored) * * Returns zero on success; non-zero otherwise */ static int ecryptfs_miscdev_open(struct inode *inode, struct file *file) { struct ecryptfs_daemon *daemon = NULL; |
4eea03539
|
88 |
uid_t euid = current_euid(); |
8bf2debd5
|
89 90 91 92 93 94 95 96 97 98 99 |
int rc; mutex_lock(&ecryptfs_daemon_hash_mux); rc = try_module_get(THIS_MODULE); if (rc == 0) { rc = -EIO; printk(KERN_ERR "%s: Error attempting to increment module use " "count; rc = [%d] ", __func__, rc); goto out_unlock_daemon_list; } |
18b6e0414
|
100 |
rc = ecryptfs_find_daemon_by_euid(&daemon, euid, current_user_ns()); |
8bf2debd5
|
101 |
if (rc || !daemon) { |
18b6e0414
|
102 |
rc = ecryptfs_spawn_daemon(&daemon, euid, current_user_ns(), |
6a3fd92e7
|
103 |
task_pid(current)); |
8bf2debd5
|
104 105 106 107 108 109 110 111 |
if (rc) { printk(KERN_ERR "%s: Error attempting to spawn daemon; " "rc = [%d] ", __func__, rc); goto out_module_put_unlock_daemon_list; } } mutex_lock(&daemon->mux); |
6a3fd92e7
|
112 |
if (daemon->pid != task_pid(current)) { |
8bf2debd5
|
113 |
rc = -EINVAL; |
6a3fd92e7
|
114 115 |
printk(KERN_ERR "%s: pid [0x%p] has registered with euid [%d], " "but pid [0x%p] has attempted to open the handle " |
8bf2debd5
|
116 117 |
"instead ", __func__, daemon->pid, daemon->euid, |
6a3fd92e7
|
118 |
task_pid(current)); |
8bf2debd5
|
119 120 121 122 123 |
goto out_unlock_daemon; } if (daemon->flags & ECRYPTFS_DAEMON_MISCDEV_OPEN) { rc = -EBUSY; printk(KERN_ERR "%s: Miscellaneous device handle may only be " |
6a3fd92e7
|
124 |
"opened once per daemon; pid [0x%p] already has this " |
8bf2debd5
|
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 |
"handle open ", __func__, daemon->pid); goto out_unlock_daemon; } daemon->flags |= ECRYPTFS_DAEMON_MISCDEV_OPEN; atomic_inc(&ecryptfs_num_miscdev_opens); out_unlock_daemon: mutex_unlock(&daemon->mux); out_module_put_unlock_daemon_list: if (rc) module_put(THIS_MODULE); out_unlock_daemon_list: mutex_unlock(&ecryptfs_daemon_hash_mux); return rc; } /** * ecryptfs_miscdev_release * @inode: inode of fs/ecryptfs/euid handle (ignored) * @file: file for fs/ecryptfs/euid handle (ignored) * * This keeps the daemon registered until the daemon sends another * ioctl to fs/ecryptfs/ctl or until the kernel module unregisters. * * Returns zero on success; non-zero otherwise */ static int ecryptfs_miscdev_release(struct inode *inode, struct file *file) { struct ecryptfs_daemon *daemon = NULL; |
4eea03539
|
155 |
uid_t euid = current_euid(); |
8bf2debd5
|
156 157 158 |
int rc; mutex_lock(&ecryptfs_daemon_hash_mux); |
18b6e0414
|
159 |
rc = ecryptfs_find_daemon_by_euid(&daemon, euid, current_user_ns()); |
8bf2debd5
|
160 161 |
BUG_ON(rc || !daemon); mutex_lock(&daemon->mux); |
6a3fd92e7
|
162 |
BUG_ON(daemon->pid != task_pid(current)); |
8bf2debd5
|
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 |
BUG_ON(!(daemon->flags & ECRYPTFS_DAEMON_MISCDEV_OPEN)); daemon->flags &= ~ECRYPTFS_DAEMON_MISCDEV_OPEN; atomic_dec(&ecryptfs_num_miscdev_opens); mutex_unlock(&daemon->mux); rc = ecryptfs_exorcise_daemon(daemon); if (rc) { printk(KERN_CRIT "%s: Fatal error whilst attempting to " "shut down daemon; rc = [%d]. Please report this " "bug. ", __func__, rc); BUG(); } module_put(THIS_MODULE); mutex_unlock(&ecryptfs_daemon_hash_mux); return rc; } /** * ecryptfs_send_miscdev * @data: Data to send to daemon; may be NULL * @data_size: Amount of data to send to daemon * @msg_ctx: Message context, which is used to handle the reply. If * this is NULL, then we do not expect a reply. * @msg_type: Type of message * @msg_flags: Flags for message * @daemon: eCryptfs daemon object * * Add msg_ctx to queue and then, if it exists, notify the blocked * miscdevess about the data being available. Must be called with * ecryptfs_daemon_hash_mux held. * * Returns zero on success; non-zero otherwise */ int ecryptfs_send_miscdev(char *data, size_t data_size, struct ecryptfs_msg_ctx *msg_ctx, u8 msg_type, u16 msg_flags, struct ecryptfs_daemon *daemon) { int rc = 0; mutex_lock(&msg_ctx->mux); |
57ea34d19
|
203 204 205 206 207 208 209 210 211 212 |
msg_ctx->msg = kmalloc((sizeof(*msg_ctx->msg) + data_size), GFP_KERNEL); if (!msg_ctx->msg) { rc = -ENOMEM; printk(KERN_ERR "%s: Out of memory whilst attempting " "to kmalloc(%zd, GFP_KERNEL) ", __func__, (sizeof(*msg_ctx->msg) + data_size)); goto out_unlock; } |
8bf2debd5
|
213 214 215 |
msg_ctx->msg->index = msg_ctx->index; msg_ctx->msg->data_len = data_size; msg_ctx->type = msg_type; |
57ea34d19
|
216 217 |
memcpy(msg_ctx->msg->data, data, data_size); msg_ctx->msg_size = (sizeof(*msg_ctx->msg) + data_size); |
8bf2debd5
|
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 |
mutex_lock(&daemon->mux); list_add_tail(&msg_ctx->daemon_out_list, &daemon->msg_ctx_out_queue); daemon->num_queued_msg_ctx++; wake_up_interruptible(&daemon->wait); mutex_unlock(&daemon->mux); out_unlock: mutex_unlock(&msg_ctx->mux); return rc; } /** * ecryptfs_miscdev_read - format and send message from queue * @file: fs/ecryptfs/euid miscdevfs handle (ignored) * @buf: User buffer into which to copy the next message on the daemon queue * @count: Amount of space available in @buf * @ppos: Offset in file (ignored) * * Pulls the most recent message from the daemon queue, formats it for * being sent via a miscdevfs handle, and copies it into @buf * * Returns the number of bytes copied into the user buffer */ |
f66e883eb
|
240 |
static ssize_t |
8bf2debd5
|
241 242 243 244 245 246 |
ecryptfs_miscdev_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) { struct ecryptfs_daemon *daemon; struct ecryptfs_msg_ctx *msg_ctx; size_t packet_length_size; |
8bf2debd5
|
247 248 249 |
char packet_length[3]; size_t i; size_t total_length; |
4eea03539
|
250 |
uid_t euid = current_euid(); |
8bf2debd5
|
251 252 253 254 |
int rc; mutex_lock(&ecryptfs_daemon_hash_mux); /* TODO: Just use file->private_data? */ |
18b6e0414
|
255 |
rc = ecryptfs_find_daemon_by_euid(&daemon, euid, current_user_ns()); |
8bf2debd5
|
256 257 258 259 |
BUG_ON(rc || !daemon); mutex_lock(&daemon->mux); if (daemon->flags & ECRYPTFS_DAEMON_ZOMBIE) { rc = 0; |
43f14d856
|
260 |
mutex_unlock(&ecryptfs_daemon_hash_mux); |
8bf2debd5
|
261 262 263 264 265 266 267 |
printk(KERN_WARNING "%s: Attempt to read from zombified " "daemon ", __func__); goto out_unlock_daemon; } if (daemon->flags & ECRYPTFS_DAEMON_IN_READ) { rc = 0; |
43f14d856
|
268 |
mutex_unlock(&ecryptfs_daemon_hash_mux); |
8bf2debd5
|
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 |
goto out_unlock_daemon; } /* This daemon will not go away so long as this flag is set */ daemon->flags |= ECRYPTFS_DAEMON_IN_READ; mutex_unlock(&ecryptfs_daemon_hash_mux); check_list: if (list_empty(&daemon->msg_ctx_out_queue)) { mutex_unlock(&daemon->mux); rc = wait_event_interruptible( daemon->wait, !list_empty(&daemon->msg_ctx_out_queue)); mutex_lock(&daemon->mux); if (rc < 0) { rc = 0; goto out_unlock_daemon; } } if (daemon->flags & ECRYPTFS_DAEMON_ZOMBIE) { rc = 0; goto out_unlock_daemon; } if (list_empty(&daemon->msg_ctx_out_queue)) { /* Something else jumped in since the * wait_event_interruptable() and removed the * message from the queue; try again */ goto check_list; } |
4eea03539
|
295 |
BUG_ON(euid != daemon->euid); |
18b6e0414
|
296 |
BUG_ON(current_user_ns() != daemon->user_ns); |
6a3fd92e7
|
297 |
BUG_ON(task_pid(current) != daemon->pid); |
8bf2debd5
|
298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 |
msg_ctx = list_first_entry(&daemon->msg_ctx_out_queue, struct ecryptfs_msg_ctx, daemon_out_list); BUG_ON(!msg_ctx); mutex_lock(&msg_ctx->mux); if (msg_ctx->msg) { rc = ecryptfs_write_packet_length(packet_length, msg_ctx->msg_size, &packet_length_size); if (rc) { rc = 0; printk(KERN_WARNING "%s: Error writing packet length; " "rc = [%d] ", __func__, rc); goto out_unlock_msg_ctx; } } else { packet_length_size = 0; msg_ctx->msg_size = 0; } /* miscdevfs packet format: * Octet 0: Type * Octets 1-4: network byte order msg_ctx->counter * Octets 5-N0: Size of struct ecryptfs_message to follow * Octets N0-N1: struct ecryptfs_message (including data) * * Octets 5-N1 not written if the packet type does not * include a message */ total_length = (1 + 4 + packet_length_size + msg_ctx->msg_size); if (count < total_length) { rc = 0; printk(KERN_WARNING "%s: Only given user buffer of " |
df261c52a
|
329 |
"size [%zd], but we need [%zd] to read the " |
8bf2debd5
|
330 331 332 333 |
"pending message ", __func__, count, total_length); goto out_unlock_msg_ctx; } |
79bc12a0a
|
334 335 336 337 338 339 |
rc = -EFAULT; if (put_user(msg_ctx->type, buf)) goto out_unlock_msg_ctx; if (put_user(cpu_to_be32(msg_ctx->counter), (__be32 __user *)(buf + 1))) goto out_unlock_msg_ctx; i = 5; |
8bf2debd5
|
340 |
if (msg_ctx->msg) { |
79bc12a0a
|
341 342 |
if (copy_to_user(&buf[i], packet_length, packet_length_size)) goto out_unlock_msg_ctx; |
8bf2debd5
|
343 |
i += packet_length_size; |
79bc12a0a
|
344 |
if (copy_to_user(&buf[i], msg_ctx->msg, msg_ctx->msg_size)) |
8bf2debd5
|
345 |
goto out_unlock_msg_ctx; |
8bf2debd5
|
346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 |
i += msg_ctx->msg_size; } rc = i; list_del(&msg_ctx->daemon_out_list); kfree(msg_ctx->msg); msg_ctx->msg = NULL; /* We do not expect a reply from the userspace daemon for any * message type other than ECRYPTFS_MSG_REQUEST */ if (msg_ctx->type != ECRYPTFS_MSG_REQUEST) ecryptfs_msg_ctx_alloc_to_free(msg_ctx); out_unlock_msg_ctx: mutex_unlock(&msg_ctx->mux); out_unlock_daemon: daemon->flags &= ~ECRYPTFS_DAEMON_IN_READ; mutex_unlock(&daemon->mux); return rc; } /** |
8bf2debd5
|
365 366 367 368 |
* ecryptfs_miscdev_response - miscdevess response to message previously sent to daemon * @data: Bytes comprising struct ecryptfs_message * @data_size: sizeof(struct ecryptfs_message) + data len * @euid: Effective user id of miscdevess sending the miscdev response |
6a3fd92e7
|
369 |
* @user_ns: The namespace in which @euid applies |
8bf2debd5
|
370 371 372 373 374 375 |
* @pid: Miscdevess id of miscdevess sending the miscdev response * @seq: Sequence number for miscdev response packet * * Returns zero on success; non-zero otherwise */ static int ecryptfs_miscdev_response(char *data, size_t data_size, |
6a3fd92e7
|
376 377 |
uid_t euid, struct user_namespace *user_ns, struct pid *pid, u32 seq) |
8bf2debd5
|
378 379 380 381 382 383 |
{ struct ecryptfs_message *msg = (struct ecryptfs_message *)data; int rc; if ((sizeof(*msg) + msg->data_len) != data_size) { printk(KERN_WARNING "%s: (sizeof(*msg) + msg->data_len) = " |
df261c52a
|
384 385 |
"[%zd]; data_size = [%zd]. Invalid packet. ", __func__, |
8bf2debd5
|
386 387 388 389 |
(sizeof(*msg) + msg->data_len), data_size); rc = -EINVAL; goto out; } |
6a3fd92e7
|
390 |
rc = ecryptfs_process_response(msg, euid, user_ns, pid, seq); |
8bf2debd5
|
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 |
if (rc) printk(KERN_ERR "Error processing response message; rc = [%d] ", rc); out: return rc; } /** * ecryptfs_miscdev_write - handle write to daemon miscdev handle * @file: File for misc dev handle (ignored) * @buf: Buffer containing user data * @count: Amount of data in @buf * @ppos: Pointer to offset in file (ignored) * * miscdevfs packet format: * Octet 0: Type * Octets 1-4: network byte order msg_ctx->counter (0's for non-response) * Octets 5-N0: Size of struct ecryptfs_message to follow * Octets N0-N1: struct ecryptfs_message (including data) * * Returns the number of bytes read from @buf */ static ssize_t ecryptfs_miscdev_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) { |
79bc12a0a
|
418 419 |
__be32 counter_nbo; u32 seq; |
8bf2debd5
|
420 421 422 |
size_t packet_size, packet_size_length, i; ssize_t sz = 0; char *data; |
4eea03539
|
423 |
uid_t euid = current_euid(); |
8bf2debd5
|
424 425 426 427 |
int rc; if (count == 0) goto out; |
fd56d242b
|
428 429 430 431 432 433 |
data = memdup_user(buf, count); if (IS_ERR(data)) { printk(KERN_ERR "%s: memdup_user returned error [%ld] ", __func__, PTR_ERR(data)); |
8bf2debd5
|
434 435 |
goto out; } |
8bf2debd5
|
436 437 438 439 440 441 |
sz = count; i = 0; switch (data[i++]) { case ECRYPTFS_MSG_RESPONSE: if (count < (1 + 4 + 1 + sizeof(struct ecryptfs_message))) { printk(KERN_WARNING "%s: Minimum acceptable packet " |
df261c52a
|
442 443 444 |
"size is [%zd], but amount of data written is " "only [%zd]. Discarding response packet. ", |
8bf2debd5
|
445 446 447 448 449 |
__func__, (1 + 4 + 1 + sizeof(struct ecryptfs_message)), count); goto out_free; } |
79bc12a0a
|
450 |
memcpy(&counter_nbo, &data[i], 4); |
8bf2debd5
|
451 452 453 454 455 456 457 458 459 460 461 462 |
seq = be32_to_cpu(counter_nbo); i += 4; rc = ecryptfs_parse_packet_length(&data[i], &packet_size, &packet_size_length); if (rc) { printk(KERN_WARNING "%s: Error parsing packet length; " "rc = [%d] ", __func__, rc); goto out_free; } i += packet_size_length; if ((1 + 4 + packet_size_length + packet_size) != count) { |
df261c52a
|
463 464 465 466 |
printk(KERN_WARNING "%s: (1 + packet_size_length([%zd])" " + packet_size([%zd]))([%zd]) != " "count([%zd]). Invalid packet format. ", |
8bf2debd5
|
467 468 469 470 471 |
__func__, packet_size_length, packet_size, (1 + packet_size_length + packet_size), count); goto out_free; } rc = ecryptfs_miscdev_response(&data[i], packet_size, |
18b6e0414
|
472 |
euid, current_user_ns(), |
6a3fd92e7
|
473 |
task_pid(current), seq); |
8bf2debd5
|
474 475 476 477 478 479 480 |
if (rc) printk(KERN_WARNING "%s: Failed to deliver miscdev " "response to requesting operation; rc = [%d] ", __func__, rc); break; case ECRYPTFS_MSG_HELO: |
8bf2debd5
|
481 |
case ECRYPTFS_MSG_QUIT: |
8bf2debd5
|
482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 |
break; default: ecryptfs_printk(KERN_WARNING, "Dropping miscdev " "message of unrecognized type [%d] ", data[0]); break; } out_free: kfree(data); out: return sz; } static const struct file_operations ecryptfs_miscdev_fops = { .open = ecryptfs_miscdev_open, .poll = ecryptfs_miscdev_poll, .read = ecryptfs_miscdev_read, .write = ecryptfs_miscdev_write, .release = ecryptfs_miscdev_release, |
6038f373a
|
503 |
.llseek = noop_llseek, |
8bf2debd5
|
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 |
}; static struct miscdevice ecryptfs_miscdev = { .minor = MISC_DYNAMIC_MINOR, .name = "ecryptfs", .fops = &ecryptfs_miscdev_fops }; /** * ecryptfs_init_ecryptfs_miscdev * * Messages sent to the userspace daemon from the kernel are placed on * a queue associated with the daemon. The next read against the * miscdev handle by that daemon will return the oldest message placed * on the message queue for the daemon. * * Returns zero on success; non-zero otherwise */ |
7371a3820
|
522 |
int __init ecryptfs_init_ecryptfs_miscdev(void) |
8bf2debd5
|
523 524 525 526 |
{ int rc; atomic_set(&ecryptfs_num_miscdev_opens, 0); |
8bf2debd5
|
527 528 529 530 531 532 |
rc = misc_register(&ecryptfs_miscdev); if (rc) printk(KERN_ERR "%s: Failed to register miscellaneous device " "for communications with userspace daemons; rc = [%d] ", __func__, rc); |
8bf2debd5
|
533 534 535 536 537 538 539 540 541 542 543 544 545 546 |
return rc; } /** * ecryptfs_destroy_ecryptfs_miscdev * * All of the daemons must be exorcised prior to calling this * function. */ void ecryptfs_destroy_ecryptfs_miscdev(void) { BUG_ON(atomic_read(&ecryptfs_num_miscdev_opens) != 0); misc_deregister(&ecryptfs_miscdev); } |