main.cpp 6.89 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

Jeff Sharkey's avatar
Jeff Sharkey committed
17 18 19
#include "Disk.h"
#include "VolumeManager.h"
#include "CommandListener.h"
20
#include "CryptCommandListener.h"
Jeff Sharkey's avatar
Jeff Sharkey committed
21 22 23 24 25 26 27 28 29 30
#include "NetlinkManager.h"
#include "cryptfs.h"
#include "sehandle.h"

#include <base/logging.h>
#include <base/stringprintf.h>
#include <cutils/klog.h>
#include <cutils/properties.h>
#include <cutils/sockets.h>

31 32 33 34
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
35 36
#include <sys/stat.h>
#include <sys/types.h>
37
#include <getopt.h>
38 39
#include <fcntl.h>
#include <dirent.h>
Ken Sumrall's avatar
Ken Sumrall committed
40
#include <fs_mgr.h>
41 42

static int process_config(VolumeManager *vm);
43
static void coldboot(const char *path);
44
static void parse_args(int argc, char** argv);
45

Ken Sumrall's avatar
Ken Sumrall committed
46 47
struct fstab *fstab;

48 49
struct selabel_handle *sehandle;

50 51
using android::base::StringPrintf;

52
int main(int argc, char** argv) {
53
    setenv("ANDROID_LOG_TAGS", "*:v", 1);
54
    android::base::InitLogging(argv, android::base::LogdLogger(android::base::SYSTEM));
55

Jeff Sharkey's avatar
Jeff Sharkey committed
56 57
    LOG(INFO) << "Vold 3.0 (the awakening) firing up";

58 59
    VolumeManager *vm;
    CommandListener *cl;
60
    CryptCommandListener *ccl;
61 62
    NetlinkManager *nm;

63
    parse_args(argc, argv);
64

65
    sehandle = selinux_android_file_context_handle();
66
    if (sehandle) {
67
        selinux_android_set_sehandle(sehandle);
68
    }
69

Jeff Sharkey's avatar
Jeff Sharkey committed
70 71
    // Quickly throw a CLOEXEC on the socket we just inherited from init
    fcntl(android_get_control_socket("vold"), F_SETFD, FD_CLOEXEC);
72
    fcntl(android_get_control_socket("cryptd"), F_SETFD, FD_CLOEXEC);
Jeff Sharkey's avatar
Jeff Sharkey committed
73

74
    mkdir("/dev/block/vold", 0755);
75

76 77 78
    /* For when cryptfs checks and mounts an encrypted filesystem */
    klog_set_level(6);

79 80
    /* Create our singleton managers */
    if (!(vm = VolumeManager::Instance())) {
Jeff Sharkey's avatar
Jeff Sharkey committed
81
        LOG(ERROR) << "Unable to create VolumeManager";
82
        exit(1);
83
    }
84 85

    if (!(nm = NetlinkManager::Instance())) {
Jeff Sharkey's avatar
Jeff Sharkey committed
86
        LOG(ERROR) << "Unable to create NetlinkManager";
87
        exit(1);
88
    }
89

Jeff Sharkey's avatar
Jeff Sharkey committed
90 91 92 93
    if (property_get_bool("vold.debug", false)) {
        vm->setDebug(true);
    }

94
    cl = new CommandListener();
95
    ccl = new CryptCommandListener();
96 97 98 99
    vm->setBroadcaster((SocketListener *) cl);
    nm->setBroadcaster((SocketListener *) cl);

    if (vm->start()) {
Jeff Sharkey's avatar
Jeff Sharkey committed
100
        PLOG(ERROR) << "Unable to start VolumeManager";
101 102 103 104
        exit(1);
    }

    if (process_config(vm)) {
Jeff Sharkey's avatar
Jeff Sharkey committed
105
        PLOG(ERROR) << "Error reading configuration... continuing anyways";
106 107 108
    }

    if (nm->start()) {
Jeff Sharkey's avatar
Jeff Sharkey committed
109
        PLOG(ERROR) << "Unable to start NetlinkManager";
110 111 112
        exit(1);
    }

113
    coldboot("/sys/block");
114
//    coldboot("/sys/class/switch");
115

116 117 118 119
    /*
     * Now that we're up, we can respond to commands
     */
    if (cl->startListener()) {
Jeff Sharkey's avatar
Jeff Sharkey committed
120
        PLOG(ERROR) << "Unable to start CommandListener";
121 122 123
        exit(1);
    }

124 125 126 127 128
    if (ccl->startListener()) {
        PLOG(ERROR) << "Unable to start CryptCommandListener";
        exit(1);
    }

129 130 131 132 133
    // Eventually we'll become the monitoring thread
    while(1) {
        sleep(1000);
    }

Jeff Sharkey's avatar
Jeff Sharkey committed
134
    LOG(ERROR) << "Vold exiting";
135 136 137
    exit(0);
}

