Change:
disabled PPC builds due to the following error: Additional comments here
cc
The issue on PowerPC is both for cross and native-builds. The issue appears to be with the toolchain (golang) and how the linking is being done. The object sections have grown too large to link. We are looking at it cc
Have you tried to upgrade to a newer version? It might or might not help... You might also try to look at what in the gcc linker differs from for example, where it doesn't fail
We are looking into this and it might take some more time. In the meanwhile is it possible to remove hyperkube from the ppc64le builds? All other binaries are building perfectly fine. We can resume the hyperkube for ppc64le build as soon as this issue resolves. cc:
Ah, this is only partially fixed. Reopening...
The error occurs because the hyperkube binary is very large and when building the binary, golang is generating a single go.o file with a single text section that is larger than 2^26 on ppc64le. When there is a call instruction within that section where the call target offset is beyond what can fit in the instruction the relocation truncation error will be generated by the GNU linker. When there are multiple, smaller text sections sent to the GNU linker for linking, it can generate appropriate call instructions even the call target is beyond that limit. I'm working on a fix to do that but hitting other issues as a result which I'm working through. I suspect that this same error will be hit at some point on arm64 unless their linker has another way to handle this situation. On ppc64le we are very close to the limit and from build to build it varies so that some days it will build and others it won't.
Interesting. How does amd64 handle it?
I don't know for sure how arm64 handles it because I don't have access to a machine that is set up to build for arm64. I suspect their text section size is not as large as it is on ppc64le so they haven't hit the limit yet.
Ok, you may easily see what's going on for arm64 by investigating what does in kube-cross. But I asked about what amd64 (x86_64) does to prevent this :) (I'm assuming this will never happen to amd64)
Sorry I misread your question about amd64... The call instruction in amd64 has a 32 bit field instead of a 24 bit field in ppc64le for the call target address. That means they wouldn't hit this error when linking hyperkube until its text section was larger than 2^32. If you search on "relocation truncated to fit" you will see that this error has happened in the past on x86 with other programming languages.
Once a fix is ready, how does it need to be provided?
I saw https://go- probably won't make 1.7, and that's sad. We would just upgrade golang version I think, not really sure what you're asking for
I assume you only use official golang versions or those provided with distros for your builds? Are you doing all your builds as cross builds from a golang on an x86?
Official versions, yes. We're using the docker image. All official builds are built on amd64 hosts.
Where are you getting this docker image from? Will you be moving to golang:1.7 when it is released?
We're using the official images, and will pick up as soon as it is released for testing I think. Then if the testing and scalability teams think it's safe to use, we'll switch to 1.7 BTW, where is your patch for this? Can you link to it?
is also broken right now - see .
Hi, I'm sorry I missed your last question to me. Here is the CL for my patch for the PPC64 relocations truncation error. https://go- The error with kubemark is also size related but somewhat different because that one is being built as static. Just curious, why are some built static and some non-static?
just to tie everything together, disabled linux/ppc64le compilation entirely. hopefully by go1.8 we can reenable it.
Well, we've hit 1.8 I think with Want to link to any other relevant issues to kinda tie this one together, and close this if it seems appropriate?
yeah, ppc64le builds have been re-enabled for k8s 1.6.
The issue on PowerPC is both for cross and native builds. The issue appears to be with the toolchain (golang) and how the linking is being done. The object sections have grown too large to link. We are looking at it cc
this issue is quite old. Can you provide more context to your comment? Specifically, more detail to help me reproduce. I was unable to find anything related to ppc64le on .

Discussion:
kube-scheduler,ppc64le/busybox kube-proxy,gcr.io/google_containers/debian-iptables-ppc64le:v3 federation-apiserver,ppc64le/busybox <del> federation-controller-manager,ppc64lebusybox </del> <ins> federation-controller-manager,ppc64le/busybox </ins> );; esac

