diff --git a/Android.bp b/Android.bp
index 7167bb3..461f1db 100644
--- a/Android.bp
+++ b/Android.bp
@@ -14,6 +14,22 @@
 // limitations under the License.
 //
 
+package {
+    default_applicable_licenses: ["system_libbase_license"],
+}
+
+license {
+    name: "system_libbase_license",
+    visibility: [":__subpackages__"],
+    license_kinds: [
+        "SPDX-license-identifier-Apache-2.0",
+        "SPDX-license-identifier-BSD",
+    ],
+    license_text: [
+        "NOTICE",
+    ],
+}
+
 cc_defaults {
     name: "libbase_cflags_defaults",
     cflags: [
@@ -163,6 +179,7 @@
         "errors_test.cpp",
         "expected_test.cpp",
         "file_test.cpp",
+        "function_ref_test.cpp",
         "logging_splitters_test.cpp",
         "logging_test.cpp",
         "macros_test.cpp",
diff --git a/function_ref_test.cpp b/function_ref_test.cpp
new file mode 100644
index 0000000..44194f7
--- /dev/null
+++ b/function_ref_test.cpp
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2021 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 "android-base/function_ref.h"
+
+#include <gtest/gtest.h>
+
+#include <functional>
+#include <string>
+
+namespace android::base {
+
+TEST(function_ref, Ctor) {
+  // Making sure it can be constructed in all meaningful ways
+
+  using EmptyFunc = function_ref<void()>;
+
+  EmptyFunc f1([] {});
+
+  struct Functor {
+    void operator()() const {}
+  };
+  EmptyFunc f2(Functor{});
+  Functor fctr;
+  EmptyFunc f3(fctr);
+
+  EmptyFunc f4(std::function<void()>([f1, f2, f3] {
+    (void)f1;
+    (void)f2;
+    (void)f3;
+  }));
+
+  const std::function<void()> func = [] {};
+  EmptyFunc f5(func);
+
+  static_assert(sizeof(f1) <= 2 * sizeof(void*), "Too big function_ref");
+  static_assert(sizeof(f2) <= 2 * sizeof(void*), "Too big function_ref");
+  static_assert(sizeof(f3) <= 2 * sizeof(void*), "Too big function_ref");
+  static_assert(sizeof(f4) <= 2 * sizeof(void*), "Too big function_ref");
+  static_assert(sizeof(f5) <= 2 * sizeof(void*), "Too big function_ref");
+}
+
+TEST(function_ref, Call) {
+  function_ref<int(int)> view = [](int i) { return i + 1; };
+  EXPECT_EQ(1, view(0));
+  EXPECT_EQ(-1, view(-2));
+
+  function_ref<std::string(std::string)> fs = [](const std::string& s) { return s + "1"; };
+  EXPECT_STREQ("s1", fs("s").c_str());
+  EXPECT_STREQ("ssss1", fs("ssss").c_str());
+
+  std::string base;
+  auto lambda = [&base]() { return base + "1"; };
+  function_ref<std::string()> fs2 = lambda;
+  base = "one";
+  EXPECT_STREQ("one1", fs2().c_str());
+  base = "forty two";
+  EXPECT_STREQ("forty two1", fs2().c_str());
+}
+
+TEST(function_ref, CopyAndAssign) {
+  function_ref<int(int)> view = [](int i) { return i + 1; };
+  EXPECT_EQ(1, view(0));
+  view = [](int i) { return i - 1; };
+  EXPECT_EQ(0, view(1));
+
+  function_ref<int(int)> view2 = view;
+  EXPECT_EQ(view(10), view2(10));
+
+  view = view2;
+  EXPECT_EQ(view(10), view2(10));
+}
+
+}  // namespace android::base
diff --git a/include/android-base/function_ref.h b/include/android-base/function_ref.h
new file mode 100644
index 0000000..2de14e3
--- /dev/null
+++ b/include/android-base/function_ref.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2021 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 <stdint.h>
+#include <type_traits>
+#include <utility>
+
+namespace android::base {
+
+//
+// function_ref<> - a class that stores a reference to a callable object,
+//      similar to string_view for strings.
+//
+// We need to pass around lots of callbacks. The standard way of doing it
+// is via std::function<> class, and it usually works OK. But there are some
+// noticeable drawbacks:
+//
+//  1. std::function<> in most STLs performs heap allocation for all callables
+//     bigger than a single poiner to a function.
+//  2. std::function<> goes through at least two pointers + a vptr call to call
+//     the stored function.
+//  3. std::function<> copies the passed object inside at least once; this also
+//     means it can't work with non-copyable functors.
+//
+// function_ref is an alternative way of passing functors around. Instead of
+// storing a copy of the functor inside, it follows the path of string_view and
+// merely captures a pointer to the object to call. This allows for a simple,
+// fast and lightweight wrapper design; it also dictates the limitations:
+//
+//  1. function_ref<> stores a pointer to outside functor. That functor _must_
+//     outlive the ref.
+//  2. function_ref<> has two calls through a function pointer in its call
+//     operator. That's still better than std::function<>, but slower compared
+//     to a raw function pointer call with a "void* opaque" context parameter.
+//
+// Limitation #1 dictates the best use case: a function parameter type for some
+// generic callback which doesn't get stored inside an object field but only
+// gets called in this call. E.g.:
+//
+//  void someLongOperation(function_ref<void(int progress)> onProgress) {
+//      firstStep(onProgress);
+//      ...
+//      onProgress(50);
+//      ...
+//      lastStep(onProgress);
+//      onProgress(100);
+//  }
+//
+// In this code std::function<> is an overkill as the whole use of |onProgresss|
+// callback is scoped and easy to track. An alternative design - making it a
+// template parameter (template <class Callback> ... (Callback onProgress))
+// forces one to put someLongOperation() + some private functions into the
+// header. function_ref<> is the choice then.
+//
+// NOTE: Beware of passing temporary functions via function_ref<>! Temporaries
+//  live until the end of full expression (usually till the next semicolon), and
+//  having a function_ref<> that refers to a dangling pointer is a bug that's
+//  hard to debug. E.g.:
+//      function_ref<...> v = [](){};                     // this is fine
+//      function_ref<...> v = std::function<...>([](){}); // this will kill you
+//
+// NOTE2: function_ref<> should not have an empty state, but it doesn't have a
+//  runtime check against that. Don't construct it from a null function!
+
+template <class Signature>
+class function_ref;
+
+template <class Ret, class... Args>
+class function_ref<Ret(Args...)> final {
+ public:
+  constexpr function_ref() noexcept = delete;
+  constexpr function_ref(const function_ref& other) noexcept = default;
+  constexpr function_ref& operator=(const function_ref&) noexcept = default;
+
+  template <class Callable, class = std::enable_if_t<
+                                std::is_invocable_r<Ret, Callable, Args...>::value &&
+                                !std::is_same_v<function_ref, std::remove_reference_t<Callable>>>>
+  function_ref(Callable&& c) noexcept
+      : mTypeErasedFunction([](const function_ref* self, Args... args) -> Ret {
+          // Generate a lambda that remembers the type of the passed
+          // |Callable|.
+          return (*reinterpret_cast<std::remove_reference_t<Callable>*>(self->mCallable))(
+              std::forward<Args>(args)...);
+        }),
+        mCallable(reinterpret_cast<intptr_t>(&c)) {}
+
+  template <class Callable, class = std::enable_if_t<
+                                std::is_invocable_r<Ret, Callable, Args...>::value &&
+                                !std::is_same_v<function_ref, std::remove_reference_t<Callable>>>>
+  function_ref& operator=(Callable&& c) noexcept {
+    mTypeErasedFunction = [](const function_ref* self, Args... args) -> Ret {
+      // Generate a lambda that remembers the type of the passed
+      // |Callable|.
+      return (*reinterpret_cast<std::remove_reference_t<Callable>*>(self->mCallable))(
+          std::forward<Args>(args)...);
+    };
+    mCallable = reinterpret_cast<intptr_t>(&c);
+    return *this;
+  }
+
+  Ret operator()(Args... args) const {
+    return mTypeErasedFunction(this, std::forward<Args>(args)...);
+  }
+
+ private:
+  using TypeErasedFunc = Ret(const function_ref*, Args...);
+  TypeErasedFunc* mTypeErasedFunction;
+  intptr_t mCallable;
+};
+
+}  // namespace android::base
diff --git a/include/android-base/logging.h b/include/android-base/logging.h
index 9064075..179ddf0 100644
--- a/include/android-base/logging.h
+++ b/include/android-base/logging.h
@@ -27,6 +27,8 @@
 //   LOG(INFO) << "Some text; " << some_value;
 //
 // Replace `INFO` with any severity from `enum LogSeverity`.
+// Most devices filter out VERBOSE logs by default, run
+// `adb shell setprop log.tag.<TAG> V` to see them in adb logcat.
 //
 // To log the result of a failed function and include the string
 // representation of `errno` at the end:
diff --git a/include/android-base/properties.h b/include/android-base/properties.h
index 0f208ec..021f466 100644
--- a/include/android-base/properties.h
+++ b/include/android-base/properties.h
@@ -97,8 +97,8 @@
 };
 #endif
 
-static inline int TimeoutMultiplier() {
-  return android::base::GetIntProperty("ro.timeout_multiplier", 1);
+static inline int HwTimeoutMultiplier() {
+  return android::base::GetIntProperty("ro.hw_timeout_multiplier", 1);
 }
 
 } // namespace base
diff --git a/include/android-base/silent_death_test.h b/include/android-base/silent_death_test.h
new file mode 100644
index 0000000..2aec890
--- /dev/null
+++ b/include/android-base/silent_death_test.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2014 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 <signal.h>
+
+#include <gtest/gtest.h>
+
+#if !defined(__BIONIC__)
+#define sigaction64 sigaction
+#endif
+
+// Disables debuggerd stack traces to speed up death tests and make them less
+// noisy in logcat.
+//
+// Use `using my_DeathTest = SilentDeathTest;` instead of inheriting from
+// testing::Test yourself.
+class SilentDeathTest : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    // Suppress debuggerd stack traces. Too slow.
+    for (int signo : {SIGABRT, SIGBUS, SIGSEGV, SIGSYS}) {
+      struct sigaction64 action = {.sa_handler = SIG_DFL};
+      sigaction64(signo, &action, &previous_);
+    }
+  }
+
+  virtual void TearDown() {
+    for (int signo : {SIGABRT, SIGBUS, SIGSEGV, SIGSYS}) {
+      sigaction64(signo, &previous_, nullptr);
+    }
+  }
+
+ private:
+  struct sigaction64 previous_;
+};
diff --git a/logging.cpp b/logging.cpp
index 54f3fcc..4942e2f 100644
--- a/logging.cpp
+++ b/logging.cpp
@@ -32,10 +32,6 @@
 #include <errno.h>
 #endif
 
