Subj : Beware; for I am fearless, and therefore powerful.
To   : Little Mikey
From : Benny Pedersen
Date : Sat Aug 04 2018 23:16:56

Hello Little!

03 Aug 2018 21:14, Little Mikey wrote to Benny Pedersen:

 BP>> i have glibc from truck github if i want to use it, there is no
 BP>> safe way back if emerged

 LM> Understood.  glibc is the trickiest package to upgrade since 
 LM> everything relies on it.

+1

 LM> That is why special partitions are deployed 
 LM> here for experimenting with glibc.

how is the layout with it ?

lvm2 snapshot rollbacks ?

 LM> Having said that, this reply is 
 LM> being entered on a booted rootfs based on glibc-2.28 with a 
 LM> bootstrapped gcc-8.2.0 and at this writing a linux-4.17.11 kernel.  
 LM> The original post you are replying to was also from this same rootfs.

i could do this on gentoo, i know enough to hack this with gentoo portage, but 
i dont know how cold it could be on the maunting top :)

 BP>> could you test this ? :)
 LM> Do you mean the gentoo package?

   ----- glibc-9999.ebuild begins -----
# Copyright 1999-2018 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2

EAPI=6

inherit prefix eutils versionator toolchain-funcs flag-o-matic gnuconfig \
        multilib systemd multiprocessing

DESCRIPTION="GNU libc C library"
HOMEPAGE="https://www.gnu.org/software/libc/"
LICENSE="LGPL-2.1+ BSD HPND ISC inner-net rc PCRE"
RESTRICT="strip" # Strip ourself #46186
SLOT="2.2"

EMULTILIB_PKG="true"

if [[ ${PV} == 9999* ]]; then
        EGIT_REPO_URI="https://sourceware.org/git/glibc.git"
        inherit git-r3
else
        # KEYWORDS="~alpha ~amd64 ~arm ~arm64 ~hppa ~ia64 ~m68k ~mips ~ppc 
~ppc64 ~s390 ~sh ~sparc ~x86"
        KEYWORDS=""
        SRC_URI="mirror://gnu/glibc/${P}.tar.xz"
fi

RELEASE_VER=${PV}

GCC_BOOTSTRAP_VER=20180511

# Gentoo patchset
PATCH_VER=7

SRC_URI+=" https://dev.gentoo.org/~dilfridge/distfiles/${P}-patches-${PATCH_VER}.tar.bz2"
SRC_URI+=" multilib? ( https://dev.gentoo.org/~dilfridge/distfiles/gcc-multilib-bootstrap-${GCC_BOOTSTRAP_VER}.tar.xz )"

IUSE="audit caps cet compile-locales doc gd hardened headers-only +multiarch 
multilib nscd profile selinux suid systemtap test vanilla"

# Minimum kernel version that glibc requires
MIN_KERN_VER="3.2.0"

# Here's how the cross-compile logic breaks down ...
#  CTARGET - machine that will target the binaries
#  CHOST   - machine that will host the binaries
#  CBUILD  - machine that will build the binaries
# If CTARGET != CHOST, it means you want a libc for cross-compiling.
# If CHOST != CBUILD, it means you want to cross-compile the libc.
#  CBUILD = CHOST = CTARGET    - native build/install
#  CBUILD != (CHOST = CTARGET) - cross-compile a native build
#  (CBUILD = CHOST) != CTARGET - libc for cross-compiler
#  CBUILD != CHOST != CTARGET  - cross-compile a libc for a cross-compiler
# For install paths:
#  CHOST = CTARGET  - install into /
#  CHOST != CTARGET - install into /usr/CTARGET/
#
export CBUILD=${CBUILD:-${CHOST}}
export CTARGET=${CTARGET:-${CHOST}}
if [[ ${CTARGET} == ${CHOST} ]] ; then
        if [[ ${CATEGORY} == cross-* ]] ; then
                export CTARGET=${CATEGORY#cross-}
        fi
fi

# We need a new-enough binutils/gcc to match upstream baseline.
# Also we need to make sure our binutils/gcc supports TLS.
COMMON_DEPEND="
        nscd? ( selinux? (
                audit? ( sys-process/audit )
                caps? ( sys-libs/libcap )
        ) )
        suid? ( caps? ( sys-libs/libcap ) )
        selinux? ( sys-libs/libselinux )
        systemtap? ( dev-util/systemtap )
"
DEPEND="${COMMON_DEPEND}
        >=app-misc/pax-utils-0.1.10
        sys-devel/bison
        !<sys-apps/sandbox-1.6
        !<sys-apps/portage-2.1.2
        !<sys-devel/bison-2.7
        !<sys-devel/make-4
        doc? ( sys-apps/texinfo )
        test? ( >=net-dns/libidn2-2.0.5 )
"
RDEPEND="${COMMON_DEPEND}
        >=net-dns/libidn2-2.0.5
        sys-apps/gentoo-functions
        !sys-kernel/ps3-sources
        !sys-libs/nss-db
"

if [[ ${CATEGORY} == cross-* ]] ; then
        DEPEND+=" !headers-only? (
                >=${CATEGORY}/binutils-2.24
                >=${CATEGORY}/gcc-4.9
        )"
        [[ ${CATEGORY} == *-linux* ]] && DEPEND+=" ${CATEGORY}/linux-headers"