if [[ -n "${KUBE_DOCKER_IMAGE_TAG-}" && -n "${KUBE_DOCKER_REGISTRY-}" ]]; then for arch in "${KUBE_SERVER_PLATFORMS[@]##*/}"; do <del> kube::log::status "Building hyperkube image for arch: ${arch}" REGISTRY="${KUBE_DOCKER_REGISTRY}" VERSION="${KUBE_DOCKER_IMAGE_TAG}" ARCH="${arch}" make -C cluster/images/hyperkube/ build </del> <ins> # TODO(IBM): Enable hyperkube builds for ppc64le again if [[ ${arch} != "ppc64le" ]]; then kube::log::status "Building hyperkube image for arch: ${arch}" REGISTRY="${KUBE_DOCKER_REGISTRY}" VERSION="${KUBE_DOCKER_IMAGE_TAG}" ARCH="${arch}" make -C cluster/images/hyperkube/ build fi </ins> done fi }

for arch in "${KUBE_SERVER_PLATFORMS[@]##*/}"; do for binary in "${binaries[@]}"; do <del> local docker_target="${KUBE_DOCKER_REGISTRY}/${binary}-${arch}:${KUBE_DOCKER_IMAGE_TAG}" kube::log::status "Pushing ${binary} to ${docker_target}" "${docker_push_cmd[@]}" push "${docker_target}" </del> <ins> # TODO(IBM): Enable hyperkube builds for ppc64le again if [[ ${binary} != "hyperkube" || ${arch} != "ppc64le" ]]; then local docker_target="${KUBE_DOCKER_REGISTRY}/${binary}-${arch}:${KUBE_DOCKER_IMAGE_TAG}" kube::log::status "Pushing ${binary} to ${docker_target}" "${docker_push_cmd[@]}" push "${docker_target}" </ins> <del> # If we have a amd64 docker image. Tag it without -amd64 also and push it for compatibility with earlier versions if [[ ${arch} == "amd64" ]]; then local legacy_docker_target="${KUBE_DOCKER_REGISTRY}/${binary}:${KUBE_DOCKER_IMAGE_TAG}" </del> <ins> # If we have a amd64 docker image. Tag it without -amd64 also and push it for compatibility with earlier versions if [[ ${arch} == "amd64" ]]; then local legacy_docker_target="${KUBE_DOCKER_REGISTRY}/${binary}:${KUBE_DOCKER_IMAGE_TAG}" </ins> <del> "${DOCKER[@]}" tag -f "${docker_target}" "${legacy_docker_target}" 2>/dev/null </del> <ins> "${DOCKER[@]}" tag -f "${docker_target}" "${legacy_docker_target}" 2>/dev/null </ins> <del> kube::log::status "Pushing ${binary} to ${legacy_docker_target}" "${docker_push_cmd[@]}" push "${legacy_docker_target}" </del> <ins> kube::log::status "Pushing ${binary} to ${legacy_docker_target}" "${docker_push_cmd[@]}" push "${legacy_docker_target}" fi </ins> fi done done

linux/amd64 linux/arm linux/arm64 <del> #linux/ppc64le # temporarily disabled due to a linking error </del> <ins> linux/ppc64le # note: hyperkube is temporarily disabled due to a linking error </ins> ) # If we update this we should also update the set of golang compilers we build

linux/386 linux/arm linux/arm64 <del> #linux/ppc64le # temporarily disabled due to a linking error </del> <ins> linux/ppc64le </ins> darwin/amd64 darwin/386 windows/amd64

local -a nonstatics=() local -a tests=() for binary in "${binaries[@]}"; do <del> if [[ "${binary}" =~ ".test"$ ]]; then </del> <ins> # TODO(IBM): Enable hyperkube builds for ppc64le again # The current workaround creates a text file with help text instead of a binary # We're doing it this way so the build system isn't affected so much if [[ "${binary}" == *"hyperkube" && "${platform}" == "linux/ppc64le" ]]; then echo "hyperkube build for ppc64le is disabled. Creating dummy text file instead." local outfile=$(kube::golang::output_filename_for_binary "${binary}" "${platform}") mkdir -p $(dirname ${outfile}) echo "Not available at the moment. Please see: https://github.com/kubernetes/kubernetes/issues/25886 for more information." > ${outfile} elif [[ "${binary}" =~ ".test"$ ]]; then </ins> tests+=($binary) elif kube::golang::is_statically_linked_library "${binary}"; then statics+=($binary)

nonstatics+=($binary) fi done if [[ "${#statics[@]}" != 0 ]]; then kube::golang::fallback_if_stdlib_not_installable; fi