Changeset 31687


Ignore:
Timestamp:
Mar 16, 2017, 11:41:12 PM (3 months ago)
Author:
brainslayer
Message:

update kernel

Location:
src/linux/universal
Files:
88 edited

Legend:

Unmodified
Added
Removed
  • src/linux/universal/linux-4.4/Makefile

    r31677 r31687  
    11VERSION = 4
    22PATCHLEVEL = 4
    3 SUBLEVEL = 54
    4 EXTRAVERSION =
     3SUBLEVEL = 55
     4EXTRAVERSION = -rc1
    55NAME = Blurry Fish Butt
    66
  • src/linux/universal/linux-4.4/arch/mips/configs/ip22_defconfig

    r28606 r31687  
    6969CONFIG_NF_CONNTRACK_SECMARK=y
    7070CONFIG_NF_CONNTRACK_EVENTS=y
    71 CONFIG_NF_CT_PROTO_DCCP=m
    72 CONFIG_NF_CT_PROTO_UDPLITE=m
     71CONFIG_NF_CT_PROTO_DCCP=y
     72CONFIG_NF_CT_PROTO_UDPLITE=y
    7373CONFIG_NF_CONNTRACK_AMANDA=m
    7474CONFIG_NF_CONNTRACK_FTP=m
  • src/linux/universal/linux-4.4/arch/mips/configs/ip27_defconfig

    r28606 r31687  
    135135CONFIG_SCSI_PMCRAID=m
    136136CONFIG_SCSI_BFA_FC=m
    137 CONFIG_SCSI_DH=m
     137CONFIG_SCSI_DH=y
    138138CONFIG_SCSI_DH_RDAC=m
    139139CONFIG_SCSI_DH_HP_SW=m
     
    207207CONFIG_TEHUTI=m
    208208CONFIG_BNX2X=m
    209 CONFIG_QLGE=m
    210209CONFIG_SFC=m
    211210CONFIG_BE2NET=m
  • src/linux/universal/linux-4.4/arch/mips/configs/lemote2f_defconfig

    r28606 r31687  
    4040CONFIG_CPU_FREQ=y
    4141CONFIG_CPU_FREQ_DEBUG=y
    42 CONFIG_CPU_FREQ_STAT=m
     42CONFIG_CPU_FREQ_STAT=y
    4343CONFIG_CPU_FREQ_STAT_DETAILS=y
    4444CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND=y
  • src/linux/universal/linux-4.4/arch/mips/configs/malta_defconfig

    r28606 r31687  
    6060CONFIG_NF_CONNTRACK_SECMARK=y
    6161CONFIG_NF_CONNTRACK_EVENTS=y
    62 CONFIG_NF_CT_PROTO_DCCP=m
    63 CONFIG_NF_CT_PROTO_UDPLITE=m
     62CONFIG_NF_CT_PROTO_DCCP=y
     63CONFIG_NF_CT_PROTO_UDPLITE=y
    6464CONFIG_NF_CONNTRACK_AMANDA=m
    6565CONFIG_NF_CONNTRACK_FTP=m
  • src/linux/universal/linux-4.4/arch/mips/configs/malta_kvm_defconfig

    r28606 r31687  
    6161CONFIG_NF_CONNTRACK_SECMARK=y
    6262CONFIG_NF_CONNTRACK_EVENTS=y
    63 CONFIG_NF_CT_PROTO_DCCP=m
    64 CONFIG_NF_CT_PROTO_UDPLITE=m
     63CONFIG_NF_CT_PROTO_DCCP=y
     64CONFIG_NF_CT_PROTO_UDPLITE=y
    6565CONFIG_NF_CONNTRACK_AMANDA=m
    6666CONFIG_NF_CONNTRACK_FTP=m
  • src/linux/universal/linux-4.4/arch/mips/configs/malta_kvm_guest_defconfig

    r28606 r31687  
    6060CONFIG_NF_CONNTRACK_SECMARK=y
    6161CONFIG_NF_CONNTRACK_EVENTS=y
    62 CONFIG_NF_CT_PROTO_DCCP=m
    63 CONFIG_NF_CT_PROTO_UDPLITE=m
     62CONFIG_NF_CT_PROTO_DCCP=y
     63CONFIG_NF_CT_PROTO_UDPLITE=y
    6464CONFIG_NF_CONNTRACK_AMANDA=m
    6565CONFIG_NF_CONNTRACK_FTP=m
  • src/linux/universal/linux-4.4/arch/mips/configs/maltaup_xpa_defconfig

    r28606 r31687  
    6262CONFIG_NF_CONNTRACK_SECMARK=y
    6363CONFIG_NF_CONNTRACK_EVENTS=y
    64 CONFIG_NF_CT_PROTO_DCCP=m
    65 CONFIG_NF_CT_PROTO_UDPLITE=m
     64CONFIG_NF_CT_PROTO_DCCP=y
     65CONFIG_NF_CT_PROTO_UDPLITE=y
    6666CONFIG_NF_CONNTRACK_AMANDA=m
    6767CONFIG_NF_CONNTRACK_FTP=m
  • src/linux/universal/linux-4.4/arch/mips/configs/nlm_xlp_defconfig

    r28606 r31687  
    112112CONFIG_NF_CONNTRACK_SECMARK=y
    113113CONFIG_NF_CONNTRACK_EVENTS=y
    114 CONFIG_NF_CT_PROTO_UDPLITE=m
     114CONFIG_NF_CT_PROTO_UDPLITE=y
    115115CONFIG_NF_CONNTRACK_AMANDA=m
    116116CONFIG_NF_CONNTRACK_FTP=m
  • src/linux/universal/linux-4.4/arch/mips/configs/nlm_xlr_defconfig

    r28606 r31687  
    9292CONFIG_NF_CONNTRACK_SECMARK=y
    9393CONFIG_NF_CONNTRACK_EVENTS=y
    94 CONFIG_NF_CT_PROTO_UDPLITE=m
     94CONFIG_NF_CT_PROTO_UDPLITE=y
    9595CONFIG_NF_CONNTRACK_AMANDA=m
    9696CONFIG_NF_CONNTRACK_FTP=m
  • src/linux/universal/linux-4.4/arch/mips/dec/int-handler.S

    r28606 r31687  
    147147                 * Find irq with highest priority
    148148                 */
    149                  PTR_LA t1,cpu_mask_nr_tbl
     149                # open coded PTR_LA t1, cpu_mask_nr_tbl
     150#if (_MIPS_SZPTR == 32)
     151                # open coded la t1, cpu_mask_nr_tbl
     152                lui     t1, %hi(cpu_mask_nr_tbl)
     153                addiu   t1, %lo(cpu_mask_nr_tbl)
     154
     155#endif
     156#if (_MIPS_SZPTR == 64)
     157                # open coded dla t1, cpu_mask_nr_tbl
     158                .set    push
     159                .set    noat
     160                lui     t1, %highest(cpu_mask_nr_tbl)
     161                lui     AT, %hi(cpu_mask_nr_tbl)
     162                daddiu  t1, t1, %higher(cpu_mask_nr_tbl)
     163                daddiu  AT, AT, %lo(cpu_mask_nr_tbl)
     164                dsll    t1, 32
     165                daddu   t1, t1, AT
     166                .set    pop
     167#endif
    1501681:              lw      t2,(t1)
    151169                nop
     
    196214                 * Find irq with highest priority
    197215                 */
    198                  PTR_LA t1,asic_mask_nr_tbl
     216                # open coded PTR_LA t1,asic_mask_nr_tbl
     217#if (_MIPS_SZPTR == 32)
     218                # open coded la t1, asic_mask_nr_tbl
     219                lui     t1, %hi(asic_mask_nr_tbl)
     220                addiu   t1, %lo(asic_mask_nr_tbl)
     221
     222#endif
     223#if (_MIPS_SZPTR == 64)
     224                # open coded dla t1, asic_mask_nr_tbl
     225                .set    push
     226                .set    noat
     227                lui     t1, %highest(asic_mask_nr_tbl)
     228                lui     AT, %hi(asic_mask_nr_tbl)
     229                daddiu  t1, t1, %higher(asic_mask_nr_tbl)
     230                daddiu  AT, AT, %lo(asic_mask_nr_tbl)
     231                dsll    t1, 32
     232                daddu   t1, t1, AT
     233                .set    pop
     234#endif
    1992352:              lw      t2,(t1)
    200236                nop
  • src/linux/universal/linux-4.4/arch/mips/netlogic/common/reset.S

    r28606 r31687  
    5151#include <asm/netlogic/xlp-hal/cpucontrol.h>
    5252
    53 #define CP0_EBASE       $15
    5453#define SYS_CPU_COHERENT_BASE   CKSEG1ADDR(XLP_DEFAULT_IO_BASE) + \
    5554                        XLP_IO_SYS_OFFSET(0) + XLP_IO_PCI_HDRSZ + \
     
    9392 */
    9493.macro  xlp_flush_l1_dcache
    95         mfc0    t0, CP0_EBASE, 0
     94        mfc0    t0, CP0_PRID
    9695        andi    t0, t0, PRID_IMP_MASK
    9796        slt     t1, t0, 0x1200
     
    172171
    1731721:      /* Entry point on core wakeup */
    174         mfc0    t0, CP0_EBASE, 0        /* processor ID */
     173        mfc0    t0, CP0_PRID            /* processor ID */
    175174        andi    t0, PRID_IMP_MASK
    176175        li      t1, 0x1500              /* XLP 9xx */
     
    183182
    184183        /* set bit in SYS coherent register for the core */
    185         mfc0    t0, CP0_EBASE, 1
    186         mfc0    t1, CP0_EBASE, 1
     184        mfc0    t0, CP0_EBASE
     185        mfc0    t1, CP0_EBASE
    187186        srl     t1, 5
    188187        andi    t1, 0x3                 /* t1 <- node */
     
    233232         * NOTE: All GPR contents are lost after the mtcr above!
    234233         */
    235         mfc0    v0, CP0_EBASE, 1
     234        mfc0    v0, CP0_EBASE
    236235        andi    v0, 0x3ff               /* v0 <- node/core */
    237236
  • src/linux/universal/linux-4.4/arch/mips/netlogic/common/smpboot.S

    r28606 r31687  
    4949#include <asm/netlogic/xlp-hal/cpucontrol.h>
    5050
    51 #define CP0_EBASE       $15
    52 
    5351        .set    noreorder
    5452        .set    noat
     
    8785
    8886        /* a0 has the processor id */
    89         mfc0    a0, CP0_EBASE, 1
     87        mfc0    a0, CP0_EBASE
    9088        andi    a0, 0x3ff               /* a0 <- node/core */
    9189        PTR_LA  t0, nlm_early_init_secondary
  • src/linux/universal/linux-4.4/arch/mips/sgi-ip22/Platform

    r28606 r31687  
    2626#
    2727ifdef CONFIG_SGI_IP28
    28   ifeq ($(call cc-option-yn,-mr10k-cache-barrier=store), n)
     28  ifeq ($(call cc-option-yn,-march=r10000 -mr10k-cache-barrier=store), n)
    2929      $(error gcc doesn't support needed option -mr10k-cache-barrier=store)
    3030  endif
  • src/linux/universal/linux-4.4/arch/powerpc/lib/sstep.c

    r28606 r31687  
    18071807
    18081808        case LARX:
    1809                 if (regs->msr & MSR_LE)
    1810                         return 0;
    18111809                if (op.ea & (size - 1))
    18121810                        break;          /* can't handle misaligned */
     
    18301828
    18311829        case STCX:
    1832                 if (regs->msr & MSR_LE)
    1833                         return 0;
    18341830                if (op.ea & (size - 1))
    18351831                        break;          /* can't handle misaligned */
     
    18551851
    18561852        case LOAD:
    1857                 if (regs->msr & MSR_LE)
    1858                         return 0;
    18591853                err = read_mem(&regs->gpr[op.reg], op.ea, size, regs);
    18601854                if (!err) {
     
    18681862#ifdef CONFIG_PPC_FPU
    18691863        case LOAD_FP:
    1870                 if (regs->msr & MSR_LE)
    1871                         return 0;
    18721864                if (size == 4)
    18731865                        err = do_fp_load(op.reg, do_lfs, op.ea, size, regs);
     
    18781870#ifdef CONFIG_ALTIVEC
    18791871        case LOAD_VMX:
    1880                 if (regs->msr & MSR_LE)
    1881                         return 0;
    18821872                err = do_vec_load(op.reg, do_lvx, op.ea & ~0xfUL, regs);
    18831873                goto ldst_done;
     
    18851875#ifdef CONFIG_VSX
    18861876        case LOAD_VSX:
    1887                 if (regs->msr & MSR_LE)
    1888                         return 0;
    18891877                err = do_vsx_load(op.reg, do_lxvd2x, op.ea, regs);
    18901878                goto ldst_done;
     
    19091897
    19101898        case STORE:
    1911                 if (regs->msr & MSR_LE)
    1912                         return 0;
    19131899                if ((op.type & UPDATE) && size == sizeof(long) &&
    19141900                    op.reg == 1 && op.update_reg == 1 &&
     
    19231909#ifdef CONFIG_PPC_FPU
    19241910        case STORE_FP:
    1925                 if (regs->msr & MSR_LE)
    1926                         return 0;
    19271911                if (size == 4)
    19281912                        err = do_fp_store(op.reg, do_stfs, op.ea, size, regs);
     
    19331917#ifdef CONFIG_ALTIVEC
    19341918        case STORE_VMX:
    1935                 if (regs->msr & MSR_LE)
    1936                         return 0;
    19371919                err = do_vec_store(op.reg, do_stvx, op.ea & ~0xfUL, regs);
    19381920                goto ldst_done;
     
    19401922#ifdef CONFIG_VSX
    19411923        case STORE_VSX:
    1942                 if (regs->msr & MSR_LE)
    1943                         return 0;
    19441924                err = do_vsx_store(op.reg, do_stxvd2x, op.ea, regs);
    19451925                goto ldst_done;
  • src/linux/universal/linux-4.4/arch/s390/kernel/crash_dump.c

    r28606 r31687  
    2323#define PTR_SUB(x, y) (((char *) (x)) - ((unsigned long) (y)))
    2424#define PTR_DIFF(x, y) ((unsigned long)(((char *) (x)) - ((unsigned long) (y))))
     25
     26#define LINUX_NOTE_NAME "LINUX"
    2527
    2628static struct memblock_region oldmem_region;
     
    313315{
    314316        return nt_init(ptr, NT_S390_TIMER, &sa->timer, sizeof(sa->timer),
    315                          KEXEC_CORE_NOTE_NAME);
     317                         LINUX_NOTE_NAME);
    316318}
    317319
     
    322324{
    323325        return nt_init(ptr, NT_S390_TODCMP, &sa->clk_cmp,
    324                        sizeof(sa->clk_cmp), KEXEC_CORE_NOTE_NAME);
     326                       sizeof(sa->clk_cmp), LINUX_NOTE_NAME);
    325327}
    326328
     
    331333{
    332334        return nt_init(ptr, NT_S390_TODPREG, &sa->tod_reg,
    333                        sizeof(sa->tod_reg), KEXEC_CORE_NOTE_NAME);
     335                       sizeof(sa->tod_reg), LINUX_NOTE_NAME);
    334336}
    335337
     
    340342{
    341343        return nt_init(ptr, NT_S390_CTRS, &sa->ctrl_regs,
    342                        sizeof(sa->ctrl_regs), KEXEC_CORE_NOTE_NAME);
     344                       sizeof(sa->ctrl_regs), LINUX_NOTE_NAME);
    343345}
    344346
     
    349351{
    350352        return nt_init(ptr, NT_S390_PREFIX, &sa->pref_reg,
    351                          sizeof(sa->pref_reg), KEXEC_CORE_NOTE_NAME);
     353                         sizeof(sa->pref_reg), LINUX_NOTE_NAME);
    352354}
    353355
     
    358360{
    359361        return nt_init(ptr, NT_S390_VXRS_HIGH, &vx_regs[16],
    360                        16 * sizeof(__vector128), KEXEC_CORE_NOTE_NAME);
     362                       16 * sizeof(__vector128), LINUX_NOTE_NAME);
    361363}
    362364
     
    371373
    372374        note = (Elf64_Nhdr *)ptr;
    373         note->n_namesz = strlen(KEXEC_CORE_NOTE_NAME) + 1;
     375        note->n_namesz = strlen(LINUX_NOTE_NAME) + 1;
    374376        note->n_descsz = 16 * 8;
    375377        note->n_type = NT_S390_VXRS_LOW;
    376378        len = sizeof(Elf64_Nhdr);
    377379
    378         memcpy(ptr + len, KEXEC_CORE_NOTE_NAME, note->n_namesz);
     380        memcpy(ptr + len, LINUX_NOTE_NAME, note->n_namesz);
    379381        len = roundup(len + note->n_namesz, 4);
    380382
  • src/linux/universal/linux-4.4/arch/s390/mm/pgtable.c

    r30802 r31687  
    12381238bool gmap_test_and_clear_dirty(unsigned long address, struct gmap *gmap)
    12391239{
     1240        pgd_t *pgd;
     1241        pud_t *pud;
     1242        pmd_t *pmd;
    12401243        pte_t *pte;
    12411244        spinlock_t *ptl;
    12421245        bool dirty = false;
    12431246
    1244         pte = get_locked_pte(gmap->mm, address, &ptl);
     1247        pgd = pgd_offset(gmap->mm, address);
     1248        pud = pud_alloc(gmap->mm, pgd, address);
     1249        if (!pud)
     1250                return false;
     1251        pmd = pmd_alloc(gmap->mm, pud, address);
     1252        if (!pmd)
     1253                return false;
     1254        /* We can't run guests backed by huge pages, but userspace can
     1255         * still set them up and then try to migrate them without any
     1256         * migration support.
     1257         */
     1258        if (pmd_large(*pmd))
     1259                return true;
     1260
     1261        pte = pte_alloc_map_lock(gmap->mm, pmd, address, &ptl);
    12451262        if (unlikely(!pte))
    12461263                return false;
  • src/linux/universal/linux-4.4/crypto/Makefile

    r30947 r31687  
    6363obj-$(CONFIG_CRYPTO_SHA512) += sha512_generic.o
    6464obj-$(CONFIG_CRYPTO_WP512) += wp512.o
     65CFLAGS_wp512.o := $(call cc-option,-fno-schedule-insns)  # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79149
    6566obj-$(CONFIG_CRYPTO_TGR192) += tgr192.o
    6667obj-$(CONFIG_CRYPTO_GF128MUL) += gf128mul.o
     
    8687obj-$(CONFIG_CRYPTO_TWOFISH_COMMON) += twofish_common.o
    8788obj-$(CONFIG_CRYPTO_SERPENT) += serpent_generic.o
     89CFLAGS_serpent_generic.o := $(call cc-option,-fsched-pressure)  # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79149
    8890obj-$(CONFIG_CRYPTO_AES) += aes_generic.o
    8991obj-$(CONFIG_CRYPTO_CAMELLIA) += camellia_generic.o
  • src/linux/universal/linux-4.4/drivers/acpi/nfit.c

    r30802 r31687  
    966966}
    967967
    968 static int cmp_map(const void *m0, const void *m1)
     968static int cmp_map_compat(const void *m0, const void *m1)
    969969{
    970970        const struct nfit_set_info_map *map0 = m0;
     
    973973        return memcmp(&map0->region_offset, &map1->region_offset,
    974974                        sizeof(u64));
     975}
     976
     977static int cmp_map(const void *m0, const void *m1)
     978{
     979        const struct nfit_set_info_map *map0 = m0;
     980        const struct nfit_set_info_map *map1 = m1;
     981
     982        return map0->region_offset - map1->region_offset;
    975983}
    976984
     
    10301038                        cmp_map, NULL);
    10311039        nd_set->cookie = nd_fletcher64(info, sizeof_nfit_set_info(nr), 0);
     1040
     1041        /* support namespaces created with the wrong sort order */
     1042        sort(&info->mapping[0], nr, sizeof(struct nfit_set_info_map),
     1043                        cmp_map_compat, NULL);
     1044        nd_set->altcookie = nd_fletcher64(info, sizeof_nfit_set_info(nr), 0);
     1045
    10321046        ndr_desc->nd_set = nd_set;
    10331047        devm_kfree(dev, info);
  • src/linux/universal/linux-4.4/drivers/md/dm.c

    r30871 r31687  
    14681468EXPORT_SYMBOL_GPL(dm_accept_partial_bio);
    14691469
     1470/*
     1471 * Flush current->bio_list when the target map method blocks.
     1472 * This fixes deadlocks in snapshot and possibly in other targets.
     1473 */
     1474struct dm_offload {
     1475        struct blk_plug plug;
     1476        struct blk_plug_cb cb;
     1477};
     1478
     1479static void flush_current_bio_list(struct blk_plug_cb *cb, bool from_schedule)
     1480{
     1481        struct dm_offload *o = container_of(cb, struct dm_offload, cb);
     1482        struct bio_list list;
     1483        struct bio *bio;
     1484
     1485        INIT_LIST_HEAD(&o->cb.list);
     1486
     1487        if (unlikely(!current->bio_list))
     1488                return;
     1489
     1490        list = *current->bio_list;
     1491        bio_list_init(current->bio_list);
     1492
     1493        while ((bio = bio_list_pop(&list))) {
     1494                struct bio_set *bs = bio->bi_pool;
     1495                if (unlikely(!bs) || bs == fs_bio_set) {
     1496                        bio_list_add(current->bio_list, bio);
     1497                        continue;
     1498                }
     1499
     1500                spin_lock(&bs->rescue_lock);
     1501                bio_list_add(&bs->rescue_list, bio);
     1502                queue_work(bs->rescue_workqueue, &bs->rescue_work);
     1503                spin_unlock(&bs->rescue_lock);
     1504        }
     1505}
     1506
     1507static void dm_offload_start(struct dm_offload *o)
     1508{
     1509        blk_start_plug(&o->plug);
     1510        o->cb.callback = flush_current_bio_list;
     1511        list_add(&o->cb.list, &current->plug->cb_list);
     1512}
     1513
     1514static void dm_offload_end(struct dm_offload *o)
     1515{
     1516        list_del(&o->cb.list);
     1517        blk_finish_plug(&o->plug);
     1518}
     1519
    14701520static void __map_bio(struct dm_target_io *tio)
    14711521{
     
    14731523        sector_t sector;
    14741524        struct mapped_device *md;
     1525        struct dm_offload o;
    14751526        struct bio *clone = &tio->clone;
    14761527        struct dm_target *ti = tio->ti;
     
    14851536        atomic_inc(&tio->io->io_count);
    14861537        sector = clone->bi_iter.bi_sector;
     1538
     1539        dm_offload_start(&o);
    14871540        r = ti->type->map(ti, clone);
     1541        dm_offload_end(&o);
     1542
    14881543        if (r == DM_MAPIO_REMAPPED) {
    14891544                /* the bio has been remapped so dispatch it */
  • src/linux/universal/linux-4.4/drivers/mtd/maps/pmcmsp-flash.c

    r30708 r31687  
    140140
    141141                msp_maps[i].bankwidth = 1;
    142                 msp_maps[i].name = kmalloc(7, GFP_KERNEL);
     142                msp_maps[i].name = kstrndup(flash_name, 7, GFP_KERNEL);
    143143                if (!msp_maps[i].name) {
    144144                        iounmap(msp_maps[i].virt);
     
    146146                        goto cleanup_loop;
    147147                }
    148 
    149                 msp_maps[i].name = strncpy(msp_maps[i].name, flash_name, 7);
    150148
    151149                for (j = 0; j < pcnt; j++) {
  • src/linux/universal/linux-4.4/drivers/net/ethernet/ti/cpmac.c

    r31121 r31687  
    12381238        }
    12391239
    1240 #warning FIXME: unhardcode gpio&reset bits
     1240        /* FIXME: unhardcode gpio&reset bits */
    12411241        ar7_gpio_disable(26);
    12421242        ar7_gpio_disable(27);
  • src/linux/universal/linux-4.4/drivers/nvdimm/namespace_devs.c

    r29166 r31687  
    15351535                struct nd_namespace_pmem *nspm)
    15361536{
     1537        u64 altcookie = nd_region_interleave_set_altcookie(nd_region);
    15371538        u64 cookie = nd_region_interleave_set_cookie(nd_region);
    15381539        struct nd_namespace_label *nd_label;
     
    15431544        u16 i;
    15441545
    1545         if (cookie == 0)
     1546        if (cookie == 0) {
     1547                dev_dbg(&nd_region->dev, "invalid interleave-set-cookie\n");
    15461548                return -ENXIO;
     1549        }
    15471550
    15481551        /*
     
    15531556                u64 isetcookie = __le64_to_cpu(nd_label->isetcookie);
    15541557
    1555                 if (isetcookie != cookie)
    1556                         continue;
    1557 
    1558                 for (i = 0; nd_region->ndr_mappings; i++)
    1559                         if (!has_uuid_at_pos(nd_region, nd_label->uuid,
    1560                                                 cookie, i))
    1561                                 break;
     1558                if (isetcookie != cookie) {
     1559                        dev_dbg(&nd_region->dev, "invalid cookie in label: %pUb\n",
     1560                                        nd_label->uuid);
     1561                        if (isetcookie != altcookie)
     1562                                continue;
     1563
     1564                        dev_dbg(&nd_region->dev, "valid altcookie in label: %pUb\n",
     1565                                        nd_label->uuid);
     1566                }
     1567
     1568                for (i = 0; nd_region->ndr_mappings; i++) {
     1569                        if (has_uuid_at_pos(nd_region, nd_label->uuid, cookie, i))
     1570                                continue;
     1571                        if (has_uuid_at_pos(nd_region, nd_label->uuid, altcookie, i))
     1572                                continue;
     1573                        break;
     1574                }
     1575
    15621576                if (i < nd_region->ndr_mappings) {
    15631577                        /*
  • src/linux/universal/linux-4.4/drivers/nvdimm/nd.h

    r28606 r31687  
    246246int nd_region_register_namespaces(struct nd_region *nd_region, int *err);
    247247u64 nd_region_interleave_set_cookie(struct nd_region *nd_region);
     248u64 nd_region_interleave_set_altcookie(struct nd_region *nd_region);
    248249void nvdimm_bus_lock(struct device *dev);
    249250void nvdimm_bus_unlock(struct device *dev);
  • src/linux/universal/linux-4.4/drivers/nvdimm/region_devs.c

    r29166 r31687  
    377377        if (nd_set)
    378378                return nd_set->cookie;
     379        return 0;
     380}
     381
     382u64 nd_region_interleave_set_altcookie(struct nd_region *nd_region)
     383{
     384        struct nd_interleave_set *nd_set = nd_region->nd_set;
     385
     386        if (nd_set)
     387                return nd_set->altcookie;
    379388        return 0;
    380389}
  • src/linux/universal/linux-4.4/drivers/scsi/mvsas/mv_sas.c

    r28606 r31687  
    738738                                SAS_ADDR(dev->sas_addr));
    739739
    740                         rc = SAS_PHY_DOWN;
    741                         return rc;
     740                rc = SAS_PHY_DOWN;
     741                return rc;
    742742        }
    743743        tei.port = dev->port->lldd_port;
  • src/linux/universal/linux-4.4/drivers/tty/serial/samsung.c

    r30452 r31687  
    10311031                ret = s3c24xx_serial_request_dma(ourport);
    10321032                if (ret < 0) {
    1033                         dev_warn(port->dev, "DMA request failed\n");
    1034                         return ret;
     1033                        dev_warn(port->dev,
     1034                                 "DMA request failed, DMA will not be used\n");
     1035                        devm_kfree(port->dev, ourport->dma);
     1036                        ourport->dma = NULL;
    10351037                }
    10361038        }
  • src/linux/universal/linux-4.4/drivers/usb/dwc3/gadget.h

    r28606 r31687  
    2929
    3030/* DEPCFG parameter 1 */
    31 #define DWC3_DEPCFG_INT_NUM(n)          ((n) << 0)
     31#define DWC3_DEPCFG_INT_NUM(n)          (((n) & 0x1f) << 0)
    3232#define DWC3_DEPCFG_XFER_COMPLETE_EN    (1 << 8)
    3333#define DWC3_DEPCFG_XFER_IN_PROGRESS_EN (1 << 9)
     
    3535#define DWC3_DEPCFG_FIFO_ERROR_EN       (1 << 11)
    3636#define DWC3_DEPCFG_STREAM_EVENT_EN     (1 << 13)
    37 #define DWC3_DEPCFG_BINTERVAL_M1(n)     ((n) << 16)
     37#define DWC3_DEPCFG_BINTERVAL_M1(n)     (((n) & 0xff) << 16)
    3838#define DWC3_DEPCFG_STREAM_CAPABLE      (1 << 24)
    39 #define DWC3_DEPCFG_EP_NUMBER(n)        ((n) << 25)
     39#define DWC3_DEPCFG_EP_NUMBER(n)        (((n) & 0x1f) << 25)
    4040#define DWC3_DEPCFG_BULK_BASED          (1 << 30)
    4141#define DWC3_DEPCFG_FIFO_BASED          (1 << 31)
    4242
    4343/* DEPCFG parameter 0 */
    44 #define DWC3_DEPCFG_EP_TYPE(n)          ((n) << 1)
    45 #define DWC3_DEPCFG_MAX_PACKET_SIZE(n)  ((n) << 3)
    46 #define DWC3_DEPCFG_FIFO_NUMBER(n)      ((n) << 17)
    47 #define DWC3_DEPCFG_BURST_SIZE(n)       ((n) << 22)
     44#define DWC3_DEPCFG_EP_TYPE(n)          (((n) & 0x3) << 1)
     45#define DWC3_DEPCFG_MAX_PACKET_SIZE(n)  (((n) & 0x7ff) << 3)
     46#define DWC3_DEPCFG_FIFO_NUMBER(n)      (((n) & 0x1f) << 17)
     47#define DWC3_DEPCFG_BURST_SIZE(n)       (((n) & 0xf) << 22)
    4848#define DWC3_DEPCFG_DATA_SEQ_NUM(n)     ((n) << 26)
    4949/* This applies for core versions earlier than 1.94a */
  • src/linux/universal/linux-4.4/drivers/usb/gadget/function/f_fs.c

    r31294 r31687  
    16441644        do {
    16451645                struct usb_endpoint_descriptor *ds;
     1646                struct usb_ss_ep_comp_descriptor *comp_desc = NULL;
     1647                int needs_comp_desc = false;
    16461648                int desc_idx;
    16471649
    1648                 if (ffs->gadget->speed == USB_SPEED_SUPER)
     1650                if (ffs->gadget->speed == USB_SPEED_SUPER) {
    16491651                        desc_idx = 2;
    1650                 else if (ffs->gadget->speed == USB_SPEED_HIGH)
     1652                        needs_comp_desc = true;
     1653                } else if (ffs->gadget->speed == USB_SPEED_HIGH)
    16511654                        desc_idx = 1;
    16521655                else
     
    16651668                ep->ep->driver_data = ep;
    16661669                ep->ep->desc = ds;
     1670
     1671                comp_desc = (struct usb_ss_ep_comp_descriptor *)(ds +
     1672                                USB_DT_ENDPOINT_SIZE);
     1673                ep->ep->maxburst = comp_desc->bMaxBurst + 1;
     1674
     1675                if (needs_comp_desc)
     1676                        ep->ep->comp_desc = comp_desc;
     1677
    16671678                ret = usb_ep_enable(ep->ep);
    16681679                if (likely(!ret)) {
  • src/linux/universal/linux-4.4/drivers/usb/gadget/udc/dummy_hcd.c

    r31121 r31687  
    10341034
    10351035        dum = *((void **)dev_get_platdata(&pdev->dev));
     1036        /* Clear usb_gadget region for new registration to udc-core */
     1037        memzero_explicit(&dum->gadget, sizeof(struct usb_gadget));
    10361038        dum->gadget.name = gadget_name;
    10371039        dum->gadget.ops = &dummy_ops;
  • src/linux/universal/linux-4.4/drivers/usb/host/xhci-dbg.c

    r28606 r31687  
    112112
    113113        /* xhci 1.1 controllers have the HCCPARAMS2 register */
    114         if (hci_version > 100) {
     114        if (hci_version > 0x100) {
    115115                temp = readl(&xhci->cap_regs->hcc_params2);
    116116                xhci_dbg(xhci, "HCC PARAMS2 0x%x:\n", (unsigned int) temp);
  • src/linux/universal/linux-4.4/drivers/usb/host/xhci-plat.c

    r31632 r31687  
    229229        struct clk *clk = xhci->clk;
    230230
     231        xhci->xhc_state |= XHCI_STATE_REMOVING;
     232
    231233        usb_remove_hcd(xhci->shared_hcd);
    232234        usb_phy_shutdown(hcd->usb_phy);
  • src/linux/universal/linux-4.4/drivers/usb/misc/iowarrior.c

    r29439 r31687  
    788788        dev->product_id = le16_to_cpu(udev->descriptor.idProduct);
    789789
    790         if (iface_desc->desc.bNumEndpoints < 1) {
    791                 dev_err(&interface->dev, "Invalid number of endpoints\n");
    792                 retval = -EINVAL;
    793                 goto error;
    794         }
    795 
    796790        /* set up the endpoint information */
    797791        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
     
    804798                        dev->int_out_endpoint = endpoint;
    805799        }
     800
     801        if (!dev->int_in_endpoint) {
     802                dev_err(&interface->dev, "no interrupt-in endpoint found\n");
     803                retval = -ENODEV;
     804                goto error;
     805        }
     806
     807        if (dev->product_id == USB_DEVICE_ID_CODEMERCS_IOW56) {
     808                if (!dev->int_out_endpoint) {
     809                        dev_err(&interface->dev, "no interrupt-out endpoint found\n");
     810                        retval = -ENODEV;
     811                        goto error;
     812                }
     813        }
     814
    806815        /* we have to check the report_size often, so remember it in the endianness suitable for our machine */
    807816        dev->report_size = usb_endpoint_maxp(dev->int_in_endpoint);
  • src/linux/universal/linux-4.4/drivers/usb/serial/digi_acceleport.c

    r29439 r31687  
    14841484        struct tty_struct *tty;
    14851485        struct digi_port *priv = usb_get_serial_port_data(port);
     1486        unsigned char *buf = urb->transfer_buffer;
    14861487        int opcode, line, status, val;
    14871488        int i;
    14881489        unsigned int rts;
    14891490
     1491        if (urb->actual_length < 4)
     1492                return -1;
     1493
    14901494        /* handle each oob command */
    1491         for (i = 0; i < urb->actual_length - 3;) {
    1492                 opcode = ((unsigned char *)urb->transfer_buffer)[i++];
    1493                 line = ((unsigned char *)urb->transfer_buffer)[i++];
    1494                 status = ((unsigned char *)urb->transfer_buffer)[i++];
    1495                 val = ((unsigned char *)urb->transfer_buffer)[i++];
     1495        for (i = 0; i < urb->actual_length - 3; i += 4) {
     1496                opcode = buf[i];
     1497                line = buf[i + 1];
     1498                status = buf[i + 2];
     1499                val = buf[i + 3];
    14961500
    14971501                dev_dbg(&port->dev, "digi_read_oob_callback: opcode=%d, line=%d, status=%d, val=%d\n",
  • src/linux/universal/linux-4.4/drivers/usb/serial/io_ti.c

    r31121 r31687  
    16751675        dev_dbg(dev, "%s - port_number %d, function %d, info 0x%x\n", __func__,
    16761676                port_number, function, data[1]);
     1677
     1678        if (port_number >= edge_serial->serial->num_ports) {
     1679                dev_err(dev, "bad port number %d\n", port_number);
     1680                goto exit;
     1681        }
     1682
    16771683        port = edge_serial->serial->port[port_number];
    16781684        edge_port = usb_get_serial_port_data(port);
     
    17561762        port_number = edge_port->port->port_number;
    17571763
    1758         if (edge_port->lsr_event) {
     1764        if (urb->actual_length > 0 && edge_port->lsr_event) {
    17591765                edge_port->lsr_event = 0;
    17601766                dev_dbg(dev, "%s ===== Port %u LSR Status = %02x, Data = %02x ======\n",
  • src/linux/universal/linux-4.4/drivers/usb/serial/omninet.c

    r31121 r31687  
    143143static int omninet_open(struct tty_struct *tty, struct usb_serial_port *port)
    144144{
    145         struct usb_serial       *serial = port->serial;
    146         struct usb_serial_port  *wport;
    147 
    148         wport = serial->port[1];
    149         tty_port_tty_set(&wport->port, tty);
    150 
    151145        return usb_serial_generic_open(tty, port);
    152146}
  • src/linux/universal/linux-4.4/drivers/usb/serial/safe_serial.c

    r28606 r31687  
    206206                goto out;
    207207
     208        if (length < 2) {
     209                dev_err(&port->dev, "malformed packet\n");
     210                return;
     211        }
     212
    208213        fcs = fcs_compute10(data, length, CRC10_INITFCS);
    209214        if (fcs) {
  • src/linux/universal/linux-4.4/fs/ext4/inode.c

    r31632 r31687  
    35733573        unsigned blocksize;
    35743574        struct inode *inode = mapping->host;
     3575
     3576        /* If we are processing an encrypted inode during orphan list handling */
     3577        if (ext4_encrypted_inode(inode) && !ext4_has_encryption_key(inode))
     3578                return 0;
    35753579
    35763580        blocksize = inode->i_sb->s_blocksize;
  • src/linux/universal/linux-4.4/include/linux/libnvdimm.h

    r28606 r31687  
    8484struct nd_interleave_set {
    8585        u64 cookie;
     86        /* compatibility with initial buggy Linux implementation */
     87        u64 altcookie;
    8688};
    8789
  • src/linux/universal/linux-4.4/include/trace/events/syscalls.h

    r28606 r31687  
    11#undef TRACE_SYSTEM
    22#define TRACE_SYSTEM raw_syscalls
     3#undef TRACE_INCLUDE_FILE
    34#define TRACE_INCLUDE_FILE syscalls
    45
  • src/linux/universal/linux-4.4/mm/memcontrol.c

    r31220 r31687  
    41514151}
    41524152
    4153 static struct mem_cgroup *mem_cgroup_id_get_online(struct mem_cgroup *memcg)
    4154 {
    4155         while (!atomic_inc_not_zero(&memcg->id.ref)) {
    4156                 /*
    4157                  * The root cgroup cannot be destroyed, so it's refcount must
    4158                  * always be >= 1.
    4159                  */
    4160                 if (WARN_ON_ONCE(memcg == root_mem_cgroup)) {
    4161                         VM_BUG_ON(1);
    4162                         break;
    4163                 }
    4164                 memcg = parent_mem_cgroup(memcg);
    4165                 if (!memcg)
    4166                         memcg = root_mem_cgroup;
    4167         }
    4168         return memcg;
    4169 }
    4170 
    41714153static void mem_cgroup_id_put_many(struct mem_cgroup *memcg, unsigned int n)
    41724154{
     
    57525734
    57535735#ifdef CONFIG_MEMCG_SWAP
     5736static struct mem_cgroup *mem_cgroup_id_get_online(struct mem_cgroup *memcg)
     5737{
     5738        while (!atomic_inc_not_zero(&memcg->id.ref)) {
     5739                /*
     5740                 * The root cgroup cannot be destroyed, so it's refcount must
     5741                 * always be >= 1.
     5742                 */
     5743                if (WARN_ON_ONCE(memcg == root_mem_cgroup)) {
     5744                        VM_BUG_ON(1);
     5745                        break;
     5746                }
     5747                memcg = parent_mem_cgroup(memcg);
     5748                if (!memcg)
     5749                        memcg = root_mem_cgroup;
     5750        }
     5751        return memcg;
     5752}
     5753
    57545754/**
    57555755 * mem_cgroup_swapout - transfer a memsw charge to swap
  • src/linux/universal/linux-4.9/Makefile

    r31677 r31687  
    11VERSION = 4
    22PATCHLEVEL = 9
    3 SUBLEVEL = 15
    4 EXTRAVERSION =
     3SUBLEVEL = 16
     4EXTRAVERSION = -rc1
    55NAME = Roaring Lionus
    66
  • src/linux/universal/linux-4.9/arch/mips/configs/ip22_defconfig

    r31574 r31687  
    6868CONFIG_NF_CONNTRACK_SECMARK=y
    6969CONFIG_NF_CONNTRACK_EVENTS=y
    70 CONFIG_NF_CT_PROTO_DCCP=m
    71 CONFIG_NF_CT_PROTO_UDPLITE=m
     70CONFIG_NF_CT_PROTO_DCCP=y
     71CONFIG_NF_CT_PROTO_UDPLITE=y
    7272CONFIG_NF_CONNTRACK_AMANDA=m
    7373CONFIG_NF_CONNTRACK_FTP=m
  • src/linux/universal/linux-4.9/arch/mips/configs/ip27_defconfig

    r31574 r31687  
    134134CONFIG_SCSI_PMCRAID=m
    135135CONFIG_SCSI_BFA_FC=m
    136 CONFIG_SCSI_DH=m
     136CONFIG_SCSI_DH=y
    137137CONFIG_SCSI_DH_RDAC=m
    138138CONFIG_SCSI_DH_HP_SW=m
     
    206206CONFIG_TEHUTI=m
    207207CONFIG_BNX2X=m
    208 CONFIG_QLGE=m
    209208CONFIG_SFC=m
    210209CONFIG_BE2NET=m
  • src/linux/universal/linux-4.9/arch/mips/configs/lemote2f_defconfig

    r31574 r31687  
    4040CONFIG_CPU_FREQ=y
    4141CONFIG_CPU_FREQ_DEBUG=y
    42 CONFIG_CPU_FREQ_STAT=m
     42CONFIG_CPU_FREQ_STAT=y
    4343CONFIG_CPU_FREQ_STAT_DETAILS=y
    4444CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND=y
  • src/linux/universal/linux-4.9/arch/mips/configs/malta_defconfig

    r31574 r31687  
    6060CONFIG_NF_CONNTRACK_SECMARK=y
    6161CONFIG_NF_CONNTRACK_EVENTS=y
    62 CONFIG_NF_CT_PROTO_DCCP=m
    63 CONFIG_NF_CT_PROTO_UDPLITE=m
     62CONFIG_NF_CT_PROTO_DCCP=y
     63CONFIG_NF_CT_PROTO_UDPLITE=y
    6464CONFIG_NF_CONNTRACK_AMANDA=m
    6565CONFIG_NF_CONNTRACK_FTP=m
  • src/linux/universal/linux-4.9/arch/mips/configs/malta_kvm_defconfig

    r31574 r31687  
    6161CONFIG_NF_CONNTRACK_SECMARK=y
    6262CONFIG_NF_CONNTRACK_EVENTS=y
    63 CONFIG_NF_CT_PROTO_DCCP=m
    64 CONFIG_NF_CT_PROTO_UDPLITE=m
     63CONFIG_NF_CT_PROTO_DCCP=y
     64CONFIG_NF_CT_PROTO_UDPLITE=y
    6565CONFIG_NF_CONNTRACK_AMANDA=m
    6666CONFIG_NF_CONNTRACK_FTP=m
  • src/linux/universal/linux-4.9/arch/mips/configs/malta_kvm_guest_defconfig

    r31574 r31687  
    6060CONFIG_NF_CONNTRACK_SECMARK=y
    6161CONFIG_NF_CONNTRACK_EVENTS=y
    62 CONFIG_NF_CT_PROTO_DCCP=m
    63 CONFIG_NF_CT_PROTO_UDPLITE=m
     62CONFIG_NF_CT_PROTO_DCCP=y
     63CONFIG_NF_CT_PROTO_UDPLITE=y
    6464CONFIG_NF_CONNTRACK_AMANDA=m
    6565CONFIG_NF_CONNTRACK_FTP=m
  • src/linux/universal/linux-4.9/arch/mips/configs/maltaup_xpa_defconfig

    r31574 r31687  
    6262CONFIG_NF_CONNTRACK_SECMARK=y
    6363CONFIG_NF_CONNTRACK_EVENTS=y
    64 CONFIG_NF_CT_PROTO_DCCP=m
    65 CONFIG_NF_CT_PROTO_UDPLITE=m
     64CONFIG_NF_CT_PROTO_DCCP=y
     65CONFIG_NF_CT_PROTO_UDPLITE=y
    6666CONFIG_NF_CONNTRACK_AMANDA=m
    6767CONFIG_NF_CONNTRACK_FTP=m
  • src/linux/universal/linux-4.9/arch/mips/configs/nlm_xlp_defconfig

    r31574 r31687  
    111111CONFIG_NF_CONNTRACK_SECMARK=y
    112112CONFIG_NF_CONNTRACK_EVENTS=y
    113 CONFIG_NF_CT_PROTO_UDPLITE=m
     113CONFIG_NF_CT_PROTO_UDPLITE=y
    114114CONFIG_NF_CONNTRACK_AMANDA=m
    115115CONFIG_NF_CONNTRACK_FTP=m
  • src/linux/universal/linux-4.9/arch/mips/configs/nlm_xlr_defconfig

    r31574 r31687  
    9191CONFIG_NF_CONNTRACK_SECMARK=y
    9292CONFIG_NF_CONNTRACK_EVENTS=y
    93 CONFIG_NF_CT_PROTO_UDPLITE=m
     93CONFIG_NF_CT_PROTO_UDPLITE=y
    9494CONFIG_NF_CONNTRACK_AMANDA=m
    9595CONFIG_NF_CONNTRACK_FTP=m
  • src/linux/universal/linux-4.9/arch/mips/include/asm/mach-ip27/spaces.h

    r31574 r31687  
    1313/*
    1414 * IP27 uses the R10000's uncached attribute feature.  Attribute 3 selects
    15  * uncached memory addressing.
     15 * uncached memory addressing. Hide the definitions on 32-bit compilation
     16 * of the compat-vdso code.
    1617 */
    17 
     18#ifdef CONFIG_64BIT
    1819#define HSPEC_BASE              0x9000000000000000
    1920#define IO_BASE                 0x9200000000000000
     
    2122#define UNCAC_BASE              0x9600000000000000
    2223#define CAC_BASE                0xa800000000000000
     24#endif
    2325
    2426#define TO_MSPEC(x)             (MSPEC_BASE | ((x) & TO_PHYS_MASK))
  • src/linux/universal/linux-4.9/arch/mips/ralink/timer.c

    r31574 r31687  
    7070}
    7171
    72 static void rt_timer_free(struct rt_timer *rt)
    73 {
    74         free_irq(rt->irq, rt);
    75 }
    76 
    7772static int rt_timer_config(struct rt_timer *rt, unsigned long divisor)
    7873{
     
    9893
    9994        return 0;
    100 }
    101 
    102 static void rt_timer_disable(struct rt_timer *rt)
    103 {
    104         u32 t;
    105 
    106         t = rt_timer_r32(rt, TIMER_REG_TMR0CTL);
    107         t &= ~TMR0CTL_ENABLE;
    108         rt_timer_w32(rt, TIMER_REG_TMR0CTL, t);
    10995}
    11096
  • src/linux/universal/linux-4.9/arch/mips/sgi-ip22/Platform

    r31574 r31687  
    2626#
    2727ifdef CONFIG_SGI_IP28
    28   ifeq ($(call cc-option-yn,-mr10k-cache-barrier=store), n)
     28  ifeq ($(call cc-option-yn,-march=r10000 -mr10k-cache-barrier=store), n)
    2929      $(error gcc doesn't support needed option -mr10k-cache-barrier=store)
    3030  endif
  • src/linux/universal/linux-4.9/arch/powerpc/lib/sstep.c

    r31574 r31687  
    18081808
    18091809        case LARX:
    1810                 if (regs->msr & MSR_LE)
    1811                         return 0;
    18121810                if (op.ea & (size - 1))
    18131811                        break;          /* can't handle misaligned */
     
    18331831
    18341832        case STCX:
    1835                 if (regs->msr & MSR_LE)
    1836                         return 0;
    18371833                if (op.ea & (size - 1))
    18381834                        break;          /* can't handle misaligned */
     
    18601856
    18611857        case LOAD:
    1862                 if (regs->msr & MSR_LE)
    1863                         return 0;
    18641858                err = read_mem(&regs->gpr[op.reg], op.ea, size, regs);
    18651859                if (!err) {
     
    18731867#ifdef CONFIG_PPC_FPU
    18741868        case LOAD_FP:
    1875                 if (regs->msr & MSR_LE)
    1876                         return 0;
    18771869                if (size == 4)
    18781870                        err = do_fp_load(op.reg, do_lfs, op.ea, size, regs);
     
    18831875#ifdef CONFIG_ALTIVEC
    18841876        case LOAD_VMX:
    1885                 if (regs->msr & MSR_LE)
    1886                         return 0;
    18871877                err = do_vec_load(op.reg, do_lvx, op.ea & ~0xfUL, regs);
    18881878                goto ldst_done;
     
    18901880#ifdef CONFIG_VSX
    18911881        case LOAD_VSX:
    1892                 if (regs->msr & MSR_LE)
    1893                         return 0;
    18941882                err = do_vsx_load(op.reg, do_lxvd2x, op.ea, regs);
    18951883                goto ldst_done;
     
    19141902
    19151903        case STORE:
    1916                 if (regs->msr & MSR_LE)
    1917                         return 0;
    19181904                if ((op.type & UPDATE) && size == sizeof(long) &&
    19191905                    op.reg == 1 && op.update_reg == 1 &&
     
    19281914#ifdef CONFIG_PPC_FPU
    19291915        case STORE_FP:
    1930                 if (regs->msr & MSR_LE)
    1931                         return 0;
    19321916                if (size == 4)
    19331917                        err = do_fp_store(op.reg, do_stfs, op.ea, size, regs);
     
    19381922#ifdef CONFIG_ALTIVEC
    19391923        case STORE_VMX:
    1940                 if (regs->msr & MSR_LE)
    1941                         return 0;
    19421924                err = do_vec_store(op.reg, do_stvx, op.ea & ~0xfUL, regs);
    19431925                goto ldst_done;
     
    19451927#ifdef CONFIG_VSX
    19461928        case STORE_VSX:
    1947                 if (regs->msr & MSR_LE)
    1948                         return 0;
    19491929                err = do_vsx_store(op.reg, do_stxvd2x, op.ea, regs);
    19501930                goto ldst_done;
  • src/linux/universal/linux-4.9/arch/powerpc/sysdev/xics/icp-opal.c

    r31574 r31687  
    9292static void icp_opal_set_cpu_priority(unsigned char cppr)
    9393{
     94        /*
     95         * Here be dragons. The caller has asked to allow only IPI's and not
     96         * external interrupts. But OPAL XIVE doesn't support that. So instead
     97         * of allowing no interrupts allow all. That's still not right, but
     98         * currently the only caller who does this is xics_migrate_irqs_away()
     99         * and it works in that case.
     100         */
     101        if (cppr >= DEFAULT_PRIORITY)
     102                cppr = LOWEST_PRIORITY;
     103
    94104        xics_set_base_cppr(cppr);
    95105        opal_int_set_cppr(cppr);
  • src/linux/universal/linux-4.9/arch/powerpc/sysdev/xics/xics-common.c

    r31574 r31687  
    2121#include <linux/slab.h>
    2222#include <linux/spinlock.h>
     23#include <linux/delay.h>
    2324
    2425#include <asm/prom.h>
     
    198199        /* Remove ourselves from the global interrupt queue */
    199200        xics_set_cpu_giq(xics_default_distrib_server, 0);
    200 
    201         /* Allow IPIs again... */
    202         icp_ops->set_priority(DEFAULT_PRIORITY);
    203201
    204202        for_each_irq_desc(virq, desc) {
     
    256254                raw_spin_unlock_irqrestore(&desc->lock, flags);
    257255        }
     256
     257        /* Allow "sufficient" time to drop any inflight IRQ's */
     258        mdelay(5);
     259
     260        /*
     261         * Allow IPIs again. This is done at the very end, after migrating all
     262         * interrupts, the expectation is that we'll only get woken up by an IPI
     263         * interrupt beyond this point, but leave externals masked just to be
     264         * safe. If we're using icp-opal this may actually allow all
     265         * interrupts anyway, but that should be OK.
     266         */
     267        icp_ops->set_priority(DEFAULT_PRIORITY);
     268
    258269}
    259270#endif /* CONFIG_HOTPLUG_CPU */
  • src/linux/universal/linux-4.9/arch/s390/mm/pgtable.c

    r31574 r31687  
    607607{
    608608        spinlock_t *ptl;
     609        pgd_t *pgd;
     610        pud_t *pud;
     611        pmd_t *pmd;
    609612        pgste_t pgste;
    610613        pte_t *ptep;
     
    612615        bool dirty;
    613616
    614         ptep = get_locked_pte(mm, addr, &ptl);
     617        pgd = pgd_offset(mm, addr);
     618        pud = pud_alloc(mm, pgd, addr);
     619        if (!pud)
     620                return false;
     621        pmd = pmd_alloc(mm, pud, addr);
     622        if (!pmd)
     623                return false;
     624        /* We can't run guests backed by huge pages, but userspace can
     625         * still set them up and then try to migrate them without any
     626         * migration support.
     627         */
     628        if (pmd_large(*pmd))
     629                return true;
     630
     631        ptep = pte_alloc_map_lock(mm, pmd, addr, &ptl);
    615632        if (unlikely(!ptep))
    616633                return false;
  • src/linux/universal/linux-4.9/crypto/Makefile

    r31574 r31687  
    7272obj-$(CONFIG_CRYPTO_SHA3) += sha3_generic.o
    7373obj-$(CONFIG_CRYPTO_WP512) += wp512.o
     74CFLAGS_wp512.o := $(call cc-option,-fno-schedule-insns)  # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79149
    7475obj-$(CONFIG_CRYPTO_TGR192) += tgr192.o
    7576obj-$(CONFIG_CRYPTO_GF128MUL) += gf128mul.o
     
    9596obj-$(CONFIG_CRYPTO_TWOFISH_COMMON) += twofish_common.o
    9697obj-$(CONFIG_CRYPTO_SERPENT) += serpent_generic.o
     98CFLAGS_serpent_generic.o := $(call cc-option,-fsched-pressure)  # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79149
    9799obj-$(CONFIG_CRYPTO_AES) += aes_generic.o
    98100obj-$(CONFIG_CRYPTO_CAMELLIA) += camellia_generic.o
  • src/linux/universal/linux-4.9/drivers/firmware/efi/arm-runtime.c

    r31574 r31687  
    6666
    6767        efi_mm.pgd = pgd_alloc(&efi_mm);
     68        mm_init_cpumask(&efi_mm);
    6869        init_new_context(NULL, &efi_mm);
    6970
  • src/linux/universal/linux-4.9/drivers/i2c/i2c-mux.c

    r31574 r31687  
    430430                struct i2c_adapter *adap = muxc->adapter[--muxc->num_adapters];
    431431                struct i2c_mux_priv *priv = adap->algo_data;
     432                struct device_node *np = adap->dev.of_node;
    432433
    433434                muxc->adapter[muxc->num_adapters] = NULL;
     
    439440                sysfs_remove_link(&priv->adap.dev.kobj, "mux_device");
    440441                i2c_del_adapter(adap);
     442                of_node_put(np);
    441443                kfree(priv);
    442444        }
  • src/linux/universal/linux-4.9/drivers/infiniband/hw/mlx5/main.c

    r31574 r31687  
    31423142                goto err_rsrc;
    31433143
    3144         err = mlx5_ib_alloc_q_counters(dev);
    3145         if (err)
    3146                 goto err_odp;
     3144        if (MLX5_CAP_GEN(dev->mdev, max_qp_cnt)) {
     3145                err = mlx5_ib_alloc_q_counters(dev);
     3146                if (err)
     3147                        goto err_odp;
     3148        }
    31473149
    31483150        err = ib_register_device(&dev->ib_dev, NULL);
     
    31723174
    31733175err_q_cnt:
    3174         mlx5_ib_dealloc_q_counters(dev);
     3176        if (MLX5_CAP_GEN(dev->mdev, max_qp_cnt))
     3177                mlx5_ib_dealloc_q_counters(dev);
    31753178
    31763179err_odp:
     
    32023205        mlx5_remove_roce_notifier(dev);
    32033206        ib_unregister_device(&dev->ib_dev);
    3204         mlx5_ib_dealloc_q_counters(dev);
     3207        if (MLX5_CAP_GEN(dev->mdev, max_qp_cnt))
     3208                mlx5_ib_dealloc_q_counters(dev);
    32053209        destroy_umrc_res(dev);
    32063210        mlx5_ib_odp_remove_one(dev);
  • src/linux/universal/linux-4.9/drivers/md/dm.c

    r31574 r31687  
    973973EXPORT_SYMBOL_GPL(dm_accept_partial_bio);
    974974
     975/*
     976 * Flush current->bio_list when the target map method blocks.
     977 * This fixes deadlocks in snapshot and possibly in other targets.
     978 */
     979struct dm_offload {
     980        struct blk_plug plug;
     981        struct blk_plug_cb cb;
     982};
     983
     984static void flush_current_bio_list(struct blk_plug_cb *cb, bool from_schedule)
     985{
     986        struct dm_offload *o = container_of(cb, struct dm_offload, cb);
     987        struct bio_list list;
     988        struct bio *bio;
     989
     990        INIT_LIST_HEAD(&o->cb.list);
     991
     992        if (unlikely(!current->bio_list))
     993                return;
     994
     995        list = *current->bio_list;
     996        bio_list_init(current->bio_list);
     997
     998        while ((bio = bio_list_pop(&list))) {
     999                struct bio_set *bs = bio->bi_pool;
     1000                if (unlikely(!bs) || bs == fs_bio_set) {
     1001                        bio_list_add(current->bio_list, bio);
     1002                        continue;
     1003                }
     1004
     1005                spin_lock(&bs->rescue_lock);
     1006                bio_list_add(&bs->rescue_list, bio);
     1007                queue_work(bs->rescue_workqueue, &bs->rescue_work);
     1008                spin_unlock(&bs->rescue_lock);
     1009        }
     1010}
     1011
     1012static void dm_offload_start(struct dm_offload *o)
     1013{
     1014        blk_start_plug(&o->plug);
     1015        o->cb.callback = flush_current_bio_list;
     1016        list_add(&o->cb.list, &current->plug->cb_list);
     1017}
     1018
     1019static void dm_offload_end(struct dm_offload *o)
     1020{
     1021        list_del(&o->cb.list);
     1022        blk_finish_plug(&o->plug);
     1023}
     1024
    9751025static void __map_bio(struct dm_target_io *tio)
    9761026{
    9771027        int r;
    9781028        sector_t sector;
     1029        struct dm_offload o;
    9791030        struct bio *clone = &tio->clone;
    9801031        struct dm_target *ti = tio->ti;
     
    9891040        atomic_inc(&tio->io->io_count);
    9901041        sector = clone->bi_iter.bi_sector;
     1042
     1043        dm_offload_start(&o);
    9911044        r = ti->type->map(ti, clone);
     1045        dm_offload_end(&o);
     1046
    9921047        if (r == DM_MAPIO_REMAPPED) {
    9931048                /* the bio has been remapped so dispatch it */
  • src/linux/universal/linux-4.9/drivers/media/rc/rc-main.c

    r31574 r31687  
    14121412        int minor;
    14131413        int rc;
     1414        u64 rc_type;
    14141415
    14151416        if (!dev || !dev->map_name)
     
    14971498        }
    14981499
     1500        rc_type = BIT_ULL(rc_map->rc_type);
     1501
    14991502        if (dev->change_protocol) {
    1500                 u64 rc_type = (1ll << rc_map->rc_type);
    15011503                rc = dev->change_protocol(dev, &rc_type);
    15021504                if (rc < 0)
     
    15041506                dev->enabled_protocols = rc_type;
    15051507        }
     1508
     1509        if (dev->driver_type == RC_DRIVER_IR_RAW)
     1510                ir_raw_load_modules(&rc_type);
    15061511
    15071512        /* Allow the RC sysfs nodes to be accessible */
  • src/linux/universal/linux-4.9/drivers/media/usb/dvb-usb/dw2102.c

    r31574 r31687  
    6969        u8 initialized;
    7070        u8 last_lock;
     71        u8 data[MAX_XFER_SIZE + 4];
    7172        struct i2c_client *i2c_client_demod;
    7273        struct i2c_client *i2c_client_tuner;
     
    663664{
    664665        struct dvb_usb_device *d = i2c_get_adapdata(adap);
    665         u8 obuf[0x40], ibuf[0x40];
     666        struct dw2102_state *state;
    666667
    667668        if (!d)
    668669                return -ENODEV;
     670
     671        state = d->priv;
     672
    669673        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
    670674                return -EAGAIN;
     675        if (mutex_lock_interruptible(&d->data_mutex) < 0) {
     676                mutex_unlock(&d->i2c_mutex);
     677                return -EAGAIN;
     678        }
    671679
    672680        switch (num) {
     
    674682                switch (msg[0].addr) {
    675683                case SU3000_STREAM_CTRL:
    676                         obuf[0] = msg[0].buf[0] + 0x36;
    677                         obuf[1] = 3;
    678                         obuf[2] = 0;
    679                         if (dvb_usb_generic_rw(d, obuf, 3, ibuf, 0, 0) < 0)
     684                        state->data[0] = msg[0].buf[0] + 0x36;
     685                        state->data[1] = 3;
     686                        state->data[2] = 0;
     687                        if (dvb_usb_generic_rw(d, state->data, 3,
     688                                        state->data, 0, 0) < 0)
    680689                                err("i2c transfer failed.");
    681690                        break;
    682691                case DW2102_RC_QUERY:
    683                         obuf[0] = 0x10;
    684                         if (dvb_usb_generic_rw(d, obuf, 1, ibuf, 2, 0) < 0)
     692                        state->data[0] = 0x10;
     693                        if (dvb_usb_generic_rw(d, state->data, 1,
     694                                        state->data, 2, 0) < 0)
    685695                                err("i2c transfer failed.");
    686                         msg[0].buf[1] = ibuf[0];
    687                         msg[0].buf[0] = ibuf[1];
     696                        msg[0].buf[1] = state->data[0];
     697                        msg[0].buf[0] = state->data[1];
    688698                        break;
    689699                default:
    690700                        /* always i2c write*/
    691                         obuf[0] = 0x08;
    692                         obuf[1] = msg[0].addr;
    693                         obuf[2] = msg[0].len;
    694 
    695                         memcpy(&obuf[3], msg[0].buf, msg[0].len);
    696 
    697                         if (dvb_usb_generic_rw(d, obuf, msg[0].len + 3,
    698                                                 ibuf, 1, 0) < 0)
     701                        state->data[0] = 0x08;
     702                        state->data[1] = msg[0].addr;
     703                        state->data[2] = msg[0].len;
     704
     705                        memcpy(&state->data[3], msg[0].buf, msg[0].len);
     706
     707                        if (dvb_usb_generic_rw(d, state->data, msg[0].len + 3,
     708                                                state->data, 1, 0) < 0)
    699709                                err("i2c transfer failed.");
    700710
     
    703713        case 2:
    704714                /* always i2c read */
    705                 obuf[0] = 0x09;
    706                 obuf[1] = msg[0].len;
    707                 obuf[2] = msg[1].len;
    708                 obuf[3] = msg[0].addr;
    709                 memcpy(&obuf[4], msg[0].buf, msg[0].len);
    710 
    711                 if (dvb_usb_generic_rw(d, obuf, msg[0].len + 4,
    712                                         ibuf, msg[1].len + 1, 0) < 0)
     715                state->data[0] = 0x09;
     716                state->data[1] = msg[0].len;
     717                state->data[2] = msg[1].len;
     718                state->data[3] = msg[0].addr;
     719                memcpy(&state->data[4], msg[0].buf, msg[0].len);
     720
     721                if (dvb_usb_generic_rw(d, state->data, msg[0].len + 4,
     722                                        state->data, msg[1].len + 1, 0) < 0)
    713723                        err("i2c transfer failed.");
    714724
    715                 memcpy(msg[1].buf, &ibuf[1], msg[1].len);
     725                memcpy(msg[1].buf, &state->data[1], msg[1].len);
    716726                break;
    717727        default:
     
    719729                break;
    720730        }
     731        mutex_unlock(&d->data_mutex);
    721732        mutex_unlock(&d->i2c_mutex);
    722733        return num;
     
    846857{
    847858        struct dw2102_state *state = (struct dw2102_state *)d->priv;
    848         u8 obuf[] = {0xde, 0};
     859        int ret = 0;
    849860
    850861        info("%s: %d, initialized %d", __func__, i, state->initialized);
    851862
    852863        if (i && !state->initialized) {
     864                mutex_lock(&d->data_mutex);
     865
     866                state->data[0] = 0xde;
     867                state->data[1] = 0;
     868
    853869                state->initialized = 1;
    854870                /* reset board */
    855                 return dvb_usb_generic_rw(d, obuf, 2, NULL, 0, 0);
    856         }
    857 
    858         return 0;
     871                ret = dvb_usb_generic_rw(d, state->data, 2, NULL, 0, 0);
     872                mutex_unlock(&d->data_mutex);
     873        }
     874
     875        return ret;
    859876}
    860877
     
    13111328}
    13121329
    1313 static int su3000_frontend_attach(struct dvb_usb_adapter *d)
    1314 {
    1315         u8 obuf[3] = { 0xe, 0x80, 0 };
    1316         u8 ibuf[] = { 0 };
    1317 
    1318         if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0)
     1330static int su3000_frontend_attach(struct dvb_usb_adapter *adap)
     1331{
     1332        struct dvb_usb_device *d = adap->dev;
     1333        struct dw2102_state *state = d->priv;
     1334
     1335        mutex_lock(&d->data_mutex);
     1336
     1337        state->data[0] = 0xe;
     1338        state->data[1] = 0x80;
     1339        state->data[2] = 0;
     1340
     1341        if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
    13191342                err("command 0x0e transfer failed.");
    13201343
    1321         obuf[0] = 0xe;
    1322         obuf[1] = 0x02;
    1323         obuf[2] = 1;
    1324 
    1325         if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0)
     1344        state->data[0] = 0xe;
     1345        state->data[1] = 0x02;
     1346        state->data[2] = 1;
     1347
     1348        if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
    13261349                err("command 0x0e transfer failed.");
    13271350        msleep(300);
    13281351
    1329         obuf[0] = 0xe;
    1330         obuf[1] = 0x83;
    1331         obuf[2] = 0;
    1332 
    1333         if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0)
     1352        state->data[0] = 0xe;
     1353        state->data[1] = 0x83;
     1354        state->data[2] = 0;
     1355
     1356        if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
    13341357                err("command 0x0e transfer failed.");
    13351358
    1336         obuf[0] = 0xe;
    1337         obuf[1] = 0x83;
    1338         obuf[2] = 1;
    1339 
    1340         if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0)
     1359        state->data[0] = 0xe;
     1360        state->data[1] = 0x83;
     1361        state->data[2] = 1;
     1362
     1363        if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
    13411364                err("command 0x0e transfer failed.");
    13421365
    1343         obuf[0] = 0x51;
    1344 
    1345         if (dvb_usb_generic_rw(d->dev, obuf, 1, ibuf, 1, 0) < 0)
     1366        state->data[0] = 0x51;
     1367
     1368        if (dvb_usb_generic_rw(d, state->data, 1, state->data, 1, 0) < 0)
    13461369                err("command 0x51 transfer failed.");
    13471370
    1348         d->fe_adap[0].fe = dvb_attach(ds3000_attach, &su3000_ds3000_config,
    1349                                         &d->dev->i2c_adap);
    1350         if (d->fe_adap[0].fe == NULL)
     1371        mutex_unlock(&d->data_mutex);
     1372
     1373        adap->fe_adap[0].fe = dvb_attach(ds3000_attach, &su3000_ds3000_config,
     1374                                        &d->i2c_adap);
     1375        if (adap->fe_adap[0].fe == NULL)
    13511376                return -EIO;
    13521377
    1353         if (dvb_attach(ts2020_attach, d->fe_adap[0].fe,
     1378        if (dvb_attach(ts2020_attach, adap->fe_adap[0].fe,
    13541379                                &dw2104_ts2020_config,
    1355                                 &d->dev->i2c_adap)) {
     1380                                &d->i2c_adap)) {
    13561381                info("Attached DS3000/TS2020!");
    13571382                return 0;
     
    13621387}
    13631388
    1364 static int t220_frontend_attach(struct dvb_usb_adapter *d)
    1365 {
    1366         u8 obuf[3] = { 0xe, 0x87, 0 };
    1367         u8 ibuf[] = { 0 };
    1368 
    1369         if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0)
     1389static int t220_frontend_attach(struct dvb_usb_adapter *adap)
     1390{
     1391        struct dvb_usb_device *d = adap->dev;
     1392        struct dw2102_state *state = d->priv;
     1393
     1394        mutex_lock(&d->data_mutex);
     1395
     1396        state->data[0] = 0xe;
     1397        state->data[1] = 0x87;
     1398        state->data[2] = 0x0;
     1399
     1400        if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
    13701401                err("command 0x0e transfer failed.");
    13711402
    1372         obuf[0] = 0xe;
    1373         obuf[1] = 0x86;
    1374         obuf[2] = 1;
    1375 
    1376         if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0)
     1403        state->data[0] = 0xe;
     1404        state->data[1] = 0x86;
     1405        state->data[2] = 1;
     1406
     1407        if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
    13771408                err("command 0x0e transfer failed.");
    13781409
    1379         obuf[0] = 0xe;
    1380         obuf[1] = 0x80;
    1381         obuf[2] = 0;
    1382 
    1383         if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0)
     1410        state->data[0] = 0xe;
     1411        state->data[1] = 0x80;
     1412        state->data[2] = 0;
     1413
     1414        if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
    13841415                err("command 0x0e transfer failed.");
    13851416
    13861417        msleep(50);
    13871418
    1388         obuf[0] = 0xe;
    1389         obuf[1] = 0x80;
    1390         obuf[2] = 1;
    1391 
    1392         if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0)
     1419        state->data[0] = 0xe;
     1420        state->data[1] = 0x80;
     1421        state->data[2] = 1;
     1422
     1423        if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
    13931424                err("command 0x0e transfer failed.");
    13941425
    1395         obuf[0] = 0x51;
    1396 
    1397         if (dvb_usb_generic_rw(d->dev, obuf, 1, ibuf, 1, 0) < 0)
     1426        state->data[0] = 0x51;
     1427
     1428        if (dvb_usb_generic_rw(d, state->data, 1, state->data, 1, 0) < 0)
    13981429                err("command 0x51 transfer failed.");
    13991430
    1400         d->fe_adap[0].fe = dvb_attach(cxd2820r_attach, &cxd2820r_config,
    1401                                         &d->dev->i2c_adap, NULL);
    1402         if (d->fe_adap[0].fe != NULL) {
    1403                 if (dvb_attach(tda18271_attach, d->fe_adap[0].fe, 0x60,
    1404                                         &d->dev->i2c_adap, &tda18271_config)) {
     1431        mutex_unlock(&d->data_mutex);
     1432
     1433        adap->fe_adap[0].fe = dvb_attach(cxd2820r_attach, &cxd2820r_config,
     1434                                        &d->i2c_adap, NULL);
     1435        if (adap->fe_adap[0].fe != NULL) {
     1436                if (dvb_attach(tda18271_attach, adap->fe_adap[0].fe, 0x60,
     1437                                        &d->i2c_adap, &tda18271_config)) {
    14051438                        info("Attached TDA18271HD/CXD2820R!");
    14061439                        return 0;
     
    14121445}
    14131446
    1414 static int m88rs2000_frontend_attach(struct dvb_usb_adapter *d)
    1415 {
    1416         u8 obuf[] = { 0x51 };
    1417         u8 ibuf[] = { 0 };
    1418 
    1419         if (dvb_usb_generic_rw(d->dev, obuf, 1, ibuf, 1, 0) < 0)
     1447static int m88rs2000_frontend_attach(struct dvb_usb_adapter *adap)
     1448{
     1449        struct dvb_usb_device *d = adap->dev;
     1450        struct dw2102_state *state = d->priv;
     1451
     1452        mutex_lock(&d->data_mutex);
     1453
     1454        state->data[0] = 0x51;
     1455
     1456        if (dvb_usb_generic_rw(d, state->data, 1, state->data, 1, 0) < 0)
    14201457                err("command 0x51 transfer failed.");
    14211458
    1422         d->fe_adap[0].fe = dvb_attach(m88rs2000_attach, &s421_m88rs2000_config,
    1423                                         &d->dev->i2c_adap);
    1424 
    1425         if (d->fe_adap[0].fe == NULL)
     1459        mutex_unlock(&d->data_mutex);
     1460
     1461        adap->fe_adap[0].fe = dvb_attach(m88rs2000_attach,
     1462                                        &s421_m88rs2000_config,
     1463                                        &d->i2c_adap);
     1464
     1465        if (adap->fe_adap[0].fe == NULL)
    14261466                return -EIO;
    14271467
    1428         if (dvb_attach(ts2020_attach, d->fe_adap[0].fe,
     1468        if (dvb_attach(ts2020_attach, adap->fe_adap[0].fe,
    14291469                                &dw2104_ts2020_config,
    1430                                 &d->dev->i2c_adap)) {
     1470                                &d->i2c_adap)) {
    14311471                info("Attached RS2000/TS2020!");
    14321472                return 0;
     
    14411481        struct dvb_usb_device *d = adap->dev;
    14421482        struct dw2102_state *state = d->priv;
    1443         u8 obuf[3] = { 0xe, 0x80, 0 };
    1444         u8 ibuf[] = { 0 };
    14451483        struct i2c_adapter *i2c_adapter;
    14461484        struct i2c_client *client;
     
    14491487        struct ts2020_config ts2020_config = {};
    14501488
    1451         if (dvb_usb_generic_rw(d, obuf, 3, ibuf, 1, 0) < 0)
     1489        mutex_lock(&d->data_mutex);
     1490
     1491        state->data[0] = 0xe;
     1492        state->data[1] = 0x80;
     1493        state->data[2] = 0x0;
     1494
     1495        if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
    14521496                err("command 0x0e transfer failed.");
    14531497
    1454         obuf[0] = 0xe;
    1455         obuf[1] = 0x02;
    1456         obuf[2] = 1;
    1457 
    1458         if (dvb_usb_generic_rw(d, obuf, 3, ibuf, 1, 0) < 0)
     1498        state->data[0] = 0xe;
     1499        state->data[1] = 0x02;
     1500        state->data[2] = 1;
     1501
     1502        if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
    14591503                err("command 0x0e transfer failed.");
    14601504        msleep(300);
    14611505
    1462         obuf[0] = 0xe;
    1463         obuf[1] = 0x83;
    1464         obuf[2] = 0;
    1465 
    1466         if (dvb_usb_generic_rw(d, obuf, 3, ibuf, 1, 0) < 0)
     1506        state->data[0] = 0xe;
     1507        state->data[1] = 0x83;
     1508        state->data[2] = 0;
     1509
     1510        if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
    14671511                err("command 0x0e transfer failed.");
    14681512
    1469         obuf[0] = 0xe;
    1470         obuf[1] = 0x83;
    1471         obuf[2] = 1;
    1472 
    1473         if (dvb_usb_generic_rw(d, obuf, 3, ibuf, 1, 0) < 0)
     1513        state->data[0] = 0xe;
     1514        state->data[1] = 0x83;
     1515        state->data[2] = 1;
     1516
     1517        if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
    14741518                err("command 0x0e transfer failed.");
    14751519
    1476         obuf[0] = 0x51;
    1477 
    1478         if (dvb_usb_generic_rw(d, obuf, 1, ibuf, 1, 0) < 0)
     1520        state->data[0] = 0x51;
     1521
     1522        if (dvb_usb_generic_rw(d, state->data, 1, state->data, 1, 0) < 0)
    14791523                err("command 0x51 transfer failed.");
     1524
     1525        mutex_unlock(&d->data_mutex);
    14801526
    14811527        /* attach demod */
  • src/linux/universal/linux-4.9/drivers/mtd/maps/pmcmsp-flash.c

    r31574 r31687  
    140140
    141141                msp_maps[i].bankwidth = 1;
    142                 msp_maps[i].name = kmalloc(7, GFP_KERNEL);
     142                msp_maps[i].name = kstrndup(flash_name, 7, GFP_KERNEL);
    143143                if (!msp_maps[i].name) {
    144144                        iounmap(msp_maps[i].virt);
     
    146146                        goto cleanup_loop;
    147147                }
    148 
    149                 msp_maps[i].name = strncpy(msp_maps[i].name, flash_name, 7);
    150148
    151149                for (j = 0; j < pcnt; j++) {
  • src/linux/universal/linux-4.9/drivers/net/ethernet/broadcom/bcm63xx_enet.c

    r31574 r31687  
    914914                priv->old_duplex = -1;
    915915                priv->old_pause = -1;
     916        } else {
     917                phydev = NULL;
    916918        }
    917919
     
    10841086                         ENETDMAC_IRMASK, priv->tx_chan);
    10851087
    1086         if (priv->has_phy)
     1088        if (phydev)
    10871089                phy_start(phydev);
    10881090        else
     
    11271129
    11281130out_phy_disconnect:
    1129         if (priv->has_phy)
     1131        if (phydev)
    11301132                phy_disconnect(phydev);
    11311133
  • src/linux/universal/linux-4.9/drivers/net/ethernet/ti/cpmac.c

    r31574 r31687  
    12121212        }
    12131213
    1214 #warning FIXME: unhardcode gpio&reset bits
     1214        /* FIXME: unhardcode gpio&reset bits */
    12151215        ar7_gpio_disable(26);
    12161216        ar7_gpio_disable(27);
  • src/linux/universal/linux-4.9/drivers/pci/quirks.c

    r31574 r31687  
    21752175DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATTANSIC, PCI_ANY_ID,
    21762176                quirk_blacklist_vpd);
     2177DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_QLOGIC, 0x2261, quirk_blacklist_vpd);
    21772178
    21782179/*
  • src/linux/universal/linux-4.9/drivers/tty/serial/samsung.c

    r31574 r31687  
    10371037                ret = s3c24xx_serial_request_dma(ourport);
    10381038                if (ret < 0) {
    1039                         dev_warn(port->dev, "DMA request failed\n");
    1040                         return ret;
     1039                        dev_warn(port->dev,
     1040                                 "DMA request failed, DMA will not be used\n");
     1041                        devm_kfree(port->dev, ourport->dma);
     1042                        ourport->dma = NULL;
    10411043                }
    10421044        }
  • src/linux/universal/linux-4.9/drivers/usb/dwc3/dwc3-omap.c

    r31574 r31687  
    250250                val |= USBOTGSS_UTMI_OTG_CTRL_IDDIG;
    251251                dwc3_omap_write_utmi_ctrl(omap, val);
     252                break;
    252253
    253254        case OMAP_DWC3_VBUS_OFF:
  • src/linux/universal/linux-4.9/drivers/usb/dwc3/gadget.h

    r31574 r31687  
    2929
    3030/* DEPCFG parameter 1 */
    31 #define DWC3_DEPCFG_INT_NUM(n)          ((n) << 0)
     31#define DWC3_DEPCFG_INT_NUM(n)          (((n) & 0x1f) << 0)
    3232#define DWC3_DEPCFG_XFER_COMPLETE_EN    (1 << 8)
    3333#define DWC3_DEPCFG_XFER_IN_PROGRESS_EN (1 << 9)
     
    3535#define DWC3_DEPCFG_FIFO_ERROR_EN       (1 << 11)
    3636#define DWC3_DEPCFG_STREAM_EVENT_EN     (1 << 13)
    37 #define DWC3_DEPCFG_BINTERVAL_M1(n)     ((n) << 16)
     37#define DWC3_DEPCFG_BINTERVAL_M1(n)     (((n) & 0xff) << 16)
    3838#define DWC3_DEPCFG_STREAM_CAPABLE      (1 << 24)
    39 #define DWC3_DEPCFG_EP_NUMBER(n)        ((n) << 25)
     39#define DWC3_DEPCFG_EP_NUMBER(n)        (((n) & 0x1f) << 25)
    4040#define DWC3_DEPCFG_BULK_BASED          (1 << 30)
    4141#define DWC3_DEPCFG_FIFO_BASED          (1 << 31)
    4242
    4343/* DEPCFG parameter 0 */
    44 #define DWC3_DEPCFG_EP_TYPE(n)          ((n) << 1)
    45 #define DWC3_DEPCFG_MAX_PACKET_SIZE(n)  ((n) << 3)
    46 #define DWC3_DEPCFG_FIFO_NUMBER(n)      ((n) << 17)
    47 #define DWC3_DEPCFG_BURST_SIZE(n)       ((n) << 22)
     44#define DWC3_DEPCFG_EP_TYPE(n)          (((n) & 0x3) << 1)
     45#define DWC3_DEPCFG_MAX_PACKET_SIZE(n)  (((n) & 0x7ff) << 3)
     46#define DWC3_DEPCFG_FIFO_NUMBER(n)      (((n) & 0x1f) << 17)
     47#define DWC3_DEPCFG_BURST_SIZE(n)       (((n) & 0xf) << 22)
    4848#define DWC3_DEPCFG_DATA_SEQ_NUM(n)     ((n) << 26)
    4949/* This applies for core versions earlier than 1.94a */
  • src/linux/universal/linux-4.9/drivers/usb/gadget/function/f_fs.c

    r31574 r31687  
    18341834        do {
    18351835                struct usb_endpoint_descriptor *ds;
     1836                struct usb_ss_ep_comp_descriptor *comp_desc = NULL;
     1837                int needs_comp_desc = false;
    18361838                int desc_idx;
    18371839
    1838                 if (ffs->gadget->speed == USB_SPEED_SUPER)
     1840                if (ffs->gadget->speed == USB_SPEED_SUPER) {
    18391841                        desc_idx = 2;
    1840                 else if (ffs->gadget->speed == USB_SPEED_HIGH)
     1842                        needs_comp_desc = true;
     1843                } else if (ffs->gadget->speed == USB_SPEED_HIGH)
    18411844                        desc_idx = 1;
    18421845                else
     
    18551858                ep->ep->driver_data = ep;
    18561859                ep->ep->desc = ds;
     1860
     1861                comp_desc = (struct usb_ss_ep_comp_descriptor *)(ds +
     1862                                USB_DT_ENDPOINT_SIZE);
     1863                ep->ep->maxburst = comp_desc->bMaxBurst + 1;
     1864
     1865                if (needs_comp_desc)
     1866                        ep->ep->comp_desc = comp_desc;
     1867
    18571868                ret = usb_ep_enable(ep->ep);
    18581869                if (likely(!ret)) {
  • src/linux/universal/linux-4.9/drivers/usb/gadget/function/f_uvc.c

    r31574 r31687  
    258258        memcpy(&uvc_event->req, ctrl, sizeof(uvc_event->req));
    259259        v4l2_event_queue(&uvc->vdev, &v4l2_event);
    260 
    261         /* Pass additional setup data to userspace */
    262         if (uvc->event_setup_out && uvc->event_length) {
    263                 uvc->control_req->length = uvc->event_length;
    264                 return usb_ep_queue(uvc->func.config->cdev->gadget->ep0,
    265                         uvc->control_req, GFP_ATOMIC);
    266         }
    267260
    268261        return 0;
  • src/linux/universal/linux-4.9/drivers/usb/gadget/udc/dummy_hcd.c

    r31574 r31687  
    10321032
    10331033        dum = *((void **)dev_get_platdata(&pdev->dev));
     1034        /* Clear usb_gadget region for new registration to udc-core */
     1035        memzero_explicit(&dum->gadget, sizeof(struct usb_gadget));
    10341036        dum->gadget.name = gadget_name;
    10351037        dum->gadget.ops = &dummy_ops;
  • src/linux/universal/linux-4.9/drivers/usb/host/ohci-at91.c

    r31574 r31687  
    362362                case USB_PORT_FEAT_SUSPEND:
    363363                        dev_dbg(hcd->self.controller, "SetPortFeat: SUSPEND\n");
    364                         if (valid_port(wIndex)) {
     364                        if (valid_port(wIndex) && ohci_at91->sfr_regmap) {
    365365                                ohci_at91_port_suspend(ohci_at91->sfr_regmap,
    366366                                                       1);
     
    405405                case USB_PORT_FEAT_SUSPEND:
    406406                        dev_dbg(hcd->self.controller, "ClearPortFeature: SUSPEND\n");
    407                         if (valid_port(wIndex)) {
     407                        if (valid_port(wIndex) && ohci_at91->sfr_regmap) {
    408408                                ohci_at91_port_suspend(ohci_at91->sfr_regmap,
    409409                                                       0);
  • src/linux/universal/linux-4.9/drivers/usb/host/xhci-dbg.c

    r31574 r31687  
    112112
    113113        /* xhci 1.1 controllers have the HCCPARAMS2 register */
    114         if (hci_version > 100) {
     114        if (hci_version > 0x100) {
    115115                temp = readl(&xhci->cap_regs->hcc_params2);
    116116                xhci_dbg(xhci, "HCC PARAMS2 0x%x:\n", (unsigned int) temp);
  • src/linux/universal/linux-4.9/drivers/usb/host/xhci-plat.c

    r31632 r31687  
    290290        struct clk *clk = xhci->clk;
    291291
     292        xhci->xhc_state |= XHCI_STATE_REMOVING;
     293
    292294        usb_remove_hcd(xhci->shared_hcd);
    293295        usb_phy_shutdown(hcd->usb_phy);
  • src/linux/universal/linux-4.9/drivers/usb/misc/iowarrior.c

    r31574 r31687  
    782782        dev->product_id = le16_to_cpu(udev->descriptor.idProduct);
    783783
    784         if (iface_desc->desc.bNumEndpoints < 1) {
    785                 dev_err(&interface->dev, "Invalid number of endpoints\n");
    786                 retval = -EINVAL;
    787                 goto error;
    788         }
    789 
    790784        /* set up the endpoint information */
    791785        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
     
    798792                        dev->int_out_endpoint = endpoint;
    799793        }
     794
     795        if (!dev->int_in_endpoint) {
     796                dev_err(&interface->dev, "no interrupt-in endpoint found\n");
     797                retval = -ENODEV;
     798                goto error;
     799        }
     800
     801        if (dev->product_id == USB_DEVICE_ID_CODEMERCS_IOW56) {
     802                if (!dev->int_out_endpoint) {
     803                        dev_err(&interface->dev, "no interrupt-out endpoint found\n");
     804                        retval = -ENODEV;
     805                        goto error;
     806                }
     807        }
     808
    800809        /* we have to check the report_size often, so remember it in the endianness suitable for our machine */
    801810        dev->report_size = usb_endpoint_maxp(dev->int_in_endpoint);
  • src/linux/universal/linux-4.9/drivers/usb/serial/digi_acceleport.c

    r31574 r31687  
    14831483        struct tty_struct *tty;
    14841484        struct digi_port *priv = usb_get_serial_port_data(port);
     1485        unsigned char *buf = urb->transfer_buffer;
    14851486        int opcode, line, status, val;
    14861487        int i;
    14871488        unsigned int rts;
    14881489
     1490        if (urb->actual_length < 4)
     1491                return -1;
     1492
    14891493        /* handle each oob command */
    1490         for (i = 0; i < urb->actual_length - 3;) {
    1491                 opcode = ((unsigned char *)urb->transfer_buffer)[i++];
    1492                 line = ((unsigned char *)urb->transfer_buffer)[i++];
    1493                 status = ((unsigned char *)urb->transfer_buffer)[i++];
    1494                 val = ((unsigned char *)urb->transfer_buffer)[i++];
     1494        for (i = 0; i < urb->actual_length - 3; i += 4) {
     1495                opcode = buf[i];
     1496                line = buf[i + 1];
     1497                status = buf[i + 2];
     1498                val = buf[i + 3];
    14951499
    14961500                dev_dbg(&port->dev, "digi_read_oob_callback: opcode=%d, line=%d, status=%d, val=%d\n",
  • src/linux/universal/linux-4.9/drivers/usb/serial/io_ti.c

    r31574 r31687  
    16751675        dev_dbg(dev, "%s - port_number %d, function %d, info 0x%x\n", __func__,
    16761676                port_number, function, data[1]);
     1677
     1678        if (port_number >= edge_serial->serial->num_ports) {
     1679                dev_err(dev, "bad port number %d\n", port_number);
     1680                goto exit;
     1681        }
     1682
    16771683        port = edge_serial->serial->port[port_number];
    16781684        edge_port = usb_get_serial_port_data(port);
     
    17561762        port_number = edge_port->port->port_number;
    17571763
    1758         if (edge_port->lsr_event) {
     1764        if (urb->actual_length > 0 && edge_port->lsr_event) {
    17591765                edge_port->lsr_event = 0;
    17601766                dev_dbg(dev, "%s ===== Port %u LSR Status = %02x, Data = %02x ======\n",
  • src/linux/universal/linux-4.9/drivers/usb/serial/omninet.c

    r31574 r31687  
    143143static int omninet_open(struct tty_struct *tty, struct usb_serial_port *port)
    144144{
    145         struct usb_serial       *serial = port->serial;
    146         struct usb_serial_port  *wport;
    147 
    148         wport = serial->port[1];
    149         tty_port_tty_set(&wport->port, tty);
    150 
    151145        return usb_serial_generic_open(tty, port);
    152146}
  • src/linux/universal/linux-4.9/drivers/usb/serial/safe_serial.c

    r31574 r31687  
    201201                goto out;
    202202
     203        if (length < 2) {
     204                dev_err(&port->dev, "malformed packet\n");
     205                return;
     206        }
     207
    203208        fcs = fcs_compute10(data, length, CRC10_INITFCS);
    204209        if (fcs) {
  • src/linux/universal/linux-4.9/fs/ext4/inode.c

    r31632 r31687  
    38243824        unsigned blocksize;
    38253825        struct inode *inode = mapping->host;
     3826
     3827        /* If we are processing an encrypted inode during orphan list handling */
     3828        if (ext4_encrypted_inode(inode) && !fscrypt_has_encryption_key(inode))
     3829                return 0;
    38263830
    38273831        blocksize = inode->i_sb->s_blocksize;
  • src/linux/universal/linux-4.9/include/linux/user_namespace.h

    r31574 r31687  
    6666        struct user_namespace *ns;
    6767        kuid_t uid;
    68         atomic_t count;
     68        int count;
    6969        atomic_t ucount[UCOUNT_COUNTS];
    7070};
  • src/linux/universal/linux-4.9/include/trace/events/syscalls.h

    r31574 r31687  
    11#undef TRACE_SYSTEM
    22#define TRACE_SYSTEM raw_syscalls
     3#undef TRACE_INCLUDE_FILE
    34#define TRACE_INCLUDE_FILE syscalls
    45
  • src/linux/universal/linux-4.9/kernel/ucount.c

    r31574 r31687  
    140140                new->ns = ns;
    141141                new->uid = uid;
    142                 atomic_set(&new->count, 0);
     142                new->count = 0;
    143143
    144144                spin_lock_irq(&ucounts_lock);
     
    151151                }
    152152        }
    153         if (!atomic_add_unless(&ucounts->count, 1, INT_MAX))
     153        if (ucounts->count == INT_MAX)
    154154                ucounts = NULL;
     155        else
     156                ucounts->count += 1;
    155157        spin_unlock_irq(&ucounts_lock);
    156158        return ucounts;
     
    161163        unsigned long flags;
    162164
    163         if (atomic_dec_and_test(&ucounts->count)) {
    164                 spin_lock_irqsave(&ucounts_lock, flags);
     165        spin_lock_irqsave(&ucounts_lock, flags);
     166        ucounts->count -= 1;
     167        if (!ucounts->count)
    165168                hlist_del_init(&ucounts->node);
    166                 spin_unlock_irqrestore(&ucounts_lock, flags);
    167 
    168                 kfree(ucounts);
    169         }
     169        else
     170                ucounts = NULL;
     171        spin_unlock_irqrestore(&ucounts_lock, flags);
     172
     173        kfree(ucounts);
    170174}
    171175
  • src/linux/universal/linux-4.9/virt/kvm/arm/vgic/vgic-mmio.c

    r31574 r31687  
    188188                                    bool new_active_state)
    189189{
     190        struct kvm_vcpu *requester_vcpu;
    190191        spin_lock(&irq->irq_lock);
     192
     193        /*
     194         * The vcpu parameter here can mean multiple things depending on how
     195         * this function is called; when handling a trap from the kernel it
     196         * depends on the GIC version, and these functions are also called as
     197         * part of save/restore from userspace.
     198         *
     199         * Therefore, we have to figure out the requester in a reliable way.
     200         *
     201         * When accessing VGIC state from user space, the requester_vcpu is
     202         * NULL, which is fine, because we guarantee that no VCPUs are running
     203         * when accessing VGIC state from user space so irq->vcpu->cpu is
     204         * always -1.
     205         */
     206        requester_vcpu = kvm_arm_get_running_vcpu();
     207
    191208        /*
    192209         * If this virtual IRQ was written into a list register, we
    193210         * have to make sure the CPU that runs the VCPU thread has
    194          * synced back LR state to the struct vgic_irq.  We can only
    195          * know this for sure, when either this irq is not assigned to
    196          * anyone's AP list anymore, or the VCPU thread is not
    197          * running on any CPUs.
     211         * synced back the LR state to the struct vgic_irq.
    198212         *
    199          * In the opposite case, we know the VCPU thread may be on its
    200          * way back from the guest and still has to sync back this
    201          * IRQ, so we release and re-acquire the spin_lock to let the
    202          * other thread sync back the IRQ.
     213         * As long as the conditions below are true, we know the VCPU thread
     214         * may be on its way back from the guest (we kicked the VCPU thread in
     215         * vgic_change_active_prepare)  and still has to sync back this IRQ,
     216         * so we release and re-acquire the spin_lock to let the other thread
     217         * sync back the IRQ.
    203218         */
    204219        while (irq->vcpu && /* IRQ may have state in an LR somewhere */
     220               irq->vcpu != requester_vcpu && /* Current thread is not the VCPU thread */
    205221               irq->vcpu->cpu != -1) /* VCPU thread is running */
    206222                cond_resched_lock(&irq->irq_lock);
Note: See TracChangeset for help on using the changeset viewer.