Add libudev-sys well-known annotation (#140)

Author: dzbarsky

.bazelrc

@@ -11,7 +11,6 @@ common --disk_cache=~/bazel_cache
 
 common --@llvm//config:experimental_stub_libgcc_s
 common --enable_platform_specific_config
-common:linux --host_platform=//:local_gnu_platform
 
 common --remote_cache=grpcs://remote.buildbuddy.io
 common --experimental_remote_downloader=grpcs://remote.buildbuddy.io

3rd_party/libudev-sys/include.MODULE.bazel

@@ -0,0 +1,10 @@
+bazel_dep(name = "systemd", version = "260.1")
+
+crate = use_extension("@rules_rs//rs:extensions.bzl", "crate")
+crate.annotation(
+    crate = "libudev-sys",
+    gen_build_script = "off",
+    deps = ["@systemd//:libudev"],
+)
+
+inject_repo(crate, "systemd")

README.md

@@ -66,25 +66,18 @@ use_repo(crate, "crates")
 
 ### `.bazelrc`
 
-Set an explicit host platform for operating systems with ABI choices. Linux and Windows host platforms need an ABI constraint so Rust toolchain resolution can choose the matching exec toolchain.
+Linux hosts work with Bazel's default host platform. If you also build on Windows,
+set an explicit host platform there so Rust toolchain resolution can choose the
+right ABI.
 
 ```bazelrc
 common --enable_platform_specific_config
-common:linux --host_platform=//platforms:local_gnu
 common:windows --host_platform=//platforms:local_windows_msvc
 ```
 
 ### `platforms/BUILD.bazel`
 
 ```bzl
-platform(
-    name = "local_gnu",
-    parents = ["@platforms//host"],
-    constraint_values = [
-        "@llvm//constraints/libc:gnu.2.28",
-    ],
-)
-
 platform(
     name = "local_windows_msvc",
     parents = ["@platforms//host"],

rs/experimental/miri/private/declare_toolchains.bzl

@@ -1,7 +1,7 @@
 load("@rules_rust//rust/platform:triple.bzl", _parse_triple = "triple")
 load("//rs/experimental/miri/private:sysroot.bzl", "miri_sysroot")
 load("//rs/experimental/miri/private:toolchain.bzl", "miri_sysroot_toolchain", "miri_toolchain")
-load("//rs/platforms:triples.bzl", "ALL_TARGET_TRIPLES", "SUPPORTED_EXEC_TRIPLES", "triple_to_constraint_set")
+load("//rs/platforms:triples.bzl", "ALL_TARGET_TRIPLES", "SUPPORTED_EXEC_TRIPLES", "triple_to_rust_constraint_set")
 load("//rs/toolchains:toolchain_utils.bzl", "sanitize_triple", "sanitize_version")
 
 def declare_miri_toolchains(
@@ -61,7 +61,7 @@ def declare_miri_toolchains(
 
         for target_triple in ALL_TARGET_TRIPLES:
             target_key = sanitize_triple(target_triple)
-            target_compatible_with = triple_to_constraint_set(target_triple)
+            target_compatible_with = triple_to_rust_constraint_set(target_triple)
 
             native.toolchain(
                 name = "%s_to_%s_%s_miri_sysroot" % (triple_suffix, target_key, version_key),

rs/platforms/config/declare_config_settings.bzl

@@ -1,11 +1,11 @@
 """Config settings for Rust target triples."""
 
-load("//rs/platforms:triples.bzl", "ALL_TARGET_TRIPLES", "triple_to_constraint_set")
+load("//rs/platforms:triples.bzl", "ALL_TARGET_TRIPLES", "triple_to_rust_constraint_set")
 
 def declare_config_settings(targets = ALL_TARGET_TRIPLES):
     for target_triple in targets:
         native.config_setting(
             name = target_triple,
-            constraint_values = triple_to_constraint_set(target_triple),
+            constraint_values = triple_to_rust_constraint_set(target_triple),
             visibility = ["//visibility:public"],
         )

rs/platforms/constraints/BUILD.bazel

@@ -1,5 +1,24 @@
 package(default_visibility = ["//visibility:public"])
 
+constraint_setting(
+    name = "linux_libc",
+    # Keep plain Linux platforms on the normal GNU path unless they explicitly
+    # opt into musl. This lets Rust toolchains match either a versioned LLVM
+    # glibc platform or the generic LLVM glibc platform without depending on
+    # LLVM's concrete libc version constraint.
+    default_constraint_value = "glibc",
+)
+
+constraint_value(
+    name = "glibc",
+    constraint_setting = "linux_libc",
+)
+
+constraint_value(
+    name = "musl",
+    constraint_setting = "linux_libc",
+)
+
 alias(
     name = "windows_abi",
     actual = "@llvm//constraints/windows/abi:abi",

rs/platforms/triples.bzl

@@ -4,17 +4,15 @@ load(
     _triple_to_constraint_set = "triple_to_constraint_set",
 )
 
-def triple_to_constraint_set(target_triple):
+def triple_to_rust_constraint_set(target_triple):
     constraints = _triple_to_constraint_set(target_triple)
     t = triple(target_triple)
 
     if t.system in ("linux", "nixos"):
         if t.abi == "musl" or "musl" in target_triple:
-            # Rustc passes `-no-pie` on musl so make sure we align.
-            constraints.append("@llvm//constraints/libc:musl")
-            constraints.append("@llvm//constraints/pie:off")
+            constraints.append("@rules_rs//rs/platforms/constraints:musl")
         else:
-            constraints.append("@llvm//constraints/libc:gnu.2.28")
+            constraints.append("@rules_rs//rs/platforms/constraints:glibc")
     elif t.system == "windows":
         constraints.append("@llvm//constraints/windows/abi:" + t.abi)
 
@@ -26,6 +24,23 @@ def triple_to_constraint_set(target_triple):
 
     return constraints
 
+def triple_to_constraint_set(target_triple):
+    constraints = triple_to_rust_constraint_set(target_triple)
+    t = triple(target_triple)
+
+    if t.system in ("linux", "nixos"):
+        if t.abi == "musl" or "musl" in target_triple:
+            # Rustc passes `-no-pie` on musl so make sure we align.
+            constraints.append("@llvm//constraints/libc:musl")
+            constraints.append("@llvm//constraints/pie:off")
+        else:
+            # Leave the concrete glibc version to the consuming workspace. The
+            # generated rules_rs platforms should still select LLVM's GNU
+            # toolchains when used directly.
+            constraints.append("@llvm//constraints/libc:unconstrained")
+
+    return constraints
+
 SUPPORTED_EXEC_TRIPLES = [
     "x86_64-unknown-linux-gnu",
     "aarch64-unknown-linux-gnu",

rs/toolchains/declare_rustc_toolchains.bzl

@@ -1,6 +1,6 @@
 load("@rules_rust//rust:toolchain.bzl", "rust_toolchain")
 load("@rules_rust//rust/platform:triple.bzl", _parse_triple = "triple")
-load("//rs/platforms:triples.bzl", "ALL_TARGET_TRIPLES", "SUPPORTED_EXEC_TRIPLES", "SUPPORTED_TIER_3_TRIPLES", "triple_to_constraint_set")
+load("//rs/platforms:triples.bzl", "ALL_TARGET_TRIPLES", "SUPPORTED_EXEC_TRIPLES", "SUPPORTED_TIER_3_TRIPLES", "triple_to_rust_constraint_set")
 load("//rs/toolchains:toolchain_utils.bzl", "sanitize_triple", "sanitize_version")
 
 def _channel(version):
@@ -38,7 +38,7 @@ def declare_rustc_toolchains(
         config_setting = "source_stdlib_building_" + target_key
         native.config_setting(
             name = config_setting,
-            constraint_values = triple_to_constraint_set(target_triple),
+            constraint_values = triple_to_rust_constraint_set(target_triple),
             flag_values = {
                 "@rules_rs//rs/private:source_stdlib_building": "true",
             },
@@ -179,7 +179,7 @@ def declare_rustc_toolchains(
                     "@platforms//os:" + exec_triple.system,
                     "@platforms//cpu:" + exec_triple.arch,
                 ],
-                target_compatible_with = triple_to_constraint_set(target_triple),
+                target_compatible_with = triple_to_rust_constraint_set(target_triple),
                 target_settings = [
                     "@rules_rust//rust/private:bootstrapped",
                     "@rules_rust//rust/toolchain/channel:" + channel,
@@ -195,7 +195,7 @@ def declare_rustc_toolchains(
                     "@platforms//os:" + exec_triple.system,
                     "@platforms//cpu:" + exec_triple.arch,
                 ],
-                target_compatible_with = triple_to_constraint_set(target_triple),
+                target_compatible_with = triple_to_rust_constraint_set(target_triple),
                 target_settings = [
                     "@rules_rust//rust/private:bootstrapping",
                     "@rules_rust//rust/toolchain/channel:" + channel,

test/BUILD.bazel

@@ -357,23 +357,46 @@ ALL_PLATFORMS = [
     "x86_64-pc-windows-gnullvm",
 ]
 
+LINUX_GNU_PLATFORMS = {
+    "aarch64-unknown-linux-gnu": ":aarch64-unknown-linux-gnu",
+    "x86_64-unknown-linux-gnu": ":x86_64-unknown-linux-gnu",
+}
+
 [
     platform_transition_filegroup(
         name = "all_builds_" + platform,
         srcs = ["all_builds"],
-        target_platform = "@rules_rs//rs/platforms:" + platform,
+        target_platform = LINUX_GNU_PLATFORMS.get(platform, "@rules_rs//rs/platforms:" + platform),
     )
     for platform in ALL_PLATFORMS
 ]
 
+platform(
+    name = "aarch64-unknown-linux-gnu",
+    constraint_values = [
+        "@platforms//cpu:aarch64",
+        "@platforms//os:linux",
+        "@llvm//constraints/libc:gnu.2.35",
+    ],
+)
+
+platform(
+    name = "x86_64-unknown-linux-gnu",
+    constraint_values = [
+        "@platforms//cpu:x86_64",
+        "@platforms//os:linux",
+        "@llvm//constraints/libc:gnu.2.35",
+    ],
+)
+
 platform(
     name = "rbe",
     constraint_values = [
         "@platforms//cpu:x86_64",
         "@platforms//os:linux",
         # Note: We need this so that Rust cfg=exec builds (build script, tools, proc_macros)
         # can properly target the remote.
-        "@llvm//constraints/libc:gnu.2.28",
+        "@llvm//constraints/libc:gnu.2.35",
     ],
     exec_properties = {
         "container-image": "docker://ubuntu:22.04",

test/MODULE.bazel

@@ -88,6 +88,12 @@ single_version_override(
     patches = ["//:libffi-aarch64-trampoline.patch"],
 )
 
+single_version_override(
+    module_name = "systemd",
+    patch_strip = 1,
+    patches = ["//:systemd-codegen.patch"],
+)
+
 # Fix swift toolchains...
 bazel_dep(name = "rules_swift", version = "3.5.0")
 single_version_override(
@@ -281,6 +287,7 @@ include("//:3rd_party/bzip2-sys/include.MODULE.bazel")
 include("//:3rd_party/glib-sys/include.MODULE.bazel")
 include("//:3rd_party/libssh2-sys/include.MODULE.bazel")
 include("//:3rd_party/lzma-sys/include.MODULE.bazel")
+include("//:3rd_party/libudev-sys/include.MODULE.bazel")
 include("//:3rd_party/apriltag-sys/include.MODULE.bazel")
 include("//:3rd_party/zstd-sys/include.MODULE.bazel")