else
        DEPEND+="
                >=sys-devel/binutils-2.24
                >=sys-devel/gcc-4.9
                virtual/os-headers
        "
        RDEPEND+=" vanilla? ( !sys-libs/timezone-data )"
        PDEPEND+=" !vanilla? ( sys-libs/timezone-data )"
fi

#
# Small helper functions
#

is_crosscompile() {
        [[ ${CHOST} != ${CTARGET} ]]
}

just_headers() {
        is_crosscompile && use headers-only
}

alt_prefix() {
        is_crosscompile && echo /usr/${CTARGET}
}

# We need to be able to set alternative headers for compiling for non-native
# platform. Will also become useful for testing kernel-headers without screwing
# up the whole system.
alt_headers() {
        echo ${ALT_HEADERS:=$(alt_prefix)/usr/include}
}

alt_build_headers() {
        if [[ -z ${ALT_BUILD_HEADERS} ]] ; then
                ALT_BUILD_HEADERS="${EPREFIX}$(alt_headers)"
                if tc-is-cross-compiler ; then
                        ALT_BUILD_HEADERS=${SYSROOT}$(alt_headers)
                        if [[ ! -e ${ALT_BUILD_HEADERS}/linux/version.h ]] ; 
then
                                local header_path=$(echo '#include 
<linux/version.h>' | $(tc-getCPP ${CTARGET}) ${CFLAGS} 2>&1 | grep -o 
'[^"]*linux/version.h')
                                ALT_BUILD_HEADERS=${header_path%/linux/version.h}
                        fi
                fi
        fi
        echo "${ALT_BUILD_HEADERS}"
}

alt_libdir() {
        echo $(alt_prefix)/$(get_libdir)
}
alt_usrlibdir() {
        echo $(alt_prefix)/usr/$(get_libdir)
}

builddir() {
        echo "${WORKDIR}/build-${ABI}-${CTARGET}-$1"
}

do_compile_test() {
        local ret save_cflags=${CFLAGS}
        CFLAGS+=" $1"
        shift

        pushd "${T}" >/dev/null

        rm -f glibc-test*
        printf '%b' "$*" > glibc-test.c

        nonfatal emake -s glibc-test
        ret=$?

        popd >/dev/null

        CFLAGS=${save_cflags}
        return ${ret}
}

do_run_test() {
        local ret

        if [[ ${MERGE_TYPE} == "binary" ]] ; then
                # ignore build failures when installing a binary package 
#324685
                do_compile_test "" "$@" 2>/dev/null || return 0
        else
                if ! do_compile_test "" "$@" ; then
                        ewarn "Simple build failed ... assuming this is desired 
#324685"
                        return 0
                fi
        fi

        pushd "${T}" >/dev/null

        ./glibc-test
        ret=$?
        rm -f glibc-test*

        popd >/dev/null

        return ${ret}
}

