Merge "fastbootd: Add is-userspace variable."
diff --git a/adb/Android.bp b/adb/Android.bp
index dabc5ce..a18dc1a 100644
--- a/adb/Android.bp
+++ b/adb/Android.bp
@@ -455,17 +455,14 @@
srcs: [
"test_adb.py",
],
- libs: [
- "adb_py",
- ],
test_config: "adb_integration_test_adb.xml",
test_suites: ["general-tests"],
version: {
py2: {
- enabled: true,
+ enabled: false,
},
py3: {
- enabled: false,
+ enabled: true,
},
},
}
diff --git a/adb/client/auth.cpp b/adb/client/auth.cpp
index 5fbef09..71c19b8 100644
--- a/adb/client/auth.cpp
+++ b/adb/client/auth.cpp
@@ -465,6 +465,7 @@
if (key == nullptr) {
// No more private keys to try, send the public key.
t->SetConnectionState(kCsUnauthorized);
+ t->SetConnectionEstablished(true);
send_auth_publickey(t);
return;
}
diff --git a/adb/daemon/remount_service.cpp b/adb/daemon/remount_service.cpp
index 0e79d82..f7017dd 100644
--- a/adb/daemon/remount_service.cpp
+++ b/adb/daemon/remount_service.cpp
@@ -30,6 +30,7 @@
#include <sys/vfs.h>
#include <unistd.h>
+#include <memory>
#include <set>
#include <string>
#include <vector>
@@ -38,28 +39,30 @@
#include <bootloader_message/bootloader_message.h>
#include <cutils/android_reboot.h>
#include <ext4_utils/ext4_utils.h>
+#include <fs_mgr.h>
+#include <fs_mgr_overlayfs.h>
#include "adb.h"
#include "adb_io.h"
#include "adb_unique_fd.h"
#include "adb_utils.h"
-#include "fs_mgr.h"
#include "set_verity_enable_state_service.h"
-// Returns the device used to mount a directory in /proc/mounts.
+// Returns the last device used to mount a directory in /proc/mounts.
+// This will find overlayfs entry where upperdir=lowerdir, to make sure
+// remount is associated with the correct directory.
static std::string find_proc_mount(const char* dir) {
std::unique_ptr<FILE, int(*)(FILE*)> fp(setmntent("/proc/mounts", "r"), endmntent);
- if (!fp) {
- return "";
- }
+ std::string mnt_fsname;
+ if (!fp) return mnt_fsname;
mntent* e;
while ((e = getmntent(fp.get())) != nullptr) {
if (strcmp(dir, e->mnt_dir) == 0) {
- return e->mnt_fsname;
+ mnt_fsname = e->mnt_fsname;
}
}
- return "";
+ return mnt_fsname;
}
// Returns the device used to mount a directory in the fstab.
@@ -81,6 +84,7 @@
}
bool make_block_device_writable(const std::string& dev) {
+ if ((dev == "overlay") || (dev == "overlayfs")) return true;
int fd = unix_open(dev.c_str(), O_RDONLY | O_CLOEXEC);
if (fd == -1) {
return false;
@@ -234,6 +238,14 @@
partitions.push_back("/system");
}
+ bool verity_enabled = (system_verified || vendor_verified);
+
+ // If we can use overlayfs, lets get it in place first
+ // before we struggle with determining deduplication operations.
+ if (!verity_enabled && fs_mgr_overlayfs_setup() && fs_mgr_overlayfs_mount_all()) {
+ WriteFdExactly(fd.get(), "overlayfs mounted\n");
+ }
+
// Find partitions that are deduplicated, and can be un-deduplicated.
std::set<std::string> dedup;
for (const auto& partition : partitions) {
@@ -246,8 +258,6 @@
}
}
- bool verity_enabled = (system_verified || vendor_verified);
-
// Reboot now if the user requested it (and an operation needs a reboot).
if (user_requested_reboot) {
if (!dedup.empty() || verity_enabled) {
diff --git a/adb/daemon/set_verity_enable_state_service.cpp b/adb/daemon/set_verity_enable_state_service.cpp
index 2b6ec21..3676de5 100644
--- a/adb/daemon/set_verity_enable_state_service.cpp
+++ b/adb/daemon/set_verity_enable_state_service.cpp
@@ -19,6 +19,7 @@
#include "set_verity_enable_state_service.h"
#include "sysdeps.h"
+#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <libavb_user/libavb_user.h>
@@ -28,12 +29,14 @@
#include <android-base/properties.h>
#include <android-base/stringprintf.h>
+#include <fs_mgr.h>
+#include <fs_mgr_overlayfs.h>
+#include <fstab/fstab.h>
#include <log/log_properties.h>
#include "adb.h"
#include "adb_io.h"
#include "adb_unique_fd.h"
-#include "fs_mgr.h"
#include "remount_service.h"
#include "fec/io.h"
@@ -46,6 +49,10 @@
static const bool kAllowDisableVerity = false;
#endif
+void suggest_run_adb_root(int fd) {
+ if (getuid() != 0) WriteFdExactly(fd, "Maybe run adb root?\n");
+}
+
/* Turn verity on/off */
static bool set_verity_enabled_state(int fd, const char* block_device, const char* mount_point,
bool enable) {
@@ -59,7 +66,7 @@
if (!fh) {
WriteFdFmt(fd, "Could not open block device %s (%s).\n", block_device, strerror(errno));
- WriteFdFmt(fd, "Maybe run adb root?\n");
+ suggest_run_adb_root(fd);
return false;
}
@@ -87,6 +94,17 @@
return false;
}
+ auto change = false;
+ errno = 0;
+ if (enable ? fs_mgr_overlayfs_teardown(mount_point, &change)
+ : fs_mgr_overlayfs_setup(nullptr, mount_point, &change)) {
+ if (change) {
+ WriteFdFmt(fd, "%s overlayfs for %s\n", enable ? "disabling" : "using", mount_point);
+ }
+ } else if (errno) {
+ WriteFdFmt(fd, "Overlayfs %s for %s failed with error %s\n", enable ? "teardown" : "setup",
+ mount_point, strerror(errno));
+ }
WriteFdFmt(fd, "Verity %s on %s\n", enable ? "enabled" : "disabled", mount_point);
return true;
}
@@ -103,6 +121,22 @@
return android::base::GetProperty("ro.boot.vbmeta.device_state", "") == "locked";
}
+static bool overlayfs_setup(int fd, bool enable) {
+ auto change = false;
+ errno = 0;
+ if (enable ? fs_mgr_overlayfs_teardown(nullptr, &change)
+ : fs_mgr_overlayfs_setup(nullptr, nullptr, &change)) {
+ if (change) {
+ WriteFdFmt(fd, "%s overlayfs\n", enable ? "disabling" : "using");
+ }
+ } else if (errno) {
+ WriteFdFmt(fd, "Overlayfs %s failed with error %s\n", enable ? "teardown" : "setup",
+ strerror(errno));
+ suggest_run_adb_root(fd);
+ }
+ return change;
+}
+
/* Use AVB to turn verity on/off */
static bool set_avb_verity_enabled_state(int fd, AvbOps* ops, bool enable_verity) {
std::string ab_suffix = get_ab_suffix();
@@ -128,6 +162,7 @@
return false;
}
+ overlayfs_setup(fd, enable_verity);
WriteFdFmt(fd, "Successfully %s verity\n", enable_verity ? "enabled" : "disabled");
return true;
}
@@ -150,6 +185,7 @@
}
if (!android::base::GetBoolProperty("ro.secure", false)) {
+ overlayfs_setup(fd, enable);
WriteFdExactly(fd.get(), "verity not enabled - ENG build\n");
return;
}
@@ -177,13 +213,14 @@
// Not using AVB - assume VB1.0.
// read all fstab entries at once from all sources
- fstab = fs_mgr_read_fstab_default();
+ if (!fstab) fstab = fs_mgr_read_fstab_default();
if (!fstab) {
- WriteFdExactly(fd.get(), "Failed to read fstab\nMaybe run adb root?\n");
+ WriteFdExactly(fd.get(), "Failed to read fstab\n");
+ suggest_run_adb_root(fd.get());
return;
}
- // Loop through entries looking for ones that vold manages.
+ // Loop through entries looking for ones that verity manages.
for (int i = 0; i < fstab->num_entries; i++) {
if (fs_mgr_is_verified(&fstab->recs[i])) {
if (set_verity_enabled_state(fd.get(), fstab->recs[i].blk_device,
@@ -193,6 +230,7 @@
}
}
}
+ if (!any_changed) any_changed = overlayfs_setup(fd, enable);
if (any_changed) {
WriteFdExactly(fd.get(), "Now reboot your device for settings to take effect\n");
diff --git a/adb/test_adb.py b/adb/test_adb.py
old mode 100644
new mode 100755
index ddd3ff0..d4c98e4
--- a/adb/test_adb.py
+++ b/adb/test_adb.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
#
# Copyright (C) 2015 The Android Open Source Project
#
@@ -19,9 +19,7 @@
This differs from things in test_device.py in that there is no API for these
things. Most of these tests involve specific error messages or the help text.
"""
-from __future__ import print_function
-import binascii
import contextlib
import os
import random
@@ -32,8 +30,6 @@
import threading
import unittest
-import adb
-
@contextlib.contextmanager
def fake_adbd(protocol=socket.AF_INET, port=0):
@@ -42,61 +38,61 @@
serversock = socket.socket(protocol, socket.SOCK_STREAM)
serversock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
if protocol == socket.AF_INET:
- serversock.bind(('127.0.0.1', port))
+ serversock.bind(("127.0.0.1", port))
else:
- serversock.bind(('::1', port))
+ serversock.bind(("::1", port))
serversock.listen(1)
# A pipe that is used to signal the thread that it should terminate.
- readpipe, writepipe = os.pipe()
+ readsock, writesock = socket.socketpair()
- def _adb_packet(command, arg0, arg1, data):
- bin_command = struct.unpack('I', command)[0]
- buf = struct.pack('IIIIII', bin_command, arg0, arg1, len(data), 0,
+ def _adb_packet(command: bytes, arg0: int, arg1: int, data: bytes) -> bytes:
+ bin_command = struct.unpack("I", command)[0]
+ buf = struct.pack("IIIIII", bin_command, arg0, arg1, len(data), 0,
bin_command ^ 0xffffffff)
buf += data
return buf
- def _handle():
- rlist = [readpipe, serversock]
- cnxn_sent = {}
- while True:
- read_ready, _, _ = select.select(rlist, [], [])
- for ready in read_ready:
- if ready == readpipe:
- # Closure pipe
- os.close(ready)
- serversock.shutdown(socket.SHUT_RDWR)
- serversock.close()
- return
- elif ready == serversock:
- # Server socket
- conn, _ = ready.accept()
- rlist.append(conn)
- else:
- # Client socket
- data = ready.recv(1024)
- if not data or data.startswith('OPEN'):
+ def _handle(sock):
+ with contextlib.closing(sock) as serversock:
+ rlist = [readsock, serversock]
+ cnxn_sent = {}
+ while True:
+ read_ready, _, _ = select.select(rlist, [], [])
+ for ready in read_ready:
+ if ready == readsock:
+ # Closure pipe
+ for f in rlist:
+ f.close()
+ return
+ elif ready == serversock:
+ # Server socket
+ conn, _ = ready.accept()
+ rlist.append(conn)
+ else:
+ # Client socket
+ data = ready.recv(1024)
+ if not data or data.startswith(b"OPEN"):
+ if ready in cnxn_sent:
+ del cnxn_sent[ready]
+ ready.shutdown(socket.SHUT_RDWR)
+ ready.close()
+ rlist.remove(ready)
+ continue
if ready in cnxn_sent:
- del cnxn_sent[ready]
- ready.shutdown(socket.SHUT_RDWR)
- ready.close()
- rlist.remove(ready)
- continue
- if ready in cnxn_sent:
- continue
- cnxn_sent[ready] = True
- ready.sendall(_adb_packet('CNXN', 0x01000001, 1024 * 1024,
- 'device::ro.product.name=fakeadb'))
+ continue
+ cnxn_sent[ready] = True
+ ready.sendall(_adb_packet(b"CNXN", 0x01000001, 1024 * 1024,
+ b"device::ro.product.name=fakeadb"))
port = serversock.getsockname()[1]
- server_thread = threading.Thread(target=_handle)
+ server_thread = threading.Thread(target=_handle, args=(serversock,))
server_thread.start()
try:
yield port
finally:
- os.close(writepipe)
+ writesock.close()
server_thread.join()
@@ -107,14 +103,15 @@
This automatically disconnects when done with the connection.
"""
- output = subprocess.check_output(['adb', 'connect', serial])
- unittest.assertEqual(output.strip(), 'connected to {}'.format(serial))
+ output = subprocess.check_output(["adb", "connect", serial])
+ unittest.assertEqual(output.strip(),
+ "connected to {}".format(serial).encode("utf8"))
try:
yield
finally:
# Perform best-effort disconnection. Discard the output.
- subprocess.Popen(['adb', 'disconnect', serial],
+ subprocess.Popen(["adb", "disconnect", serial],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE).communicate()
@@ -123,21 +120,22 @@
def adb_server():
"""Context manager for an ADB server.
- This creates an ADB server and returns the port it's listening on.
+ This creates an ADB server and returns the port it"s listening on.
"""
port = 5038
# Kill any existing server on this non-default port.
- subprocess.check_output(['adb', '-P', str(port), 'kill-server'],
+ subprocess.check_output(["adb", "-P", str(port), "kill-server"],
stderr=subprocess.STDOUT)
read_pipe, write_pipe = os.pipe()
- proc = subprocess.Popen(['adb', '-L', 'tcp:localhost:{}'.format(port),
- 'fork-server', 'server',
- '--reply-fd', str(write_pipe)])
+ os.set_inheritable(write_pipe, True)
+ proc = subprocess.Popen(["adb", "-L", "tcp:localhost:{}".format(port),
+ "fork-server", "server",
+ "--reply-fd", str(write_pipe)], close_fds=False)
try:
os.close(write_pipe)
greeting = os.read(read_pipe, 1024)
- assert greeting == 'OK\n', repr(greeting)
+ assert greeting == b"OK\n", repr(greeting)
yield port
finally:
proc.terminate()
@@ -150,35 +148,37 @@
def test_help(self):
"""Make sure we get _something_ out of help."""
out = subprocess.check_output(
- ['adb', 'help'], stderr=subprocess.STDOUT)
+ ["adb", "help"], stderr=subprocess.STDOUT)
self.assertGreater(len(out), 0)
def test_version(self):
"""Get a version number out of the output of adb."""
- lines = subprocess.check_output(['adb', 'version']).splitlines()
+ lines = subprocess.check_output(["adb", "version"]).splitlines()
version_line = lines[0]
- self.assertRegexpMatches(
- version_line, r'^Android Debug Bridge version \d+\.\d+\.\d+$')
+ self.assertRegex(
+ version_line, rb"^Android Debug Bridge version \d+\.\d+\.\d+$")
if len(lines) == 2:
# Newer versions of ADB have a second line of output for the
# version that includes a specific revision (git SHA).
revision_line = lines[1]
- self.assertRegexpMatches(
- revision_line, r'^Revision [0-9a-f]{12}-android$')
+ self.assertRegex(
+ revision_line, rb"^Revision [0-9a-f]{12}-android$")
def test_tcpip_error_messages(self):
"""Make sure 'adb tcpip' parsing is sane."""
- proc = subprocess.Popen(['adb', 'tcpip'], stdout=subprocess.PIPE,
+ proc = subprocess.Popen(["adb", "tcpip"],
+ stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
out, _ = proc.communicate()
self.assertEqual(1, proc.returncode)
- self.assertIn('requires an argument', out)
+ self.assertIn(b"requires an argument", out)
- proc = subprocess.Popen(['adb', 'tcpip', 'foo'], stdout=subprocess.PIPE,
+ proc = subprocess.Popen(["adb", "tcpip", "foo"],
+ stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
out, _ = proc.communicate()
self.assertEqual(1, proc.returncode)
- self.assertIn('invalid port', out)
+ self.assertIn(b"invalid port", out)
class ServerTest(unittest.TestCase):
@@ -214,12 +214,12 @@
port = 5038
# Kill any existing server on this non-default port.
- subprocess.check_output(['adb', '-P', str(port), 'kill-server'],
+ subprocess.check_output(["adb", "-P", str(port), "kill-server"],
stderr=subprocess.STDOUT)
try:
# Run the adb client and have it start the adb server.
- proc = subprocess.Popen(['adb', '-P', str(port), 'start-server'],
+ proc = subprocess.Popen(["adb", "-P", str(port), "start-server"],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
@@ -229,14 +229,12 @@
stdout_thread = threading.Thread(
target=ServerTest._read_pipe_and_set_event,
args=(proc.stdout, stdout_event))
- stdout_thread.daemon = True
stdout_thread.start()
stderr_event = threading.Event()
stderr_thread = threading.Thread(
target=ServerTest._read_pipe_and_set_event,
args=(proc.stderr, stderr_event))
- stderr_thread.daemon = True
stderr_thread.start()
# Wait for the adb client to finish. Once that has occurred, if
@@ -250,7 +248,8 @@
# probably letting the adb server inherit stdin which would be
# wrong.
with self.assertRaises(IOError):
- proc.stdin.write('x')
+ proc.stdin.write(b"x")
+ proc.stdin.flush()
# Wait a few seconds for stdout/stderr to be closed (in the success
# case, this won't wait at all). If there is a timeout, that means
@@ -259,9 +258,11 @@
# inherit stdout/stderr which would be wrong.
self.assertTrue(stdout_event.wait(5), "adb stdout not closed")
self.assertTrue(stderr_event.wait(5), "adb stderr not closed")
+ stdout_thread.join()
+ stderr_thread.join()
finally:
# If we started a server, kill it.
- subprocess.check_output(['adb', '-P', str(port), 'kill-server'],
+ subprocess.check_output(["adb", "-P", str(port), "kill-server"],
stderr=subprocess.STDOUT)
@@ -271,7 +272,7 @@
def _reset_socket_on_close(self, sock):
"""Use SO_LINGER to cause TCP RST segment to be sent on socket close."""
# The linger structure is two shorts on Windows, but two ints on Unix.
- linger_format = 'hh' if os.name == 'nt' else 'ii'
+ linger_format = "hh" if os.name == "nt" else "ii"
l_onoff = 1
l_linger = 0
@@ -292,33 +293,33 @@
# Use SO_REUSEADDR so subsequent runs of the test can grab the port
# even if it is in TIME_WAIT.
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
- listener.bind(('127.0.0.1', 0))
+ listener.bind(("127.0.0.1", 0))
listener.listen(4)
port = listener.getsockname()[1]
# Now that listening has started, start adb emu kill, telling it to
# connect to our mock emulator.
proc = subprocess.Popen(
- ['adb', '-s', 'emulator-' + str(port), 'emu', 'kill'],
+ ["adb", "-s", "emulator-" + str(port), "emu", "kill"],
stderr=subprocess.STDOUT)
accepted_connection, addr = listener.accept()
with contextlib.closing(accepted_connection) as conn:
# If WSAECONNABORTED (10053) is raised by any socket calls,
# then adb probably isn't reading the data that we sent it.
- conn.sendall('Android Console: type \'help\' for a list ' +
- 'of commands\r\n')
- conn.sendall('OK\r\n')
+ conn.sendall(("Android Console: type 'help' for a list "
+ "of commands\r\n").encode("utf8"))
+ conn.sendall(b"OK\r\n")
with contextlib.closing(conn.makefile()) as connf:
line = connf.readline()
- if line.startswith('auth'):
+ if line.startswith("auth"):
# Ignore the first auth line.
line = connf.readline()
- self.assertEqual('kill\n', line)
- self.assertEqual('quit\n', connf.readline())
+ self.assertEqual("kill\n", line)
+ self.assertEqual("quit\n", connf.readline())
- conn.sendall('OK: killing emulator, bye bye\r\n')
+ conn.sendall(b"OK: killing emulator, bye bye\r\n")
# Use SO_LINGER to send TCP RST segment to test whether adb
# ignores WSAECONNRESET on Windows. This happens with the
@@ -342,31 +343,31 @@
"""
with adb_server() as server_port:
with fake_adbd() as port:
- serial = 'emulator-{}'.format(port - 1)
+ serial = "emulator-{}".format(port - 1)
# Ensure that the emulator is not there.
try:
- subprocess.check_output(['adb', '-P', str(server_port),
- '-s', serial, 'get-state'],
+ subprocess.check_output(["adb", "-P", str(server_port),
+ "-s", serial, "get-state"],
stderr=subprocess.STDOUT)
- self.fail('Device should not be available')
+ self.fail("Device should not be available")
except subprocess.CalledProcessError as err:
self.assertEqual(
err.output.strip(),
- 'error: device \'{}\' not found'.format(serial))
+ "error: device '{}' not found".format(serial).encode("utf8"))
# Let the ADB server know that the emulator has started.
with contextlib.closing(
- socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
- sock.connect(('localhost', server_port))
- command = 'host:emulator:{}'.format(port)
- sock.sendall('%04x%s' % (len(command), command))
+ socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
+ sock.connect(("localhost", server_port))
+ command = "host:emulator:{}".format(port).encode("utf8")
+ sock.sendall(b"%04x%s" % (len(command), command))
# Ensure the emulator is there.
- subprocess.check_call(['adb', '-P', str(server_port),
- '-s', serial, 'wait-for-device'])
- output = subprocess.check_output(['adb', '-P', str(server_port),
- '-s', serial, 'get-state'])
- self.assertEqual(output.strip(), 'device')
+ subprocess.check_call(["adb", "-P", str(server_port),
+ "-s", serial, "wait-for-device"])
+ output = subprocess.check_output(["adb", "-P", str(server_port),
+ "-s", serial, "get-state"])
+ self.assertEqual(output.strip(), b"device")
class ConnectionTest(unittest.TestCase):
@@ -380,7 +381,7 @@
for protocol in (socket.AF_INET, socket.AF_INET6):
try:
with fake_adbd(protocol=protocol) as port:
- serial = 'localhost:{}'.format(port)
+ serial = "localhost:{}".format(port)
with adb_connect(self, serial):
pass
except socket.error:
@@ -391,49 +392,51 @@
"""Ensure that an already-connected device stays connected."""
with fake_adbd() as port:
- serial = 'localhost:{}'.format(port)
+ serial = "localhost:{}".format(port)
with adb_connect(self, serial):
# b/31250450: this always returns 0 but probably shouldn't.
- output = subprocess.check_output(['adb', 'connect', serial])
+ output = subprocess.check_output(["adb", "connect", serial])
self.assertEqual(
- output.strip(), 'already connected to {}'.format(serial))
+ output.strip(),
+ "already connected to {}".format(serial).encode("utf8"))
def test_reconnect(self):
"""Ensure that a disconnected device reconnects."""
with fake_adbd() as port:
- serial = 'localhost:{}'.format(port)
+ serial = "localhost:{}".format(port)
with adb_connect(self, serial):
- output = subprocess.check_output(['adb', '-s', serial,
- 'get-state'])
- self.assertEqual(output.strip(), 'device')
+ output = subprocess.check_output(["adb", "-s", serial,
+ "get-state"])
+ self.assertEqual(output.strip(), b"device")
# This will fail.
- proc = subprocess.Popen(['adb', '-s', serial, 'shell', 'true'],
+ proc = subprocess.Popen(["adb", "-s", serial, "shell", "true"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, _ = proc.communicate()
- self.assertEqual(output.strip(), 'error: closed')
+ self.assertEqual(output.strip(), b"error: closed")
- subprocess.check_call(['adb', '-s', serial, 'wait-for-device'])
+ subprocess.check_call(["adb", "-s", serial, "wait-for-device"])
- output = subprocess.check_output(['adb', '-s', serial,
- 'get-state'])
- self.assertEqual(output.strip(), 'device')
+ output = subprocess.check_output(["adb", "-s", serial,
+ "get-state"])
+ self.assertEqual(output.strip(), b"device")
# Once we explicitly kick a device, it won't attempt to
# reconnect.
- output = subprocess.check_output(['adb', 'disconnect', serial])
+ output = subprocess.check_output(["adb", "disconnect", serial])
self.assertEqual(
- output.strip(), 'disconnected {}'.format(serial))
+ output.strip(),
+ "disconnected {}".format(serial).encode("utf8"))
try:
- subprocess.check_output(['adb', '-s', serial, 'get-state'],
+ subprocess.check_output(["adb", "-s", serial, "get-state"],
stderr=subprocess.STDOUT)
- self.fail('Device should not be available')
+ self.fail("Device should not be available")
except subprocess.CalledProcessError as err:
self.assertEqual(
err.output.strip(),
- 'error: device \'{}\' not found'.format(serial))
+ "error: device '{}' not found".format(serial).encode("utf8"))
def main():
@@ -442,5 +445,5 @@
unittest.main(verbosity=3)
-if __name__ == '__main__':
+if __name__ == "__main__":
main()
diff --git a/adb/test_device.py b/adb/test_device.py
index 4abe7a7..42aadc4 100644
--- a/adb/test_device.py
+++ b/adb/test_device.py
@@ -762,9 +762,10 @@
os.chmod(host_dir, 0o700)
# Create an empty directory.
- os.mkdir(os.path.join(host_dir, 'empty'))
+ empty_dir_path = os.path.join(host_dir, 'empty')
+ os.mkdir(empty_dir_path);
- self.device.push(host_dir, self.DEVICE_TEMP_DIR)
+ self.device.push(empty_dir_path, self.DEVICE_TEMP_DIR)
test_empty_cmd = ['[', '-d',
os.path.join(self.DEVICE_TEMP_DIR, 'empty')]
@@ -1032,7 +1033,8 @@
if host_dir is not None:
shutil.rmtree(host_dir)
- def test_pull_symlink_dir(self):
+ # selinux prevents adbd from accessing symlinks on /data/local/tmp.
+ def disabled_test_pull_symlink_dir(self):
"""Pull a symlink to a directory of symlinks to files."""
try:
host_dir = tempfile.mkdtemp()
diff --git a/adb/transport.cpp b/adb/transport.cpp
index 3c74c75..0e8db04 100644
--- a/adb/transport.cpp
+++ b/adb/transport.cpp
@@ -1190,14 +1190,15 @@
}
#endif // ADB_HOST
-int register_socket_transport(unique_fd s, std::string serial, int port, int local,
- atransport::ReconnectCallback reconnect) {
+bool register_socket_transport(unique_fd s, std::string serial, int port, int local,
+ atransport::ReconnectCallback reconnect, int* error) {
atransport* t = new atransport(std::move(reconnect), kCsOffline);
D("transport: %s init'ing for socket %d, on port %d", serial.c_str(), s.get(), port);
if (init_socket_transport(t, std::move(s), port, local) < 0) {
delete t;
- return -1;
+ if (error) *error = errno;
+ return false;
}
std::unique_lock<std::recursive_mutex> lock(transport_lock);
@@ -1206,7 +1207,8 @@
VLOG(TRANSPORT) << "socket transport " << transport->serial
<< " is already in pending_list and fails to register";
delete t;
- return -EALREADY;
+ if (error) *error = EALREADY;
+ return false;
}
}
@@ -1215,7 +1217,8 @@
VLOG(TRANSPORT) << "socket transport " << transport->serial
<< " is already in transport_list and fails to register";
delete t;
- return -EALREADY;
+ if (error) *error = EALREADY;
+ return false;
}
}
@@ -1229,10 +1232,20 @@
if (local == 1) {
// Do not wait for emulator transports.
- return 0;
+ return true;
}
- return waitable->WaitForConnection(std::chrono::seconds(10)) ? 0 : -1;
+ if (!waitable->WaitForConnection(std::chrono::seconds(10))) {
+ if (error) *error = ETIMEDOUT;
+ return false;
+ }
+
+ if (t->GetConnectionState() == kCsUnauthorized) {
+ if (error) *error = EPERM;
+ return false;
+ }
+
+ return true;
}
#if ADB_HOST
diff --git a/adb/transport.h b/adb/transport.h
index 4bfc2ce..f362f24 100644
--- a/adb/transport.h
+++ b/adb/transport.h
@@ -364,8 +364,8 @@
void connect_device(const std::string& address, std::string* response);
/* cause new transports to be init'd and added to the list */
-int register_socket_transport(unique_fd s, std::string serial, int port, int local,
- atransport::ReconnectCallback reconnect);
+bool register_socket_transport(unique_fd s, std::string serial, int port, int local,
+ atransport::ReconnectCallback reconnect, int* error = nullptr);
// This should only be used for transports with connection_state == kCsNoPerm.
void unregister_usb_transport(usb_handle* usb);
diff --git a/adb/transport_local.cpp b/adb/transport_local.cpp
index b20dee9..1431252 100644
--- a/adb/transport_local.cpp
+++ b/adb/transport_local.cpp
@@ -125,10 +125,12 @@
return init_socket_transport(t, std::move(fd), port, 0) >= 0;
};
- int ret = register_socket_transport(std::move(fd), serial, port, 0, std::move(reconnect));
- if (ret < 0) {
- if (ret == -EALREADY) {
+ int error;
+ if (!register_socket_transport(std::move(fd), serial, port, 0, std::move(reconnect), &error)) {
+ if (error == EALREADY) {
*response = android::base::StringPrintf("already connected to %s", serial.c_str());
+ } else if (error == EPERM) {
+ *response = android::base::StringPrintf("failed to authenticate to %s", serial.c_str());
} else {
*response = android::base::StringPrintf("failed to connect to %s", serial.c_str());
}
@@ -162,7 +164,7 @@
disable_tcp_nagle(fd.get());
std::string serial = getEmulatorSerialString(console_port);
if (register_socket_transport(std::move(fd), std::move(serial), adb_port, 1,
- [](atransport*) { return false; }) == 0) {
+ [](atransport*) { return false; })) {
return 0;
}
}
diff --git a/base/include/android-base/parsedouble.h b/base/include/android-base/parsedouble.h
index 7b1c648..ccffba2 100644
--- a/base/include/android-base/parsedouble.h
+++ b/base/include/android-base/parsedouble.h
@@ -20,6 +20,7 @@
#include <stdlib.h>
#include <limits>
+#include <string>
namespace android {
namespace base {
@@ -52,6 +53,11 @@
double max = std::numeric_limits<double>::max()) {
return ParseFloatingPoint<double, strtod>(s, out, min, max);
}
+static inline bool ParseDouble(const std::string& s, double* out,
+ double min = std::numeric_limits<double>::lowest(),
+ double max = std::numeric_limits<double>::max()) {
+ return ParseFloatingPoint<double, strtod>(s.c_str(), out, min, max);
+}
// Parse float value in the string 's' and sets 'out' to that value if it exists.
// Optionally allows the caller to define a 'min' and 'max' beyond which
@@ -61,6 +67,11 @@
float max = std::numeric_limits<float>::max()) {
return ParseFloatingPoint<float, strtof>(s, out, min, max);
}
+static inline bool ParseFloat(const std::string& s, float* out,
+ float min = std::numeric_limits<float>::lowest(),
+ float max = std::numeric_limits<float>::max()) {
+ return ParseFloatingPoint<float, strtof>(s.c_str(), out, min, max);
+}
} // namespace base
} // namespace android
diff --git a/fs_mgr/Android.bp b/fs_mgr/Android.bp
index 196321c..6329d54 100644
--- a/fs_mgr/Android.bp
+++ b/fs_mgr/Android.bp
@@ -43,6 +43,7 @@
"fs_mgr_avb.cpp",
"fs_mgr_avb_ops.cpp",
"fs_mgr_dm_linear.cpp",
+ "fs_mgr_overlayfs.cpp",
],
shared_libs: [
"libfec",
diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 5f57182..99f2df8 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#include "fs_mgr.h"
+
#include <ctype.h>
#include <dirent.h>
#include <errno.h>
@@ -51,6 +53,7 @@
#include <ext4_utils/ext4_sb.h>
#include <ext4_utils/ext4_utils.h>
#include <ext4_utils/wipe.h>
+#include <fs_mgr_overlayfs.h>
#include <libdm/dm.h>
#include <linux/fs.h>
#include <linux/loop.h>
@@ -58,7 +61,6 @@
#include <log/log_properties.h>
#include <logwrap/logwrap.h>
-#include "fs_mgr.h"
#include "fs_mgr_avb.h"
#include "fs_mgr_priv.h"
@@ -1035,6 +1037,10 @@
}
}
+#if ALLOW_ADBD_DISABLE_VERITY == 1 // "userdebug" build
+ fs_mgr_overlayfs_mount_all();
+#endif
+
if (error_count) {
return FS_MGR_MNTALL_FAIL;
} else {
diff --git a/fs_mgr/fs_mgr_overlayfs.cpp b/fs_mgr/fs_mgr_overlayfs.cpp
new file mode 100644
index 0000000..bafa2b3
--- /dev/null
+++ b/fs_mgr/fs_mgr_overlayfs.cpp
@@ -0,0 +1,478 @@
+/*
+ * Copyright (C) 2018 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.
+ */
+
+#include <dirent.h>
+#include <errno.h>
+#include <linux/fs.h>
+#include <selinux/selinux.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/mount.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <android-base/file.h>
+#include <android-base/macros.h>
+#include <android-base/properties.h>
+#include <android-base/strings.h>
+#include <fs_mgr_overlayfs.h>
+#include <fstab/fstab.h>
+
+#include "fs_mgr_priv.h"
+
+using namespace std::literals;
+
+#if ALLOW_ADBD_DISABLE_VERITY == 0 // If we are a user build, provide stubs
+
+bool fs_mgr_overlayfs_mount_all() {
+ return false;
+}
+
+bool fs_mgr_overlayfs_setup(const char*, const char*, bool* change) {
+ if (change) change = false;
+ return false;
+}
+
+bool fs_mgr_overlayfs_teardown(const char*, bool* change) {
+ if (change) change = false;
+ return false;
+}
+
+#else // ALLOW_ADBD_DISABLE_VERITY == 0
+
+namespace {
+
+// acceptable overlayfs backing storage
+const auto kOverlayMountPoint = "/cache"s;
+
+// return true if everything is mounted, but before adb is started. At
+// 'trigger firmware_mounts_complete' after 'trigger load_persist_props_action'.
+bool fs_mgr_boot_completed() {
+ return !android::base::GetProperty("ro.boottime.init", "").empty() &&
+ !!access("/dev/.booting", F_OK);
+}
+
+bool fs_mgr_is_dir(const std::string& path) {
+ struct stat st;
+ return !stat(path.c_str(), &st) && S_ISDIR(st.st_mode);
+}
+
+// Similar test as overlayfs workdir= validation in the kernel for read-write
+// validation, except we use fs_mgr_work. Covers space and storage issues.
+bool fs_mgr_dir_is_writable(const std::string& path) {
+ auto test_directory = path + "/fs_mgr_work";
+ rmdir(test_directory.c_str());
+ auto ret = !mkdir(test_directory.c_str(), 0700);
+ return ret | !rmdir(test_directory.c_str());
+}
+
+std::string fs_mgr_get_context(const std::string& mount_point) {
+ char* ctx = nullptr;
+ auto len = getfilecon(mount_point.c_str(), &ctx);
+ if ((len > 0) && ctx) {
+ std::string context(ctx, len);
+ free(ctx);
+ return context;
+ }
+ return "";
+}
+
+bool fs_mgr_overlayfs_enabled(const struct fstab_rec* fsrec) {
+ // readonly filesystem, can not be mount -o remount,rw
+ return "squashfs"s == fsrec->fs_type;
+}
+
+constexpr char upper_name[] = "upper";
+constexpr char work_name[] = "work";
+
+std::string fs_mgr_get_overlayfs_candidate(const std::string& mount_point) {
+ if (!fs_mgr_is_dir(mount_point)) return "";
+ auto dir = kOverlayMountPoint + "/overlay/" + android::base::Basename(mount_point) + "/";
+ auto upper = dir + upper_name;
+ if (!fs_mgr_is_dir(upper)) return "";
+ auto work = dir + work_name;
+ if (!fs_mgr_is_dir(work)) return "";
+ if (!fs_mgr_dir_is_writable(work)) return "";
+ return dir;
+}
+
+constexpr char lowerdir_option[] = "lowerdir=";
+constexpr char upperdir_option[] = "upperdir=";
+
+// default options for mount_point, returns empty string for none available.
+std::string fs_mgr_get_overlayfs_options(const char* mount_point) {
+ auto fsrec_mount_point = std::string(mount_point);
+ auto candidate = fs_mgr_get_overlayfs_candidate(fsrec_mount_point);
+ if (candidate.empty()) return "";
+
+ auto context = fs_mgr_get_context(fsrec_mount_point);
+ if (!context.empty()) context = ",rootcontext="s + context;
+ return "override_creds=off,"s + lowerdir_option + fsrec_mount_point + "," + upperdir_option +
+ candidate + upper_name + ",workdir=" + candidate + work_name + context;
+}
+
+bool fs_mgr_system_root_image(const fstab* fstab) {
+ if (!fstab) { // can not happen?
+ // This will return empty on init first_stage_mount,
+ // hence why we prefer checking the fstab instead.
+ return android::base::GetBoolProperty("ro.build.system_root_image", false);
+ }
+ for (auto i = 0; i < fstab->num_entries; i++) {
+ const auto fsrec = &fstab->recs[i];
+ auto fsrec_mount_point = fsrec->mount_point;
+ if (!fsrec_mount_point) continue;
+ if ("/system"s == fsrec_mount_point) return false;
+ }
+ return true;
+}
+
+std::string fs_mgr_get_overlayfs_options(const fstab* fstab, const char* mount_point) {
+ if (fs_mgr_system_root_image(fstab) && ("/"s == mount_point)) mount_point = "/system";
+
+ return fs_mgr_get_overlayfs_options(mount_point);
+}
+
+// return true if system supports overlayfs
+bool fs_mgr_wants_overlayfs() {
+ // This will return empty on init first_stage_mount, so speculative
+ // determination, empty (unset) _or_ "1" is true which differs from the
+ // official ro.debuggable policy. ALLOW_ADBD_DISABLE_VERITY == 0 should
+ // protect us from false in any case, so this is insurance.
+ auto debuggable = android::base::GetProperty("ro.debuggable", "1");
+ if (debuggable != "1") return false;
+
+ // Overlayfs available in the kernel, and patched for override_creds?
+ static signed char overlayfs_in_kernel = -1; // cache for constant condition
+ if (overlayfs_in_kernel == -1) {
+ overlayfs_in_kernel = !access("/sys/module/overlay/parameters/override_creds", F_OK);
+ }
+ return overlayfs_in_kernel;
+}
+
+bool fs_mgr_wants_overlayfs(const fstab_rec* fsrec) {
+ if (!fsrec) return false;
+
+ auto fsrec_mount_point = fsrec->mount_point;
+ if (!fsrec_mount_point) return false;
+
+ if (!fsrec->fs_type) return false;
+
+ // Don't check entries that are managed by vold.
+ if (fsrec->fs_mgr_flags & (MF_VOLDMANAGED | MF_RECOVERYONLY)) return false;
+
+ // Only concerned with readonly partitions.
+ if (!(fsrec->flags & MS_RDONLY)) return false;
+
+ // If unbindable, do not allow overlayfs as this could expose us to
+ // security issues. On Android, this could also be used to turn off
+ // the ability to overlay an otherwise acceptable filesystem since
+ // /system and /vendor are never bound(sic) to.
+ if (fsrec->flags & MS_UNBINDABLE) return false;
+
+ if (!fs_mgr_overlayfs_enabled(fsrec)) return false;
+
+ // Verity enabled?
+ const auto basename_mount_point(android::base::Basename(fsrec_mount_point));
+ auto found = false;
+ fs_mgr_update_verity_state(
+ [&basename_mount_point, &found](fstab_rec*, const char* mount_point, int, int) {
+ if (mount_point && (basename_mount_point == mount_point)) found = true;
+ });
+ return !found;
+}
+
+bool fs_mgr_rm_all(const std::string& path, bool* change = nullptr) {
+ auto save_errno = errno;
+ std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(path.c_str()), closedir);
+ if (!dir) {
+ if (errno == ENOENT) {
+ errno = save_errno;
+ return true;
+ }
+ PERROR << "overlayfs open " << path;
+ return false;
+ }
+ dirent* entry;
+ auto ret = true;
+ while ((entry = readdir(dir.get()))) {
+ if (("."s == entry->d_name) || (".."s == entry->d_name)) continue;
+ auto file = path + "/" + entry->d_name;
+ if (entry->d_type == DT_UNKNOWN) {
+ struct stat st;
+ if (!lstat(file.c_str(), &st) && (st.st_mode & S_IFDIR)) entry->d_type = DT_DIR;
+ }
+ if (entry->d_type == DT_DIR) {
+ ret &= fs_mgr_rm_all(file, change);
+ if (!rmdir(file.c_str())) {
+ if (change) *change = true;
+ } else {
+ ret = false;
+ PERROR << "overlayfs rmdir " << file;
+ }
+ continue;
+ }
+ if (!unlink(file.c_str())) {
+ if (change) *change = true;
+ } else {
+ ret = false;
+ PERROR << "overlayfs rm " << file;
+ }
+ }
+ return ret;
+}
+
+bool fs_mgr_overlayfs_setup_one(const std::string& overlay, const std::string& mount_point,
+ bool* change) {
+ auto ret = true;
+ auto fsrec_mount_point = overlay + android::base::Basename(mount_point) + "/";
+ auto save_errno = errno;
+ if (!mkdir(fsrec_mount_point.c_str(), 0755)) {
+ if (change) *change = true;
+ } else if (errno != EEXIST) {
+ ret = false;
+ PERROR << "overlayfs mkdir " << fsrec_mount_point;
+ } else {
+ errno = save_errno;
+ }
+
+ save_errno = errno;
+ if (!mkdir((fsrec_mount_point + work_name).c_str(), 0755)) {
+ if (change) *change = true;
+ } else if (errno != EEXIST) {
+ ret = false;
+ PERROR << "overlayfs mkdir " << fsrec_mount_point << work_name;
+ } else {
+ errno = save_errno;
+ }
+
+ auto new_context = fs_mgr_get_context(mount_point);
+ if (!new_context.empty() && setfscreatecon(new_context.c_str())) {
+ ret = false;
+ PERROR << "overlayfs setfscreatecon " << new_context;
+ }
+ auto upper = fsrec_mount_point + upper_name;
+ save_errno = errno;
+ if (!mkdir(upper.c_str(), 0755)) {
+ if (change) *change = true;
+ } else if (errno != EEXIST) {
+ ret = false;
+ PERROR << "overlayfs mkdir " << upper;
+ } else {
+ errno = save_errno;
+ }
+ if (!new_context.empty()) setfscreatecon(nullptr);
+
+ return ret;
+}
+
+bool fs_mgr_overlayfs_mount(const fstab* fstab, const fstab_rec* fsrec) {
+ if (!fs_mgr_wants_overlayfs(fsrec)) return false;
+ auto fsrec_mount_point = fsrec->mount_point;
+ if (!fsrec_mount_point || !fsrec_mount_point[0]) return false;
+ auto options = fs_mgr_get_overlayfs_options(fstab, fsrec_mount_point);
+ if (options.empty()) return false;
+
+ // hijack __mount() report format to help triage
+ auto report = "__mount(source=overlay,target="s + fsrec_mount_point + ",type=overlay";
+ const auto opt_list = android::base::Split(options, ",");
+ for (const auto opt : opt_list) {
+ if (android::base::StartsWith(opt, upperdir_option)) {
+ report = report + "," + opt;
+ break;
+ }
+ }
+ report = report + ")=";
+
+ auto ret = mount("overlay", fsrec_mount_point, "overlay", MS_RDONLY | MS_RELATIME,
+ options.c_str());
+ if (ret) {
+ PERROR << report << ret;
+ return false;
+ } else {
+ LINFO << report << ret;
+ return true;
+ }
+}
+
+bool fs_mgr_overlayfs_already_mounted(const char* mount_point) {
+ if (!mount_point) return false;
+ std::unique_ptr<struct fstab, decltype(&fs_mgr_free_fstab)> fstab(
+ fs_mgr_read_fstab("/proc/mounts"), fs_mgr_free_fstab);
+ if (!fstab) return false;
+ const auto lowerdir = std::string(lowerdir_option) + mount_point;
+ for (auto i = 0; i < fstab->num_entries; ++i) {
+ const auto fsrec = &fstab->recs[i];
+ const auto fs_type = fsrec->fs_type;
+ if (!fs_type) continue;
+ if (("overlay"s != fs_type) && ("overlayfs"s != fs_type)) continue;
+ auto fsrec_mount_point = fsrec->mount_point;
+ if (!fsrec_mount_point) continue;
+ if (strcmp(fsrec_mount_point, mount_point)) continue;
+ const auto fs_options = fsrec->fs_options;
+ if (!fs_options) continue;
+ const auto options = android::base::Split(fs_options, ",");
+ for (const auto opt : options) {
+ if (opt == lowerdir) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+} // namespace
+
+bool fs_mgr_overlayfs_mount_all() {
+ auto ret = false;
+
+ if (!fs_mgr_wants_overlayfs()) return ret;
+
+ std::unique_ptr<struct fstab, decltype(&fs_mgr_free_fstab)> fstab(fs_mgr_read_fstab_default(),
+ fs_mgr_free_fstab);
+ if (!fstab) return ret;
+
+ for (auto i = 0; i < fstab->num_entries; i++) {
+ const auto fsrec = &fstab->recs[i];
+ auto fsrec_mount_point = fsrec->mount_point;
+ if (!fsrec_mount_point) continue;
+ if (fs_mgr_overlayfs_already_mounted(fsrec_mount_point)) continue;
+
+ if (fs_mgr_overlayfs_mount(fstab.get(), fsrec)) ret = true;
+ }
+ return ret;
+}
+
+// Returns false if setup not permitted, errno set to last error.
+// If something is altered, set *change.
+bool fs_mgr_overlayfs_setup(const char* backing, const char* mount_point, bool* change) {
+ if (change) *change = false;
+ auto ret = false;
+ if (backing && (kOverlayMountPoint != backing)) {
+ errno = EINVAL;
+ return ret;
+ }
+ if (!fs_mgr_wants_overlayfs()) return ret;
+ if (!fs_mgr_boot_completed()) {
+ errno = EBUSY;
+ PERROR << "overlayfs setup";
+ return ret;
+ }
+
+ std::unique_ptr<struct fstab, decltype(&fs_mgr_free_fstab)> fstab(fs_mgr_read_fstab_default(),
+ fs_mgr_free_fstab);
+ std::vector<std::string> mounts;
+ if (fstab) {
+ if (!fs_mgr_get_entry_for_mount_point(fstab.get(), kOverlayMountPoint)) return ret;
+ for (auto i = 0; i < fstab->num_entries; i++) {
+ const auto fsrec = &fstab->recs[i];
+ auto fsrec_mount_point = fsrec->mount_point;
+ if (!fsrec_mount_point) continue;
+ if (mount_point && strcmp(fsrec_mount_point, mount_point)) continue;
+ if (!fs_mgr_wants_overlayfs(fsrec)) continue;
+ mounts.emplace_back(fsrec_mount_point);
+ }
+ if (mounts.empty()) return ret;
+ }
+
+ if (mount_point && ("/"s == mount_point) && fs_mgr_system_root_image(fstab.get())) {
+ mount_point = "/system";
+ }
+ auto overlay = kOverlayMountPoint + "/overlay/";
+ auto save_errno = errno;
+ if (!mkdir(overlay.c_str(), 0755)) {
+ if (change) *change = true;
+ } else if (errno != EEXIST) {
+ PERROR << "overlayfs mkdir " << overlay;
+ } else {
+ errno = save_errno;
+ }
+ if (!fstab && mount_point && fs_mgr_overlayfs_setup_one(overlay, mount_point, change)) {
+ ret = true;
+ }
+ for (const auto& fsrec_mount_point : mounts) {
+ ret |= fs_mgr_overlayfs_setup_one(overlay, fsrec_mount_point, change);
+ }
+ return ret;
+}
+
+// Returns false if teardown not permitted, errno set to last error.
+// If something is altered, set *change.
+bool fs_mgr_overlayfs_teardown(const char* mount_point, bool* change) {
+ if (change) *change = false;
+ if (mount_point && ("/"s == mount_point)) {
+ std::unique_ptr<struct fstab, decltype(&fs_mgr_free_fstab)> fstab(
+ fs_mgr_read_fstab_default(), fs_mgr_free_fstab);
+ if (fs_mgr_system_root_image(fstab.get())) mount_point = "/system";
+ }
+ auto ret = true;
+ const auto overlay = kOverlayMountPoint + "/overlay";
+ const auto oldpath = overlay + (mount_point ?: "");
+ const auto newpath = oldpath + ".teardown";
+ ret &= fs_mgr_rm_all(newpath);
+ auto save_errno = errno;
+ if (rename(oldpath.c_str(), newpath.c_str())) {
+ if (change) *change = true;
+ } else if (errno != ENOENT) {
+ ret = false;
+ PERROR << "overlayfs mv " << oldpath << " " << newpath;
+ } else {
+ errno = save_errno;
+ }
+ ret &= fs_mgr_rm_all(newpath, change);
+ save_errno = errno;
+ if (!rmdir(newpath.c_str())) {
+ if (change) *change = true;
+ } else if (errno != ENOENT) {
+ ret = false;
+ PERROR << "overlayfs rmdir " << newpath;
+ } else {
+ errno = save_errno;
+ }
+ if (mount_point) {
+ save_errno = errno;
+ if (!rmdir(overlay.c_str())) {
+ if (change) *change = true;
+ } else if ((errno != ENOENT) && (errno != ENOTEMPTY)) {
+ ret = false;
+ PERROR << "overlayfs rmdir " << overlay;
+ } else {
+ errno = save_errno;
+ }
+ }
+ if (!fs_mgr_wants_overlayfs()) {
+ // After obligatory teardown to make sure everything is clean, but if
+ // we didn't want overlayfs in the the first place, we do not want to
+ // waste time on a reboot (or reboot request message).
+ if (change) *change = false;
+ }
+ // And now that we did what we could, lets inform
+ // caller that there may still be more to do.
+ if (!fs_mgr_boot_completed()) {
+ errno = EBUSY;
+ PERROR << "overlayfs teardown";
+ ret = false;
+ }
+ return ret;
+}
+
+#endif // ALLOW_ADBD_DISABLE_VERITY != 0
diff --git a/fs_mgr/include/fs_mgr_overlayfs.h b/fs_mgr/include/fs_mgr_overlayfs.h
new file mode 100644
index 0000000..1d2ff03
--- /dev/null
+++ b/fs_mgr/include/fs_mgr_overlayfs.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2018 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.
+ */
+
+#pragma once
+
+#include <fstab/fstab.h>
+
+bool fs_mgr_overlayfs_mount_all();
+bool fs_mgr_overlayfs_setup(const char* backing = nullptr, const char* mount_point = nullptr,
+ bool* change = nullptr);
+bool fs_mgr_overlayfs_teardown(const char* mount_point = nullptr, bool* change = nullptr);
diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index 41e8fff..0c5cf76 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -35,6 +35,7 @@
#include "fs_mgr.h"
#include "fs_mgr_avb.h"
#include "fs_mgr_dm_linear.h"
+#include "fs_mgr_overlayfs.h"
#include "uevent.h"
#include "uevent_listener.h"
#include "util.h"
@@ -351,6 +352,7 @@
return false;
}
}
+ fs_mgr_overlayfs_mount_all();
return true;
}