VolumeManager.cpp revision 048b0801fcd6fcfbb8fa812284c751181e4821b8
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, int, 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 323int VolumeManager::unmountAsec(const char *id) { 324 char asecFileName[255]; 325 char mountPoint[255]; 326 327 snprintf(asecFileName, sizeof(asecFileName), 328 "/sdcard/android_secure/%s.asec", id); 329 snprintf(mountPoint, sizeof(mountPoint), "/asec/%s", id); 330 331 if (!isMountpointMounted(mountPoint)) { 332 LOGE("Unmount request for ASEC %s when not mounted", id); 333 errno = EINVAL; 334 return -1; 335 } 336 337 int i, rc; 338 for (i = 0; i < 10; i++) { 339 rc = umount(mountPoint); 340 if (!rc) { 341 break; 342 } 343 if (rc && (errno == EINVAL || errno == ENOENT)) { 344 rc = 0; 345 break; 346 } 347 LOGW("ASEC %s unmount attempt %d failed (%s)", 348 id, i +1, strerror(errno)); 349 350 if (i >= 5) { 351 KillProcessesWithOpenFiles(mountPoint, (i < 7 ? 0 : 1), 352 NULL, 0); 353 } 354 usleep(1000 * 250); 355 } 356 357 if (rc) { 358 LOGE("Failed to unmount ASEC %s", id); 359 return -1; 360 } 361 362 unlink(mountPoint); 363 364 if (Devmapper::destroy(id) && errno != ENXIO) { 365 LOGE("Failed to destroy devmapper instance (%s)", strerror(errno)); 366 } 367 368 char loopDevice[255]; 369 if (!Loop::lookupActive(asecFileName, loopDevice, sizeof(loopDevice))) { 370 Loop::destroyByDevice(loopDevice); 371 } 372 373 AsecIdCollection::iterator it; 374 for (it = mActiveContainers->begin(); it != mActiveContainers->end(); ++it) { 375 if (!strcmp(*it, id)) { 376 free(*it); 377 mActiveContainers->erase(it); 378 break; 379 } 380 } 381 if (it == mActiveContainers->end()) { 382 LOGW("mActiveContainers is inconsistent!"); 383 } 384 return 0; 385} 386 387int VolumeManager::destroyAsec(const char *id) { 388 char asecFileName[255]; 389 char mountPoint[255]; 390 391 snprintf(asecFileName, sizeof(asecFileName), 392 "/sdcard/android_secure/%s.asec", id); 393 snprintf(mountPoint, sizeof(mountPoint), "/asec/%s", id); 394 395 if (isMountpointMounted(mountPoint)) { 396 LOGD("Unmounting container before destroy"); 397 if (unmountAsec(id)) { 398 LOGE("Failed to unmount asec %s for destroy (%s)", id, strerror(errno)); 399 return -1; 400 } 401 } 402 403 if (unlink(asecFileName)) { 404 LOGE("Failed to unlink asec '%s' (%s)", asecFileName, strerror(errno)); 405 return -1; 406 } 407 408 LOGD("ASEC %s destroyed", id); 409 return 0; 410} 411 412int VolumeManager::mountAsec(const char *id, const char *key, int ownerUid) { 413 char asecFileName[255]; 414 char mountPoint[255]; 415 416 snprintf(asecFileName, sizeof(asecFileName), 417 "/sdcard/android_secure/%s.asec", id); 418 snprintf(mountPoint, sizeof(mountPoint), "/asec/%s", id); 419 420 if (isMountpointMounted(mountPoint)) { 421 LOGE("ASEC %s already mounted", id); 422 errno = EBUSY; 423 return -1; 424 } 425 426 char loopDevice[255]; 427 if (Loop::lookupActive(asecFileName, loopDevice, sizeof(loopDevice))) { 428 if (Loop::create(asecFileName, loopDevice, sizeof(loopDevice))) { 429 LOGE("ASEC loop device creation failed (%s)", strerror(errno)); 430 return -1; 431 } 432 LOGD("New loop device created at %s", loopDevice); 433 } else { 434 LOGD("Found active loopback for %s at %s", asecFileName, loopDevice); 435 } 436 437 char dmDevice[255]; 438 bool cleanupDm = false; 439 if (strcmp(key, "none")) { 440 if (Devmapper::lookupActive(id, dmDevice, sizeof(dmDevice))) { 441 unsigned int nr_sec = 0; 442 int fd; 443 444 if ((fd = open(loopDevice, O_RDWR)) < 0) { 445 LOGE("Failed to open loopdevice (%s)", strerror(errno)); 446 Loop::destroyByDevice(loopDevice); 447 return -1; 448 } 449 450 if (ioctl(fd, BLKGETSIZE, &nr_sec)) { 451 LOGE("Failed to get loop size (%s)", strerror(errno)); 452 Loop::destroyByDevice(loopDevice); 453 close(fd); 454 return -1; 455 } 456 close(fd); 457 if (Devmapper::create(id, loopDevice, key, nr_sec, 458 dmDevice, sizeof(dmDevice))) { 459 LOGE("ASEC device mapping failed (%s)", strerror(errno)); 460 Loop::destroyByDevice(loopDevice); 461 return -1; 462 } 463 LOGD("New devmapper instance created at %s", dmDevice); 464 } else { 465 LOGD("Found active devmapper for %s at %s", asecFileName, dmDevice); 466 } 467 cleanupDm = true; 468 } else { 469 strcpy(dmDevice, loopDevice); 470 } 471 472 if (mkdir(mountPoint, 0777)) { 473 if (errno != EEXIST) { 474 LOGE("Mountpoint creation failed (%s)", strerror(errno)); 475 if (cleanupDm) { 476 Devmapper::destroy(id); 477 } 478 Loop::destroyByDevice(loopDevice); 479 return -1; 480 } 481 } 482 483 if (Fat::doMount(dmDevice, mountPoint, true, false, ownerUid, 0, 484 0222, false)) { 485// 0227, false)) { 486 LOGE("ASEC mount failed (%s)", strerror(errno)); 487 if (cleanupDm) { 488 Devmapper::destroy(id); 489 } 490 Loop::destroyByDevice(loopDevice); 491 return -1; 492 } 493 494 mActiveContainers->push_back(strdup(id)); 495 LOGD("ASEC %s mounted", id); 496 return 0; 497} 498 499int VolumeManager::mountVolume(const char *label) { 500 Volume *v = lookupVolume(label); 501 502 if (!v) { 503 errno = ENOENT; 504 return -1; 505 } 506 507 return v->mountVol(); 508} 509 510int VolumeManager::shareAvailable(const char *method, bool *avail) { 511 512 if (strcmp(method, "ums")) { 513 errno = ENOSYS; 514 return -1; 515 } 516 517 if (mUsbMassStorageConnected) 518 *avail = true; 519 else 520 *avail = false; 521 return 0; 522} 523 524int VolumeManager::simulate(const char *cmd, const char *arg) { 525 526 if (!strcmp(cmd, "ums")) { 527 if (!strcmp(arg, "connect")) { 528 notifyUmsConnected(true); 529 } else if (!strcmp(arg, "disconnect")) { 530 notifyUmsConnected(false); 531 } else { 532 errno = EINVAL; 533 return -1; 534 } 535 } else { 536 errno = EINVAL; 537 return -1; 538 } 539 return 0; 540} 541 542int VolumeManager::shareVolume(const char *label, const char *method) { 543 Volume *v = lookupVolume(label); 544 545 if (!v) { 546 errno = ENOENT; 547 return -1; 548 } 549 550 /* 551 * Eventually, we'll want to support additional share back-ends, 552 * some of which may work while the media is mounted. For now, 553 * we just support UMS 554 */ 555 if (strcmp(method, "ums")) { 556 errno = ENOSYS; 557 return -1; 558 } 559 560 if (v->getState() == Volume::State_NoMedia) { 561 errno = ENODEV; 562 return -1; 563 } 564 565 if (v->getState() != Volume::State_Idle) { 566 // You need to unmount manually befoe sharing 567 errno = EBUSY; 568 return -1; 569 } 570 571 dev_t d = v->getDiskDevice(); 572 if ((MAJOR(d) == 0) && (MINOR(d) == 0)) { 573 // This volume does not support raw disk access 574 errno = EINVAL; 575 return -1; 576 } 577 578 int fd; 579 char nodepath[255]; 580 snprintf(nodepath, 581 sizeof(nodepath), "/dev/block/vold/%d:%d", 582 MAJOR(d), MINOR(d)); 583 584 if ((fd = open("/sys/devices/platform/usb_mass_storage/lun0/file", 585 O_WRONLY)) < 0) { 586 LOGE("Unable to open ums lunfile (%s)", strerror(errno)); 587 return -1; 588 } 589 590 if (write(fd, nodepath, strlen(nodepath)) < 0) { 591 LOGE("Unable to write to ums lunfile (%s)", strerror(errno)); 592 close(fd); 593 return -1; 594 } 595 596 close(fd); 597 v->handleVolumeShared(); 598 return 0; 599} 600 601int VolumeManager::unshareVolume(const char *label, const char *method) { 602 Volume *v = lookupVolume(label); 603 604 if (!v) { 605 errno = ENOENT; 606 return -1; 607 } 608 609 if (strcmp(method, "ums")) { 610 errno = ENOSYS; 611 return -1; 612 } 613 614 if (v->getState() != Volume::State_Shared) { 615 errno = EINVAL; 616 return -1; 617 } 618 619 dev_t d = v->getDiskDevice(); 620 621 int fd; 622 char nodepath[255]; 623 snprintf(nodepath, 624 sizeof(nodepath), "/dev/block/vold/%d:%d", 625 MAJOR(d), MINOR(d)); 626 627 if ((fd = open("/sys/devices/platform/usb_mass_storage/lun0/file", O_WRONLY)) < 0) { 628 LOGE("Unable to open ums lunfile (%s)", strerror(errno)); 629 return -1; 630 } 631 632 char ch = 0; 633 if (write(fd, &ch, 1) < 0) { 634 LOGE("Unable to write to ums lunfile (%s)", strerror(errno)); 635 close(fd); 636 return -1; 637 } 638 639 close(fd); 640 v->handleVolumeUnshared(); 641 return 0; 642} 643 644int VolumeManager::unmountVolume(const char *label) { 645 Volume *v = lookupVolume(label); 646 647 if (!v) { 648 errno = ENOENT; 649 return -1; 650 } 651 652 if (v->getState() == Volume::State_NoMedia) { 653 errno = ENODEV; 654 return -1; 655 } 656 657 if (v->getState() != Volume::State_Mounted) { 658 LOGW("Attempt to unmount volume which isn't mounted (%d)\n", 659 v->getState()); 660 errno = EBUSY; 661 return -1; 662 } 663 664 while(mActiveContainers->size()) { 665 AsecIdCollection::iterator it = mActiveContainers->begin(); 666 LOGI("Unmounting ASEC %s (dependant on %s)", *it, v->getMountpoint()); 667 if (unmountAsec(*it)) { 668 LOGE("Failed to unmount ASEC %s (%s) - unmount of %s may fail!", *it, 669 strerror(errno), v->getMountpoint()); 670 } 671 } 672 673 return v->unmountVol(); 674} 675 676/* 677 * Looks up a volume by it's label or mount-point 678 */ 679Volume *VolumeManager::lookupVolume(const char *label) { 680 VolumeCollection::iterator i; 681 682 for (i = mVolumes->begin(); i != mVolumes->end(); ++i) { 683 if (label[0] == '/') { 684 if (!strcmp(label, (*i)->getMountpoint())) 685 return (*i); 686 } else { 687 if (!strcmp(label, (*i)->getLabel())) 688 return (*i); 689 } 690 } 691 return NULL; 692} 693 694bool VolumeManager::isMountpointMounted(const char *mp) 695{ 696 char device[256]; 697 char mount_path[256]; 698 char rest[256]; 699 FILE *fp; 700 char line[1024]; 701 702 if (!(fp = fopen("/proc/mounts", "r"))) { 703 LOGE("Error opening /proc/mounts (%s)", strerror(errno)); 704 return false; 705 } 706 707 while(fgets(line, sizeof(line), fp)) { 708 line[strlen(line)-1] = '\0'; 709 sscanf(line, "%255s %255s %255s\n", device, mount_path, rest); 710 if (!strcmp(mount_path, mp)) { 711 fclose(fp); 712 return true; 713 } 714 715 } 716 717 fclose(fp); 718 return false; 719} 720 721