setup_target_flags() {
        # This largely mucks with compiler flags.  None of which should matter
        # when building up just the headers.
        just_headers && return 0

        case $(tc-arch) in
                x86)
                        # -march needed for #185404 #199334
                        # TODO: When creating the first glibc cross-compile, 
this test will
                        # always fail as it does a full link which in turn 
requires glibc.
                        # Probably also applies when changing multilib profile 
settings (e.g.
                        # enabling x86 when the profile was amd64-only 
previously).
                        # We could change main to _start and pass -nostdlib 
here so that we
                        # only test the gcc code compilation.  Or we could do a 
compile and
                        # then look for the symbol via scanelf.
                        if ! do_compile_test "" 'void f(int i, void *p) {if 
(__sync_fetch_and_add(&i, 1)) f(i, p);}\nint main(){return 0;}\n' 2>/dev/null ; 
then
                                local t=${CTARGET_OPT:-${CTARGET}}
                                t=${t%%-*}
                                filter-flags '-march=*'
                                export CFLAGS="-march=${t} ${CFLAGS}"
                                einfo "Auto adding -march=${t} to CFLAGS 
#185404"
                        fi
                ;;
                amd64)
                        # -march needed for #185404 #199334
                        # Note: This test only matters when the x86 ABI is 
enabled, so we could
                        # optimize a bit and elide it.
                        # TODO: See cross-compile issues listed above for x86.
                        if ! do_compile_test "${CFLAGS_x86}" 'void f(int i, 
void *p) {if (__sync_fetch_and_add(&i, 1)) f(i, p);}\nint main(){return 0;}\n' 
2>/dev/null ; then
                                local t=${CTARGET_OPT:-${CTARGET}}
                                t=${t%%-*}
                                # Normally the target is x86_64-xxx, so turn 
that into the -march that
                                # gcc actually accepts. #528708
                                [[ ${t} == "x86_64" ]] && t="x86-64"
                                filter-flags '-march=*'
                                # ugly, ugly, ugly.  ugly.
                                CFLAGS_x86=$(CFLAGS=${CFLAGS_x86} filter-flags 
'-march=*'; echo "${CFLAGS}")
                                export CFLAGS_x86="${CFLAGS_x86} -march=${t}"
                                einfo "Auto adding -march=${t} to CFLAGS_x86 
#185404"
                        fi
                ;;
                mips)
                        # The mips abi cannot support the GNU style hashes. 
#233233
                        filter-ldflags -Wl,--hash-style=gnu 
-Wl,--hash-style=both
                ;;
                sparc)
                        # Both sparc and sparc64 can use -fcall-used-g6.  -g7 
is bad, though.
                        filter-flags "-fcall-used-g7"
                        append-flags "-fcall-used-g6"

                        # If the CHOST is the basic one (e.g. not sparcv9-xxx 
already),
                        # try to pick a better one so glibc can use 
cpu-specific .S files.
                        # We key off the CFLAGS to get a good value.  Also need 
to handle
                        # version skew.
                        # We can't force users to set their CHOST to their 
exact machine
                        # as many of these are not recognized by config.sub/gcc 
and such :(.
                        # Note: If the mcpu values don't scale, we might try 
probing CPP defines.
                        # Note: Should we factor in -Wa,-AvXXX flags too ?  Or 
-mvis/etc... ?

                        local cpu
                        case ${CTARGET} in
                        sparc64-*)
                                case $(get-flag mcpu) in
                                niagara[234])
                                        if version_is_at_least 2.8 ; then
                                                cpu="sparc64v2"
                                        elif version_is_at_least 2.4 ; then
                                                cpu="sparc64v"
                                        elif version_is_at_least 2.2.3 ; then
                                                cpu="sparc64b"
                                        fi
                                        ;;
                                niagara)
                                        if version_is_at_least 2.4 ; then
                                                cpu="sparc64v"
                                        elif version_is_at_least 2.2.3 ; then
                                                cpu="sparc64b"
                                        fi
                                        ;;
                                ultrasparc3)
                                        cpu="sparc64b"
                                        ;;
                                *)
                                        # We need to force at least v9a because 
