Commit 55229247 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/dgibson/tags/ppc-for-2.9-20170222' into staging 



ppc patch queue for 2017-02-22

This pull request has:
   * Yet more POWER9 instruction implementations
   * Some extensions to the softfloat code which are necesssary for
     some of those instructions
   * Some preliminary patches in preparation for POWER9 softmmu
     implementation
   * Igor Mammedov's cleanups to unify hotplug cpu handling across
     architectures
   * Assorted bugfixes

The softfloat and cpu hotplug changes aren't entirely ppc specific (in
fact the hotplug stuff contains some pc specific patches).  However
they're included here because ppc is one of the main beneficiaries,
and the series depend on some ppc specific patches.

# gpg: Signature made Wed 22 Feb 2017 06:29:47 GMT
# gpg:                using RSA key 0x6C38CACA20D9B392
# gpg: Good signature from "David Gibson <david@gibson.dropbear.id.au>"
# gpg:                 aka "David Gibson (Red Hat) <dgibson@redhat.com>"
# gpg:                 aka "David Gibson (ozlabs.org) <dgibson@ozlabs.org>"
# gpg:                 aka "David Gibson (kernel.org) <dwg@kernel.org>"
# Primary key fingerprint: 75F4 6586 AE61 A66C C44E  87DC 6C38 CACA 20D9 B392

* remotes/dgibson/tags/ppc-for-2.9-20170222: (43 commits)
  hw/ppc/ppc405_uc.c: Avoid integer overflows
  hw/ppc/spapr: Check for valid page size when hot plugging memory
  target-ppc: fix Book-E TLB matching
  hw/net/spapr_llan: 6 byte mac address device tree entry
  machine: replace query_hotpluggable_cpus() callback with has_hotpluggable_cpus flag
  machine: unify [pc_|spapr_]query_hotpluggable_cpus() callbacks
  spapr: reuse machine->possible_cpus instead of cores[]
  change CPUArchId.cpu type to Object*
  pc: pass apic_id to pc_find_cpu_slot() directly so lookup could be done without CPU object
  pc: calculate topology only once when possible_cpus is initialised
  pc: move pcms->possible_cpus init out of pc_cpus_init()
  machine: move possible_cpus to MachineState
  hw/pci-host/prep: Do not use hw_error() in realize function
  target/ppc/POWER9: Direct all instr and data storage interrupts to the hypv
  target/ppc/POWER9: Adapt LPCR handling for POWER9
  target/ppc/POWER9: Add ISAv3.00 MMU definition
  target/ppc: Fix LPCR DPFD mask define
  target-ppc: Add xscvqpudz and xscvqpuwz instructions
  target-ppc: Implement round to odd variants of quad FP instructions
  softfloat: Add float128_to_uint32_round_to_zero()
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 2d896b45 fb6971c1

fpu/softfloat.c

+107 −1
Original line number Diff line number Diff line
@@ -623,6 +623,9 @@ static float64 roundAndPackFloat64(flag zSign, int zExp, uint64_t zSig, 
    case float_round_down:

        roundIncrement = zSign ? 0x3ff : 0;

        break;

    case float_round_to_odd:

        roundIncrement = (zSig & 0x400) ? 0 : 0x3ff;

        break;

    default:

        abort();

    }