138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
static void parse_args(int argc, char** argv) {
    static struct option opts[] = {
        {"blkid_context", required_argument, 0, 'b' },
        {"blkid_untrusted_context", required_argument, 0, 'B' },
        {"fsck_context", required_argument, 0, 'f' },
        {"fsck_untrusted_context", required_argument, 0, 'F' },
    };

    int c;
    while ((c = getopt_long(argc, argv, "", opts, nullptr)) != -1) {
        switch (c) {
        case 'b': android::vold::sBlkidContext = optarg; break;
        case 'B': android::vold::sBlkidUntrustedContext = optarg; break;
        case 'f': android::vold::sFsckContext = optarg; break;
        case 'F': android::vold::sFsckUntrustedContext = optarg; break;
        }
    }

    CHECK(android::vold::sBlkidContext != nullptr);
    CHECK(android::vold::sBlkidUntrustedContext != nullptr);
    CHECK(android::vold::sFsckContext != nullptr);
    CHECK(android::vold::sFsckUntrustedContext != nullptr);
}

static void do_coldboot(DIR *d, int lvl) {
163 164 165 166 167
    struct dirent *de;
    int dfd, fd;

    dfd = dirfd(d);

Jeff Sharkey's avatar
Jeff Sharkey committed
168
    fd = openat(dfd, "uevent", O_WRONLY | O_CLOEXEC);
169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196
    if(fd >= 0) {
        write(fd, "add\n", 4);
        close(fd);
    }

    while((de = readdir(d))) {
        DIR *d2;

        if (de->d_name[0] == '.')
            continue;

        if (de->d_type != DT_DIR && lvl > 0)
            continue;

        fd = openat(dfd, de->d_name, O_RDONLY | O_DIRECTORY);
        if(fd < 0)
            continue;

        d2 = fdopendir(fd);
        if(d2 == 0)
            close(fd);
        else {
            do_coldboot(d2, lvl + 1);
            closedir(d2);
        }
    }
}

197
static void coldboot(const char *path) {
198 199 200 201 202 203 204
    DIR *d = opendir(path);
    if(d) {
        do_coldboot(d, 0);
        closedir(d);
    }
}

205
static int process_config(VolumeManager *vm) {
206
    bool has_adoptable = false;
207 208 209 210 211 212 213 214 215 216
    char hardware[PROPERTY_VALUE_MAX];
    property_get("ro.hardware", hardware, "");
    std::string fstab_filename(StringPrintf("/fstab.%s", hardware));

#ifdef DEBUG_FSTAB
    if (access(DEBUG_FSTAB, R_OK) == 0) {
        LOG(DEBUG) << "Found debug fstab; switching!";
        fstab_filename = DEBUG_FSTAB;
    }
#endif
Ken Sumrall's avatar
Ken Sumrall committed
217

218
    fstab = fs_mgr_read_fstab(fstab_filename.c_str());
Ken Sumrall's avatar
Ken Sumrall committed
219
    if (!fstab) {
220
        PLOG(ERROR) << "Failed to open " << fstab_filename;
221 222 223
        return -1;
    }

Ken Sumrall's avatar
Ken Sumrall committed
224
    /* Loop through entries looking for ones that vold manages */
225
    for (int i = 0; i < fstab->num_entries; i++) {
Ken Sumrall's avatar
Ken Sumrall committed
226 227
        if (fs_mgr_is_voldmanaged(&fstab->recs[i])) {
            if (fs_mgr_is_nonremovable(&fstab->recs[i])) {
228 229
                LOG(WARNING) << "nonremovable no longer supported; ignoring volume";
                continue;
Ken Sumrall's avatar
Ken Sumrall committed
230
            }
231 232 233 234 235

            std::string sysPattern(fstab->recs[i].blk_device);
            std::string nickname(fstab->recs[i].label);
            int flags = 0;

Ken Sumrall's avatar
Ken Sumrall committed
236
            if (fs_mgr_is_encryptable(&fstab->recs[i])) {
237
                flags |= android::vold::Disk::Flags::kAdoptable;
238
                has_adoptable = true;
239
            }
240 241
            if (fs_mgr_is_noemulatedsd(&fstab->recs[i])
                    || property_get_bool("vold.debug.default_primary", false)) {
242
                flags |= android::vold::Disk::Flags::kDefaultPrimary;
243 244
            }

245 246
            vm->addDiskSource(std::shared_ptr<VolumeManager::DiskSource>(
                    new VolumeManager::DiskSource(sysPattern, nickname, flags)));
247 248
        }
    }
249
    property_set("vold.has_adoptable", has_adoptable ? "1" : "0");
250
    return 0;
251
}