the base build doesn't
                                        # work with just v9.
                                        # 
https://sourceware.org/bugzilla/show_bug.cgi?id=19477
                                        [[ -z ${cpu} ]] && append-flags 
"-Wa,-xarch=v9a"
                                        ;;
                                esac
                                ;;
                        sparc-*)
                                case $(get-flag mcpu) in
                                niagara[234])
                                        if version_is_at_least 2.8 ; then
                                                cpu="sparcv9v2"
                                        elif version_is_at_least 2.4 ; then
                                                cpu="sparcv9v"
                                        elif version_is_at_least 2.2.3 ; then
                                                cpu="sparcv9b"
                                        else
                                                cpu="sparcv9"
                                        fi
                                        ;;
                                niagara)
                                        if version_is_at_least 2.4 ; then
                                                cpu="sparcv9v"
                                        elif version_is_at_least 2.2.3 ; then
                                                cpu="sparcv9b"
                                        else
                                                cpu="sparcv9"
                                        fi
                                        ;;
                                ultrasparc3)
                                        cpu="sparcv9b"
                                        ;;
                                v9|ultrasparc)
                                        cpu="sparcv9"
                                        ;;
                                v8|supersparc|hypersparc|leon|leon3)
                                        cpu="sparcv8"
                                        ;;
                                esac
                        ;;
                        esac
                        [[ -n ${cpu} ]] && CTARGET_OPT="${cpu}-${CTARGET#*-}"
                ;;
        esac
}

setup_flags() {
        # Make sure host make.conf doesn't pollute us
        if is_crosscompile || tc-is-cross-compiler ; then
                CHOST=${CTARGET} strip-unsupported-flags
        fi

        # Store our CFLAGS because it's changed depending on which CTARGET
        # we are building when pulling glibc on a multilib profile
        CFLAGS_BASE=${CFLAGS_BASE-${CFLAGS}}
        CFLAGS=${CFLAGS_BASE}
        CXXFLAGS_BASE=${CXXFLAGS_BASE-${CXXFLAGS}}
        CXXFLAGS=${CXXFLAGS_BASE}
        ASFLAGS_BASE=${ASFLAGS_BASE-${ASFLAGS}}
        ASFLAGS=${ASFLAGS_BASE}

        # Over-zealous CFLAGS can often cause problems.  What may work for one
        # person may not work for another.  To avoid a large influx of bugs
        # relating to failed builds, we strip most CFLAGS out to ensure as few
        # problems as possible.
        strip-flags
        strip-unsupported-flags
        filter-flags -m32 -m64 '-mabi=*'

        # glibc aborts if rpath is set by LDFLAGS
        filter-ldflags '-Wl,-rpath=*'

        # #492892
        filter-flags -frecord-gcc-switches

        unset CBUILD_OPT CTARGET_OPT
        if use multilib ; then
                CTARGET_OPT=$(get_abi_CTARGET)
                [[ -z ${CTARGET_OPT} ]] && CTARGET_OPT=$(get_abi_CHOST)
        fi

        setup_target_flags

        if [[ -n ${CTARGET_OPT} && ${CBUILD} == ${CHOST} ]] && ! 
is_crosscompile; then
                CBUILD_OPT=${CTARGET_OPT}
        fi

        # Lock glibc at -O2; we want to be conservative here.
        # -fno-strict-aliasing is to work around #155906.
        filter-flags '-O?'
        append-flags -O2 -fno-strict-aliasing

        filter-flags '-fstack-protector*'

        # Starting with gcc-6 (and fully upstreamed pie patches) we control
        # default enabled/disabled pie via use flags. So nothing to do
        # here then. #618160
        if [[ $(gcc-major-version) -lt 6 ]]; then
                if use hardened && tc-enables-pie ; then
                        # Force PIC macro definition for all compilations since 
they're all
                        # either -fPIC or -fPIE with the default-PIE compiler.
                        append-cppflags -DPIC
                else
                        # Don't build -fPIE without the default-PIE compiler 
and the
                        # hardened-pie patch
                        filter-flags -fPIE
                fi
        fi
}

