1 /*
2 * Copyright (C) 2019 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 "mount_handler.h"
18
19 #include <ctype.h>
20 #include <fcntl.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <sys/epoll.h>
24 #include <sys/types.h>
25 #include <unistd.h>
26
27 #include <algorithm>
28 #include <string>
29 #include <utility>
30 #include <vector>
31
32 #include <android-base/file.h>
33 #include <android-base/logging.h>
34 #include <android-base/properties.h>
35 #include <android-base/strings.h>
36 #include <fs_mgr.h>
37 #include <fstab/fstab.h>
38 #include <libdm/dm.h>
39
40 #include "epoll.h"
41 #include "property_service.h"
42
43 namespace android {
44 namespace init {
45
46 namespace {
47
ParseMount(const std::string & line)48 MountHandlerEntry ParseMount(const std::string& line) {
49 auto fields = android::base::Split(line, " ");
50 while (fields.size() < 3) fields.emplace_back("");
51 if (fields[0] == "/dev/root") {
52 auto& dm = dm::DeviceMapper::Instance();
53 std::string path;
54 if (dm.GetDmDevicePathByName("system", &path) || dm.GetDmDevicePathByName("vroot", &path)) {
55 fields[0] = path;
56 } else if (android::fs_mgr::Fstab fstab; android::fs_mgr::ReadDefaultFstab(&fstab)) {
57 auto entry = GetEntryForMountPoint(&fstab, "/");
58 if (entry || (entry = GetEntryForMountPoint(&fstab, "/system"))) {
59 fields[0] = entry->blk_device;
60 }
61 }
62 }
63 if (android::base::StartsWith(fields[0], "/dev/")) {
64 if (std::string link; android::base::Readlink(fields[0], &link)) {
65 fields[0] = link;
66 }
67 }
68 return MountHandlerEntry(fields[0], fields[1], fields[2]);
69 }
70
SetMountProperty(const MountHandlerEntry & entry,bool add)71 void SetMountProperty(const MountHandlerEntry& entry, bool add) {
72 static constexpr char devblock[] = "/dev/block/";
73 if (!android::base::StartsWith(entry.blk_device, devblock)) return;
74 std::string value;
75 if (add) {
76 value = entry.blk_device.substr(strlen(devblock));
77 if (android::base::StartsWith(value, "sd")) {
78 // All sd partitions inherit their queue characteristics
79 // from the whole device reference. Strip partition number.
80 auto it = std::find_if(value.begin(), value.end(), [](char c) { return isdigit(c); });
81 if (it != value.end()) value.erase(it, value.end());
82 }
83 auto queue = "/sys/block/" + value + "/queue";
84 struct stat sb;
85 if (stat(queue.c_str(), &sb) || !S_ISDIR(sb.st_mode)) value = "";
86 if (stat(entry.mount_point.c_str(), &sb) || !S_ISDIR(sb.st_mode)) value = "";
87 // Clear the noise associated with loopback and APEX.
88 if (android::base::StartsWith(value, "loop")) value = "";
89 if (android::base::StartsWith(entry.mount_point, "/apex/")) value = "";
90 }
91 auto mount_prop = entry.mount_point;
92 if (mount_prop == "/") mount_prop = "/root";
93 std::replace(mount_prop.begin(), mount_prop.end(), '/', '.');
94 mount_prop = "dev.mnt.blk" + mount_prop;
95 // Set property even if its value does not change to trigger 'on property:'
96 // handling, except for clearing non-existent or already clear property.
97 // Goal is reduction of empty properties and associated triggers.
98 if (value.empty() && android::base::GetProperty(mount_prop, "").empty()) return;
99 property_set(mount_prop, value);
100 }
101
102 } // namespace
103
MountHandlerEntry(const std::string & blk_device,const std::string & mount_point,const std::string & fs_type)104 MountHandlerEntry::MountHandlerEntry(const std::string& blk_device, const std::string& mount_point,
105 const std::string& fs_type)
106 : blk_device(blk_device), mount_point(mount_point), fs_type(fs_type) {}
107
operator <(const MountHandlerEntry & r) const108 bool MountHandlerEntry::operator<(const MountHandlerEntry& r) const {
109 if (blk_device < r.blk_device) return true;
110 if (blk_device > r.blk_device) return false;
111 if (mount_point < r.mount_point) return true;
112 if (mount_point > r.mount_point) return false;
113 return fs_type < r.fs_type;
114 }
115
MountHandler(Epoll * epoll)116 MountHandler::MountHandler(Epoll* epoll) : epoll_(epoll), fp_(fopen("/proc/mounts", "re"), fclose) {
117 if (!fp_) PLOG(FATAL) << "Could not open /proc/mounts";
118 auto result = epoll->RegisterHandler(
119 fileno(fp_.get()), [this]() { this->MountHandlerFunction(); }, EPOLLERR | EPOLLPRI);
120 if (!result) LOG(FATAL) << result.error();
121 }
122
~MountHandler()123 MountHandler::~MountHandler() {
124 if (fp_) epoll_->UnregisterHandler(fileno(fp_.get())).IgnoreError();
125 }
126
MountHandlerFunction()127 void MountHandler::MountHandlerFunction() {
128 rewind(fp_.get());
129 std::vector<MountHandlerEntry> touched;
130 auto untouched = mounts_;
131 char* buf = nullptr;
132 size_t len = 0;
133 while (getline(&buf, &len, fp_.get()) != -1) {
134 auto entry = ParseMount(std::string(buf));
135 auto match = untouched.find(entry);
136 if (match == untouched.end()) {
137 touched.emplace_back(std::move(entry));
138 } else {
139 untouched.erase(match);
140 }
141 }
142 free(buf);
143 for (auto entry : untouched) {
144 SetMountProperty(entry, false);
145 mounts_.erase(entry);
146 }
147 for (auto entry : touched) {
148 SetMountProperty(entry, true);
149 mounts_.emplace(std::move(entry));
150 }
151 }
152
153 } // namespace init
154 } // namespace android
155