VolumeManager.cpp revision 0586d54053ee00e6d6523d4f125282ccb9a24aab
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 mBroadcaster = NULL; 55 mUsbMassStorageConnected = false; 56} 57 58VolumeManager::~VolumeManager() { 59 delete mBlockDevices; 60} 61 62int VolumeManager::start() { 63 return 0; 64} 65 66int VolumeManager::stop() { 67 return 0; 68} 69 70int VolumeManager::addVolume(Volume *v) { 71 mVolumes->push_back(v); 72 return 0; 73} 74 75void VolumeManager::notifyUmsConnected(bool connected) { 76 char msg[255]; 77 78 if (connected) { 79 mUsbMassStorageConnected = true; 80 } else { 81 mUsbMassStorageConnected = false; 82 } 83 snprintf(msg, sizeof(msg), "Share method ums now %s", 84 (connected ? "available" : "unavailable")); 85 86 getBroadcaster()->sendBroadcast(ResponseCode::ShareAvailabilityChange, 87 msg, false); 88} 89 90void VolumeManager::handleSwitchEvent(NetlinkEvent *evt) { 91 const char *devpath = evt->findParam("DEVPATH"); 92 const char *name = evt->findParam("SWITCH_NAME"); 93 const char *state = evt->findParam("SWITCH_STATE"); 94 95 if (!name || !state) { 96 LOGW("Switch %s event missing name/state info", devpath); 97 return; 98 } 99 100 if (!strcmp(name, "usb_mass_storage")) { 101 102 if (!strcmp(state, "online")) { 103 notifyUmsConnected(true); 104 } else { 105 notifyUmsConnected(false); 106 } 107 } else { 108 LOGW("Ignoring unknown switch '%s'", name); 109 } 110} 111 112void VolumeManager::handleBlockEvent(NetlinkEvent *evt) { 113 const char *devpath = evt->findParam("DEVPATH"); 114 115 /* Lookup a volume to handle this device */ 116 VolumeCollection::iterator it; 117 bool hit = false; 118 for (it = mVolumes->begin(); it != mVolumes->end(); ++it) { 119 if (!(*it)->handleBlockEvent(evt)) { 120#ifdef NETLINK_DEBUG 121 LOGD("Device '%s' event handled by volume %s\n", devpath, (*it)->getLabel()); 122#endif 123 hit = true; 124 break; 125 } 126 } 127 128 if (!hit) { 129#ifdef NETLINK_DEBUG 130 LOGW("No volumes handled block event for '%s'", devpath); 131#endif 132 } 133} 134 135int VolumeManager::listVolumes(SocketClient *cli) { 136 VolumeCollection::iterator i; 137 138 for (i = mVolumes->begin(); i != mVolumes->end(); ++i) { 139 char *buffer; 140 asprintf(&buffer, "%s %s %d", 141 (*i)->getLabel(), (*i)->getMountpoint(), 142 (*i)->getState()); 143 cli->sendMsg(ResponseCode::VolumeListResult, buffer, false); 144 free(buffer); 145 } 146 cli->sendMsg(ResponseCode::CommandOkay, "Volumes listed.", false); 147 return 0; 148} 149 150int VolumeManager::formatVolume(const char *label) { 151 Volume *v = lookupVolume(label); 152 153 if (!v) { 154 errno = ENOENT; 155 return -1; 156 } 157 158 return v->formatVol(); 159} 160 161int VolumeManager::getAsecMountPath(const char *id, char *buffer, int maxlen) { 162 char mountPoint[255]; 163 164 snprintf(mountPoint, sizeof(mountPoint), "/asec/%s", id); 165 166 if (!isMountpointMounted(mountPoint)) { 167 errno = ENOENT; 168 return -1; 169 } 170 snprintf(buffer, maxlen, "/asec/%s", id); 171 return 0; 172} 173 174int VolumeManager::createAsec(const char *id, unsigned int numSectors, 175 const char *fstype, const char *key, int ownerUid) { 176 177 mkdir("/sdcard/android_secure", 0777); 178 179 if (lookupVolume(id)) { 180 LOGE("ASEC volume '%s' currently exists", id); 181 errno = EADDRINUSE; 182 return -1; 183 } 184 185 char asecFileName[255]; 186 snprintf(asecFileName, sizeof(asecFileName), 187 "/sdcard/android_secure/%s.asec", id); 188 189 if (!access(asecFileName, F_OK)) { 190 LOGE("ASEC file '%s' currently exists - destroy it first! (%s)", 191 asecFileName, strerror(errno)); 192 errno = EADDRINUSE; 193 return -1; 194 } 195 196 if (Loop::createImageFile(asecFileName, numSectors)) { 197 LOGE("ASEC image file creation failed (%s)", strerror(errno)); 198 return -1; 199 } 200 201 char loopDevice[255]; 202 if (Loop::create(asecFileName, loopDevice, sizeof(loopDevice))) { 203 LOGE("ASEC loop device creation failed (%s)", strerror(errno)); 204 unlink(asecFileName); 205 return -1; 206 } 207 208 char dmDevice[255]; 209 bool cleanupDm = false; 210 211 if (strcmp(key, "none")) { 212 if (Devmapper::create(id, loopDevice, key, numSectors, dmDevice, 213 sizeof(dmDevice))) { 214 LOGE("ASEC device mapping failed (%s)", strerror(errno)); 215 Loop::destroyByDevice(loopDevice); 216 unlink(asecFileName); 217 return -1; 218 } 219 cleanupDm = true; 220 } else { 221 strcpy(dmDevice, loopDevice); 222 } 223 224 if (Fat::format(dmDevice)) { 225 LOGE("ASEC FAT format failed (%s)", strerror(errno)); 226 if (cleanupDm) { 227 Devmapper::destroy(id); 228 } 229 Loop::destroyByDevice(loopDevice); 230 unlink(asecFileName); 231 return -1; 232 } 233 234 char mountPoint[255]; 235 236 snprintf(mountPoint, sizeof(mountPoint), "/asec/%s", id); 237 if (mkdir(mountPoint, 0777)) { 238 if (errno != EEXIST) { 239 LOGE("Mountpoint creation failed (%s)", strerror(errno)); 240 if (cleanupDm) { 241 Devmapper::destroy(id); 242 } 243 Loop::destroyByDevice(loopDevice); 244 unlink(asecFileName); 245 return -1; 246 } 247 } 248 249 if (Fat::doMount(dmDevice, mountPoint, false, false, ownerUid, 250 0, 0000, false)) { 251// 0, 0007, false)) { 252 LOGE("ASEC FAT mount failed (%s)", strerror(errno)); 253 if (cleanupDm) { 254 Devmapper::destroy(id); 255 } 256 Loop::destroyByDevice(loopDevice); 257 unlink(asecFileName); 258 return -1; 259 } 260 261 return 0; 262} 263 264int VolumeManager::finalizeAsec(const char *id) { 265 char asecFileName[255]; 266 char loopDevice[255]; 267 char mountPoint[255]; 268 269 snprintf(asecFileName, sizeof(asecFileName), 270 "/sdcard/android_secure/%s.asec", id); 271 272 if (Loop::lookupActive(asecFileName, loopDevice, sizeof(loopDevice))) { 273 LOGE("Unable to finalize %s (%s)", id, strerror(errno)); 274 return -1; 275 } 276 277 snprintf(mountPoint, sizeof(mountPoint), "/asec/%s", id); 278 // XXX: 279 if (Fat::doMount(loopDevice, mountPoint, true, true, 0, 0, 0227, false)) { 280 LOGE("ASEC finalize mount failed (%s)", strerror(errno)); 281 return -1; 282 } 283 284 LOGD("ASEC %s finalized", id); 285 return 0; 286} 287 288int VolumeManager::unmountAsec(const char *id) { 289 char asecFileName[255]; 290 char mountPoint[255]; 291 292 snprintf(asecFileName, sizeof(asecFileName), 293 "/sdcard/android_secure/%s.asec", id); 294 snprintf(mountPoint, sizeof(mountPoint), "/asec/%s", id); 295 296 if (!isMountpointMounted(mountPoint)) { 297 LOGE("Unmount request for ASEC %s when not mounted", id); 298 errno = EINVAL; 299 return -1; 300 } 301 302 int i, rc; 303 for (i = 0; i < 10; i++) { 304 rc = umount(mountPoint); 305 if (!rc) { 306 break; 307 } 308 if (rc && (errno == EINVAL || errno == ENOENT)) { 309 rc = 0; 310 break; 311 } 312 LOGW("ASEC %s unmount attempt %d failed (%s)", 313 id, i +1, strerror(errno)); 314 315 if (i >= 5) { 316 KillProcessesWithOpenFiles(mountPoint, (i < 7 ? 0 : 1), 317 NULL, 0); 318 } 319 usleep(1000 * 250); 320 } 321 322 if (rc) { 323 LOGE("Failed to unmount ASEC %s", id); 324 return -1; 325 } 326 327 if (Devmapper::destroy(id) && errno != ENXIO) { 328 LOGE("Failed to destroy devmapper instance (%s)", strerror(errno)); 329 } 330 331 char loopDevice[255]; 332 if (!Loop::lookupActive(asecFileName, loopDevice, sizeof(loopDevice))) { 333 Loop::destroyByDevice(loopDevice); 334 } 335 return 0; 336} 337 338int VolumeManager::destroyAsec(const char *id) { 339 char asecFileName[255]; 340 char mountPoint[255]; 341 342 snprintf(asecFileName, sizeof(asecFileName), 343 "/sdcard/android_secure/%s.asec", id); 344 snprintf(mountPoint, sizeof(mountPoint), "/asec/%s", id); 345 346 if (isMountpointMounted(mountPoint)) { 347 if (unmountAsec(id)) { 348 LOGE("Failed to unmount asec %s for destroy (%s)", id, strerror(errno)); 349 return -1; 350 } 351 } 352 353 if (unlink(asecFileName)) { 354 LOGE("Failed to unlink asec %s (%s)", id, strerror(errno)); 355 return -1; 356 } 357 358 LOGD("ASEC %s destroyed", id); 359 return 0; 360} 361 362int VolumeManager::mountAsec(const char *id, const char *key, int ownerUid) { 363 char asecFileName[255]; 364 char mountPoint[255]; 365 366 snprintf(asecFileName, sizeof(asecFileName), 367 "/sdcard/android_secure/%s.asec", id); 368 snprintf(mountPoint, sizeof(mountPoint), "/asec/%s", id); 369 370 if (isMountpointMounted(mountPoint)) { 371 LOGE("ASEC %s already mounted", id); 372 errno = EBUSY; 373 return -1; 374 } 375 376 char loopDevice[255]; 377 if (Loop::lookupActive(asecFileName, loopDevice, sizeof(loopDevice))) { 378 if (Loop::create(asecFileName, loopDevice, sizeof(loopDevice))) { 379 LOGE("ASEC loop device creation failed (%s)", strerror(errno)); 380 return -1; 381 } 382 LOGD("New loop device created at %s", loopDevice); 383 } else { 384 LOGD("Found active loopback for %s at %s", asecFileName, loopDevice); 385 } 386 387 char dmDevice[255]; 388 bool cleanupDm = false; 389 if (strcmp(key, "none")) { 390 if (Devmapper::lookupActive(id, dmDevice, sizeof(dmDevice))) { 391 unsigned int nr_sec = 0; 392 int fd; 393 394 if ((fd = open(loopDevice, O_RDWR)) < 0) { 395 LOGE("Failed to open loopdevice (%s)", strerror(errno)); 396 Loop::destroyByDevice(loopDevice); 397 return -1; 398 } 399 400 if (ioctl(fd, BLKGETSIZE, &nr_sec)) { 401 LOGE("Failed to get loop size (%s)", strerror(errno)); 402 Loop::destroyByDevice(loopDevice); 403 close(fd); 404 return -1; 405 } 406 close(fd); 407 if (Devmapper::create(id, loopDevice, key, nr_sec, 408 dmDevice, sizeof(dmDevice))) { 409 LOGE("ASEC device mapping failed (%s)", strerror(errno)); 410 Loop::destroyByDevice(loopDevice); 411 return -1; 412 } 413 LOGD("New devmapper instance created at %s", dmDevice); 414 } else { 415 LOGD("Found active devmapper for %s at %s", asecFileName, dmDevice); 416 } 417 cleanupDm = true; 418 } else { 419 strcpy(dmDevice, loopDevice); 420 } 421 422 if (mkdir(mountPoint, 0777)) { 423 if (errno != EEXIST) { 424 LOGE("Mountpoint creation failed (%s)", strerror(errno)); 425 if (cleanupDm) { 426 Devmapper::destroy(id); 427 } 428 Loop::destroyByDevice(loopDevice); 429 return -1; 430 } 431 } 432 433 if (Fat::doMount(dmDevice, mountPoint, true, false, ownerUid, 0, 434 0222, false)) { 435// 0227, false)) { 436 LOGE("ASEC mount failed (%s)", strerror(errno)); 437 if (cleanupDm) { 438 Devmapper::destroy(id); 439 } 440 Loop::destroyByDevice(loopDevice); 441 return -1; 442 } 443 444 LOGD("ASEC %s mounted", id); 445 return 0; 446} 447 448int VolumeManager::mountVolume(const char *label) { 449 Volume *v = lookupVolume(label); 450 451 if (!v) { 452 errno = ENOENT; 453 return -1; 454 } 455 456 return v->mountVol(); 457} 458 459int VolumeManager::shareAvailable(const char *method, bool *avail) { 460 461 if (strcmp(method, "ums")) { 462 errno = ENOSYS; 463 return -1; 464 } 465 466 if (mUsbMassStorageConnected) 467 *avail = true; 468 else 469 *avail = false; 470 return 0; 471} 472 473int VolumeManager::simulate(const char *cmd, const char *arg) { 474 475 if (!strcmp(cmd, "ums")) { 476 if (!strcmp(arg, "connect")) { 477 notifyUmsConnected(true); 478 } else if (!strcmp(arg, "disconnect")) { 479 notifyUmsConnected(false); 480 } else { 481 errno = EINVAL; 482 return -1; 483 } 484 } else { 485 errno = EINVAL; 486 return -1; 487 } 488 return 0; 489} 490 491int VolumeManager::shareVolume(const char *label, const char *method) { 492 Volume *v = lookupVolume(label); 493 494 if (!v) { 495 errno = ENOENT; 496 return -1; 497 } 498 499 /* 500 * Eventually, we'll want to support additional share back-ends, 501 * some of which may work while the media is mounted. For now, 502 * we just support UMS 503 */ 504 if (strcmp(method, "ums")) { 505 errno = ENOSYS; 506 return -1; 507 } 508 509 if (v->getState() == Volume::State_NoMedia) { 510 errno = ENODEV; 511 return -1; 512 } 513 514 if (v->getState() != Volume::State_Idle) { 515 // You need to unmount manually befoe sharing 516 errno = EBUSY; 517 return -1; 518 } 519 520 dev_t d = v->getDiskDevice(); 521 if ((MAJOR(d) == 0) && (MINOR(d) == 0)) { 522 // This volume does not support raw disk access 523 errno = EINVAL; 524 return -1; 525 } 526 527 int fd; 528 char nodepath[255]; 529 snprintf(nodepath, 530 sizeof(nodepath), "/dev/block/vold/%d:%d", 531 MAJOR(d), MINOR(d)); 532 533 if ((fd = open("/sys/devices/platform/usb_mass_storage/lun0/file", 534 O_WRONLY)) < 0) { 535 LOGE("Unable to open ums lunfile (%s)", strerror(errno)); 536 return -1; 537 } 538 539 if (write(fd, nodepath, strlen(nodepath)) < 0) { 540 LOGE("Unable to write to ums lunfile (%s)", strerror(errno)); 541 close(fd); 542 return -1; 543 } 544 545 close(fd); 546 v->handleVolumeShared(); 547 return 0; 548} 549 550int VolumeManager::unshareVolume(const char *label, const char *method) { 551 Volume *v = lookupVolume(label); 552 553 if (!v) { 554 errno = ENOENT; 555 return -1; 556 } 557 558 if (strcmp(method, "ums")) { 559 errno = ENOSYS; 560 return -1; 561 } 562 563 if (v->getState() != Volume::State_Shared) { 564 errno = EINVAL; 565 return -1; 566 } 567 568 dev_t d = v->getDiskDevice(); 569 570 int fd; 571 char nodepath[255]; 572 snprintf(nodepath, 573 sizeof(nodepath), "/dev/block/vold/%d:%d", 574 MAJOR(d), MINOR(d)); 575 576 if ((fd = open("/sys/devices/platform/usb_mass_storage/lun0/file", O_WRONLY)) < 0) { 577 LOGE("Unable to open ums lunfile (%s)", strerror(errno)); 578 return -1; 579 } 580 581 char ch = 0; 582 if (write(fd, &ch, 1) < 0) { 583 LOGE("Unable to write to ums lunfile (%s)", strerror(errno)); 584 close(fd); 585 return -1; 586 } 587 588 close(fd); 589 v->handleVolumeUnshared(); 590 return 0; 591} 592 593int VolumeManager::unmountVolume(const char *label) { 594 Volume *v = lookupVolume(label); 595 596 if (!v) { 597 errno = ENOENT; 598 return -1; 599 } 600 601 if (v->getState() == Volume::State_NoMedia) { 602 errno = ENODEV; 603 return -1; 604 } 605 606 if (v->getState() != Volume::State_Mounted) { 607 LOGW("Attempt to unmount volume which isn't mounted (%d)\n", 608 v->getState()); 609 errno = EBUSY; 610 return -1; 611 } 612 613 return v->unmountVol(); 614} 615 616/* 617 * Looks up a volume by it's label or mount-point 618 */ 619Volume *VolumeManager::lookupVolume(const char *label) { 620 VolumeCollection::iterator i; 621 622 for (i = mVolumes->begin(); i != mVolumes->end(); ++i) { 623 if (label[0] == '/') { 624 if (!strcmp(label, (*i)->getMountpoint())) 625 return (*i); 626 } else { 627 if (!strcmp(label, (*i)->getLabel())) 628 return (*i); 629 } 630 } 631 return NULL; 632} 633 634bool VolumeManager::isMountpointMounted(const char *mp) 635{ 636 char device[256]; 637 char mount_path[256]; 638 char rest[256]; 639 FILE *fp; 640 char line[1024]; 641 642 if (!(fp = fopen("/proc/mounts", "r"))) { 643 LOGE("Error opening /proc/mounts (%s)", strerror(errno)); 644 return false; 645 } 646 647 while(fgets(line, sizeof(line), fp)) { 648 line[strlen(line)-1] = '\0'; 649 sscanf(line, "%255s %255s %255s\n", device, mount_path, rest); 650 if (!strcmp(mount_path, mp)) { 651 fclose(fp); 652 return true; 653 } 654 655 } 656 657 fclose(fp); 658 return false; 659} 660 661