want_tls() {
        # Archs that can use TLS (Thread Local Storage)
        case $(tc-arch) in
                x86)
                        # requires i486 or better #106556
                        [[ ${CTARGET} == i[4567]86* ]] && return 0
                        return 1
                ;;
        esac
        return 0
}

want__thread() {
        want_tls || return 1

        # For some reason --with-tls --with__thread is causing segfaults on 
sparc32.
        [[ ${PROFILE_ARCH} == "sparc" ]] && return 1

        [[ -n ${WANT__THREAD} ]] && return ${WANT__THREAD}

        # only test gcc -- can't test linking yet
        tc-has-tls -c ${CTARGET}
        WANT__THREAD=$?

        return ${WANT__THREAD}
}

use_multiarch() {
        # Allow user to disable runtime arch detection in multilib.
        use multiarch || return 1
        # Make sure binutils is new enough to support indirect functions,
        # #336792. This funky sed supports gold and bfd linkers.
        local bver nver
        bver=$($(tc-getLD ${CTARGET}) -v | sed -n -r 
'1{s:[^0-9]*::;s:^([0-9.]*).*:\1:;p}')
        case $(tc-arch ${CTARGET}) in
        amd64|x86) nver="2.20" ;;
        arm)       nver="2.22" ;;
        hppa)      nver="2.23" ;;
        ppc|ppc64) nver="2.20" ;;
        # ifunc support was added in 2.23, but glibc also needs
        # machinemode which is in 2.24.
        s390)      nver="2.24" ;;
        sparc)     nver="2.21" ;;
        *)         return 1 ;;
        esac
        version_is_at_least ${nver} ${bver}
}

