1 /*
2  * Copyright (C) 2020 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 <android-base/logging.h>
18 #include <android-base/properties.h>
19 #include <android-base/strings.h>
20 #include <gflags/gflags.h>
21 #include <snapuserd/snapuserd_client.h>
22 
23 #include "snapuserd_daemon.h"
24 
25 DEFINE_string(socket, android::snapshot::kSnapuserdSocket, "Named socket or socket path.");
26 DEFINE_bool(no_socket, false,
27             "If true, no socket is used. Each additional argument is an INIT message.");
28 DEFINE_bool(socket_handoff, false,
29             "If true, perform a socket hand-off with an existing snapuserd instance, then exit.");
30 DEFINE_bool(user_snapshot, false, "If true, user-space snapshots are used");
31 DEFINE_bool(io_uring, false, "If true, io_uring feature is enabled");
32 
33 namespace android {
34 namespace snapshot {
35 
IsUserspaceSnapshotsEnabled()36 bool Daemon::IsUserspaceSnapshotsEnabled() {
37     const std::string UNKNOWN = "unknown";
38     const std::string vendor_release =
39             android::base::GetProperty("ro.vendor.build.version.release_or_codename", UNKNOWN);
40 
41     // No user-space snapshots if vendor partition is on Android 12
42     if (vendor_release.find("12") != std::string::npos) {
43         LOG(INFO) << "Userspace snapshots disabled as vendor partition is on Android: "
44                   << vendor_release;
45         return false;
46     }
47 
48     return android::base::GetBoolProperty("ro.virtual_ab.userspace.snapshots.enabled", false);
49 }
50 
IsDmSnapshotTestingEnabled()51 bool Daemon::IsDmSnapshotTestingEnabled() {
52     return android::base::GetBoolProperty("snapuserd.test.dm.snapshots", false);
53 }
54 
StartDaemon(int argc,char ** argv)55 bool Daemon::StartDaemon(int argc, char** argv) {
56     int arg_start = gflags::ParseCommandLineFlags(&argc, &argv, true);
57 
58     // Daemon launched from first stage init and during selinux transition
59     // will have the command line "-user_snapshot" flag set if the user-space
60     // snapshots are enabled.
61     //
62     // Daemon launched as a init service during "socket-handoff" and when OTA
63     // is applied will check for the property. This is ok as the system
64     // properties are valid at this point. We can't do this during first
65     // stage init and hence use the command line flags to get the information.
66     bool user_snapshots = FLAGS_user_snapshot;
67     if (!user_snapshots) {
68         user_snapshots = (!IsDmSnapshotTestingEnabled() && IsUserspaceSnapshotsEnabled());
69     }
70 
71     if (user_snapshots) {
72         LOG(INFO) << "Starting daemon for user-space snapshots.....";
73         return StartServerForUserspaceSnapshots(arg_start, argc, argv);
74     } else {
75         LOG(INFO) << "Starting daemon for dm-snapshots.....";
76         return StartServerForDmSnapshot(arg_start, argc, argv);
77     }
78 }
79 
StartServerForUserspaceSnapshots(int arg_start,int argc,char ** argv)80 bool Daemon::StartServerForUserspaceSnapshots(int arg_start, int argc, char** argv) {
81     sigfillset(&signal_mask_);
82     sigdelset(&signal_mask_, SIGINT);
83     sigdelset(&signal_mask_, SIGTERM);
84     sigdelset(&signal_mask_, SIGUSR1);
85 
86     // Masking signals here ensure that after this point, we won't handle INT/TERM
87     // until after we call into ppoll()
88     signal(SIGINT, Daemon::SignalHandler);
89     signal(SIGTERM, Daemon::SignalHandler);
90     signal(SIGPIPE, Daemon::SignalHandler);
91     signal(SIGUSR1, Daemon::SignalHandler);
92 
93     MaskAllSignalsExceptIntAndTerm();
94 
95     user_server_.SetServerRunning();
96     if (FLAGS_io_uring) {
97         user_server_.SetIouringEnabled();
98     }
99 
100     if (FLAGS_socket_handoff) {
101         return user_server_.RunForSocketHandoff();
102     }
103     if (!FLAGS_no_socket) {
104         if (!user_server_.Start(FLAGS_socket)) {
105             return false;
106         }
107         return user_server_.Run();
108     }
109 
110     for (int i = arg_start; i < argc; i++) {
111         auto parts = android::base::Split(argv[i], ",");
112         if (parts.size() != 4) {
113             LOG(ERROR) << "Malformed message, expected four sub-arguments.";
114             return false;
115         }
116         auto handler = user_server_.AddHandler(parts[0], parts[1], parts[2], parts[3]);
117         if (!handler || !user_server_.StartHandler(handler)) {
118             return false;
119         }
120     }
121 
122     // We reach this point only during selinux transition during device boot.
123     // At this point, all threads are spin up and are ready to serve the I/O
124     // requests for dm-user. Lets inform init.
125     auto client = std::make_unique<SnapuserdClient>();
126     client->NotifyTransitionDaemonIsReady();
127 
128     // Skip the accept() call to avoid spurious log spam. The server will still
129     // run until all handlers have completed.
130     return user_server_.WaitForSocket();
131 }
132 
StartServerForDmSnapshot(int arg_start,int argc,char ** argv)133 bool Daemon::StartServerForDmSnapshot(int arg_start, int argc, char** argv) {
134     sigfillset(&signal_mask_);
135     sigdelset(&signal_mask_, SIGINT);
136     sigdelset(&signal_mask_, SIGTERM);
137     sigdelset(&signal_mask_, SIGUSR1);
138 
139     // Masking signals here ensure that after this point, we won't handle INT/TERM
140     // until after we call into ppoll()
141     signal(SIGINT, Daemon::SignalHandler);
142     signal(SIGTERM, Daemon::SignalHandler);
143     signal(SIGPIPE, Daemon::SignalHandler);
144     signal(SIGUSR1, Daemon::SignalHandler);
145 
146     MaskAllSignalsExceptIntAndTerm();
147 
148     if (FLAGS_socket_handoff) {
149         return server_.RunForSocketHandoff();
150     }
151     if (!FLAGS_no_socket) {
152         if (!server_.Start(FLAGS_socket)) {
153             return false;
154         }
155         return server_.Run();
156     }
157 
158     for (int i = arg_start; i < argc; i++) {
159         auto parts = android::base::Split(argv[i], ",");
160         if (parts.size() != 3) {
161             LOG(ERROR) << "Malformed message, expected three sub-arguments.";
162             return false;
163         }
164         auto handler = server_.AddHandler(parts[0], parts[1], parts[2]);
165         if (!handler || !server_.StartHandler(handler)) {
166             return false;
167         }
168     }
169 
170     // Skip the accept() call to avoid spurious log spam. The server will still
171     // run until all handlers have completed.
172     return server_.WaitForSocket();
173 }
174 
MaskAllSignalsExceptIntAndTerm()175 void Daemon::MaskAllSignalsExceptIntAndTerm() {
176     sigset_t signal_mask;
177     sigfillset(&signal_mask);
178     sigdelset(&signal_mask, SIGINT);
179     sigdelset(&signal_mask, SIGTERM);
180     sigdelset(&signal_mask, SIGPIPE);
181     sigdelset(&signal_mask, SIGUSR1);
182     if (sigprocmask(SIG_SETMASK, &signal_mask, NULL) != 0) {
183         PLOG(ERROR) << "Failed to set sigprocmask";
184     }
185 }
186 
MaskAllSignals()187 void Daemon::MaskAllSignals() {
188     sigset_t signal_mask;
189     sigfillset(&signal_mask);
190     if (sigprocmask(SIG_SETMASK, &signal_mask, NULL) != 0) {
191         PLOG(ERROR) << "Couldn't mask all signals";
192     }
193 }
194 
Interrupt()195 void Daemon::Interrupt() {
196     // TODO: We cannot access system property during first stage init.
197     // Until we remove the dm-snapshot code, we will have this check
198     // and verify it through a temp variable.
199     if (user_server_.IsServerRunning()) {
200         user_server_.Interrupt();
201     } else {
202         server_.Interrupt();
203     }
204 }
205 
ReceivedSocketSignal()206 void Daemon::ReceivedSocketSignal() {
207     if (user_server_.IsServerRunning()) {
208         user_server_.ReceivedSocketSignal();
209     } else {
210         server_.ReceivedSocketSignal();
211     }
212 }
213 
SignalHandler(int signal)214 void Daemon::SignalHandler(int signal) {
215     LOG(DEBUG) << "Snapuserd received signal: " << signal;
216     switch (signal) {
217         case SIGINT:
218         case SIGTERM: {
219             Daemon::Instance().Interrupt();
220             break;
221         }
222         case SIGPIPE: {
223             LOG(ERROR) << "Received SIGPIPE signal";
224             break;
225         }
226         case SIGUSR1: {
227             LOG(INFO) << "Received SIGUSR1, attaching to proxy socket";
228             Daemon::Instance().ReceivedSocketSignal();
229             break;
230         }
231         default:
232             LOG(ERROR) << "Received unknown signal " << signal;
233             break;
234     }
235 }
236 
237 }  // namespace snapshot
238 }  // namespace android
239 
main(int argc,char ** argv)240 int main(int argc, char** argv) {
241     android::base::InitLogging(argv, &android::base::KernelLogger);
242 
243     android::snapshot::Daemon& daemon = android::snapshot::Daemon::Instance();
244 
245     if (!daemon.StartDaemon(argc, argv)) {
246         LOG(ERROR) << "Snapuserd daemon failed to start";
247         exit(EXIT_FAILURE);
248     }
249 
250     return 0;
251 }
252