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