Home | History | Annotate | Download | only in vold 
      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 
     22 #include <linux/kdev_t.h>
     23 
     24 #define LOG_TAG "DirectVolume"
     25 
     26 #include <cutils/log.h>
     27 #include <sysutils/NetlinkEvent.h>
     28 
     29 #include "DirectVolume.h"
     30 #include "VolumeManager.h"
     31 #include "ResponseCode.h"
     32 #include "cryptfs.h"
     33 
     34 // #define PARTITION_DEBUG
     35 
     36 DirectVolume::DirectVolume(VolumeManager *vm, const char *label,
     37                            const char *mount_point, int partIdx) :
     38               Volume(vm, label, mount_point) {
     39     mPartIdx = partIdx;
     40 
     41     mPaths = new PathCollection();
     42     for (int i = 0; i < MAX_PARTITIONS; i++)
     43         mPartMinors[i] = -1;
     44     mPendingPartMap = 0;
     45     mDiskMajor = -1;
     46     mDiskMinor = -1;
     47     mDiskNumParts = 0;
     48 
     49     setState(Volume::State_NoMedia);
     50 }
     51 
     52 DirectVolume::~DirectVolume() {
     53     PathCollection::iterator it;
     54 
     55     for (it = mPaths->begin(); it != mPaths->end(); ++it)
     56         free(*it);
     57     delete mPaths;
     58 }
     59 
     60 int DirectVolume::addPath(const char *path) {
     61     mPaths->push_back(strdup(path));
     62     return 0;
     63 }
     64 
     65 void DirectVolume::setFlags(int flags) {
     66     mFlags = flags;
     67 }
     68 
     69 dev_t DirectVolume::getDiskDevice() {
     70     return MKDEV(mDiskMajor, mDiskMinor);
     71 }
     72 
     73 dev_t DirectVolume::getShareDevice() {
     74     if (mPartIdx != -1) {
     75         return MKDEV(mDiskMajor, mPartIdx);
     76     } else {
     77         return MKDEV(mDiskMajor, mDiskMinor);
     78     }
     79 }
     80 
     81 void DirectVolume::handleVolumeShared() {
     82     setState(Volume::State_Shared);
     83 }
     84 
     85 void DirectVolume::handleVolumeUnshared() {
     86     setState(Volume::State_Idle);
     87 }
     88 
     89 int DirectVolume::handleBlockEvent(NetlinkEvent *evt) {
     90     const char *dp = evt->findParam("DEVPATH");
     91 
     92     PathCollection::iterator  it;
     93     for (it = mPaths->begin(); it != mPaths->end(); ++it) {
     94         if (!strncmp(dp, *it, strlen(*it))) {
     95             /* We can handle this disk */
     96             int action = evt->getAction();
     97             const char *devtype = evt->findParam("DEVTYPE");
     98 
     99             if (action == NetlinkEvent::NlActionAdd) {
    100                 int major = atoi(evt->findParam("MAJOR"));
    101                 int minor = atoi(evt->findParam("MINOR"));
    102                 char nodepath[255];
    103 
    104                 snprintf(nodepath,
    105                          sizeof(nodepath), "/dev/block/vold/%d:%d",
    106                          major, minor);
    107                 if (createDeviceNode(nodepath, major, minor)) {
    108                     SLOGE("Error making device node '%s' (%s)", nodepath,
    109                                                                strerror(errno));
    110                 }
    111                 if (!strcmp(devtype, "disk")) {
    112                     handleDiskAdded(dp, evt);
    113                 } else {
    114                     handlePartitionAdded(dp, evt);
    115                 }
    116                 /* Send notification iff disk is ready (ie all partitions found) */
    117                 if (getState() == Volume::State_Idle) {
    118                     char msg[255];
    119 
    120                     snprintf(msg, sizeof(msg),
    121                              "Volume %s %s disk inserted (%d:%d)", getLabel(),
    122                              getMountpoint(), mDiskMajor, mDiskMinor);
    123                     mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskInserted,
    124                                                          msg, false);
    125                 }
    126             } else if (action == NetlinkEvent::NlActionRemove) {
    127                 if (!strcmp(devtype, "disk")) {
    128                     handleDiskRemoved(dp, evt);
    129                 } else {
    130                     handlePartitionRemoved(dp, evt);
    131                 }
    132             } else if (action == NetlinkEvent::NlActionChange) {
    133                 if (!strcmp(devtype, "disk")) {
    134                     handleDiskChanged(dp, evt);
    135                 } else {
    136                     handlePartitionChanged(dp, evt);
    137                 }
    138             } else {
    139                     SLOGW("Ignoring non add/remove/change event");
    140             }
    141 
    142             return 0;
    143         }
    144     }
    145     errno = ENODEV;
    146     return -1;
    147 }
    148 
    149 void DirectVolume::handleDiskAdded(const char *devpath, NetlinkEvent *evt) {
    150     mDiskMajor = atoi(evt->findParam("MAJOR"));
    151     mDiskMinor = atoi(evt->findParam("MINOR"));
    152 
    153     const char *tmp = evt->findParam("NPARTS");
    154     if (tmp) {
    155         mDiskNumParts = atoi(tmp);
    156     } else {
    157         SLOGW("Kernel block uevent missing 'NPARTS'");
    158         mDiskNumParts = 1;
    159     }
    160 
    161     int partmask = 0;
    162     int i;
    163     for (i = 1; i <= mDiskNumParts; i++) {
    164         partmask |= (1 << i);
    165     }
    166     mPendingPartMap = partmask;
    167 
    168     if (mDiskNumParts == 0) {
    169 #ifdef PARTITION_DEBUG
    170         SLOGD("Dv::diskIns - No partitions - good to go son!");
    171 #endif
    172         setState(Volume::State_Idle);
    173     } else {
    174 #ifdef PARTITION_DEBUG
    175         SLOGD("Dv::diskIns - waiting for %d partitions (mask 0x%x)",
    176              mDiskNumParts, mPendingPartMap);
    177 #endif
    178         setState(Volume::State_Pending);
    179     }
    180 }
    181 
    182 void DirectVolume::handlePartitionAdded(const char *devpath, NetlinkEvent *evt) {
    183     int major = atoi(evt->findParam("MAJOR"));
    184     int minor = atoi(evt->findParam("MINOR"));
    185 
    186     int part_num;
    187 
    188     const char *tmp = evt->findParam("PARTN");
    189 
    190     if (tmp) {
    191         part_num = atoi(tmp);
    192     } else {
    193         SLOGW("Kernel block uevent missing 'PARTN'");
    194         part_num = 1;
    195     }
    196 
    197     if (part_num > MAX_PARTITIONS || part_num < 1) {
    198         SLOGE("Invalid 'PARTN' value");
    199         return;
    200     }
    201 
    202     if (part_num > mDiskNumParts) {
    203         mDiskNumParts = part_num;
    204     }
    205 
    206     if (major != mDiskMajor) {
    207         SLOGE("Partition '%s' has a different major than its disk!", devpath);
    208         return;
    209     }
    210 #ifdef PARTITION_DEBUG
    211     SLOGD("Dv:partAdd: part_num = %d, minor = %d\n", part_num, minor);
    212 #endif
    213     if (part_num >= MAX_PARTITIONS) {
    214         SLOGE("Dv:partAdd: ignoring part_num = %d (max: %d)\n", part_num, MAX_PARTITIONS-1);
    215     } else {
    216         mPartMinors[part_num -1] = minor;
    217     }
    218     mPendingPartMap &= ~(1 << part_num);
    219 
    220     if (!mPendingPartMap) {
    221 #ifdef PARTITION_DEBUG
    222         SLOGD("Dv:partAdd: Got all partitions - ready to rock!");
    223 #endif
    224         if (getState() != Volume::State_Formatting) {
    225             setState(Volume::State_Idle);
    226             if (mRetryMount == true) {
    227                 mRetryMount = false;
    228                 mountVol();
    229             }
    230         }
    231     } else {
    232 #ifdef PARTITION_DEBUG
    233         SLOGD("Dv:partAdd: pending mask now = 0x%x", mPendingPartMap);
    234 #endif
    235     }
    236 }
    237 
    238 void DirectVolume::handleDiskChanged(const char *devpath, NetlinkEvent *evt) {
    239     int major = atoi(evt->findParam("MAJOR"));
    240     int minor = atoi(evt->findParam("MINOR"));
    241 
    242     if ((major != mDiskMajor) || (minor != mDiskMinor)) {
    243         return;
    244     }
    245 
    246     SLOGI("Volume %s disk has changed", getLabel());
    247     const char *tmp = evt->findParam("NPARTS");
    248     if (tmp) {
    249         mDiskNumParts = atoi(tmp);
    250     } else {
    251         SLOGW("Kernel block uevent missing 'NPARTS'");
    252         mDiskNumParts = 1;
    253     }
    254 
    255     int partmask = 0;
    256     int i;
    257     for (i = 1; i <= mDiskNumParts; i++) {
    258         partmask |= (1 << i);
    259     }
    260     mPendingPartMap = partmask;
    261 
    262     if (getState() != Volume::State_Formatting) {
    263         if (mDiskNumParts == 0) {
    264             setState(Volume::State_Idle);
    265         } else {
    266             setState(Volume::State_Pending);
    267         }
    268     }
    269 }
    270 
    271 void DirectVolume::handlePartitionChanged(const char *devpath, NetlinkEvent *evt) {
    272     int major = atoi(evt->findParam("MAJOR"));
    273     int minor = atoi(evt->findParam("MINOR"));
    274     SLOGD("Volume %s %s partition %d:%d changed\n", getLabel(), getMountpoint(), major, minor);
    275 }
    276 
    277 void DirectVolume::handleDiskRemoved(const char *devpath, NetlinkEvent *evt) {
    278     int major = atoi(evt->findParam("MAJOR"));
    279     int minor = atoi(evt->findParam("MINOR"));
    280     char msg[255];
    281     bool enabled;
    282 
    283     if (mVm->shareEnabled(getLabel(), "ums", &enabled) == 0 && enabled) {
    284         mVm->unshareVolume(getLabel(), "ums");
    285     }
    286 
    287     SLOGD("Volume %s %s disk %d:%d removed\n", getLabel(), getMountpoint(), major, minor);
    288     snprintf(msg, sizeof(msg), "Volume %s %s disk removed (%d:%d)",
    289              getLabel(), getMountpoint(), major, minor);
    290     mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskRemoved,
    291                                              msg, false);
    292     setState(Volume::State_NoMedia);
    293 }
    294 
    295 void DirectVolume::handlePartitionRemoved(const char *devpath, NetlinkEvent *evt) {
    296     int major = atoi(evt->findParam("MAJOR"));
    297     int minor = atoi(evt->findParam("MINOR"));
    298     char msg[255];
    299     int state;
    300 
    301     SLOGD("Volume %s %s partition %d:%d removed\n", getLabel(), getMountpoint(), major, minor);
    302 
    303     /*
    304      * The framework doesn't need to get notified of
    305      * partition removal unless it's mounted. Otherwise
    306      * the removal notification will be sent on the Disk
    307      * itself
    308      */
    309     state = getState();
    310     if (state != Volume::State_Mounted && state != Volume::State_Shared) {
    311         return;
    312     }
    313 
    314     if ((dev_t) MKDEV(major, minor) == mCurrentlyMountedKdev) {
    315         /*
    316          * Yikes, our mounted partition is going away!
    317          */
    318 
    319         snprintf(msg, sizeof(msg), "Volume %s %s bad removal (%d:%d)",
    320                  getLabel(), getMountpoint(), major, minor);
    321         mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeBadRemoval,
    322                                              msg, false);
    323 
    324 	if (mVm->cleanupAsec(this, true)) {
    325             SLOGE("Failed to cleanup ASEC - unmount will probably fail!");
    326         }
    327 
    328         if (Volume::unmountVol(true, false)) {
    329             SLOGE("Failed to unmount volume on bad removal (%s)",
    330                  strerror(errno));
    331             // XXX: At this point we're screwed for now
    332         } else {
    333             SLOGD("Crisis averted");
    334         }
    335     } else if (state == Volume::State_Shared) {
    336         /* removed during mass storage */
    337         snprintf(msg, sizeof(msg), "Volume %s bad removal (%d:%d)",
    338                  getLabel(), major, minor);
    339         mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeBadRemoval,
    340                                              msg, false);
    341 
    342         if (mVm->unshareVolume(getLabel(), "ums")) {
    343             SLOGE("Failed to unshare volume on bad removal (%s)",
    344                 strerror(errno));
    345         } else {
    346             SLOGD("Crisis averted");
    347         }
    348     }
    349 }
    350 
    351 /*
    352  * Called from base to get a list of devicenodes for mounting
    353  */
    354 int DirectVolume::getDeviceNodes(dev_t *devs, int max) {
    355 
    356     if (mPartIdx == -1) {
    357         // If the disk has no partitions, try the disk itself
    358         if (!mDiskNumParts) {
    359             devs[0] = MKDEV(mDiskMajor, mDiskMinor);
    360             return 1;
    361         }
    362 
    363         int i;
    364         for (i = 0; i < mDiskNumParts; i++) {
    365             if (i == max)
    366                 break;
    367             devs[i] = MKDEV(mDiskMajor, mPartMinors[i]);
    368         }
    369         return mDiskNumParts;
    370     }
    371     devs[0] = MKDEV(mDiskMajor, mPartMinors[mPartIdx -1]);
    372     return 1;
    373 }
    374 
    375 /*
    376  * Called from base to update device info,
    377  * e.g. When setting up an dm-crypt mapping for the sd card.
    378  */
    379 int DirectVolume::updateDeviceInfo(char *new_path, int new_major, int new_minor)
    380 {
    381     PathCollection::iterator it;
    382 
    383     if (mPartIdx == -1) {
    384         SLOGE("Can only change device info on a partition\n");
    385         return -1;
    386     }
    387 
    388     /*
    389      * This is to change the sysfs path associated with a partition, in particular,
    390      * for an internal SD card partition that is encrypted.  Thus, the list is
    391      * expected to be only 1 entry long.  Check that and bail if not.
    392      */
    393     if (mPaths->size() != 1) {
    394         SLOGE("Cannot change path if there are more than one for a volume\n");
    395         return -1;
    396     }
    397 
    398     it = mPaths->begin();
    399     free(*it); /* Free the string storage */
    400     mPaths->erase(it); /* Remove it from the list */
    401     addPath(new_path); /* Put the new path on the list */
    402 
    403     /* Save away original info so we can restore it when doing factory reset.
    404      * Then, when doing the format, it will format the original device in the
    405      * clear, otherwise it just formats the encrypted device which is not
    406      * readable when the device boots unencrypted after the reset.
    407      */
    408     mOrigDiskMajor = mDiskMajor;
    409     mOrigDiskMinor = mDiskMinor;
    410     mOrigPartIdx = mPartIdx;
    411     memcpy(mOrigPartMinors, mPartMinors, sizeof(mPartMinors));
    412 
    413     mDiskMajor = new_major;
    414     mDiskMinor = new_minor;
    415     /* Ugh, virual block devices don't use minor 0 for whole disk and minor > 0 for
    416      * partition number.  They don't have partitions, they are just virtual block
    417      * devices, and minor number 0 is the first dm-crypt device.  Luckily the first
    418      * dm-crypt device is for the userdata partition, which gets minor number 0, and
    419      * it is not managed by vold.  So the next device is minor number one, which we
    420      * will call partition one.
    421      */
    422     mPartIdx = new_minor;
    423     mPartMinors[new_minor-1] = new_minor;
    424 
    425     mIsDecrypted = 1;
    426 
    427     return 0;
    428 }
    429 
    430 /*
    431  * Called from base to revert device info to the way it was before a
    432  * crypto mapping was created for it.
    433  */
    434 void DirectVolume::revertDeviceInfo(void)
    435 {
    436     if (mIsDecrypted) {
    437         mDiskMajor = mOrigDiskMajor;
    438         mDiskMinor = mOrigDiskMinor;
    439         mPartIdx = mOrigPartIdx;
    440         memcpy(mPartMinors, mOrigPartMinors, sizeof(mPartMinors));
    441 
    442         mIsDecrypted = 0;
    443     }
    444 
    445     return;
    446 }
    447 
    448 /*
    449  * Called from base to give cryptfs all the info it needs to encrypt eligible volumes
    450  */
    451 int DirectVolume::getVolInfo(struct volume_info *v)
    452 {
    453     strcpy(v->label, mLabel);
    454     strcpy(v->mnt_point, mMountpoint);
    455     v->flags=mFlags;
    456     /* Other fields of struct volume_info are filled in by the caller or cryptfs.c */
    457 
    458     return 0;
    459 }
    460