Disk.cpp

   1 /*
   2  * Copyright (C) 2015 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 "Disk.h"
  18 #include "PublicVolume.h"
  19 #include "PrivateVolume.h"
  20 #include "Utils.h"
  21 #include "VolumeBase.h"
  22 #include "VolumeManager.h"
  23 #include "ResponseCode.h"
  24 #include "Ext4Crypt.h"
  25
  26 #include <android-base/file.h>
  27 #include <android-base/properties.h>
  28 #include <android-base/stringprintf.h>
  29 #include <android-base/logging.h>
  30 #include <diskconfig/diskconfig.h>
  31
  32 #include <vector>
  33 #include <fcntl.h>
  34 #include <inttypes.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <sys/types.h>
  38 #include <sys/stat.h>
  39 #include <sys/sysmacros.h>
  40 #include <sys/mount.h>
  41
  42 using android::base::ReadFileToString;
  43 using android::base::WriteStringToFile;
  44 using android::base::StringPrintf;
  45
  46 namespace android {
  47 namespace vold {
  48
  49 static const char* kSgdiskPath = "/system/bin/sgdisk";
  50 static const char* kSgdiskToken = " \t\n";
  51
  52 static const char* kSysfsLoopMaxMinors = "/sys/module/loop/parameters/max_part";
  53 static const char* kSysfsMmcMaxMinors = "/sys/module/mmcblk/parameters/perdev_minors";
  54
  55 static const unsigned int kMajorBlockLoop = 7;
  56 static const unsigned int kMajorBlockScsiA = 8;
  57 static const unsigned int kMajorBlockScsiB = 65;
  58 static const unsigned int kMajorBlockScsiC = 66;
  59 static const unsigned int kMajorBlockScsiD = 67;
  60 static const unsigned int kMajorBlockScsiE = 68;
  61 static const unsigned int kMajorBlockScsiF = 69;
  62 static const unsigned int kMajorBlockScsiG = 70;
  63 static const unsigned int kMajorBlockScsiH = 71;
  64 static const unsigned int kMajorBlockScsiI = 128;
  65 static const unsigned int kMajorBlockScsiJ = 129;
  66 static const unsigned int kMajorBlockScsiK = 130;
  67 static const unsigned int kMajorBlockScsiL = 131;
  68 static const unsigned int kMajorBlockScsiM = 132;
  69 static const unsigned int kMajorBlockScsiN = 133;
  70 static const unsigned int kMajorBlockScsiO = 134;
  71 static const unsigned int kMajorBlockScsiP = 135;
  72 static const unsigned int kMajorBlockMmc = 179;
  73 static const unsigned int kMajorBlockExperimentalMin = 240;
  74 static const unsigned int kMajorBlockExperimentalMax = 254;
  75
  76 static const char* kGptBasicData = "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7";
  77 static const char* kGptAndroidMeta = "19A710A2-B3CA-11E4-B026-10604B889DCF";
  78 static const char* kGptAndroidExpand = "193D1EA4-B3CA-11E4-B075-10604B889DCF";
  79
  80 enum class Table {
  81     kUnknown,
  82     kMbr,
  83     kGpt,
  84 };
  85
  86 static bool isVirtioBlkDevice(unsigned int major) {
  87     /*
  88      * The new emulator's "ranchu" virtual board no longer includes a goldfish
  89      * MMC-based SD card device; instead, it emulates SD cards with virtio-blk,
  90      * which has been supported by upstream kernel and QEMU for quite a while.
  91      * Unfortunately, the virtio-blk block device driver does not use a fixed
  92      * major number, but relies on the kernel to assign one from a specific
  93      * range of block majors, which are allocated for "LOCAL/EXPERIMENAL USE"
  94      * per Documentation/devices.txt. This is true even for the latest Linux
  95      * kernel (4.4; see init() in drivers/block/virtio_blk.c).
  96      *
  97      * This makes it difficult for vold to detect a virtio-blk based SD card.
  98      * The current solution checks two conditions (both must be met):
  99      *
 100      *  a) If the running environment is the emulator;
 101      *  b) If the major number is an experimental block device major number (for
 102      *     x86/x86_64 3.10 ranchu kernels, virtio-blk always gets major number
 103      *     253, but it is safer to match the range than just one value).
 104      *
 105      * Other conditions could be used, too, e.g. the hardware name should be
 106      * "ranchu", the device's sysfs path should end with "/block/vd[d-z]", etc.
 107      * But just having a) and b) is enough for now.
 108      */
 109     return IsRunningInEmulator() && major >= kMajorBlockExperimentalMin
 110             && major <= kMajorBlockExperimentalMax;
 111 }
 112
 113 Disk::Disk(const std::string& eventPath, dev_t device,
 114         const std::string& nickname, int flags) :
 115         mDevice(device), mSize(-1), mNickname(nickname), mFlags(flags), mCreated(
 116                 false), mJustPartitioned(false) {
 117     mId = StringPrintf("disk:%u,%u", major(device), minor(device));
 118     mEventPath = eventPath;
 119     mSysPath = StringPrintf("/sys/%s", eventPath.c_str());
 120     mDevPath = StringPrintf("/dev/block/vold/%s", mId.c_str());
 121     CreateDeviceNode(mDevPath, mDevice);
 122 }
 123
 124 Disk::~Disk() {
 125     CHECK(!mCreated);
 126     DestroyDeviceNode(mDevPath);
 127 }
 128
 129 std::shared_ptr<VolumeBase> Disk::findVolume(const std::string& id) {
 130     for (auto vol : mVolumes) {
 131         if (vol->getId() == id) {
 132             return vol;
 133         }
 134         auto stackedVol = vol->findVolume(id);
 135         if (stackedVol != nullptr) {
 136             return stackedVol;
 137         }
 138     }
 139     return nullptr;
 140 }
 141
 142 void Disk::listVolumes(VolumeBase::Type type, std::list<std::string>& list) {
 143     for (const auto& vol : mVolumes) {
 144         if (vol->getType() == type) {
 145             list.push_back(vol->getId());
 146         }
 147         // TODO: consider looking at stacked volumes
 148     }
 149 }
 150
 151 status_t Disk::create() {
 152     CHECK(!mCreated);
 153     mCreated = true;
 154     notifyEvent(ResponseCode::DiskCreated, StringPrintf("%d", mFlags));
 155     readMetadata();
 156     readPartitions();
 157     return OK;
 158 }
 159
 160 status_t Disk::destroy() {
 161     CHECK(mCreated);
 162     destroyAllVolumes();
 163     mCreated = false;
 164     notifyEvent(ResponseCode::DiskDestroyed);
 165     return OK;
 166 }
 167
 168 void Disk::createPublicVolume(dev_t device) {
 169     auto vol = std::shared_ptr<VolumeBase>(new PublicVolume(device));
 170     if (mJustPartitioned) {
 171         LOG(DEBUG) << "Device just partitioned; silently formatting";
 172         vol->setSilent(true);
 173         vol->create();
 174         vol->format("auto");
 175         vol->destroy();
 176         vol->setSilent(false);
 177     }
 178
 179     mVolumes.push_back(vol);
 180     vol->setDiskId(getId());
 181     vol->create();
 182 }
 183
 184 void Disk::createPrivateVolume(dev_t device, const std::string& partGuid) {
 185     std::string normalizedGuid;
 186     if (NormalizeHex(partGuid, normalizedGuid)) {
 187         LOG(WARNING) << "Invalid GUID " << partGuid;
 188         return;
 189     }
 190
 191     std::string keyRaw;
 192     if (!ReadFileToString(BuildKeyPath(normalizedGuid), &keyRaw)) {
 193         PLOG(ERROR) << "Failed to load key for GUID " << normalizedGuid;
 194         return;
 195     }
 196
 197     LOG(DEBUG) << "Found key for GUID " << normalizedGuid;
 198
 199     auto vol = std::shared_ptr<VolumeBase>(new PrivateVolume(device, keyRaw));
 200     if (mJustPartitioned) {
 201         LOG(DEBUG) << "Device just partitioned; silently formatting";
 202         vol->setSilent(true);
 203         vol->create();
 204         vol->format("auto");
 205         vol->destroy();
 206         vol->setSilent(false);
 207     }
 208
 209     mVolumes.push_back(vol);
 210     vol->setDiskId(getId());
 211     vol->setPartGuid(partGuid);
 212     vol->create();
 213 }
 214
 215 void Disk::destroyAllVolumes() {
 216     for (const auto& vol : mVolumes) {
 217         vol->destroy();
 218     }
 219     mVolumes.clear();
 220 }
 221
 222 status_t Disk::readMetadata() {
 223     mSize = -1;
 224     mLabel.clear();
 225
 226     int fd = open(mDevPath.c_str(), O_RDONLY | O_CLOEXEC);
 227     if (fd != -1) {
 228         if (ioctl(fd, BLKGETSIZE64, &mSize)) {
 229             mSize = -1;
 230         }
 231         close(fd);
 232     }
 233
 234     unsigned int majorId = major(mDevice);
 235     switch (majorId) {
 236     case kMajorBlockLoop: {
 237         mLabel = "Virtual";
 238         break;
 239     }
 240     case kMajorBlockScsiA: case kMajorBlockScsiB: case kMajorBlockScsiC: case kMajorBlockScsiD:
 241     case kMajorBlockScsiE: case kMajorBlockScsiF: case kMajorBlockScsiG: case kMajorBlockScsiH:
 242     case kMajorBlockScsiI: case kMajorBlockScsiJ: case kMajorBlockScsiK: case kMajorBlockScsiL:
 243     case kMajorBlockScsiM: case kMajorBlockScsiN: case kMajorBlockScsiO: case kMajorBlockScsiP: {
 244         std::string path(mSysPath + "/device/vendor");
 245         std::string tmp;
 246         if (!ReadFileToString(path, &tmp)) {
 247             PLOG(WARNING) << "Failed to read vendor from " << path;
 248             return -errno;
 249         }
 250         mLabel = tmp;
 251         break;
 252     }
 253     case kMajorBlockMmc: {
 254         std::string path(mSysPath + "/device/manfid");
 255         std::string tmp;
 256         if (!ReadFileToString(path, &tmp)) {
 257             PLOG(WARNING) << "Failed to read manufacturer from " << path;
 258             return -errno;
 259         }
 260         uint64_t manfid = strtoll(tmp.c_str(), nullptr, 16);
 261         // Our goal here is to give the user a meaningful label, ideally
 262         // matching whatever is silk-screened on the card.  To reduce
 263         // user confusion, this list doesn't contain white-label manfid.
 264         switch (manfid) {
 265         case 0x000003: mLabel = "SanDisk"; break;
 266         case 0x00001b: mLabel = "Samsung"; break;
 267         case 0x000028: mLabel = "Lexar"; break;
 268         case 0x000074: mLabel = "Transcend"; break;
 269         }
 270         break;
 271     }
 272     default: {
 273         if (isVirtioBlkDevice(majorId)) {
 274             LOG(DEBUG) << "Recognized experimental block major ID " << majorId
 275                     << " as virtio-blk (emulator's virtual SD card device)";
 276             mLabel = "Virtual";
 277             break;
 278         }
 279         LOG(WARNING) << "Unsupported block major type " << majorId;
 280         return -ENOTSUP;
 281     }
 282     }
 283
 284     notifyEvent(ResponseCode::DiskSizeChanged, StringPrintf("%" PRIu64, mSize));
 285     notifyEvent(ResponseCode::DiskLabelChanged, mLabel);
 286     notifyEvent(ResponseCode::DiskSysPathChanged, mSysPath);
 287     return OK;
 288 }
 289
 290 status_t Disk::readPartitions() {
 291     int8_t maxMinors = getMaxMinors();
 292     if (maxMinors < 0) {
 293         return -ENOTSUP;
 294     }
 295
 296     destroyAllVolumes();
 297
 298     // Parse partition table
 299
 300     std::vector<std::string> cmd;
 301     cmd.push_back(kSgdiskPath);
 302     cmd.push_back("--android-dump");
 303     cmd.push_back(mDevPath);
 304
 305     std::vector<std::string> output;
 306     status_t res = ForkExecvp(cmd, output);
 307     if (res != OK) {
 308         LOG(WARNING) << "sgdisk failed to scan " << mDevPath;
 309         notifyEvent(ResponseCode::DiskScanned);
 310         mJustPartitioned = false;
 311         return res;
 312     }
 313
 314     Table table = Table::kUnknown;
 315     bool foundParts = false;
 316     for (const auto& line : output) {
 317         char* cline = (char*) line.c_str();
 318         char* token = strtok(cline, kSgdiskToken);
 319         if (token == nullptr) continue;
 320
 321         if (!strcmp(token, "DISK")) {
 322             const char* type = strtok(nullptr, kSgdiskToken);
 323             if (!strcmp(type, "mbr")) {
 324                 table = Table::kMbr;
 325             } else if (!strcmp(type, "gpt")) {
 326                 table = Table::kGpt;
 327             }
 328         } else if (!strcmp(token, "PART")) {
 329             foundParts = true;
 330             int i = strtol(strtok(nullptr, kSgdiskToken), nullptr, 10);
 331             if (i <= 0 || i > maxMinors) {
 332                 LOG(WARNING) << mId << " is ignoring partition " << i
 333                         << " beyond max supported devices";
 334                 continue;
 335             }
 336             dev_t partDevice = makedev(major(mDevice), minor(mDevice) + i);
 337
 338             if (table == Table::kMbr) {
 339                 const char* type = strtok(nullptr, kSgdiskToken);
 340
 341                 switch (strtol(type, nullptr, 16)) {
 342                 case 0x06: // FAT16
 343                 case 0x0b: // W95 FAT32 (LBA)
 344                 case 0x0c: // W95 FAT32 (LBA)
 345                 case 0x0e: // W95 FAT16 (LBA)
 346                     createPublicVolume(partDevice);
 347                     break;
 348                 }
 349             } else if (table == Table::kGpt) {
 350                 const char* typeGuid = strtok(nullptr, kSgdiskToken);
 351                 const char* partGuid = strtok(nullptr, kSgdiskToken);
 352
 353                 if (!strcasecmp(typeGuid, kGptBasicData)) {
 354                     createPublicVolume(partDevice);
 355                 } else if (!strcasecmp(typeGuid, kGptAndroidExpand)) {
 356                     createPrivateVolume(partDevice, partGuid);
 357                 }
 358             }
 359         }
 360     }
 361
 362     // Ugly last ditch effort, treat entire disk as partition
 363     if (table == Table::kUnknown || !foundParts) {
 364         LOG(WARNING) << mId << " has unknown partition table; trying entire device";
 365
 366         std::string fsType;
 367         std::string unused;
 368         if (ReadMetadataUntrusted(mDevPath, fsType, unused, unused) == OK) {
 369             createPublicVolume(mDevice);
 370         } else {
 371             LOG(WARNING) << mId << " failed to identify, giving up";
 372         }
 373     }
 374
 375     notifyEvent(ResponseCode::DiskScanned);
 376     mJustPartitioned = false;
 377     return OK;
 378 }
 379
 380 status_t Disk::unmountAll() {
 381     for (const auto& vol : mVolumes) {
 382         vol->unmount();
 383     }
 384     return OK;
 385 }
 386
 387 status_t Disk::partitionPublic() {
 388     int res;
 389
 390     // TODO: improve this code
 391     destroyAllVolumes();
 392     mJustPartitioned = true;
 393
 394     // First nuke any existing partition table
 395     std::vector<std::string> cmd;
 396     cmd.push_back(kSgdiskPath);
 397     cmd.push_back("--zap-all");
 398     cmd.push_back(mDevPath);
 399
 400     // Zap sometimes returns an error when it actually succeeded, so
 401     // just log as warning and keep rolling forward.
 402     if ((res = ForkExecvp(cmd)) != 0) {
 403         LOG(WARNING) << "Failed to zap; status " << res;
 404     }
 405
 406     struct disk_info dinfo;
 407     memset(&dinfo, 0, sizeof(dinfo));
 408
 409     if (!(dinfo.part_lst = (struct part_info *) malloc(
 410             MAX_NUM_PARTS * sizeof(struct part_info)))) {
 411         return -1;
 412     }
 413
 414     memset(dinfo.part_lst, 0, MAX_NUM_PARTS * sizeof(struct part_info));
 415     dinfo.device = strdup(mDevPath.c_str());
 416     dinfo.scheme = PART_SCHEME_MBR;
 417     dinfo.sect_size = 512;
 418     dinfo.skip_lba = 2048;
 419     dinfo.num_lba = 0;
 420     dinfo.num_parts = 1;
 421
 422     struct part_info *pinfo = &dinfo.part_lst[0];
 423
 424     pinfo->name = strdup("android_sdcard");
 425     pinfo->flags |= PART_ACTIVE_FLAG;
 426     pinfo->type = PC_PART_TYPE_FAT32;
 427     pinfo->len_kb = -1;
 428
 429     int rc = apply_disk_config(&dinfo, 0);
 430     if (rc) {
 431         LOG(ERROR) << "Failed to apply disk configuration: " << rc;
 432         goto out;
 433     }
 434
 435 out:
 436     free(pinfo->name);
 437     free(dinfo.device);
 438     free(dinfo.part_lst);
 439
 440     return rc;
 441 }
 442
 443 status_t Disk::partitionPrivate() {
 444     return partitionMixed(0);
 445 }
 446
 447 status_t Disk::partitionMixed(int8_t ratio) {
 448     int res;
 449
 450     if (e4crypt_is_native()
 451             && !android::base::GetBoolProperty("persist.sys.adoptable_fbe", false)) {
 452         LOG(ERROR) << "Private volumes not yet supported on FBE devices";
 453         return -EINVAL;
 454     }
 455
 456     destroyAllVolumes();
 457     mJustPartitioned = true;
 458
 459     // First nuke any existing partition table
 460     std::vector<std::string> cmd;
 461     cmd.push_back(kSgdiskPath);
 462     cmd.push_back("--zap-all");
 463     cmd.push_back(mDevPath);
 464
 465     // Zap sometimes returns an error when it actually succeeded, so
 466     // just log as warning and keep rolling forward.
 467     if ((res = ForkExecvp(cmd)) != 0) {
 468         LOG(WARNING) << "Failed to zap; status " << res;
 469     }
 470
 471     // We've had some success above, so generate both the private partition
 472     // GUID and encryption key and persist them.
 473     std::string partGuidRaw;
 474     if (GenerateRandomUuid(partGuidRaw) != OK) {
 475         LOG(ERROR) << "Failed to generate GUID";
 476         return -EIO;
 477     }
 478
 479     std::string keyRaw;
 480     if (ReadRandomBytes(16, keyRaw) != OK) {
 481         LOG(ERROR) << "Failed to generate key";
 482         return -EIO;
 483     }
 484
 485     std::string partGuid;
 486     StrToHex(partGuidRaw, partGuid);
 487
 488     if (!WriteStringToFile(keyRaw, BuildKeyPath(partGuid))) {
 489         LOG(ERROR) << "Failed to persist key";
 490         return -EIO;
 491     } else {
 492         LOG(DEBUG) << "Persisted key for GUID " << partGuid;
 493     }
 494
 495     // Now let's build the new GPT table. We heavily rely on sgdisk to
 496     // force optimal alignment on the created partitions.
 497     cmd.clear();
 498     cmd.push_back(kSgdiskPath);
 499
 500     // If requested, create a public partition first. Mixed-mode partitioning
 501     // like this is an experimental feature.
 502     if (ratio > 0) {
 503         if (ratio < 10 || ratio > 90) {
 504             LOG(ERROR) << "Mixed partition ratio must be between 10-90%";
 505             return -EINVAL;
 506         }
 507
 508         uint64_t splitMb = ((mSize / 100) * ratio) / 1024 / 1024;
 509         cmd.push_back(StringPrintf("--new=0:0:+%" PRId64 "M", splitMb));
 510         cmd.push_back(StringPrintf("--typecode=0:%s", kGptBasicData));
 511         cmd.push_back("--change-name=0:shared");
 512     }
 513
 514     // Define a metadata partition which is designed for future use; there
 515     // should only be one of these per physical device, even if there are
 516     // multiple private volumes.
 517     cmd.push_back("--new=0:0:+16M");
 518     cmd.push_back(StringPrintf("--typecode=0:%s", kGptAndroidMeta));
 519     cmd.push_back("--change-name=0:android_meta");
 520
 521     // Define a single private partition filling the rest of disk.
 522     cmd.push_back("--new=0:0:-0");
 523     cmd.push_back(StringPrintf("--typecode=0:%s", kGptAndroidExpand));
 524     cmd.push_back(StringPrintf("--partition-guid=0:%s", partGuid.c_str()));
 525     cmd.push_back("--change-name=0:android_expand");
 526
 527     cmd.push_back(mDevPath);
 528
 529     if ((res = ForkExecvp(cmd)) != 0) {
 530         LOG(ERROR) << "Failed to partition; status " << res;
 531         return res;
 532     }
 533
 534     return OK;
 535 }
 536
 537 void Disk::notifyEvent(int event) {
 538     VolumeManager::Instance()->getBroadcaster()->sendBroadcast(event,
 539             getId().c_str(), false);
 540 }
 541
 542 void Disk::notifyEvent(int event, const std::string& value) {
 543     VolumeManager::Instance()->getBroadcaster()->sendBroadcast(event,
 544             StringPrintf("%s %s", getId().c_str(), value.c_str()).c_str(), false);
 545 }
 546
 547 int Disk::getMaxMinors() {
 548     // Figure out maximum partition devices supported
 549     unsigned int majorId = major(mDevice);
 550     switch (majorId) {
 551     case kMajorBlockLoop: {
 552         std::string tmp;
 553         if (!ReadFileToString(kSysfsLoopMaxMinors, &tmp)) {
 554             LOG(ERROR) << "Failed to read max minors";
 555             return -errno;
 556         }
 557         return atoi(tmp.c_str());
 558     }
 559     case kMajorBlockScsiA: case kMajorBlockScsiB: case kMajorBlockScsiC: case kMajorBlockScsiD:
 560     case kMajorBlockScsiE: case kMajorBlockScsiF: case kMajorBlockScsiG: case kMajorBlockScsiH:
 561     case kMajorBlockScsiI: case kMajorBlockScsiJ: case kMajorBlockScsiK: case kMajorBlockScsiL:
 562     case kMajorBlockScsiM: case kMajorBlockScsiN: case kMajorBlockScsiO: case kMajorBlockScsiP: {
 563         // Per Documentation/devices.txt this is static
 564         return 15;
 565     }
 566     case kMajorBlockMmc: {
 567         // Per Documentation/devices.txt this is dynamic
 568         std::string tmp;
 569         if (!ReadFileToString(kSysfsMmcMaxMinors, &tmp)) {
 570             LOG(ERROR) << "Failed to read max minors";
 571             return -errno;
 572         }
 573         return atoi(tmp.c_str());
 574     }
 575     default: {
 576         if (isVirtioBlkDevice(majorId)) {
 577             // drivers/block/virtio_blk.c has "#define PART_BITS 4", so max is
 578             // 2^4 - 1 = 15
 579             return 15;
 580         }
 581     }
 582     }
 583
 584     LOG(ERROR) << "Unsupported block major type " << majorId;
 585     return -ENOTSUP;
 586 }
 587
 588 }  // namespace vold
 589 }  // namespace android