-#if defined(__linux__)
-#include <sys/uio.h>
-#endif
-
 #include <atomic>
 #include <iostream>
 #include <limits>
@@ -255,20 +251,22 @@
 
   int level = kLogSeverityToKernelLogLevel[severity];
 
-  // The kernel's printk buffer is only 1024 bytes.
-  // TODO: should we automatically break up long lines into multiple lines?
-  // Or we could log but with something like "..." at the end?
-  char buf[1024] __attribute__((__uninitialized__));
+  // The kernel's printk buffer is only |1024 - PREFIX_MAX| bytes, where
+  // PREFIX_MAX could be 48 or 32.
+  // Reference: kernel/printk/printk.c
+  static constexpr int LOG_LINE_MAX = 1024 - 48;
+  char buf[LOG_LINE_MAX] __attribute__((__uninitialized__));
   size_t size = snprintf(buf, sizeof(buf), "<%d>%s: %.*s\n", level, tag, length, msg);
-  if (size > sizeof(buf)) {
-    size = snprintf(buf, sizeof(buf), "<%d>%s: %zu-byte message too long for printk\n",
-                    level, tag, size);
-  }
+  TEMP_FAILURE_RETRY(write(klog_fd, buf, std::min(size, sizeof(buf))));
 
-  iovec iov[1];
-  iov[0].iov_base = buf;
-  iov[0].iov_len = size;
-  TEMP_FAILURE_RETRY(writev(klog_fd, iov, 1));
+  if (size > sizeof(buf)) {
+    size_t truncated = size - sizeof(buf);
+    size = snprintf(
+        buf, sizeof(buf),
+        "<%d>%s: **previous message missing %zu bytes** %zu-byte message too long for printk\n",
+        level, tag, truncated, size);
+    TEMP_FAILURE_RETRY(write(klog_fd, buf, std::min(size, sizeof(buf))));
+  }
 }
 
 void KernelLogger(android::base::LogId, android::base::LogSeverity severity, const char* tag,