grpc 1.84.1 → 1.85.0.pre1

data/third_party/boringssl-with-bazel/crypto/cpu_arm_freebsd.cc

@@ -22,10 +22,12 @@
 #include <openssl/mem.h>
 
 
-void OPENSSL_cpuid_setup(void) {
+using namespace bssl;
+
+void bssl::OPENSSL_cpuid_setup() {
   unsigned long hwcap = 0, hwcap2 = 0;
 
-  // |elf_aux_info| may fail, in which case |hwcap| and |hwcap2| will be
+  // `elf_aux_info` may fail, in which case `hwcap` and `hwcap2` will be
   // left at zero. The rest of this function will then gracefully report
   // the features are absent.
   elf_aux_info(AT_HWCAP, &hwcap, sizeof(hwcap));

data/third_party/boringssl-with-bazel/crypto/cpu_arm_linux.cc

@@ -22,10 +22,14 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include <string_view>
+
 #include <openssl/mem.h>
 
 #include "cpu_arm_linux.h"
 
+using namespace bssl;
+
 static int open_eintr(const char *path, int flags) {
   int ret;
   do {
@@ -42,8 +46,8 @@ static ssize_t read_eintr(int fd, void *out, size_t len) {
   return ret;
 }
 
-// read_file opens |path| and reads until end-of-file. On success, it returns
-// one and sets |*out_ptr| and |*out_len| to a newly-allocated buffer with the
+// read_file opens `path` and reads until end-of-file. On success, it returns
+// one and sets `*out_ptr` and `*out_len` to a newly-allocated buffer with the
 // contents. Otherwise, it returns zero.
 static int read_file(char **out_ptr, size_t *out_len, const char *path) {
   int fd = open_eintr(path, O_RDONLY);
@@ -55,7 +59,7 @@ static int read_file(char **out_ptr, size_t *out_len, const char *path) {
   int ret = 0;
   size_t cap = kReadSize, len = 0;
   char *buf = reinterpret_cast<char *>(OPENSSL_malloc(cap));
-  if (buf == NULL) {
+  if (buf == nullptr) {
     goto err;
   }
 
@@ -66,7 +70,7 @@ static int read_file(char **out_ptr, size_t *out_len, const char *path) {
         goto err;
       }
       char *new_buf = reinterpret_cast<char *>(OPENSSL_realloc(buf, new_cap));
-      if (new_buf == NULL) {
+      if (new_buf == nullptr) {
         goto err;
       }
       buf = new_buf;
@@ -86,7 +90,7 @@ static int read_file(char **out_ptr, size_t *out_len, const char *path) {
   *out_ptr = buf;
   *out_len = len;
   ret = 1;
-  buf = NULL;
+  buf = nullptr;
 
 err:
   OPENSSL_free(buf);
@@ -96,53 +100,72 @@ err:
 
 static int g_needs_hwcap2_workaround;
 
-void OPENSSL_cpuid_setup(void) {
-  // We ignore the return value of |read_file| and proceed with an empty
-  // /proc/cpuinfo on error. If |getauxval| works, we will still detect
-  // capabilities.
-  char *cpuinfo_data = NULL;
-  size_t cpuinfo_len = 0;
-  read_file(&cpuinfo_data, &cpuinfo_len, "/proc/cpuinfo");
-  STRING_PIECE cpuinfo;
-  cpuinfo.data = cpuinfo_data;
-  cpuinfo.len = cpuinfo_len;
-
+void bssl::OPENSSL_cpuid_setup() {
   // Matching OpenSSL, only report other features if NEON is present.
   unsigned long hwcap = getauxval(AT_HWCAP);
-  if (hwcap & HWCAP_NEON) {
+  if (hwcap & CRYPTO_HWCAP_NEON) {
+#if defined(HWCAP_ARM_NEON)
+      static_assert(HWCAP_ARM_NEON == CRYPTO_HWCAP_NEON,
+                    "CRYPTO_HWCAP values must match Linux");
+#endif
     OPENSSL_armcap_P |= ARMV7_NEON;
 
     // Some ARMv8 Android devices don't expose AT_HWCAP2. Fall back to
-    // /proc/cpuinfo. See https://crbug.com/boringssl/46. As of February 2021,
-    // this is now rare (see Chrome's Net.NeedsHWCAP2Workaround metric), but AES
-    // and PMULL extensions are very useful, so we still carry the workaround
-    // for now.
+    // /proc/cpuinfo. See https://crbug.com/40644934. The fix was added to
+    // Android CTS in N, so, after Net.NeedsHWCAP2Workaround confirms this, we
+    // should be able to disable this when __ANDROID_MIN_SDK_VERSION__ is high
+    // enough. (It may not be worth carrying the workaround at all at that
+    // point. Then again, AES and PMULL extensions are crucial for performance
+    // when available.)
     unsigned long hwcap2 = getauxval(AT_HWCAP2);
     if (hwcap2 == 0) {
-      hwcap2 = crypto_get_arm_hwcap2_from_cpuinfo(&cpuinfo);
-      g_needs_hwcap2_workaround = hwcap2 != 0;
+      char *cpuinfo_data = nullptr;
+      size_t cpuinfo_len = 0;
+      if (read_file(&cpuinfo_data, &cpuinfo_len, "/proc/cpuinfo")) {
+        hwcap2 = armcap::GetHWCAP2FromCpuinfo(
+            std::string_view(cpuinfo_data, cpuinfo_len));
+        g_needs_hwcap2_workaround = hwcap2 != 0;
+        OPENSSL_free(cpuinfo_data);
+      }
     }
 
-    if (hwcap2 & HWCAP2_AES) {
+    // HWCAP2_* values, without the "CRYPTO_" prefix, are exposed through
+    // <sys/auxv.h> in some versions of glibc(>= 2.41). Assert that we don't
+    // diverge from those values.
+    if (hwcap2 & CRYPTO_HWCAP2_AES) {
+#if defined(HWCAP2_AES)
+      static_assert(HWCAP2_AES == CRYPTO_HWCAP2_AES,
+                    "CRYPTO_HWCAP2 values must match Linux");
+#endif
       OPENSSL_armcap_P |= ARMV8_AES;
     }
-    if (hwcap2 & HWCAP2_PMULL) {
+    if (hwcap2 & CRYPTO_HWCAP2_PMULL) {
+#if defined(HWCAP2_PMULL)
+      static_assert(HWCAP2_PMULL == CRYPTO_HWCAP2_PMULL,
+                    "CRYPTO_HWCAP2 values must match Linux");
+#endif
       OPENSSL_armcap_P |= ARMV8_PMULL;
     }
-    if (hwcap2 & HWCAP2_SHA1) {
+    if (hwcap2 & CRYPTO_HWCAP2_SHA1) {
+#if defined(HWCAP2_SHA1)
+      static_assert(HWCAP2_SHA1 == CRYPTO_HWCAP2_SHA1,
+                    "CRYPTO_HWCAP2 values must match Linux");
+#endif
       OPENSSL_armcap_P |= ARMV8_SHA1;
     }
-    if (hwcap2 & HWCAP2_SHA2) {
+    if (hwcap2 & CRYPTO_HWCAP2_SHA2) {
+#if defined(HWCAP2_SHA2)
+      static_assert(HWCAP2_SHA2 == CRYPTO_HWCAP2_SHA2,
+                    "CRYPTO_HWCAP2 values must match Linux");
+#endif
       OPENSSL_armcap_P |= ARMV8_SHA256;
     }
   }
-
-  OPENSSL_free(cpuinfo_data);
 }
 
-int CRYPTO_has_broken_NEON(void) { return 0; }
+int CRYPTO_has_broken_NEON() { return 0; }
 
-int CRYPTO_needs_hwcap2_workaround(void) {
+int CRYPTO_needs_hwcap2_workaround() {
   OPENSSL_init_cpuid();
   return g_needs_hwcap2_workaround;
 }

data/third_party/boringssl-with-bazel/crypto/cpu_arm_linux.h

@@ -17,147 +17,125 @@
 
 #include <openssl/base.h>
 
-#include <string.h>
+#include <assert.h>
+
+#include <string_view>
 
 #include "internal.h"
 
-#if defined(__cplusplus)
-extern "C" {
-#endif
 
+BSSL_NAMESPACE_BEGIN
+namespace armcap {
 
 // The cpuinfo parser lives in a header file so it may be accessible from
 // cross-platform fuzzers without adding code to those platforms normally.
 
-#define HWCAP_NEON (1 << 12)
+#define CRYPTO_HWCAP_NEON (1 << 12)
 
 // See /usr/include/asm/hwcap.h on an ARM installation for the source of
 // these values.
-#define HWCAP2_AES (1 << 0)
-#define HWCAP2_PMULL (1 << 1)
-#define HWCAP2_SHA1 (1 << 2)
-#define HWCAP2_SHA2 (1 << 3)
-
-typedef struct {
-  const char *data;
-  size_t len;
-} STRING_PIECE;
-
-static int STRING_PIECE_equals(const STRING_PIECE *a, const char *b) {
-  size_t b_len = strlen(b);
-  return a->len == b_len && OPENSSL_memcmp(a->data, b, b_len) == 0;
-}
-
-// STRING_PIECE_split finds the first occurence of |sep| in |in| and, if found,
-// sets |*out_left| and |*out_right| to |in| split before and after it. It
-// returns one if |sep| was found and zero otherwise.
-static int STRING_PIECE_split(STRING_PIECE *out_left, STRING_PIECE *out_right,
-                              const STRING_PIECE *in, char sep) {
-  const char *p = (const char *)OPENSSL_memchr(in->data, sep, in->len);
-  if (p == NULL) {
-    return 0;
+// We add the prefix "CRYPTO_" to the definitions so as not to collide with
+// some versions of glibc (>= 2.41) that expose them through <sys/auxv.h>.
+#define CRYPTO_HWCAP2_AES (1 << 0)
+#define CRYPTO_HWCAP2_PMULL (1 << 1)
+#define CRYPTO_HWCAP2_SHA1 (1 << 2)
+#define CRYPTO_HWCAP2_SHA2 (1 << 3)
+
+// SplitStringView finds the first occurrence of `sep` in `in` and, if found,
+// sets `*out_left` and `*out_right` to `in` split before and after `sep`, and
+// returns true. If not found, it returns false.
+inline bool SplitStringView(std::string_view *out_left,
+                            std::string_view *out_right, std::string_view in,
+                            char sep) {
+  auto pos = in.find(sep);
+  if (pos == std::string_view::npos) {
+    return false;
   }
-  // |out_left| or |out_right| may alias |in|, so make a copy.
-  STRING_PIECE in_copy = *in;
-  out_left->data = in_copy.data;
-  out_left->len = p - in_copy.data;
-  out_right->data = in_copy.data + out_left->len + 1;
-  out_right->len = in_copy.len - out_left->len - 1;
-  return 1;
+  *out_left = in.substr(0, pos);
+  *out_right = in.substr(pos + 1);
+  return true;
 }
 
-// STRING_PIECE_get_delimited reads a |sep|-delimited entry from |s|, writing it
-// to |out| and updating |s| to point beyond it. It returns one on success and
-// zero if |s| is empty. If |s| is has no copies of |sep| and is non-empty, it
-// reads the entire string to |out|.
-static int STRING_PIECE_get_delimited(STRING_PIECE *s, STRING_PIECE *out, char sep) {
-  if (s->len == 0) {
-    return 0;
+// GetDelimited reads a `sep`-delimited entry from `s`, writing it to `out` and
+// updating `s` to point beyond it. It returns true on success and false if `s`
+// is empty. If `s` has no copies of `sep` and is non-empty, it reads the entire
+// string to `out`.
+inline bool GetDelimited(std::string_view *s, std::string_view *out, char sep) {
+  if (s->empty()) {
+    return false;
   }
-  if (!STRING_PIECE_split(out, s, s, sep)) {
-    // |s| had no instances of |sep|. Return the entire string.
+  if (!SplitStringView(out, s, *s, sep)) {
+    // `s` had no instances of `sep`. Return the entire string.
     *out = *s;
-    s->data += s->len;
-    s->len = 0;
+    *s = std::string_view();
   }
-  return 1;
+  return true;
 }
 
-// STRING_PIECE_trim removes leading and trailing whitespace from |s|.
-static void STRING_PIECE_trim(STRING_PIECE *s) {
-  while (s->len != 0 && (s->data[0] == ' ' || s->data[0] == '\t')) {
-    s->data++;
-    s->len--;
-  }
-  while (s->len != 0 &&
-         (s->data[s->len - 1] == ' ' || s->data[s->len - 1] == '\t')) {
-    s->len--;
+// TrimStringView removes leading and trailing whitespace from `s`.
+inline std::string_view TrimStringView(std::string_view s) {
+  size_t pos = s.find_first_not_of(" \t");
+  if (pos == std::string_view::npos) {
+    return {};
   }
+  s = s.substr(pos);
+  pos = s.find_last_not_of(" \t");
+  assert(pos != std::string_view::npos);
+  return s.substr(0, pos + 1);
 }
 
-// extract_cpuinfo_field extracts a /proc/cpuinfo field named |field| from
-// |in|. If found, it sets |*out| to the value and returns one. Otherwise, it
-// returns zero.
-static int extract_cpuinfo_field(STRING_PIECE *out, const STRING_PIECE *in,
-                                 const char *field) {
-  // Process |in| one line at a time.
-  STRING_PIECE remaining = *in, line;
-  while (STRING_PIECE_get_delimited(&remaining, &line, '\n')) {
-    STRING_PIECE key, value;
-    if (!STRING_PIECE_split(&key, &value, &line, ':')) {
+// ExtractCpuinfoField extracts a /proc/cpuinfo field named `field` from `in`.
+// If found, it returns the value. Otherwise, it returns the empty string.
+inline std::string_view ExtractCpuinfoField(std::string_view in,
+                                            std::string_view field) {
+  // Process `in` one line at a time.
+  std::string_view line;
+  while (GetDelimited(&in, &line, '\n')) {
+    std::string_view key, value;
+    if (!SplitStringView(&key, &value, line, ':')) {
       continue;
     }
-    STRING_PIECE_trim(&key);
-    if (STRING_PIECE_equals(&key, field)) {
-      STRING_PIECE_trim(&value);
-      *out = value;
-      return 1;
+    if (TrimStringView(key) == field) {
+      return TrimStringView(value);
     }
   }
 
-  return 0;
+  return {};
 }
 
-// has_list_item treats |list| as a space-separated list of items and returns
-// one if |item| is contained in |list| and zero otherwise.
-static int has_list_item(const STRING_PIECE *list, const char *item) {
-  STRING_PIECE remaining = *list, feature;
-  while (STRING_PIECE_get_delimited(&remaining, &feature, ' ')) {
-    if (STRING_PIECE_equals(&feature, item)) {
-      return 1;
+// HasListItem treats `list` as a space-separated list of items and returns
+// whether `item` is contained in `list`.
+inline bool HasListItem(std::string_view list, std::string_view item) {
+  std::string_view feature;
+  while (GetDelimited(&list, &feature, ' ')) {
+    if (feature == item) {
+      return true;
     }
   }
-  return 0;
+  return false;
 }
 
-// crypto_get_arm_hwcap2_from_cpuinfo returns an equivalent ARM |AT_HWCAP2|
-// value from |cpuinfo|.
-static unsigned long crypto_get_arm_hwcap2_from_cpuinfo(
-    const STRING_PIECE *cpuinfo) {
-  STRING_PIECE features;
-  if (!extract_cpuinfo_field(&features, cpuinfo, "Features")) {
-    return 0;
-  }
-
+// GetHWCAP2FromCpuinfo returns an equivalent ARM `AT_HWCAP2` value from
+// `cpuinfo`.
+inline unsigned long GetHWCAP2FromCpuinfo(std::string_view cpuinfo) {
+  std::string_view features = ExtractCpuinfoField(cpuinfo, "Features");
   unsigned long ret = 0;
-  if (has_list_item(&features, "aes")) {
-    ret |= HWCAP2_AES;
+  if (HasListItem(features, "aes")) {
+    ret |= CRYPTO_HWCAP2_AES;
   }
-  if (has_list_item(&features, "pmull")) {
-    ret |= HWCAP2_PMULL;
+  if (HasListItem(features, "pmull")) {
+    ret |= CRYPTO_HWCAP2_PMULL;
   }
-  if (has_list_item(&features, "sha1")) {
-    ret |= HWCAP2_SHA1;
+  if (HasListItem(features, "sha1")) {
+    ret |= CRYPTO_HWCAP2_SHA1;
   }
-  if (has_list_item(&features, "sha2")) {
-    ret |= HWCAP2_SHA2;
+  if (HasListItem(features, "sha2")) {
+    ret |= CRYPTO_HWCAP2_SHA2;
   }
   return ret;
 }
 
-
-#if defined(__cplusplus)
-}  // extern C
-#endif
+}  // namespace armcap
+BSSL_NAMESPACE_END
 
 #endif  // OPENSSL_HEADER_CRYPTO_CPU_ARM_LINUX_H

data/third_party/boringssl-with-bazel/crypto/cpu_intel.cc

@@ -17,8 +17,9 @@
 #if !defined(OPENSSL_NO_ASM) && \
     (defined(OPENSSL_X86) || defined(OPENSSL_X86_64))
 
+#include <errno.h>
 #include <inttypes.h>
-#include <stdio.h>
+#include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -30,9 +31,11 @@
 #include "internal.h"
 
 
-// OPENSSL_cpuid runs the cpuid instruction. |leaf| is passed in as EAX and ECX
-// is set to zero. It writes EAX, EBX, ECX, and EDX to |*out_eax| through
-// |*out_edx|.
+using namespace bssl;
+
+// OPENSSL_cpuid runs the cpuid instruction. `leaf` is passed in as EAX and ECX
+// is set to zero. It writes EAX, EBX, ECX, and EDX to `*out_eax` through
+// `*out_edx`.
 static void OPENSSL_cpuid(uint32_t *out_eax, uint32_t *out_ebx,
                           uint32_t *out_ecx, uint32_t *out_edx, uint32_t leaf) {
 #if defined(_MSC_VER)
@@ -62,7 +65,7 @@ static void OPENSSL_cpuid(uint32_t *out_eax, uint32_t *out_ebx,
 }
 
 // OPENSSL_xgetbv returns the value of an Intel Extended Control Register (XCR).
-// Currently only XCR0 is defined by Intel so |xcr| should always be zero.
+// Currently only XCR0 is defined by Intel so `xcr` should always be zero.
 static uint64_t OPENSSL_xgetbv(uint32_t xcr) {
 #if defined(_MSC_VER)
   return (uint64_t)_xgetbv(xcr);
@@ -89,23 +92,26 @@ static bool os_supports_avx512(uint64_t xcr0) {
 #endif
 }
 
-// handle_cpu_env applies the value from |in| to the CPUID values in |out[0]|
-// and |out[1]|. See the comment in |OPENSSL_cpuid_setup| about this.
-static void handle_cpu_env(uint32_t *out, const char *in) {
+// handle_cpu_env applies the value from `in` to the CPUID values in `out[0]`
+// and `out[1]`. See the comment in `OPENSSL_cpuid_setup` about this. The
+// `is_last` argument specifies whether the value is at the end of the string.
+// Otherwise it may be followed by a colon.
+static void handle_cpu_env(uint32_t out[2], const char *in, bool is_last) {
   const int invert_op = in[0] == '~';
   const int or_op = in[0] == '|';
   const int skip_first_byte = invert_op || or_op;
   const int hex = in[skip_first_byte] == '0' && in[skip_first_byte + 1] == 'x';
+  const int base = hex ? 16 : 10;
 
-  int sscanf_result;
-  uint64_t v;
-  if (hex) {
-    sscanf_result = sscanf(in + invert_op + 2, "%" PRIx64, &v);
-  } else {
-    sscanf_result = sscanf(in + invert_op, "%" PRIu64, &v);
-  }
+  const char *start = in + skip_first_byte;
+  char *end;
+  errno = 0;
+  // We need to parse 64-bit values with `strtoull`.
+  static_assert(sizeof(unsigned long long) == sizeof(uint64_t));
+  unsigned long long v = strtoull(start, &end, base);
 
-  if (!sscanf_result) {
+  if (end == start || (*end != '\0' && (is_last || *end != ':')) ||
+      (v == ULLONG_MAX && errno == ERANGE)) {
     return;
   }
 
@@ -121,18 +127,39 @@ static void handle_cpu_env(uint32_t *out, const char *in) {
   }
 }
 
-void OPENSSL_cpuid_setup(void) {
+void bssl::OPENSSL_adjust_ia32cap(uint32_t cap[4], const char *env) {
+  // OPENSSL_ia32cap can contain zero, one or two values, separated with a ':'.
+  // Each value is a 64-bit, unsigned value which may start with "0x" to
+  // indicate a hex value. Prior to the 64-bit value, a '~' or '|' may be given.
+  //
+  // If the '~' prefix is present:
+  //   the value is inverted and ANDed with the probed CPUID result
+  // If the '|' prefix is present:
+  //   the value is ORed with the probed CPUID result
+  // Otherwise:
+  //   the value is taken as the result of the CPUID
+  //
+  // The first value determines OPENSSL_ia32cap_P[0] and [1]. The second [2]
+  // and [3].
+  handle_cpu_env(cap, env, /*is_last=*/false);
+  env = strchr(env, ':');
+  if (env != nullptr) {
+    handle_cpu_env(cap + 2, env + 1, /*is_last=*/true);
+  }
+}
+
+void bssl::OPENSSL_cpuid_setup() {
   // Determine the vendor and maximum input value.
   uint32_t eax, ebx, ecx, edx;
   OPENSSL_cpuid(&eax, &ebx, &ecx, &edx, 0);
 
   uint32_t num_ids = eax;
 
-  int is_intel = ebx == 0x756e6547 /* Genu */ && //
-                 edx == 0x49656e69 /* ineI */ && //
+  int is_intel = ebx == 0x756e6547 /* Genu */ &&  //
+                 edx == 0x49656e69 /* ineI */ &&  //
                  ecx == 0x6c65746e /* ntel */;
-  int is_amd = ebx == 0x68747541 /* Auth */ && //
-               edx == 0x69746e65 /* enti */ && //
+  int is_amd = ebx == 0x68747541 /* Auth */ &&  //
+               edx == 0x69746e65 /* enti */ &&  //
                ecx == 0x444d4163 /* cAMD */;
 
   uint32_t extended_features[2] = {0};
@@ -251,30 +278,9 @@ void OPENSSL_cpuid_setup(void) {
   OPENSSL_ia32cap_P[2] = extended_features[0];
   OPENSSL_ia32cap_P[3] = extended_features[1];
 
-  const char *env1, *env2;
-  env1 = getenv("OPENSSL_ia32cap");
-  if (env1 == NULL) {
-    return;
-  }
-
-  // OPENSSL_ia32cap can contain zero, one or two values, separated with a ':'.
-  // Each value is a 64-bit, unsigned value which may start with "0x" to
-  // indicate a hex value. Prior to the 64-bit value, a '~' or '|' may be given.
-  //
-  // If the '~' prefix is present:
-  //   the value is inverted and ANDed with the probed CPUID result
-  // If the '|' prefix is present:
-  //   the value is ORed with the probed CPUID result
-  // Otherwise:
-  //   the value is taken as the result of the CPUID
-  //
-  // The first value determines OPENSSL_ia32cap_P[0] and [1]. The second [2]
-  // and [3].
-
-  handle_cpu_env(&OPENSSL_ia32cap_P[0], env1);
-  env2 = strchr(env1, ':');
-  if (env2 != NULL) {
-    handle_cpu_env(&OPENSSL_ia32cap_P[2], env2 + 1);
+  const char *env = getenv("OPENSSL_ia32cap");
+  if (env != nullptr) {
+    OPENSSL_adjust_ia32cap(OPENSSL_ia32cap_P, env);
   }
 }