VolumeManager.cpp revision 8c940ef7dbd423cadc92982b44a65ed1014389e2
1/* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include <stdio.h> 18#include <stdlib.h> 19#include <string.h> 20#include <errno.h> 21#include <fcntl.h> 22#include <sys/stat.h> 23#include <sys/types.h> 24#include <sys/mount.h> 25 26#include <linux/kdev_t.h> 27 28#define LOG_TAG "Vold" 29 30#include <cutils/log.h> 31 32#include <sysutils/NetlinkEvent.h> 33 34#include "VolumeManager.h" 35#include "DirectVolume.h" 36#include "ResponseCode.h" 37#include "Loop.h" 38#include "Fat.h" 39#include "Devmapper.h" 40 41extern "C" void KillProcessesWithOpenFiles(const char *, int); 42 43VolumeManager *VolumeManager::sInstance = NULL; 44 45VolumeManager *VolumeManager::Instance() { 46 if (!sInstance) 47 sInstance = new VolumeManager(); 48 return sInstance; 49} 50 51VolumeManager::VolumeManager() { 52 mBlockDevices = new BlockDeviceCollection(); 53 mVolumes = new VolumeCollection(); 54 mActiveContainers = new AsecIdCollection(); 55 mBroadcaster = NULL; 56 mUsbMassStorageConnected = false; 57} 58 59VolumeManager::~VolumeManager() { 60 delete mBlockDevices; 61 delete mVolumes; 62 delete mActiveContainers; 63} 64 65int VolumeManager::start() { 66 return 0; 67} 68 69int VolumeManager::stop() { 70 return 0; 71} 72 73int VolumeManager::addVolume(Volume *v) { 74 mVolumes->push_back(v); 75 return 0; 76} 77 78void VolumeManager::notifyUmsConnected(bool connected) { 79 char msg[255]; 80 81 if (connected) { 82 mUsbMassStorageConnected = true; 83 } else { 84 mUsbMassStorageConnected = false; 85 } 86 snprintf(msg, sizeof(msg), "Share method ums now %s", 87 (connected ? "available" : "unavailable")); 88 89 getBroadcaster()->sendBroadcast(ResponseCode::ShareAvailabilityChange, 90 msg, false); 91} 92 93void VolumeManager::handleSwitchEvent(NetlinkEvent *evt) { 94 const char *devpath = evt->findParam("DEVPATH"); 95 const char *name = evt->findParam("SWITCH_NAME"); 96 const char *state = evt->findParam("SWITCH_STATE"); 97 98 if (!name || !state) { 99 LOGW("Switch %s event missing name/state info", devpath); 100 return; 101 } 102 103 if (!strcmp(name, "usb_mass_storage")) { 104 105 if (!strcmp(state, "online")) { 106 notifyUmsConnected(true); 107 } else { 108 notifyUmsConnected(false); 109 } 110 } else { 111 LOGW("Ignoring unknown switch '%s'", name); 112 } 113} 114 115void VolumeManager::handleBlockEvent(NetlinkEvent *evt) { 116 const char *devpath = evt->findParam("DEVPATH"); 117 118 /* Lookup a volume to handle this device */ 119 VolumeCollection::iterator it; 120 bool hit = false; 121 for (it = mVolumes->begin(); it != mVolumes->end(); ++it) { 122 if (!(*it)->handleBlockEvent(evt)) { 123#ifdef NETLINK_DEBUG 124 LOGD("Device '%s' event handled by volume %s\n", devpath, (*it)->getLabel()); 125#endif 126 hit = true; 127 break; 128 } 129 } 130 131 if (!hit) { 132#ifdef NETLINK_DEBUG 133 LOGW("No volumes handled block event for '%s'", devpath); 134#endif 135 } 136} 137 138int VolumeManager::listVolumes(SocketClient *cli) { 139 VolumeCollection::iterator i; 140 141 for (i = mVolumes->begin(); i != mVolumes->end(); ++i) { 142 char *buffer; 143 asprintf(&buffer, "%s %s %d", 144 (*i)->getLabel(), (*i)->getMountpoint(), 145 (*i)->getState()); 146 cli->sendMsg(ResponseCode::VolumeListResult, buffer, false); 147 free(buffer); 148 } 149 cli->sendMsg(ResponseCode::CommandOkay, "Volumes listed.", false); 150 return 0; 151} 152 153int VolumeManager::formatVolume(const char *label) { 154 Volume *v = lookupVolume(label); 155 156 if (!v) { 157 errno = ENOENT; 158 return -1; 159 } 160 161 return v->formatVol(); 162} 163 164int VolumeManager::getAsecMountPath(const char *id, char *buffer, int maxlen) { 165 char mountPoint[255]; 166 167 snprintf(mountPoint, sizeof(mountPoint), "/asec/%s", id); 168 snprintf(buffer, maxlen, "/asec/%s", id); 169 return 0; 170} 171 172int VolumeManager::createAsec(const char *id, unsigned int numSectors, 173 const char *fstype, const char *key, int ownerUid) { 174 175 mkdir("/sdcard/android_secure", 0777); 176 177 if (lookupVolume(id)) { 178 LOGE("ASEC volume '%s' currently exists", id); 179 errno = EADDRINUSE; 180 return -1; 181 } 182 183 char asecFileName[255]; 184 snprintf(asecFileName, sizeof(asecFileName), 185 "/sdcard/android_secure/%s.asec", id); 186 187 if (!access(asecFileName, F_OK)) { 188 LOGE("ASEC file '%s' currently exists - destroy it first! (%s)", 189 asecFileName, strerror(errno)); 190 errno = EADDRINUSE; 191 return -1; 192 } 193 194 if (Loop::createImageFile(asecFileName, numSectors)) { 195 LOGE("ASEC image file creation failed (%s)", strerror(errno)); 196 return -1; 197 } 198 199 char loopDevice[255]; 200 if (Loop::create(asecFileName, loopDevice, sizeof(loopDevice))) { 201 LOGE("ASEC loop device creation failed (%s)", strerror(errno)); 202 unlink(asecFileName); 203 return -1; 204 } 205 206 char dmDevice[255]; 207 bool cleanupDm = false; 208 209 if (strcmp(key, "none")) { 210 if (Devmapper::create(id, loopDevice, key, numSectors, dmDevice, 211 sizeof(dmDevice))) { 212 LOGE("ASEC device mapping failed (%s)", strerror(errno)); 213 Loop::destroyByDevice(loopDevice); 214 unlink(asecFileName); 215 return -1; 216 } 217 cleanupDm = true; 218 } else { 219 strcpy(dmDevice, loopDevice); 220 } 221 222 if (Fat::format(dmDevice)) { 223 LOGE("ASEC FAT format failed (%s)", strerror(errno)); 224 if (cleanupDm) { 225 Devmapper::destroy(id); 226 } 227 Loop::destroyByDevice(loopDevice); 228 unlink(asecFileName); 229 return -1; 230 } 231 232 char mountPoint[255]; 233 234 snprintf(mountPoint, sizeof(mountPoint), "/asec/%s", id); 235 if (mkdir(mountPoint, 0777)) { 236 if (errno != EEXIST) { 237 LOGE("Mountpoint creation failed (%s)", strerror(errno)); 238 if (cleanupDm) { 239 Devmapper::destroy(id); 240 } 241 Loop::destroyByDevice(loopDevice); 242 unlink(asecFileName); 243 return -1; 244 } 245 } 246 247 if (Fat::doMount(dmDevice, mountPoint, false, false, ownerUid, 248 0, 0000, false)) { 249// 0, 0007, false)) { 250 LOGE("ASEC FAT mount failed (%s)", strerror(errno)); 251 if (cleanupDm) { 252 Devmapper::destroy(id); 253 } 254 Loop::destroyByDevice(loopDevice); 255 unlink(asecFileName); 256 return -1; 257 } 258 259 mActiveContainers->push_back(strdup(id)); 260 return 0; 261} 262 263int VolumeManager::finalizeAsec(const char *id) { 264 char asecFileName[255]; 265 char loopDevice[255]; 266 char mountPoint[255]; 267 268 snprintf(asecFileName, sizeof(asecFileName), 269 "/sdcard/android_secure/%s.asec", id); 270 271 if (Loop::lookupActive(asecFileName, loopDevice, sizeof(loopDevice))) { 272 LOGE("Unable to finalize %s (%s)", id, strerror(errno)); 273 return -1; 274 } 275 276 snprintf(mountPoint, sizeof(mountPoint), "/asec/%s", id); 277 // XXX: 278 if (Fat::doMount(loopDevice, mountPoint, true, true, 0, 0, 0227, false)) { 279 LOGE("ASEC finalize mount failed (%s)", strerror(errno)); 280 return -1; 281 } 282 283 LOGD("ASEC %s finalized", id); 284 return 0; 285} 286 287int VolumeManager::renameAsec(const char *id1, const char *id2) { 288 char *asecFilename1; 289 char *asecFilename2; 290 char mountPoint[255]; 291 292 asprintf(&asecFilename1, "/sdcard/android_secure/%s.asec", id1); 293 asprintf(&asecFilename2, "/sdcard/android_secure/%s.asec", id2); 294 295 snprintf(mountPoint, sizeof(mountPoint), "/asec/%s", id1); 296 if (isMountpointMounted(mountPoint)) { 297 LOGW("Rename attempt when src mounted"); 298 errno = EBUSY; 299 goto out_err; 300 } 301 302 if (!access(asecFilename2, F_OK)) { 303 LOGE("Rename attempt when dst exists"); 304 errno = EADDRINUSE; 305 goto out_err; 306 } 307 308 if (rename(asecFilename1, asecFilename2)) { 309 LOGE("Rename of '%s' to '%s' failed (%s)", asecFilename1, asecFilename2, strerror(errno)); 310 goto out_err; 311 } 312 313 free(asecFilename1); 314 free(asecFilename2); 315 return 0; 316 317out_err: 318 free(asecFilename1); 319 free(asecFilename2); 320 return -1; 321} 322 323#define ASEC_UNMOUNT_RETRIES 10 324int VolumeManager::unmountAsec(const char *id) { 325 char asecFileName[255]; 326 char mountPoint[255]; 327 328 snprintf(asecFileName, sizeof(asecFileName), 329 "/sdcard/android_secure/%s.asec", id); 330 snprintf(mountPoint, sizeof(mountPoint), "/asec/%s", id); 331 332 if (!isMountpointMounted(mountPoint)) { 333 LOGE("Unmount request for ASEC %s when not mounted", id); 334 errno = EINVAL; 335 return -1; 336 } 337 338 int i, rc; 339 for (i = 1; i <= ASEC_UNMOUNT_RETRIES; i++) { 340 rc = umount(mountPoint); 341 if (!rc) { 342 break; 343 } 344 if (rc && (errno == EINVAL || errno == ENOENT)) { 345 rc = 0; 346 break; 347 } 348 LOGW("ASEC %s unmount attempt %d failed (%s)", 349 id, i, strerror(errno)); 350 351 int action; 352 if (i > (ASEC_UNMOUNT_RETRIES - 2)) 353 action = 2; // SIGKILL 354 else if (i > (ASEC_UNMOUNT_RETRIES - 3)) 355 action = 1; // SIGHUP 356 else 357 action = 0; // Just complain 358 359 KillProcessesWithOpenFiles(mountPoint, action); 360 usleep(1000 * 1000); 361 } 362 363 if (rc) { 364 LOGE("Failed to unmount ASEC %s", id); 365 return -1; 366 } 367 368 if (rmdir(mountPoint)) { 369 LOGE("Failed to rmdir mountpoint (%s)", strerror(errno)); 370 } 371 372 if (Devmapper::destroy(id) && errno != ENXIO) { 373 LOGE("Failed to destroy devmapper instance (%s)", strerror(errno)); 374 } 375 376 char loopDevice[255]; 377 if (!Loop::lookupActive(asecFileName, loopDevice, sizeof(loopDevice))) { 378 Loop::destroyByDevice(loopDevice); 379 } 380 381 AsecIdCollection::iterator it; 382 for (it = mActiveContainers->begin(); it != mActiveContainers->end(); ++it) { 383 if (!strcmp(*it, id)) { 384 free(*it); 385 mActiveContainers->erase(it); 386 break; 387 } 388 } 389 if (it == mActiveContainers->end()) { 390 LOGW("mActiveContainers is inconsistent!"); 391 } 392 return 0; 393} 394 395int VolumeManager::destroyAsec(const char *id) { 396 char asecFileName[255]; 397 char mountPoint[255]; 398 399 snprintf(asecFileName, sizeof(asecFileName), 400 "/sdcard/android_secure/%s.asec", id); 401 snprintf(mountPoint, sizeof(mountPoint), "/asec/%s", id); 402 403 if (isMountpointMounted(mountPoint)) { 404 LOGD("Unmounting container before destroy"); 405 if (unmountAsec(id)) { 406 LOGE("Failed to unmount asec %s for destroy (%s)", id, strerror(errno)); 407 return -1; 408 } 409 } 410 411 if (unlink(asecFileName)) { 412 LOGE("Failed to unlink asec '%s' (%s)", asecFileName, strerror(errno)); 413 return -1; 414 } 415 416 LOGD("ASEC %s destroyed", id); 417 return 0; 418} 419 420int VolumeManager::mountAsec(const char *id, const char *key, int ownerUid) { 421 char asecFileName[255]; 422 char mountPoint[255]; 423 424 snprintf(asecFileName, sizeof(asecFileName), 425 "/sdcard/android_secure/%s.asec", id); 426 snprintf(mountPoint, sizeof(mountPoint), "/asec/%s", id); 427 428 if (isMountpointMounted(mountPoint)) { 429 LOGE("ASEC %s already mounted", id); 430 errno = EBUSY; 431 return -1; 432 } 433 434 char loopDevice[255]; 435 if (Loop::lookupActive(asecFileName, loopDevice, sizeof(loopDevice))) { 436 if (Loop::create(asecFileName, loopDevice, sizeof(loopDevice))) { 437 LOGE("ASEC loop device creation failed (%s)", strerror(errno)); 438 return -1; 439 } 440 LOGD("New loop device created at %s", loopDevice); 441 } else { 442 LOGD("Found active loopback for %s at %s", asecFileName, loopDevice); 443 } 444 445 char dmDevice[255]; 446 bool cleanupDm = false; 447 if (strcmp(key, "none")) { 448 if (Devmapper::lookupActive(id, dmDevice, sizeof(dmDevice))) { 449 unsigned int nr_sec = 0; 450 int fd; 451 452 if ((fd = open(loopDevice, O_RDWR)) < 0) { 453 LOGE("Failed to open loopdevice (%s)", strerror(errno)); 454 Loop::destroyByDevice(loopDevice); 455 return -1; 456 } 457 458 if (ioctl(fd, BLKGETSIZE, &nr_sec)) { 459 LOGE("Failed to get loop size (%s)", strerror(errno)); 460 Loop::destroyByDevice(loopDevice); 461 close(fd); 462 return -1; 463 } 464 close(fd); 465 if (Devmapper::create(id, loopDevice, key, nr_sec, 466 dmDevice, sizeof(dmDevice))) { 467 LOGE("ASEC device mapping failed (%s)", strerror(errno)); 468 Loop::destroyByDevice(loopDevice); 469 return -1; 470 } 471 LOGD("New devmapper instance created at %s", dmDevice); 472 } else { 473 LOGD("Found active devmapper for %s at %s", asecFileName, dmDevice); 474 } 475 cleanupDm = true; 476 } else { 477 strcpy(dmDevice, loopDevice); 478 } 479 480 if (mkdir(mountPoint, 0777)) { 481 if (errno != EEXIST) { 482 LOGE("Mountpoint creation failed (%s)", strerror(errno)); 483 if (cleanupDm) { 484 Devmapper::destroy(id); 485 } 486 Loop::destroyByDevice(loopDevice); 487 return -1; 488 } 489 } 490 491 if (Fat::doMount(dmDevice, mountPoint, true, false, ownerUid, 0, 492 0222, false)) { 493// 0227, false)) { 494 LOGE("ASEC mount failed (%s)", strerror(errno)); 495 if (cleanupDm) { 496 Devmapper::destroy(id); 497 } 498 Loop::destroyByDevice(loopDevice); 499 return -1; 500 } 501 502 mActiveContainers->push_back(strdup(id)); 503 LOGD("ASEC %s mounted", id); 504 return 0; 505} 506 507int VolumeManager::mountVolume(const char *label) { 508 Volume *v = lookupVolume(label); 509 510 if (!v) { 511 errno = ENOENT; 512 return -1; 513 } 514 515 return v->mountVol(); 516} 517 518int VolumeManager::shareAvailable(const char *method, bool *avail) { 519 520 if (strcmp(method, "ums")) { 521 errno = ENOSYS; 522 return -1; 523 } 524 525 if (mUsbMassStorageConnected) 526 *avail = true; 527 else 528 *avail = false; 529 return 0; 530} 531 532int VolumeManager::shareEnabled(const char *label, const char *method, bool *enabled) { 533 Volume *v = lookupVolume(label); 534 535 if (!v) { 536 errno = ENOENT; 537 return -1; 538 } 539 540 if (strcmp(method, "ums")) { 541 errno = ENOSYS; 542 return -1; 543 } 544 545 if (v->getState() != Volume::State_Shared) { 546 *enabled = false; 547 } else { 548 *enabled = true; 549 } 550 return 0; 551} 552 553int VolumeManager::simulate(const char *cmd, const char *arg) { 554 555 if (!strcmp(cmd, "ums")) { 556 if (!strcmp(arg, "connect")) { 557 notifyUmsConnected(true); 558 } else if (!strcmp(arg, "disconnect")) { 559 notifyUmsConnected(false); 560 } else { 561 errno = EINVAL; 562 return -1; 563 } 564 } else { 565 errno = EINVAL; 566 return -1; 567 } 568 return 0; 569} 570 571int VolumeManager::shareVolume(const char *label, const char *method) { 572 Volume *v = lookupVolume(label); 573 574 if (!v) { 575 errno = ENOENT; 576 return -1; 577 } 578 579 /* 580 * Eventually, we'll want to support additional share back-ends, 581 * some of which may work while the media is mounted. For now, 582 * we just support UMS 583 */ 584 if (strcmp(method, "ums")) { 585 errno = ENOSYS; 586 return -1; 587 } 588 589 if (v->getState() == Volume::State_NoMedia) { 590 errno = ENODEV; 591 return -1; 592 } 593 594 if (v->getState() != Volume::State_Idle) { 595 // You need to unmount manually befoe sharing 596 errno = EBUSY; 597 return -1; 598 } 599 600 dev_t d = v->getDiskDevice(); 601 if ((MAJOR(d) == 0) && (MINOR(d) == 0)) { 602 // This volume does not support raw disk access 603 errno = EINVAL; 604 return -1; 605 } 606 607 int fd; 608 char nodepath[255]; 609 snprintf(nodepath, 610 sizeof(nodepath), "/dev/block/vold/%d:%d", 611 MAJOR(d), MINOR(d)); 612 613 if ((fd = open("/sys/devices/platform/usb_mass_storage/lun0/file", 614 O_WRONLY)) < 0) { 615 LOGE("Unable to open ums lunfile (%s)", strerror(errno)); 616 return -1; 617 } 618 619 if (write(fd, nodepath, strlen(nodepath)) < 0) { 620 LOGE("Unable to write to ums lunfile (%s)", strerror(errno)); 621 close(fd); 622 return -1; 623 } 624 625 close(fd); 626 v->handleVolumeShared(); 627 return 0; 628} 629 630int VolumeManager::unshareVolume(const char *label, const char *method) { 631 Volume *v = lookupVolume(label); 632 633 if (!v) { 634 errno = ENOENT; 635 return -1; 636 } 637 638 if (strcmp(method, "ums")) { 639 errno = ENOSYS; 640 return -1; 641 } 642 643 if (v->getState() != Volume::State_Shared) { 644 errno = EINVAL; 645 return -1; 646 } 647 648 dev_t d = v->getDiskDevice(); 649 650 int fd; 651 char nodepath[255]; 652 snprintf(nodepath, 653 sizeof(nodepath), "/dev/block/vold/%d:%d", 654 MAJOR(d), MINOR(d)); 655 656 if ((fd = open("/sys/devices/platform/usb_mass_storage/lun0/file", O_WRONLY)) < 0) { 657 LOGE("Unable to open ums lunfile (%s)", strerror(errno)); 658 return -1; 659 } 660 661 char ch = 0; 662 if (write(fd, &ch, 1) < 0) { 663 LOGE("Unable to write to ums lunfile (%s)", strerror(errno)); 664 close(fd); 665 return -1; 666 } 667 668 close(fd); 669 v->handleVolumeUnshared(); 670 return 0; 671} 672 673int VolumeManager::unmountVolume(const char *label) { 674 Volume *v = lookupVolume(label); 675 676 if (!v) { 677 errno = ENOENT; 678 return -1; 679 } 680 681 if (v->getState() == Volume::State_NoMedia) { 682 errno = ENODEV; 683 return -1; 684 } 685 686 if (v->getState() != Volume::State_Mounted) { 687 LOGW("Attempt to unmount volume which isn't mounted (%d)\n", 688 v->getState()); 689 errno = EBUSY; 690 return -1; 691 } 692 693 while(mActiveContainers->size()) { 694 AsecIdCollection::iterator it = mActiveContainers->begin(); 695 LOGI("Unmounting ASEC %s (dependant on %s)", *it, v->getMountpoint()); 696 if (unmountAsec(*it)) { 697 LOGE("Failed to unmount ASEC %s (%s) - unmount of %s may fail!", *it, 698 strerror(errno), v->getMountpoint()); 699 } 700 } 701 702 return v->unmountVol(); 703} 704 705/* 706 * Looks up a volume by it's label or mount-point 707 */ 708Volume *VolumeManager::lookupVolume(const char *label) { 709 VolumeCollection::iterator i; 710 711 for (i = mVolumes->begin(); i != mVolumes->end(); ++i) { 712 if (label[0] == '/') { 713 if (!strcmp(label, (*i)->getMountpoint())) 714 return (*i); 715 } else { 716 if (!strcmp(label, (*i)->getLabel())) 717 return (*i); 718 } 719 } 720 return NULL; 721} 722 723bool VolumeManager::isMountpointMounted(const char *mp) 724{ 725 char device[256]; 726 char mount_path[256]; 727 char rest[256]; 728 FILE *fp; 729 char line[1024]; 730 731 if (!(fp = fopen("/proc/mounts", "r"))) { 732 LOGE("Error opening /proc/mounts (%s)", strerror(errno)); 733 return false; 734 } 735 736 while(fgets(line, sizeof(line), fp)) { 737 line[strlen(line)-1] = '\0'; 738 sscanf(line, "%255s %255s %255s\n", device, mount_path, rest); 739 if (!strcmp(mount_path, mp)) { 740 fclose(fp); 741 return true; 742 } 743 744 } 745 746 fclose(fp); 747 return false; 748} 749 750