Allow TargetOS and TargetRid to be overridden in DotNetBuild.props

[jkoritzinsky]

This is needed to fix the linux-bionic builds in the VMR.

Contributes to dotnet/source-build#4955

Copilot wasn't able to review any files in this pull request.

Files not reviewed (1)

• eng/DotNetBuild.props: Language not supported

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-infrastructure-libraries
See info in area-owners.md if you want to be subscribed.

[ViktorHofer]

Doesn't this imply that due to L18, the passed in TargetOS value will never be used?

[jkoritzinsky]

Yes. The problem is that the runtime's build scripts process and change the passed in TargetOS when determining the RID. Because of our "nested inner build" logic, we effectively were stripping the "-bionic" part of "linux-bionic" from the inner build invocation and building the product in a weird blend of linux, linux-bionic, and android.

By letting this calculation happen again and overwriting the TargetOS based on the RID, we can restore the calculation of the TargetOS to the correct value by re-extracting it from the RID (which we calculate based on the originally-passed-in TargetOS).

[tmds]

My 2 cents: it may be interesting to globally introduce a property that is the "portable rid OS corresponding to the target". That one would be linux-bionic. dotnet/sdk#44800 is also about having such a property.

[am11]

Because of our "nested inner build" logic, we effectively were stripping the "-bionic" part of "linux-bionic" from the inner build invocation and building the product in a weird blend of linux, linux-bionic, and android.

It sounds like we are missing handling of linux-bionic somewhere next to the existing handling of linux-musl which should have the same behavior but doesn't (e.g. alpine distro packages use source-build without issues). If we can find and fix that problem, I think that would be better targeted fix rather than exposing these props.

Ideally, eng/OSArch.props + eng/RuntimeIdentifier.props type of platform spec resolution should be shared via arcade/eng/common so the handling of supported platforms and effective platforms (build/host/target) is unified across the board; single source of truth.

[jkoritzinsky]

Alpine doesn't have a problem because musl and glibc builds are more similar.

[jkoritzinsky]

Coming back to this, here's the flow of what's happening in main and why musl doesn't have a problem here:

1. When the VMR orchestrator passes -os linux-bionic to the runtime outer build script, we hit this block:

   runtime/eng/build.sh

   Lines 290 to 292 in 7efe7f7

   	linux-bionic)
   	os="linux"
   	__PortableTargetOS=linux-bionic

2. We pass the os variable as the TargetOS property to the build:

   runtime/eng/build.sh

   Line 306 in 7efe7f7

   arguments="$arguments /p:TargetOS=$os"

3. We initialize the RID based on the os variable:

   runtime/eng/build.sh

   Line 558 in 7efe7f7

   runtime/eng/build.sh

   Lines 133 to 147 in 7efe7f7

   	initDistroRid()
   	{
   	source "$scriptroot"/common/native/init-distro-rid.sh
   	local passedRootfsDir=""
   	local targetOs="$1"
   	local targetArch="$2"
   	local isCrossBuild="$3"
   	# Only pass ROOTFS_DIR if __DoCrossArchBuild is specified and the current platform is not an Apple platform (that doesn't use rootfs)
   	if [[ $isCrossBuild == 1 && "$targetOs" != "osx" && "$targetOs" != "android" && "$targetOs" != "ios" && "$targetOs" != "iossimulator" && "$targetOs" != "tvos" && "$targetOs" != "tvossimulator" && "$targetOs" != "maccatalyst" ]]; then
   	passedRootfsDir=${ROOTFS_DIR}
   	fi
   	initDistroRidGlobal "${targetOs}" "${targetArch}" "${passedRootfsDir}"
   	}

4. The outer build tries to evaluate the TargetOS property based on the RID, but this is ignored:

   runtime/eng/DotNetBuild.props

   Line 18 in 7efe7f7

   <TargetOS>$(TargetRid.Substring(0, $(_targetRidPlatformIndex)))</TargetOS>

5. We pass the TargetOS property to the inner build:

   runtime/eng/DotNetBuild.props

   Line 67 in 7efe7f7

   <InnerBuildArgs Condition="'$(DotNetBuildSourceOnly)' != 'true'">$(InnerBuildArgs) $(FlagParameterPrefix)os $(TargetOS)</InnerBuildArgs>

6. The inner build sees the TargetOS property as linux instead of linux-bionic:

   runtime/eng/build.sh

   Lines 264 to 265 in 7efe7f7

   	linux)
   	os="linux" ;;

7. As linux-bionic is not a cross build, but linux is, we end up not having the -cross flag and build fails.

• linux-musl is a cross-build like linux, so -cross will be present. Since we have the correct RID passed in, we end up building everything correctly even though we pass -os linux today.
• If we pass the -cross flag for linux-bionic. We must pass a rootfs. If we pass a rootfs, we end up building the Android crypto stack instead of the OpenSSL one because we miss setting the "Force use OpenSSL Crypto" due to the rootfs being provided.

This change lets the logic at step 4 correct the adjustment in step 2 using the RID that's passed in by the orchestrator.

I'd like to get in this change as-is. After we switch to flat code-flow to the VMR, we can revisit how we handle RIDs and platform specification and simplify it from the VMR where we can do all the changes in one PR.

[tmds]

Note that in the first step, build.sh sets __PortableTargetOS=linux-bionic. dotnet/runtime then uses that to initialize _portableOS_. __PortableTargetOS/_portableOS_ gets lost when it goes from the vmr outer build to the runtime inner build (TargetOS=linux). For linux-musl the __PortableTargetOS gets "recovered" here.