1 /* $FreeBSD$ */ 2 /*- 3 * Copyright (c) 2010-2012 Hans Petter Selasky. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <stdio.h> 28 #include <stdint.h> 29 #include <pthread.h> 30 #include <signal.h> 31 #include <unistd.h> 32 #include <string.h> 33 #include <errno.h> 34 #include <stdlib.h> 35 #include <stdarg.h> 36 37 #include <sys/types.h> 38 #include <sys/queue.h> 39 #include <sys/fcntl.h> 40 #include <sys/mman.h> 41 #include <sys/param.h> 42 43 #include <fs/cuse/cuse_ioctl.h> 44 45 #include "cuse.h" 46 47 int cuse_debug_level; 48 49 #ifdef HAVE_DEBUG 50 static const char *cuse_cmd_str(int cmd); 51 52 #define DPRINTF(...) do { \ 53 if (cuse_debug_level != 0) \ 54 printf(__VA_ARGS__); \ 55 } while (0) 56 #else 57 #define DPRINTF(...) do { } while (0) 58 #endif 59 60 struct cuse_vm_allocation { 61 uint8_t *ptr; 62 uint32_t size; 63 }; 64 65 struct cuse_dev_entered { 66 TAILQ_ENTRY(cuse_dev_entered) entry; 67 pthread_t thread; 68 void *per_file_handle; 69 struct cuse_dev *cdev; 70 int cmd; 71 int is_local; 72 int got_signal; 73 }; 74 75 struct cuse_dev { 76 TAILQ_ENTRY(cuse_dev) entry; 77 const struct cuse_methods *mtod; 78 void *priv0; 79 void *priv1; 80 }; 81 82 static int f_cuse = -1; 83 84 static pthread_mutex_t m_cuse; 85 static TAILQ_HEAD(, cuse_dev) h_cuse __guarded_by(m_cuse); 86 static TAILQ_HEAD(, cuse_dev_entered) h_cuse_entered __guarded_by(m_cuse); 87 static struct cuse_vm_allocation a_cuse[CUSE_ALLOC_UNIT_MAX] 88 __guarded_by(m_cuse); 89 90 #define CUSE_LOCK() \ 91 pthread_mutex_lock(&m_cuse) 92 93 #define CUSE_UNLOCK() \ 94 pthread_mutex_unlock(&m_cuse) 95 96 int 97 cuse_init(void) 98 { 99 pthread_mutexattr_t attr; 100 101 f_cuse = open("/dev/cuse", O_RDWR); 102 if (f_cuse < 0) { 103 if (feature_present("cuse") == 0) 104 return (CUSE_ERR_NOT_LOADED); 105 else 106 return (CUSE_ERR_INVALID); 107 } 108 pthread_mutexattr_init(&attr); 109 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); 110 pthread_mutex_init(&m_cuse, &attr); 111 112 TAILQ_INIT(&h_cuse); 113 TAILQ_INIT(&h_cuse_entered); 114 115 return (0); 116 } 117 118 int 119 cuse_uninit(void) 120 { 121 int f; 122 123 if (f_cuse < 0) 124 return (CUSE_ERR_INVALID); 125 126 f = f_cuse; 127 f_cuse = -1; 128 129 close(f); 130 131 pthread_mutex_destroy(&m_cuse); 132 133 memset(a_cuse, 0, sizeof(a_cuse)); 134 135 return (0); 136 } 137 138 unsigned long 139 cuse_vmoffset(void *_ptr) 140 { 141 uint8_t *ptr_min; 142 uint8_t *ptr_max; 143 uint8_t *ptr = _ptr; 144 unsigned long remainder; 145 int n; 146 147 CUSE_LOCK(); 148 for (n = 0; n != CUSE_ALLOC_UNIT_MAX; n++) { 149 if (a_cuse[n].ptr == NULL) 150 continue; 151 152 ptr_min = a_cuse[n].ptr; 153 ptr_max = a_cuse[n].ptr + a_cuse[n].size - 1; 154 155 if ((ptr >= ptr_min) && (ptr <= ptr_max)) { 156 157 CUSE_UNLOCK(); 158 159 remainder = (ptr - ptr_min); 160 161 remainder -= remainder % PAGE_SIZE; 162 163 return ((n * PAGE_SIZE * CUSE_ALLOC_PAGES_MAX) + remainder); 164 } 165 } 166 CUSE_UNLOCK(); 167 168 return (0x80000000UL); /* failure */ 169 } 170 171 void * 172 cuse_vmalloc(int size) 173 { 174 struct cuse_alloc_info info; 175 void *ptr; 176 int error; 177 int n; 178 179 if (f_cuse < 0) 180 return (NULL); 181 182 memset(&info, 0, sizeof(info)); 183 184 if (size < 1) 185 return (NULL); 186 187 info.page_count = (size + PAGE_SIZE - 1) / PAGE_SIZE; 188 189 CUSE_LOCK(); 190 for (n = 0; n != CUSE_ALLOC_UNIT_MAX; n++) { 191 192 if (a_cuse[n].ptr != NULL) 193 continue; 194 195 a_cuse[n].ptr = ((uint8_t *)1); /* reserve */ 196 a_cuse[n].size = 0; 197 198 CUSE_UNLOCK(); 199 200 info.alloc_nr = n; 201 202 error = ioctl(f_cuse, CUSE_IOCTL_ALLOC_MEMORY, &info); 203 204 if (error) { 205 206 CUSE_LOCK(); 207 208 a_cuse[n].ptr = NULL; 209 210 if (errno == EBUSY) 211 continue; 212 else 213 break; 214 } 215 ptr = mmap(NULL, info.page_count * PAGE_SIZE, 216 PROT_READ | PROT_WRITE, 217 MAP_SHARED, f_cuse, CUSE_ALLOC_PAGES_MAX * 218 PAGE_SIZE * n); 219 220 if (ptr == MAP_FAILED) { 221 222 error = ioctl(f_cuse, CUSE_IOCTL_FREE_MEMORY, &info); 223 224 if (error) { 225 /* ignore */ 226 } 227 CUSE_LOCK(); 228 229 a_cuse[n].ptr = NULL; 230 231 break; 232 } 233 CUSE_LOCK(); 234 a_cuse[n].ptr = ptr; 235 a_cuse[n].size = size; 236 CUSE_UNLOCK(); 237 238 return (ptr); /* success */ 239 } 240 CUSE_UNLOCK(); 241 return (NULL); /* failure */ 242 } 243 244 int 245 cuse_is_vmalloc_addr(void *ptr) 246 { 247 int n; 248 249 if (f_cuse < 0 || ptr == NULL) 250 return (0); /* false */ 251 252 CUSE_LOCK(); 253 for (n = 0; n != CUSE_ALLOC_UNIT_MAX; n++) { 254 if (a_cuse[n].ptr == ptr) 255 break; 256 } 257 CUSE_UNLOCK(); 258 259 return (n != CUSE_ALLOC_UNIT_MAX); 260 } 261 262 void 263 cuse_vmfree(void *ptr) 264 { 265 struct cuse_vm_allocation temp; 266 struct cuse_alloc_info info; 267 int error; 268 int n; 269 270 if (f_cuse < 0) 271 return; 272 273 CUSE_LOCK(); 274 for (n = 0; n != CUSE_ALLOC_UNIT_MAX; n++) { 275 if (a_cuse[n].ptr != ptr) 276 continue; 277 278 temp = a_cuse[n]; 279 280 CUSE_UNLOCK(); 281 282 munmap(temp.ptr, temp.size); 283 284 memset(&info, 0, sizeof(info)); 285 286 info.alloc_nr = n; 287 288 error = ioctl(f_cuse, CUSE_IOCTL_FREE_MEMORY, &info); 289 290 if (error != 0) { 291 /* ignore any errors */ 292 DPRINTF("Freeing memory failed: %d\n", errno); 293 } 294 CUSE_LOCK(); 295 296 a_cuse[n].ptr = NULL; 297 a_cuse[n].size = 0; 298 299 break; 300 } 301 CUSE_UNLOCK(); 302 } 303 304 int 305 cuse_alloc_unit_number_by_id(int *pnum, int id) 306 { 307 int error; 308 309 if (f_cuse < 0) 310 return (CUSE_ERR_INVALID); 311 312 *pnum = (id & CUSE_ID_MASK); 313 314 error = ioctl(f_cuse, CUSE_IOCTL_ALLOC_UNIT_BY_ID, pnum); 315 if (error) 316 return (CUSE_ERR_NO_MEMORY); 317 318 return (0); 319 320 } 321 322 int 323 cuse_free_unit_number_by_id(int num, int id) 324 { 325 int error; 326 327 if (f_cuse < 0) 328 return (CUSE_ERR_INVALID); 329 330 if (num != -1 || id != -1) 331 num = (id & CUSE_ID_MASK) | (num & 0xFF); 332 333 error = ioctl(f_cuse, CUSE_IOCTL_FREE_UNIT_BY_ID, &num); 334 if (error) 335 return (CUSE_ERR_NO_MEMORY); 336 337 return (0); 338 } 339 340 int 341 cuse_alloc_unit_number(int *pnum) 342 { 343 int error; 344 345 if (f_cuse < 0) 346 return (CUSE_ERR_INVALID); 347 348 error = ioctl(f_cuse, CUSE_IOCTL_ALLOC_UNIT, pnum); 349 if (error) 350 return (CUSE_ERR_NO_MEMORY); 351 352 return (0); 353 } 354 355 int 356 cuse_free_unit_number(int num) 357 { 358 int error; 359 360 if (f_cuse < 0) 361 return (CUSE_ERR_INVALID); 362 363 error = ioctl(f_cuse, CUSE_IOCTL_FREE_UNIT, &num); 364 if (error) 365 return (CUSE_ERR_NO_MEMORY); 366 367 return (0); 368 } 369 370 struct cuse_dev * 371 cuse_dev_create(const struct cuse_methods *mtod, void *priv0, void *priv1, 372 uid_t _uid, gid_t _gid, int _perms, const char *_fmt,...) 373 { 374 struct cuse_create_dev info; 375 struct cuse_dev *cdev; 376 va_list args; 377 int error; 378 379 if (f_cuse < 0) 380 return (NULL); 381 382 cdev = malloc(sizeof(*cdev)); 383 if (cdev == NULL) 384 return (NULL); 385 386 memset(cdev, 0, sizeof(*cdev)); 387 388 cdev->mtod = mtod; 389 cdev->priv0 = priv0; 390 cdev->priv1 = priv1; 391 392 memset(&info, 0, sizeof(info)); 393 394 info.dev = cdev; 395 info.user_id = _uid; 396 info.group_id = _gid; 397 info.permissions = _perms; 398 399 va_start(args, _fmt); 400 vsnprintf(info.devname, sizeof(info.devname), _fmt, args); 401 va_end(args); 402 403 error = ioctl(f_cuse, CUSE_IOCTL_CREATE_DEV, &info); 404 if (error) { 405 free(cdev); 406 return (NULL); 407 } 408 CUSE_LOCK(); 409 TAILQ_INSERT_TAIL(&h_cuse, cdev, entry); 410 CUSE_UNLOCK(); 411 412 return (cdev); 413 } 414 415 416 void 417 cuse_dev_destroy(struct cuse_dev *cdev) 418 { 419 int error; 420 421 if (f_cuse < 0) 422 return; 423 424 CUSE_LOCK(); 425 TAILQ_REMOVE(&h_cuse, cdev, entry); 426 CUSE_UNLOCK(); 427 428 error = ioctl(f_cuse, CUSE_IOCTL_DESTROY_DEV, &cdev); 429 if (error) 430 return; 431 432 free(cdev); 433 } 434 435 void * 436 cuse_dev_get_priv0(struct cuse_dev *cdev) 437 { 438 return (cdev->priv0); 439 } 440 441 void * 442 cuse_dev_get_priv1(struct cuse_dev *cdev) 443 { 444 return (cdev->priv1); 445 } 446 447 void 448 cuse_dev_set_priv0(struct cuse_dev *cdev, void *priv) 449 { 450 cdev->priv0 = priv; 451 } 452 453 void 454 cuse_dev_set_priv1(struct cuse_dev *cdev, void *priv) 455 { 456 cdev->priv1 = priv; 457 } 458 459 int 460 cuse_wait_and_process(void) 461 { 462 pthread_t curr = pthread_self(); 463 struct cuse_dev_entered *pe; 464 struct cuse_dev_entered enter; 465 struct cuse_command info; 466 struct cuse_dev *cdev; 467 int error; 468 469 if (f_cuse < 0) 470 return (CUSE_ERR_INVALID); 471 472 error = ioctl(f_cuse, CUSE_IOCTL_GET_COMMAND, &info); 473 if (error) 474 return (CUSE_ERR_OTHER); 475 476 cdev = info.dev; 477 478 CUSE_LOCK(); 479 enter.thread = curr; 480 enter.per_file_handle = (void *)info.per_file_handle; 481 enter.cmd = info.command; 482 enter.is_local = 0; 483 enter.got_signal = 0; 484 enter.cdev = cdev; 485 TAILQ_INSERT_TAIL(&h_cuse_entered, &enter, entry); 486 CUSE_UNLOCK(); 487 488 DPRINTF("cuse: Command = %d = %s, flags = %d, arg = 0x%08x, ptr = 0x%08x\n", 489 (int)info.command, cuse_cmd_str(info.command), (int)info.fflags, 490 (int)info.argument, (int)info.data_pointer); 491 492 switch (info.command) { 493 case CUSE_CMD_OPEN: 494 if (cdev->mtod->cm_open != NULL) 495 error = (cdev->mtod->cm_open) (cdev, (int)info.fflags); 496 else 497 error = 0; 498 break; 499 500 case CUSE_CMD_CLOSE: 501 502 /* wait for other threads to stop */ 503 504 while (1) { 505 506 error = 0; 507 508 CUSE_LOCK(); 509 TAILQ_FOREACH(pe, &h_cuse_entered, entry) { 510 if (pe->cdev != cdev) 511 continue; 512 if (pe->thread == curr) 513 continue; 514 if (pe->per_file_handle != 515 enter.per_file_handle) 516 continue; 517 pe->got_signal = 1; 518 pthread_kill(pe->thread, SIGHUP); 519 error = CUSE_ERR_BUSY; 520 } 521 CUSE_UNLOCK(); 522 523 if (error == 0) 524 break; 525 else 526 usleep(10000); 527 } 528 529 if (cdev->mtod->cm_close != NULL) 530 error = (cdev->mtod->cm_close) (cdev, (int)info.fflags); 531 else 532 error = 0; 533 break; 534 535 case CUSE_CMD_READ: 536 if (cdev->mtod->cm_read != NULL) { 537 error = (cdev->mtod->cm_read) (cdev, (int)info.fflags, 538 (void *)info.data_pointer, (int)info.argument); 539 } else { 540 error = CUSE_ERR_INVALID; 541 } 542 break; 543 544 case CUSE_CMD_WRITE: 545 if (cdev->mtod->cm_write != NULL) { 546 error = (cdev->mtod->cm_write) (cdev, (int)info.fflags, 547 (void *)info.data_pointer, (int)info.argument); 548 } else { 549 error = CUSE_ERR_INVALID; 550 } 551 break; 552 553 case CUSE_CMD_IOCTL: 554 if (cdev->mtod->cm_ioctl != NULL) { 555 error = (cdev->mtod->cm_ioctl) (cdev, (int)info.fflags, 556 (unsigned int)info.argument, (void *)info.data_pointer); 557 } else { 558 error = CUSE_ERR_INVALID; 559 } 560 break; 561 562 case CUSE_CMD_POLL: 563 if (cdev->mtod->cm_poll != NULL) { 564 error = (cdev->mtod->cm_poll) (cdev, (int)info.fflags, 565 (int)info.argument); 566 } else { 567 error = CUSE_POLL_ERROR; 568 } 569 break; 570 571 case CUSE_CMD_SIGNAL: 572 CUSE_LOCK(); 573 TAILQ_FOREACH(pe, &h_cuse_entered, entry) { 574 if (pe->cdev != cdev) 575 continue; 576 if (pe->thread == curr) 577 continue; 578 if (pe->per_file_handle != 579 enter.per_file_handle) 580 continue; 581 pe->got_signal = 1; 582 pthread_kill(pe->thread, SIGHUP); 583 } 584 CUSE_UNLOCK(); 585 break; 586 587 default: 588 error = CUSE_ERR_INVALID; 589 break; 590 } 591 592 DPRINTF("cuse: Command error = %d for %s\n", 593 error, cuse_cmd_str(info.command)); 594 595 CUSE_LOCK(); 596 TAILQ_REMOVE(&h_cuse_entered, &enter, entry); 597 CUSE_UNLOCK(); 598 599 /* we ignore any sync command failures */ 600 ioctl(f_cuse, CUSE_IOCTL_SYNC_COMMAND, &error); 601 602 return (0); 603 } 604 605 static struct cuse_dev_entered * 606 cuse_dev_get_entered(void) 607 { 608 struct cuse_dev_entered *pe; 609 pthread_t curr = pthread_self(); 610 611 CUSE_LOCK(); 612 TAILQ_FOREACH(pe, &h_cuse_entered, entry) { 613 if (pe->thread == curr) 614 break; 615 } 616 CUSE_UNLOCK(); 617 return (pe); 618 } 619 620 void 621 cuse_dev_set_per_file_handle(struct cuse_dev *cdev, void *handle) 622 { 623 struct cuse_dev_entered *pe; 624 625 pe = cuse_dev_get_entered(); 626 if (pe == NULL || pe->cdev != cdev) 627 return; 628 629 pe->per_file_handle = handle; 630 ioctl(f_cuse, CUSE_IOCTL_SET_PFH, &handle); 631 } 632 633 void * 634 cuse_dev_get_per_file_handle(struct cuse_dev *cdev) 635 { 636 struct cuse_dev_entered *pe; 637 638 pe = cuse_dev_get_entered(); 639 if (pe == NULL || pe->cdev != cdev) 640 return (NULL); 641 642 return (pe->per_file_handle); 643 } 644 645 void 646 cuse_set_local(int val) 647 { 648 struct cuse_dev_entered *pe; 649 650 pe = cuse_dev_get_entered(); 651 if (pe == NULL) 652 return; 653 654 pe->is_local = val; 655 } 656 657 #ifdef HAVE_DEBUG 658 static const char * 659 cuse_cmd_str(int cmd) 660 { 661 static const char *str[CUSE_CMD_MAX] = { 662 [CUSE_CMD_NONE] = "none", 663 [CUSE_CMD_OPEN] = "open", 664 [CUSE_CMD_CLOSE] = "close", 665 [CUSE_CMD_READ] = "read", 666 [CUSE_CMD_WRITE] = "write", 667 [CUSE_CMD_IOCTL] = "ioctl", 668 [CUSE_CMD_POLL] = "poll", 669 [CUSE_CMD_SIGNAL] = "signal", 670 [CUSE_CMD_SYNC] = "sync", 671 }; 672 673 if ((cmd >= 0) && (cmd < CUSE_CMD_MAX) && 674 (str[cmd] != NULL)) 675 return (str[cmd]); 676 else 677 return ("unknown"); 678 } 679 680 #endif 681 682 int 683 cuse_get_local(void) 684 { 685 struct cuse_dev_entered *pe; 686 687 pe = cuse_dev_get_entered(); 688 if (pe == NULL) 689 return (0); 690 691 return (pe->is_local); 692 } 693 694 int 695 cuse_copy_out(const void *src, void *user_dst, int len) 696 { 697 struct cuse_data_chunk info; 698 struct cuse_dev_entered *pe; 699 int error; 700 701 if ((f_cuse < 0) || (len < 0)) 702 return (CUSE_ERR_INVALID); 703 704 pe = cuse_dev_get_entered(); 705 if (pe == NULL) 706 return (CUSE_ERR_INVALID); 707 708 DPRINTF("cuse: copy_out(%p,%p,%d), cmd = %d = %s\n", 709 src, user_dst, len, pe->cmd, cuse_cmd_str(pe->cmd)); 710 711 if (pe->is_local) { 712 memcpy(user_dst, src, len); 713 } else { 714 info.local_ptr = (uintptr_t)src; 715 info.peer_ptr = (uintptr_t)user_dst; 716 info.length = len; 717 718 error = ioctl(f_cuse, CUSE_IOCTL_WRITE_DATA, &info); 719 if (error) { 720 DPRINTF("cuse: copy_out() error = %d\n", errno); 721 return (CUSE_ERR_FAULT); 722 } 723 } 724 return (0); 725 } 726 727 int 728 cuse_copy_in(const void *user_src, void *dst, int len) 729 { 730 struct cuse_data_chunk info; 731 struct cuse_dev_entered *pe; 732 int error; 733 734 if ((f_cuse < 0) || (len < 0)) 735 return (CUSE_ERR_INVALID); 736 737 pe = cuse_dev_get_entered(); 738 if (pe == NULL) 739 return (CUSE_ERR_INVALID); 740 741 DPRINTF("cuse: copy_in(%p,%p,%d), cmd = %d = %s\n", 742 user_src, dst, len, pe->cmd, cuse_cmd_str(pe->cmd)); 743 744 if (pe->is_local) { 745 memcpy(dst, user_src, len); 746 } else { 747 info.local_ptr = (uintptr_t)dst; 748 info.peer_ptr = (uintptr_t)user_src; 749 info.length = len; 750 751 error = ioctl(f_cuse, CUSE_IOCTL_READ_DATA, &info); 752 if (error) { 753 DPRINTF("cuse: copy_in() error = %d\n", errno); 754 return (CUSE_ERR_FAULT); 755 } 756 } 757 return (0); 758 } 759 760 struct cuse_dev * 761 cuse_dev_get_current(int *pcmd) 762 { 763 struct cuse_dev_entered *pe; 764 765 pe = cuse_dev_get_entered(); 766 if (pe == NULL) { 767 if (pcmd != NULL) 768 *pcmd = 0; 769 return (NULL); 770 } 771 if (pcmd != NULL) 772 *pcmd = pe->cmd; 773 return (pe->cdev); 774 } 775 776 int 777 cuse_got_peer_signal(void) 778 { 779 struct cuse_dev_entered *pe; 780 781 pe = cuse_dev_get_entered(); 782 if (pe == NULL) 783 return (CUSE_ERR_INVALID); 784 785 if (pe->got_signal) 786 return (0); 787 788 return (CUSE_ERR_OTHER); 789 } 790 791 void 792 cuse_poll_wakeup(void) 793 { 794 int error = 0; 795 796 if (f_cuse < 0) 797 return; 798 799 ioctl(f_cuse, CUSE_IOCTL_SELWAKEUP, &error); 800 } 801