# Setup toolchain variables that had historically been defined in the
# profiles for these archs.
setup_env() {
        # silly users
        unset LD_RUN_PATH
        unset LD_ASSUME_KERNEL

        if is_crosscompile || tc-is-cross-compiler ; then
                multilib_env ${CTARGET_OPT:-${CTARGET}}

                if ! use multilib ; then
                        MULTILIB_ABIS=${DEFAULT_ABI}
                else
                        MULTILIB_ABIS=${MULTILIB_ABIS:-${DEFAULT_ABI}}
                fi

                # If the user has CFLAGS_<CTARGET> in their make.conf, use 
that,
                # and fall back on CFLAGS.
                local VAR=CFLAGS_${CTARGET//[-.]/_}
                CFLAGS=${!VAR-${CFLAGS}}
                einfo " $(printf '%15s' 'Manual CFLAGS:')   ${CFLAGS}"
        fi

        setup_flags

        export ABI=${ABI:-${DEFAULT_ABI:-default}}

        if use headers-only ; then
                # Avoid mixing host's CC and target's CFLAGS_${ABI}:
                # At this bootstrap stage we have only binutils for
                # target but not compiler yet.
                einfo "Skip CC ABI injection. We can't use (cross-)compiler 
yet."
                return 0
        fi
        local VAR=CFLAGS_${ABI}
        # We need to export CFLAGS with abi information in them because glibc's
        # configure script checks CFLAGS for some targets (like mips).  Keep
        # around the original clean value to avoid appending multiple ABIs on
        # top of each other.
        : ${__GLIBC_CC:=$(tc-getCC ${CTARGET_OPT:-${CTARGET}})}
        export __GLIBC_CC CC="${__GLIBC_CC} ${!VAR}"
        einfo " $(printf '%15s' 'Manual CC:')   ${CC}"
}

foreach_abi() {
        setup_env

        local ret=0
        local abilist=""
        if use multilib ; then
                abilist=$(get_install_abis)
        else
                abilist=${DEFAULT_ABI}
        fi
        local -x ABI
        for ABI in ${abilist:-default} ; do
                setup_env
                einfo "Running $1 for ABI ${ABI}"
                $1
                : $(( ret |= $? ))
        done
        return ${ret}
}

glibc_banner() {
        local b="Gentoo ${PVR}"
        [[ -n ${PATCH_VER} ]] && ! use vanilla && b+=" p${PATCH_VER}"
        echo "${b}"
}

check_devpts() {
        # Make sure devpts is mounted correctly for use w/out setuid pt_chown.

        # If merely building the binary package, then there's nothing to 
verify.
        [[ ${MERGE_TYPE} == "buildonly" ]] && return

        # Only sanity check when installing the native glibc.
        [[ ${ROOT} != "/" ]] && return

        # If they're opting in to the old suid code, then no need to check.
        use suid && return

        if awk '$3 == "devpts" && $4 ~ /[, ]gid=5[, ]/ { exit 1 }' /proc/mounts 
; then
                eerror "In order to use glibc with USE=-suid, you must make 
sure that"
                eerror "you have devpts mounted at /dev/pts with the gid=5 
option."
                eerror "Openrc should do this for you, so you should check 
/etc/fstab"
                eerror "and make sure you do not have any invalid settings 
there."
                die "mount & fix your /dev/pts settings"
        fi
}

# The following Kernel version handling functions are mostly copied from 
portage
# source. It's better not to use linux-info.eclass here since a) it adds too
# much magic, see bug 326693 for some of the arguments, and b) some of the
# functions are just not provided.

g_get_running_KV() {
        uname -r
        return $?
}

g_KV_major() {
        [[ -z $1 ]] && return 1
        local KV=$@
        echo "${KV%%.*}"
}

g_KV_minor() {
        [[ -z $1 ]] && return 1
        local KV=$@
        KV=${KV#*.}
        echo "${KV%%.*}"
}

g_KV_micro() {
        [[ -z $1 ]] && return 1
        local KV=$@
        KV=${KV#*.*.}
        echo "${KV%%[^[:digit:]]*}"
}

g_KV_to_int() {
        [[ -z $1 ]] && return 1
        local KV_MAJOR=$(g_KV_major "$1")
        local KV_MINOR=$(g_KV_minor "$1")
        local KV_MICRO=$(g_KV_micro "$1")
        local KV_int=$(( KV_MAJOR * 65536 + KV_MINOR * 256 + KV_MICRO ))

        # We make version 2.2.0 the minimum version we will handle as
        # a sanity check ... if its less, we fail ...
        if [[ ${KV_int} -ge 131584 ]] ; then
                echo "${KV_int}"
                return 0
        fi
        return 1
}

g_int_to_KV() {
        local version=$1 major minor micro
        major=$((version / 65536))
        minor=$(((version % 65536) / 256))
        micro=$((version % 256))
        echo ${major}.${minor}.${micro}
}

eend_KV() {
        [[ $(g_KV_to_int $1) -ge $(g_KV_to_int $2) ]]
        eend $?
}

get_kheader_version() {
        printf '#include <linux/version.h>\nLINUX_VERSION_CODE\n' | \
        $(tc-getCPP ${CTARGET}) -I "${EPREFIX}/$(alt_build_headers)" - | \
        tail -n 1
}

# We collect all sanity checks here. Consistency is not guranteed between
# pkg_ and src_ phases, so we call this function both in pkg_pretend and in
# src_unpack.
sanity_prechecks() {
        # Make sure devpts is mounted correctly for use w/out setuid pt_chown
        check_devpts

        # Prevent native builds from downgrading
        if [[ ${MERGE_TYPE} != "buildonly" ]] && \
           [[ ${ROOT} == "/" ]] && \
           [[ ${CBUILD} == ${CHOST} ]] && \
           [[ ${CHOST} == ${CTARGET} ]] ; then

                # The high rev # is to allow people to downgrade between -r#
                # versions. We want to block 2.20->2.19, but 2.20-r3->2.20-r2
                # should be fine. Hopefully we never actually use a r# this
                # high.
                if has_version ">${CATEGORY}/${P}-r10000" ; then
                        eerror "Sanity check to keep you from breaking your 
system:"
                        eerror " Downgrading glibc is not supported and a sure 
way to destruction."
                        die "Aborting to save your system."
                fi

--- Msged/LNX 6.1.2 (Linux/4.17.12-gentoo (x86_64))
 * Origin: I will always keep a PC running CPM 3.0 (2:230/0)

.