Subversion Repositories configs

# This is a simple script that checks the contents of /proc/mtrr to see if
# the BIOS maker for the computer took the easy way out in terms of
# specifying memory regions when there is a hole below 4GB for PCI access
# and the machine has 4GB or more of RAM.  When the contents of /proc/mtrr
# show a 4GB mapping of write-back cached RAM, minus punch out hole(s) of
# uncacheable regions (the area reserved for PCI access), then it becomes
# impossible for the ib_ipath driver to set write_combining on its PIO
# buffers.  To correct the problem, remap the lower memory region in various
# chunks up to the start of the punch out hole(s), then delete the punch out
# hole(s) entirely as they aren't needed any more.  That way, ib_ipath will
# be able to set write_combining on its PIO memory access region.

BEGIN {
        regs = 0
}

function check_base(mem)
{
        printf "Base memory data: base=0x%08x, size=0x%x\n", base[mem], size[mem] > "/dev/stderr"
        if (size[mem] < (512 * 1024 * 1024))
                return 0
        if (type[mem] != "write-back")
                return 0
        if (base[mem] >= (4 * 1024 * 1024 * 1024))
                return 0
        return 1
}

function check_hole(hole)
{
        printf "Hole data: base=0x%08x, size=0x%x\n", base[hole], size[hole] > "/dev/stderr"
        if (size[hole] > (1 * 1024 * 1024 * 1024))
                return 0
        if (type[hole] != "uncachable")
                return 0
        if ((base[hole] + size[hole]) > (4 * 1024 * 1024 * 1024))
                return 0
        return 1
}

function build_entries(start, end,     new_base, new_size, tmp_base)
{
        # mtrr registers require alignment of blocks, so a 256MB chunk must
        # be 256MB aligned.  Additionally, all blocks must be a power of 2
        # in size.  So, do the largest power of two size that we can and
        # still have start + block <= end, rinse and repeat.
        tmp_base = start
        do {
                new_base = tmp_base
                new_size = 4096
                while (((new_base + new_size) < end) &&
                       ((new_base % new_size) == 0))
                        new_size = lshift(new_size, 1)
                if (((new_base + new_size) > end) ||
                    ((new_base % new_size) != 0))
                        new_size = rshift(new_size, 1)
                printf "base=0x%x size=0x%x type=%s\n",
                        new_base, new_size, type[mem] > "/dev/stderr"
                printf "base=0x%x size=0x%x type=%s\n",
                        new_base, new_size, type[mem] > "/proc/mtrr"
                fflush("")
                tmp_base = new_base + new_size
        } while (tmp_base < end)
}

{
        gsub("^reg", "")
        gsub(": base=", " ")
        gsub(" [(].*), size=", " ")
        gsub(": ", " ")
        gsub(", count=.*$", "")
        register[regs] = strtonum($1)
        base[regs] = strtonum($2)
        size[regs] = strtonum($3)
        human_size[regs] = size[regs]
        if (match($3, "MB")) { size[regs] *= 1024*1024; mult[regs] = "MB" }
        else { size[regs] *= 1024; mult[regs] = "KB" }
        type[regs] = $4
        enabled[regs] = 1
        end[regs] = base[regs] + size[regs]
        regs++
}

END {
        # First we need to find our base memory region.  We only care about
        # the memory register that starts at base 0.  This is the only one
        # that we can reliably know is our global memory region, and the
        # only one that we can reliably check against overlaps.  It's entirely
        # possible that any memory region not starting at 0 and having an
        # overlap with another memory region is in fact intentional and we
        # shouldn't touch it.
        for(i=0; i<regs; i++)
                if (base[i] == 0)
                        break
        # Did we get a valid base register?
        if (i == regs)
                exit 1
        mem = i
        if (!check_base(mem))
                exit 1

        cur_hole = 0
        for(i=0; i<regs; i++) {
                if (i == mem)
                        continue
                if (base[i] < end[mem] && check_hole(i))
                        holes[cur_hole++] = i
        }
        if (cur_hole == 0) {
                print "Nothing to do" > "/dev/stderr"
                exit 1
        }
        printf "Found %d punch-out holes\n", cur_hole > "/dev/stderr"

        # We need to sort the holes according to base address
        for(j = 0; j < cur_hole - 1; j++) {
                for(i = cur_hole - 1; i > j; i--) {
                        if(base[holes[i]] < base[holes[i-1]]) {
                                tmp = holes[i]
                                holes[i] = holes[i-1]
                                holes[i-1] = tmp
                        }
                }
        }
        # OK, the common case would be that the BIOS is mapping holes out
        # of the 4GB memory range, and that our hole(s) are consecutive and
        # that our holes and our memory region end at the same place.  However,
        # things like machines with 8GB of RAM or more can foul up these
        # common traits.
        #
        # So, our modus operandi is to disable all of the memory/hole regions
        # to start, then build new base memory zones that in the end add
        # up to the same as our original zone minus the holes.  We know that
        # we will never have a hole listed here that belongs to a valid
        # hole punched in a write-combining memory region because you can't
        # overlay write-combining on top of write-back and we know our base
        # memory region is write-back, so in order for this hole to overlap
        # our base memory region it can't be also overlapping a write-combining
        # region.
        printf "disable=%d\n", register[mem] > "/dev/stderr"
        printf "disable=%d\n", register[mem] > "/proc/mtrr"
        fflush("")
        enabled[mem] = 0
        for(i=0; i < cur_hole; i++) {
                printf "disable=%d\n", register[holes[i]] > "/dev/stderr"
                printf "disable=%d\n", register[holes[i]] > "/proc/mtrr"
                fflush("")
                enabled[holes[i]] = 0
        }
        build_entries(base[mem], base[holes[0]])
        for(i=0; i < cur_hole - 1; i++)
                if (base[holes[i+1]] > end[holes[i]])
                        build_entries(end[holes[i]], base[holes[i+1]])
        if (end[mem] > end[holes[i]])
                build_entries(end[holes[i]], end[mem])
        # We changed up the mtrr regs, so signal to the rdma script to
        # reload modules that need the mtrr regs to be right.
        exit 0
}