@@ -632,8 +635,10 @@ static float64 roundAndPackFloat64(flag zSign, int zExp, uint64_t zSig, 
             || (    ( zExp == 0x7FD )

                  && ( (int64_t) ( zSig + roundIncrement ) < 0 ) )

           ) {

            bool overflow_to_inf = roundingMode != float_round_to_odd &&

                                   roundIncrement != 0;

            float_raise(float_flag_overflow | float_flag_inexact, status);

            return packFloat64( zSign, 0x7FF, - ( roundIncrement == 0 ));

            return packFloat64(zSign, 0x7FF, -(!overflow_to_inf));

        }

        if ( zExp < 0 ) {

            if (status->flush_to_zero) {
@@ -651,6 +656,13 @@ static float64 roundAndPackFloat64(flag zSign, int zExp, uint64_t zSig, 
            if (isTiny && roundBits) {

                float_raise(float_flag_underflow, status);

            }

            if (roundingMode == float_round_to_odd) {

                /*

                 * For round-to-odd case, the roundIncrement depends on

                 * zSig which just changed.

                 */

                roundIncrement = (zSig & 0x400) ? 0 : 0x3ff;

            }

        }

    }

    if (roundBits) {
@@ -1149,6 +1161,9 @@ static float128 roundAndPackFloat128(flag zSign, int32_t zExp, 
    case float_round_down:

        increment = zSign && zSig2;

        break;

    case float_round_to_odd:

        increment = !(zSig1 & 0x1) && zSig2;

        break;

    default:

        abort();

    }
@@ -1168,6 +1183,7 @@ static float128 roundAndPackFloat128(flag zSign, int32_t zExp, 
            if (    ( roundingMode == float_round_to_zero )

                 || ( zSign && ( roundingMode == float_round_up ) )

                 || ( ! zSign && ( roundingMode == float_round_down ) )

                 || (roundingMode == float_round_to_odd)

               ) {

                return

                    packFloat128(
@@ -1215,6 +1231,9 @@ static float128 roundAndPackFloat128(flag zSign, int32_t zExp, 
            case float_round_down:

                increment = zSign && zSig2;

                break;

            case float_round_to_odd:

                increment = !(zSig1 & 0x1) && zSig2;

                break;

            default:

                abort();

            }
@@ -6108,6 +6127,93 @@ int64_t float128_to_int64_round_to_zero(float128 a, float_status *status) 


}



/*----------------------------------------------------------------------------

| Returns the result of converting the quadruple-precision floating-point value

| `a' to the 64-bit unsigned integer format.  The conversion is

| performed according to the IEC/IEEE Standard for Binary Floating-Point

| Arithmetic---which means in particular that the conversion is rounded

| according to the current rounding mode.  If `a' is a NaN, the largest

| positive integer is returned.  If the conversion overflows, the

| largest unsigned integer is returned.  If 'a' is negative, the value is

| rounded and zero is returned; negative values that do not round to zero

| will raise the inexact exception.

*----------------------------------------------------------------------------*/



uint64_t float128_to_uint64(float128 a, float_status *status)

{

    flag aSign;

    int aExp;

    int shiftCount;

    uint64_t aSig0, aSig1;



    aSig0 = extractFloat128Frac0(a);

    aSig1 = extractFloat128Frac1(a);

    aExp = extractFloat128Exp(a);

    aSign = extractFloat128Sign(a);

    if (aSign && (aExp > 0x3FFE)) {

        float_raise(float_flag_invalid, status);

        if (float128_is_any_nan(a)) {

            return LIT64(0xFFFFFFFFFFFFFFFF);

        } else {

            return 0;

        }

    }

    if (aExp) {

        aSig0 |= LIT64(0x0001000000000000);

    }

    shiftCount = 0x402F - aExp;

    if (shiftCount <= 0) {

        if (0x403E < aExp) {

            float_raise(float_flag_invalid, status);

            return LIT64(0xFFFFFFFFFFFFFFFF);

        }

        shortShift128Left(aSig0, aSig1, -shiftCount, &aSig0, &aSig1);

    } else {

        shift64ExtraRightJamming(aSig0, aSig1, shiftCount, &aSig0, &aSig1);

    }

    return roundAndPackUint64(aSign, aSig0, aSig1, status);

}



uint64_t float128_to_uint64_round_to_zero(float128 a, float_status *status)

{

    uint64_t v;

    signed char current_rounding_mode = status->float_rounding_mode;



    set_float_rounding_mode(float_round_to_zero, status);

    v = float128_to_uint64(a, status);

    set_float_rounding_mode(current_rounding_mode, status);



    return v;

}



/*----------------------------------------------------------------------------

| Returns the result of converting the quadruple-precision floating-point

| value `a' to the 32-bit unsigned integer format.  The conversion

| is performed according to the IEC/IEEE Standard for Binary Floating-Point

| Arithmetic except that the conversion is always rounded toward zero.

| If `a' is a NaN, the largest positive integer is returned.  Otherwise,

| if the conversion overflows, the largest unsigned integer is returned.

| If 'a' is negative, the value is rounded and zero is returned; negative

| values that do not round to zero will raise the inexact exception.

*----------------------------------------------------------------------------*/



uint32_t float128_to_uint32_round_to_zero(float128 a, float_status *status)

{

    uint64_t v;

    uint32_t res;

    int old_exc_flags = get_float_exception_flags(status);



    v = float128_to_uint64_round_to_zero(a, status);

    if (v > 0xffffffff) {

        res = 0xffffffff;

    } else {

        return v;

    }

    set_float_exception_flags(old_exc_flags, status);

    float_raise(float_flag_invalid, status);

    return res;

}



/*----------------------------------------------------------------------------

| Returns the result of converting the quadruple-precision floating-point

| value `a' to the single-precision floating-point format.  The conversion

hw/acpi/cpu.c

+1 −1
Original line number Diff line number Diff line
@@ -198,7 +198,7 @@ void cpu_hotplug_hw_init(MemoryRegion *as, Object *owner, 
    state->dev_count = id_list->len;

    state->devs = g_new0(typeof(*state->devs), state->dev_count);

    for (i = 0; i < id_list->len; i++) {

        state->devs[i].cpu =  id_list->cpus[i].cpu;

        state->devs[i].cpu =  CPU(id_list->cpus[i].cpu);

        state->devs[i].arch_id = id_list->cpus[i].arch_id;

    }

    memory_region_init_io(&state->ctrl_reg, owner, &cpu_hotplug_ops, state,

hw/core/machine.c

+31 −0
Original line number Diff line number Diff line
@@ -357,6 +357,37 @@ static void machine_init_notify(Notifier *notifier, void *data) 
    foreach_dynamic_sysbus_device(error_on_sysbus_device, NULL);

}



HotpluggableCPUList *machine_query_hotpluggable_cpus(MachineState *machine)

{

    int i;

    Object *cpu;

    HotpluggableCPUList *head = NULL;

    const char *cpu_type;



    cpu = machine->possible_cpus->cpus[0].cpu;

    assert(cpu); /* Boot cpu is always present */

    cpu_type = object_get_typename(cpu);

    for (i = 0; i < machine->possible_cpus->len; i++) {

        HotpluggableCPUList *list_item = g_new0(typeof(*list_item), 1);

        HotpluggableCPU *cpu_item = g_new0(typeof(*cpu_item), 1);



        cpu_item->type = g_strdup(cpu_type);

        cpu_item->vcpus_count = machine->possible_cpus->cpus[i].vcpus_count;

        cpu_item->props = g_memdup(&machine->possible_cpus->cpus[i].props,

                                   sizeof(*cpu_item->props));



        cpu = machine->possible_cpus->cpus[i].cpu;

        if (cpu) {

            cpu_item->has_qom_path = true;

            cpu_item->qom_path = object_get_canonical_path(cpu);

        }

        list_item->value = cpu_item;

        list_item->next = head;

        head = list_item;

    }

    return head;

}



static void machine_class_init(ObjectClass *oc, void *data)

{

    MachineClass *mc = MACHINE_CLASS(oc);

hw/i386/pc.c

+55 −71
Original line number Diff line number Diff line
@@ -707,7 +707,8 @@ static void pc_build_smbios(PCMachineState *pcms) 
    size_t smbios_tables_len, smbios_anchor_len;

    struct smbios_phys_mem_area *mem_array;

    unsigned i, array_count;

    X86CPU *cpu = X86_CPU(pcms->possible_cpus->cpus[0].cpu);

    MachineState *ms = MACHINE(pcms);

    X86CPU *cpu = X86_CPU(ms->possible_cpus->cpus[0].cpu);



    /* tell smbios about cpuid version and features */

    smbios_set_cpuid(cpu->env.cpuid_version, cpu->env.features[FEAT_1_EDX]);
@@ -1111,7 +1112,7 @@ static void pc_new_cpu(const char *typename, int64_t apic_id, Error **errp) 
void pc_hot_add_cpu(const int64_t id, Error **errp)

{

    ObjectClass *oc;

    PCMachineState *pcms = PC_MACHINE(qdev_get_machine());

    MachineState *ms = MACHINE(qdev_get_machine());

    int64_t apic_id = x86_cpu_apic_id_from_index(id);

    Error *local_err = NULL;
@@ -1127,8 +1128,8 @@ void pc_hot_add_cpu(const int64_t id, Error **errp) 
        return;

    }



    assert(pcms->possible_cpus->cpus[0].cpu); /* BSP is always present */

    oc = OBJECT_CLASS(CPU_GET_CLASS(pcms->possible_cpus->cpus[0].cpu));

    assert(ms->possible_cpus->cpus[0].cpu); /* BSP is always present */

    oc = OBJECT_CLASS(CPU_GET_CLASS(ms->possible_cpus->cpus[0].cpu));

    pc_new_cpu(object_class_get_name(oc), apic_id, &local_err);

    if (local_err) {

        error_propagate(errp, local_err);
@@ -1143,7 +1144,9 @@ void pc_cpus_init(PCMachineState *pcms) 
    ObjectClass *oc;

    const char *typename;

    gchar **model_pieces;

    const CPUArchIdList *possible_cpus;

    MachineState *machine = MACHINE(pcms);

    MachineClass *mc = MACHINE_GET_CLASS(pcms);



    /* init CPUs */

    if (machine->cpu_model == NULL) {
@@ -1178,20 +1181,16 @@ void pc_cpus_init(PCMachineState *pcms) 
     * This is used for FW_CFG_MAX_CPUS. See comments on bochs_bios_init().

     */

    pcms->apic_id_limit = x86_cpu_apic_id_from_index(max_cpus - 1) + 1;

    pcms->possible_cpus = g_malloc0(sizeof(CPUArchIdList) +

                                    sizeof(CPUArchId) * max_cpus);

    for (i = 0; i < max_cpus; i++) {

        pcms->possible_cpus->cpus[i].arch_id = x86_cpu_apic_id_from_index(i);

        pcms->possible_cpus->len++;

        if (i < smp_cpus) {

            pc_new_cpu(typename, x86_cpu_apic_id_from_index(i), &error_fatal);

        }

    possible_cpus = mc->possible_cpu_arch_ids(machine);

    for (i = 0; i < smp_cpus; i++) {

        pc_new_cpu(typename, possible_cpus->cpus[i].arch_id, &error_fatal);

    }

}



static void pc_build_feature_control_file(PCMachineState *pcms)

{

    X86CPU *cpu = X86_CPU(pcms->possible_cpus->cpus[0].cpu);

    MachineState *ms = MACHINE(pcms);

    X86CPU *cpu = X86_CPU(ms->possible_cpus->cpus[0].cpu);

    CPUX86State *env = &cpu->env;

    uint32_t unused, ecx, edx;

    uint64_t feature_control_bits = 0;
@@ -1787,21 +1786,19 @@ static int pc_apic_cmp(const void *a, const void *b) 
}



/* returns pointer to CPUArchId descriptor that matches CPU's apic_id

 * in pcms->possible_cpus->cpus, if pcms->possible_cpus->cpus has no

 * in ms->possible_cpus->cpus, if ms->possible_cpus->cpus has no

 * entry corresponding to CPU's apic_id returns NULL.

 */

static CPUArchId *pc_find_cpu_slot(PCMachineState *pcms, CPUState *cpu,

                                   int *idx)

static CPUArchId *pc_find_cpu_slot(MachineState *ms, uint32_t id, int *idx)

{

    CPUClass *cc = CPU_GET_CLASS(cpu);

    CPUArchId apic_id, *found_cpu;



    apic_id.arch_id = cc->get_arch_id(CPU(cpu));

    found_cpu = bsearch(&apic_id, pcms->possible_cpus->cpus,

        pcms->possible_cpus->len, sizeof(*pcms->possible_cpus->cpus),

    apic_id.arch_id = id;

    found_cpu = bsearch(&apic_id, ms->possible_cpus->cpus,

        ms->possible_cpus->len, sizeof(*ms->possible_cpus->cpus),

        pc_apic_cmp);

    if (found_cpu && idx) {

        *idx = found_cpu - pcms->possible_cpus->cpus;

        *idx = found_cpu - ms->possible_cpus->cpus;

    }

    return found_cpu;

}
@@ -1812,6 +1809,7 @@ static void pc_cpu_plug(HotplugHandler *hotplug_dev, 
    CPUArchId *found_cpu;

    HotplugHandlerClass *hhc;

    Error *local_err = NULL;

    X86CPU *cpu = X86_CPU(dev);

    PCMachineState *pcms = PC_MACHINE(hotplug_dev);



    if (pcms->acpi_dev) {
@@ -1831,8 +1829,8 @@ static void pc_cpu_plug(HotplugHandler *hotplug_dev, 
        fw_cfg_modify_i16(pcms->fw_cfg, FW_CFG_NB_CPUS, pcms->boot_cpus);

    }



    found_cpu = pc_find_cpu_slot(pcms, CPU(dev), NULL);

    found_cpu->cpu = CPU(dev);

    found_cpu = pc_find_cpu_slot(MACHINE(pcms), cpu->apic_id, NULL);

    found_cpu->cpu = OBJECT(dev);

out:

    error_propagate(errp, local_err);

}
@@ -1842,9 +1840,10 @@ static void pc_cpu_unplug_request_cb(HotplugHandler *hotplug_dev, 
    int idx = -1;

    HotplugHandlerClass *hhc;

    Error *local_err = NULL;

    X86CPU *cpu = X86_CPU(dev);

    PCMachineState *pcms = PC_MACHINE(hotplug_dev);



    pc_find_cpu_slot(pcms, CPU(dev), &idx);

    pc_find_cpu_slot(MACHINE(pcms), cpu->apic_id, &idx);

    assert(idx != -1);

    if (idx == 0) {

        error_setg(&local_err, "Boot CPU is unpluggable");
@@ -1869,6 +1868,7 @@ static void pc_cpu_unplug_cb(HotplugHandler *hotplug_dev, 
    CPUArchId *found_cpu;

    HotplugHandlerClass *hhc;

    Error *local_err = NULL;

    X86CPU *cpu = X86_CPU(dev);

    PCMachineState *pcms = PC_MACHINE(hotplug_dev);



    hhc = HOTPLUG_HANDLER_GET_CLASS(pcms->acpi_dev);
@@ -1878,7 +1878,7 @@ static void pc_cpu_unplug_cb(HotplugHandler *hotplug_dev, 
        goto out;

    }



    found_cpu = pc_find_cpu_slot(pcms, CPU(dev), NULL);

    found_cpu = pc_find_cpu_slot(MACHINE(pcms), cpu->apic_id, NULL);

    found_cpu->cpu = NULL;

    object_unparent(OBJECT(dev));
@@ -1936,13 +1936,15 @@ static void pc_cpu_pre_plug(HotplugHandler *hotplug_dev, 
        cpu->apic_id = apicid_from_topo_ids(smp_cores, smp_threads, &topo);

    }



    cpu_slot = pc_find_cpu_slot(pcms, CPU(dev), &idx);

    cpu_slot = pc_find_cpu_slot(MACHINE(pcms), cpu->apic_id, &idx);

    if (!cpu_slot) {

        MachineState *ms = MACHINE(pcms);



        x86_topo_ids_from_apicid(cpu->apic_id, smp_cores, smp_threads, &topo);

        error_setg(errp, "Invalid CPU [socket: %u, core: %u, thread: %u] with"

                  " APIC ID %" PRIu32 ", valid index range 0:%d",

                   topo.pkg_id, topo.core_id, topo.smt_id, cpu->apic_id,

                   pcms->possible_cpus->len - 1);

                   ms->possible_cpus->len - 1);

        return;

    }
@@ -1953,7 +1955,7 @@ static void pc_cpu_pre_plug(HotplugHandler *hotplug_dev, 
    }



    /* if 'address' properties socket-id/core-id/thread-id are not set, set them

     * so that query_hotpluggable_cpus would show correct values

     * so that machine_query_hotpluggable_cpus would show correct values

     */

    /* TODO: move socket_id/core_id/thread_id checks into x86_cpu_realizefn()

     * once -smp refactoring is complete and there will be CPU private
@@ -2251,55 +2253,37 @@ static unsigned pc_cpu_index_to_socket_id(unsigned cpu_index) 
    return topo.pkg_id;

}



static const CPUArchIdList *pc_possible_cpu_arch_ids(MachineState *machine)

{

    PCMachineState *pcms = PC_MACHINE(machine);

    assert(pcms->possible_cpus);

    return pcms->possible_cpus;

}



static HotpluggableCPUList *pc_query_hotpluggable_cpus(MachineState *machine)

static const CPUArchIdList *pc_possible_cpu_arch_ids(MachineState *ms)

{

    int i;

    CPUState *cpu;

    HotpluggableCPUList *head = NULL;

    PCMachineState *pcms = PC_MACHINE(machine);

    const char *cpu_type;



    cpu = pcms->possible_cpus->cpus[0].cpu;

    assert(cpu); /* BSP is always present */

    cpu_type = object_class_get_name(OBJECT_CLASS(CPU_GET_CLASS(cpu)));

    if (ms->possible_cpus) {

        /*

         * make sure that max_cpus hasn't changed since the first use, i.e.

         * -smp hasn't been parsed after it

        */

        assert(ms->possible_cpus->len == max_cpus);

        return ms->possible_cpus;

    }



    for (i = 0; i < pcms->possible_cpus->len; i++) {

    ms->possible_cpus = g_malloc0(sizeof(CPUArchIdList) +

                                  sizeof(CPUArchId) * max_cpus);

    ms->possible_cpus->len = max_cpus;

    for (i = 0; i < ms->possible_cpus->len; i++) {

        X86CPUTopoInfo topo;

        HotpluggableCPUList *list_item = g_new0(typeof(*list_item), 1);

        HotpluggableCPU *cpu_item = g_new0(typeof(*cpu_item), 1);

        CpuInstanceProperties *cpu_props = g_new0(typeof(*cpu_props), 1);

        const uint32_t apic_id = pcms->possible_cpus->cpus[i].arch_id;



        x86_topo_ids_from_apicid(apic_id, smp_cores, smp_threads, &topo);



        cpu_item->type = g_strdup(cpu_type);

        cpu_item->vcpus_count = 1;

        cpu_props->has_socket_id = true;

        cpu_props->socket_id = topo.pkg_id;

        cpu_props->has_core_id = true;

        cpu_props->core_id = topo.core_id;

        cpu_props->has_thread_id = true;

        cpu_props->thread_id = topo.smt_id;

        cpu_item->props = cpu_props;



        cpu = pcms->possible_cpus->cpus[i].cpu;

        if (cpu) {

            cpu_item->has_qom_path = true;

            cpu_item->qom_path = object_get_canonical_path(OBJECT(cpu));

        }



        list_item->value = cpu_item;

        list_item->next = head;

        head = list_item;

        ms->possible_cpus->cpus[i].vcpus_count = 1;

        ms->possible_cpus->cpus[i].arch_id = x86_cpu_apic_id_from_index(i);

        x86_topo_ids_from_apicid(ms->possible_cpus->cpus[i].arch_id,

                                 smp_cores, smp_threads, &topo);

        ms->possible_cpus->cpus[i].props.has_socket_id = true;

        ms->possible_cpus->cpus[i].props.socket_id = topo.pkg_id;

        ms->possible_cpus->cpus[i].props.has_core_id = true;

        ms->possible_cpus->cpus[i].props.core_id = topo.core_id;

        ms->possible_cpus->cpus[i].props.has_thread_id = true;

        ms->possible_cpus->cpus[i].props.thread_id = topo.smt_id;

    }

    return head;

    return ms->possible_cpus;

}



static void x86_nmi(NMIState *n, int cpu_index, Error **errp)
@@ -2342,7 +2326,7 @@ static void pc_machine_class_init(ObjectClass *oc, void *data) 
    mc->get_hotplug_handler = pc_get_hotpug_handler;

    mc->cpu_index_to_socket_id = pc_cpu_index_to_socket_id;

    mc->possible_cpu_arch_ids = pc_possible_cpu_arch_ids;

    mc->query_hotpluggable_cpus = pc_query_hotpluggable_cpus;

    mc->has_hotpluggable_cpus = true;

    mc->default_boot_order = "cad";

    mc->hot_add_cpu = pc_hot_add_cpu;

    mc->block_default_type = IF_IDE;

hw/net/spapr_llan.c

+12 −6
Original line number Diff line number Diff line
@@ -385,18 +385,24 @@ static int spapr_vlan_devnode(VIOsPAPRDevice *dev, void *fdt, int node_off) 
    int ret;



    /* Some old phyp versions give the mac address in an 8-byte

     * property.  The kernel driver has an insane workaround for this;

     * property.  The kernel driver (before 3.10) has an insane workaround;

     * rather than doing the obvious thing and checking the property

     * length, it checks whether the first byte has 0b10 in the low

     * bits.  If a correct 6-byte property has a different first byte

     * the kernel will get the wrong mac address, overrunning its

     * buffer in the process (read only, thank goodness).

     *

     * Here we workaround the kernel workaround by always supplying an

     * 8-byte property, with the mac address in the last six bytes */

     * Here we return a 6-byte address unless that would break a pre-3.10

     * driver.  In that case we return a padded 8-byte address to allow the old

     * workaround to succeed. */

    if ((vdev->nicconf.macaddr.a[0] & 0x3) == 0x2) {

        ret = fdt_setprop(fdt, node_off, "local-mac-address",

                          &vdev->nicconf.macaddr, ETH_ALEN);

    } else {

        memcpy(&padded_mac[2], &vdev->nicconf.macaddr, ETH_ALEN);

        ret = fdt_setprop(fdt, node_off, "local-mac-address",

                          padded_mac, sizeof(padded_mac));

    }

    if (ret < 0) {

        return ret;

    }