Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel-alx-legacy/patches-4.9/0362-4.9.263-all-fixes.patch

    Annotation of /trunk/kernel-alx-legacy/patches-4.9/0362-4.9.263-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 3664 - (hide annotations) (download)
    Mon Oct 24 14:07:41 2022 UTC (20 months ago) by niro
    File size: 37674 byte(s) 
    -linux-4.9.263
    1 niro 3664 diff --git a/Makefile b/Makefile
    2     index be5eac0a12d37..80b265a383bb6 100644
    3     --- a/Makefile
    4     +++ b/Makefile
    5     @@ -1,6 +1,6 @@
    6     VERSION = 4
    7     PATCHLEVEL = 9
    8     -SUBLEVEL = 262
    9     +SUBLEVEL = 263
    10     EXTRAVERSION =
    11     NAME = Roaring Lionus
    12    
    13     diff --git a/arch/x86/events/intel/ds.c b/arch/x86/events/intel/ds.c
    14     index f562ddbeb20c6..f39838d78976d 100644
    15     --- a/arch/x86/events/intel/ds.c
    16     +++ b/arch/x86/events/intel/ds.c
    17     @@ -1473,7 +1473,7 @@ static void intel_pmu_drain_pebs_nhm(struct pt_regs *iregs)
    18     */
    19     if (!pebs_status && cpuc->pebs_enabled &&
    20     !(cpuc->pebs_enabled & (cpuc->pebs_enabled-1)))
    21     - pebs_status = cpuc->pebs_enabled;
    22     + pebs_status = p->status = cpuc->pebs_enabled;
    23    
    24     bit = find_first_bit((unsigned long *)&pebs_status,
    25     x86_pmu.max_pebs_events);
    26     diff --git a/arch/x86/include/asm/processor.h b/arch/x86/include/asm/processor.h
    27     index 7aa9a9bd9d982..f606ef5989172 100644
    28     --- a/arch/x86/include/asm/processor.h
    29     +++ b/arch/x86/include/asm/processor.h
    30     @@ -461,15 +461,6 @@ struct thread_struct {
    31     */
    32     };
    33    
    34     -/*
    35     - * Thread-synchronous status.
    36     - *
    37     - * This is different from the flags in that nobody else
    38     - * ever touches our thread-synchronous status, so we don't
    39     - * have to worry about atomic accesses.
    40     - */
    41     -#define TS_COMPAT 0x0002 /* 32bit syscall active (64BIT)*/
    42     -
    43     /*
    44     * Set IOPL bits in EFLAGS from given mask
    45     */
    46     diff --git a/arch/x86/include/asm/thread_info.h b/arch/x86/include/asm/thread_info.h
    47     index 0438f7fbb3839..3ba5e2fce1718 100644
    48     --- a/arch/x86/include/asm/thread_info.h
    49     +++ b/arch/x86/include/asm/thread_info.h
    50     @@ -221,10 +221,31 @@ static inline int arch_within_stack_frames(const void * const stack,
    51    
    52     #endif
    53    
    54     +/*
    55     + * Thread-synchronous status.
    56     + *
    57     + * This is different from the flags in that nobody else
    58     + * ever touches our thread-synchronous status, so we don't
    59     + * have to worry about atomic accesses.
    60     + */
    61     +#define TS_COMPAT 0x0002 /* 32bit syscall active (64BIT)*/
    62     +
    63     +#ifndef __ASSEMBLY__
    64     #ifdef CONFIG_COMPAT
    65     #define TS_I386_REGS_POKED 0x0004 /* regs poked by 32-bit ptracer */
    66     +#define TS_COMPAT_RESTART 0x0008
    67     +
    68     +#define arch_set_restart_data arch_set_restart_data
    69     +
    70     +static inline void arch_set_restart_data(struct restart_block *restart)
    71     +{
    72     + struct thread_info *ti = current_thread_info();
    73     + if (ti->status & TS_COMPAT)
    74     + ti->status |= TS_COMPAT_RESTART;
    75     + else
    76     + ti->status &= ~TS_COMPAT_RESTART;
    77     +}
    78     #endif
    79     -#ifndef __ASSEMBLY__
    80    
    81     #ifdef CONFIG_X86_32
    82     #define in_ia32_syscall() true
    83     diff --git a/arch/x86/kernel/apic/io_apic.c b/arch/x86/kernel/apic/io_apic.c
    84     index 3401b28f13121..f398612e8a816 100644
    85     --- a/arch/x86/kernel/apic/io_apic.c
    86     +++ b/arch/x86/kernel/apic/io_apic.c
    87     @@ -1042,6 +1042,16 @@ static int mp_map_pin_to_irq(u32 gsi, int idx, int ioapic, int pin,
    88     if (idx >= 0 && test_bit(mp_irqs[idx].srcbus, mp_bus_not_pci)) {
    89     irq = mp_irqs[idx].srcbusirq;
    90     legacy = mp_is_legacy_irq(irq);
    91     + /*
    92     + * IRQ2 is unusable for historical reasons on systems which
    93     + * have a legacy PIC. See the comment vs. IRQ2 further down.
    94     + *
    95     + * If this gets removed at some point then the related code
    96     + * in lapic_assign_system_vectors() needs to be adjusted as
    97     + * well.
    98     + */
    99     + if (legacy && irq == PIC_CASCADE_IR)
    100     + return -EINVAL;
    101     }
    102    
    103     mutex_lock(&ioapic_mutex);
    104     diff --git a/arch/x86/kernel/signal.c b/arch/x86/kernel/signal.c
    105     index ca010dfb9682b..4050d5092c86b 100644
    106     --- a/arch/x86/kernel/signal.c
    107     +++ b/arch/x86/kernel/signal.c
    108     @@ -767,30 +767,8 @@ handle_signal(struct ksignal *ksig, struct pt_regs *regs)
    109    
    110     static inline unsigned long get_nr_restart_syscall(const struct pt_regs *regs)
    111     {
    112     - /*
    113     - * This function is fundamentally broken as currently
    114     - * implemented.
    115     - *
    116     - * The idea is that we want to trigger a call to the
    117     - * restart_block() syscall and that we want in_ia32_syscall(),
    118     - * in_x32_syscall(), etc. to match whatever they were in the
    119     - * syscall being restarted. We assume that the syscall
    120     - * instruction at (regs->ip - 2) matches whatever syscall
    121     - * instruction we used to enter in the first place.
    122     - *
    123     - * The problem is that we can get here when ptrace pokes
    124     - * syscall-like values into regs even if we're not in a syscall
    125     - * at all.
    126     - *
    127     - * For now, we maintain historical behavior and guess based on
    128     - * stored state. We could do better by saving the actual
    129     - * syscall arch in restart_block or (with caveats on x32) by
    130     - * checking if regs->ip points to 'int $0x80'. The current
    131     - * behavior is incorrect if a tracer has a different bitness
    132     - * than the tracee.
    133     - */
    134     #ifdef CONFIG_IA32_EMULATION
    135     - if (current_thread_info()->status & (TS_COMPAT|TS_I386_REGS_POKED))
    136     + if (current_thread_info()->status & TS_COMPAT_RESTART)
    137     return __NR_ia32_restart_syscall;
    138     #endif
    139     #ifdef CONFIG_X86_X32_ABI
    140     diff --git a/drivers/iio/imu/adis16400_core.c b/drivers/iio/imu/adis16400_core.c
    141     index fb7c0dbed51cb..67837905f7b45 100644
    142     --- a/drivers/iio/imu/adis16400_core.c
    143     +++ b/drivers/iio/imu/adis16400_core.c
    144     @@ -288,8 +288,7 @@ static int adis16400_initial_setup(struct iio_dev *indio_dev)
    145     if (ret)
    146     goto err_ret;
    147    
    148     - ret = sscanf(indio_dev->name, "adis%u\n", &device_id);
    149     - if (ret != 1) {
    150     + if (sscanf(indio_dev->name, "adis%u\n", &device_id) != 1) {
    151     ret = -EINVAL;
    152     goto err_ret;
    153     }
    154     diff --git a/drivers/net/dsa/b53/b53_common.c b/drivers/net/dsa/b53/b53_common.c
    155     index 5ec0042bc3840..b6867a8915dac 100644
    156     --- a/drivers/net/dsa/b53/b53_common.c
    157     +++ b/drivers/net/dsa/b53/b53_common.c
    158     @@ -502,6 +502,19 @@ static void b53_imp_vlan_setup(struct dsa_switch *ds, int cpu_port)
    159     }
    160     }
    161    
    162     +static void b53_port_set_learning(struct b53_device *dev, int port,
    163     + bool learning)
    164     +{
    165     + u16 reg;
    166     +
    167     + b53_read16(dev, B53_CTRL_PAGE, B53_DIS_LEARNING, &reg);
    168     + if (learning)
    169     + reg &= ~BIT(port);
    170     + else
    171     + reg |= BIT(port);
    172     + b53_write16(dev, B53_CTRL_PAGE, B53_DIS_LEARNING, reg);
    173     +}
    174     +
    175     static int b53_enable_port(struct dsa_switch *ds, int port,
    176     struct phy_device *phy)
    177     {
    178     @@ -509,6 +522,8 @@ static int b53_enable_port(struct dsa_switch *ds, int port,
    179     unsigned int cpu_port = dev->cpu_port;
    180     u16 pvlan;
    181    
    182     + b53_port_set_learning(dev, port, false);
    183     +
    184     /* Clear the Rx and Tx disable bits and set to no spanning tree */
    185     b53_write8(dev, B53_CTRL_PAGE, B53_PORT_CTRL(port), 0);
    186    
    187     @@ -552,6 +567,8 @@ static void b53_enable_cpu_port(struct b53_device *dev)
    188     PORT_CTRL_RX_MCST_EN |
    189     PORT_CTRL_RX_UCST_EN;
    190     b53_write8(dev, B53_CTRL_PAGE, B53_PORT_CTRL(cpu_port), port_ctrl);
    191     +
    192     + b53_port_set_learning(dev, cpu_port, false);
    193     }
    194    
    195     static void b53_enable_mib(struct b53_device *dev)
    196     @@ -1375,6 +1392,8 @@ static int b53_br_join(struct dsa_switch *ds, int port,
    197     b53_write16(dev, B53_PVLAN_PAGE, B53_PVLAN_PORT_MASK(port), pvlan);
    198     dev->ports[port].vlan_ctl_mask = pvlan;
    199    
    200     + b53_port_set_learning(dev, port, true);
    201     +
    202     return 0;
    203     }
    204    
    205     @@ -1426,6 +1445,7 @@ static void b53_br_leave(struct dsa_switch *ds, int port)
    206     vl->untag |= BIT(port) | BIT(dev->cpu_port);
    207     b53_set_vlan_entry(dev, pvid, vl);
    208     }
    209     + b53_port_set_learning(dev, port, false);
    210     }
    211    
    212     static void b53_br_set_stp_state(struct dsa_switch *ds, int port, u8 state)
    213     diff --git a/drivers/net/dsa/b53/b53_regs.h b/drivers/net/dsa/b53/b53_regs.h
    214     index 3cf246c6bdcc4..aed70e76006da 100644
    215     --- a/drivers/net/dsa/b53/b53_regs.h
    216     +++ b/drivers/net/dsa/b53/b53_regs.h
    217     @@ -112,6 +112,7 @@
    218     #define B53_UC_FLOOD_MASK 0x32
    219     #define B53_MC_FLOOD_MASK 0x34
    220     #define B53_IPMC_FLOOD_MASK 0x36
    221     +#define B53_DIS_LEARNING 0x3c
    222    
    223     /*
    224     * Override Ports 0-7 State on devices with xMII interfaces (8 bit)
    225     diff --git a/drivers/net/dsa/bcm_sf2.c b/drivers/net/dsa/bcm_sf2.c
    226     index a3742a3b413cd..0c69d5858558a 100644
    227     --- a/drivers/net/dsa/bcm_sf2.c
    228     +++ b/drivers/net/dsa/bcm_sf2.c
    229     @@ -224,6 +224,11 @@ static int bcm_sf2_port_setup(struct dsa_switch *ds, int port,
    230     reg &= ~P_TXQ_PSM_VDD(port);
    231     core_writel(priv, reg, CORE_MEM_PSM_VDD_CTRL);
    232    
    233     + /* Disable learning */
    234     + reg = core_readl(priv, CORE_DIS_LEARN);
    235     + reg |= BIT(port);
    236     + core_writel(priv, reg, CORE_DIS_LEARN);
    237     +
    238     /* Clear the Rx and Tx disable bits and set to no spanning tree */
    239     core_writel(priv, 0, CORE_G_PCTL_PORT(port));
    240    
    241     diff --git a/drivers/net/dsa/bcm_sf2_regs.h b/drivers/net/dsa/bcm_sf2_regs.h
    242     index 838fe373cd6f7..ca1d1f2e1161a 100644
    243     --- a/drivers/net/dsa/bcm_sf2_regs.h
    244     +++ b/drivers/net/dsa/bcm_sf2_regs.h
    245     @@ -138,6 +138,8 @@
    246     #define CORE_SWITCH_CTRL 0x00088
    247     #define MII_DUMB_FWDG_EN (1 << 6)
    248    
    249     +#define CORE_DIS_LEARN 0x000f0
    250     +
    251     #define CORE_SFT_LRN_CTRL 0x000f8
    252     #define SW_LEARN_CNTL(x) (1 << (x))
    253    
    254     diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe.h b/drivers/net/ethernet/intel/ixgbe/ixgbe.h
    255     index b06e32d0d22af..293ff8cc69948 100644
    256     --- a/drivers/net/ethernet/intel/ixgbe/ixgbe.h
    257     +++ b/drivers/net/ethernet/intel/ixgbe/ixgbe.h
    258     @@ -991,6 +991,7 @@ void ixgbe_ptp_suspend(struct ixgbe_adapter *adapter);
    259     void ixgbe_ptp_stop(struct ixgbe_adapter *adapter);
    260     void ixgbe_ptp_overflow_check(struct ixgbe_adapter *adapter);
    261     void ixgbe_ptp_rx_hang(struct ixgbe_adapter *adapter);
    262     +void ixgbe_ptp_tx_hang(struct ixgbe_adapter *adapter);
    263     void ixgbe_ptp_rx_pktstamp(struct ixgbe_q_vector *, struct sk_buff *);
    264     void ixgbe_ptp_rx_rgtstamp(struct ixgbe_q_vector *, struct sk_buff *skb);
    265     static inline void ixgbe_ptp_rx_hwtstamp(struct ixgbe_ring *rx_ring,
    266     diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
    267     index 4c729faeb7132..36d73bf32f4fb 100644
    268     --- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
    269     +++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
    270     @@ -7257,7 +7257,9 @@ static void ixgbe_service_task(struct work_struct *work)
    271    
    272     if (test_bit(__IXGBE_PTP_RUNNING, &adapter->state)) {
    273     ixgbe_ptp_overflow_check(adapter);
    274     - ixgbe_ptp_rx_hang(adapter);
    275     + if (adapter->flags & IXGBE_FLAG_RX_HWTSTAMP_IN_REGISTER)
    276     + ixgbe_ptp_rx_hang(adapter);
    277     + ixgbe_ptp_tx_hang(adapter);
    278     }
    279    
    280     ixgbe_service_event_complete(adapter);
    281     diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c
    282     index a92277683a649..a93a1b3bb8e4d 100644
    283     --- a/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c
    284     +++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c
    285     @@ -662,6 +662,33 @@ static void ixgbe_ptp_clear_tx_timestamp(struct ixgbe_adapter *adapter)
    286     clear_bit_unlock(__IXGBE_PTP_TX_IN_PROGRESS, &adapter->state);
    287     }
    288    
    289     +/**
    290     + * ixgbe_ptp_tx_hang - detect error case where Tx timestamp never finishes
    291     + * @adapter: private network adapter structure
    292     + */
    293     +void ixgbe_ptp_tx_hang(struct ixgbe_adapter *adapter)
    294     +{
    295     + bool timeout = time_is_before_jiffies(adapter->ptp_tx_start +
    296     + IXGBE_PTP_TX_TIMEOUT);
    297     +
    298     + if (!adapter->ptp_tx_skb)
    299     + return;
    300     +
    301     + if (!test_bit(__IXGBE_PTP_TX_IN_PROGRESS, &adapter->state))
    302     + return;
    303     +
    304     + /* If we haven't received a timestamp within the timeout, it is
    305     + * reasonable to assume that it will never occur, so we can unlock the
    306     + * timestamp bit when this occurs.
    307     + */
    308     + if (timeout) {
    309     + cancel_work_sync(&adapter->ptp_tx_work);
    310     + ixgbe_ptp_clear_tx_timestamp(adapter);
    311     + adapter->tx_hwtstamp_timeouts++;
    312     + e_warn(drv, "clearing Tx timestamp hang\n");
    313     + }
    314     +}
    315     +
    316     /**
    317     * ixgbe_ptp_tx_hwtstamp - utility function which checks for TX time stamp
    318     * @adapter: the private adapter struct
    319     diff --git a/drivers/nvme/target/core.c b/drivers/nvme/target/core.c
    320     index 4b58f352c0c93..fb2461cc3c693 100644
    321     --- a/drivers/nvme/target/core.c
    322     +++ b/drivers/nvme/target/core.c
    323     @@ -574,9 +574,20 @@ static void nvmet_start_ctrl(struct nvmet_ctrl *ctrl)
    324     {
    325     lockdep_assert_held(&ctrl->lock);
    326    
    327     - if (nvmet_cc_iosqes(ctrl->cc) != NVME_NVM_IOSQES ||
    328     - nvmet_cc_iocqes(ctrl->cc) != NVME_NVM_IOCQES ||
    329     - nvmet_cc_mps(ctrl->cc) != 0 ||
    330     + /*
    331     + * Only I/O controllers should verify iosqes,iocqes.
    332     + * Strictly speaking, the spec says a discovery controller
    333     + * should verify iosqes,iocqes are zeroed, however that
    334     + * would break backwards compatibility, so don't enforce it.
    335     + */
    336     + if (ctrl->subsys->type != NVME_NQN_DISC &&
    337     + (nvmet_cc_iosqes(ctrl->cc) != NVME_NVM_IOSQES ||
    338     + nvmet_cc_iocqes(ctrl->cc) != NVME_NVM_IOCQES)) {
    339     + ctrl->csts = NVME_CSTS_CFS;
    340     + return;
    341     + }
    342     +
    343     + if (nvmet_cc_mps(ctrl->cc) != 0 ||
    344     nvmet_cc_ams(ctrl->cc) != 0 ||
    345     nvmet_cc_css(ctrl->cc) != 0) {
    346     ctrl->csts = NVME_CSTS_CFS;
    347     diff --git a/drivers/pci/hotplug/rpadlpar_sysfs.c b/drivers/pci/hotplug/rpadlpar_sysfs.c
    348     index a796301ea03fb..ca9d832bd9f83 100644
    349     --- a/drivers/pci/hotplug/rpadlpar_sysfs.c
    350     +++ b/drivers/pci/hotplug/rpadlpar_sysfs.c
    351     @@ -39,12 +39,11 @@ static ssize_t add_slot_store(struct kobject *kobj, struct kobj_attribute *attr,
    352     if (nbytes >= MAX_DRC_NAME_LEN)
    353     return 0;
    354    
    355     - memcpy(drc_name, buf, nbytes);
    356     + strscpy(drc_name, buf, nbytes + 1);
    357    
    358     end = strchr(drc_name, '\n');
    359     - if (!end)
    360     - end = &drc_name[nbytes];
    361     - *end = '\0';
    362     + if (end)
    363     + *end = '\0';
    364    
    365     rc = dlpar_add_slot(drc_name);
    366     if (rc)
    367     @@ -70,12 +69,11 @@ static ssize_t remove_slot_store(struct kobject *kobj,
    368     if (nbytes >= MAX_DRC_NAME_LEN)
    369     return 0;
    370    
    371     - memcpy(drc_name, buf, nbytes);
    372     + strscpy(drc_name, buf, nbytes + 1);
    373    
    374     end = strchr(drc_name, '\n');
    375     - if (!end)
    376     - end = &drc_name[nbytes];
    377     - *end = '\0';
    378     + if (end)
    379     + *end = '\0';
    380    
    381     rc = dlpar_remove_slot(drc_name);
    382     if (rc)
    383     diff --git a/drivers/scsi/lpfc/lpfc_debugfs.c b/drivers/scsi/lpfc/lpfc_debugfs.c
    384     index a63542bac1533..feb00585a7a4d 100644
    385     --- a/drivers/scsi/lpfc/lpfc_debugfs.c
    386     +++ b/drivers/scsi/lpfc/lpfc_debugfs.c
    387     @@ -1061,7 +1061,7 @@ lpfc_debugfs_dif_err_write(struct file *file, const char __user *buf,
    388     memset(dstbuf, 0, 33);
    389     size = (nbytes < 32) ? nbytes : 32;
    390     if (copy_from_user(dstbuf, buf, size))
    391     - return 0;
    392     + return -EFAULT;
    393    
    394     if (dent == phba->debug_InjErrLBA) {
    395     if ((buf[0] == 'o') && (buf[1] == 'f') && (buf[2] == 'f'))
    396     @@ -1069,7 +1069,7 @@ lpfc_debugfs_dif_err_write(struct file *file, const char __user *buf,
    397     }
    398    
    399     if ((tmp == 0) && (kstrtoull(dstbuf, 0, &tmp)))
    400     - return 0;
    401     + return -EINVAL;
    402    
    403     if (dent == phba->debug_writeGuard)
    404     phba->lpfc_injerr_wgrd_cnt = (uint32_t)tmp;
    405     diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
    406     index c574bf981140a..f33635ab967f7 100644
    407     --- a/drivers/usb/gadget/composite.c
    408     +++ b/drivers/usb/gadget/composite.c
    409     @@ -1076,7 +1076,7 @@ static void collect_langs(struct usb_gadget_strings **sp, __le16 *buf)
    410     while (*sp) {
    411     s = *sp;
    412     language = cpu_to_le16(s->language);
    413     - for (tmp = buf; *tmp && tmp < &buf[126]; tmp++) {
    414     + for (tmp = buf; *tmp && tmp < &buf[USB_MAX_STRING_LEN]; tmp++) {
    415     if (*tmp == language)
    416     goto repeat;
    417     }
    418     @@ -1151,7 +1151,7 @@ static int get_string(struct usb_composite_dev *cdev,
    419     collect_langs(sp, s->wData);
    420     }
    421    
    422     - for (len = 0; len <= 126 && s->wData[len]; len++)
    423     + for (len = 0; len <= USB_MAX_STRING_LEN && s->wData[len]; len++)
    424     continue;
    425     if (!len)
    426     return -EINVAL;
    427     diff --git a/drivers/usb/gadget/configfs.c b/drivers/usb/gadget/configfs.c
    428     index 0aa1b8fa9b47a..fe1b54a8fb0c8 100644
    429     --- a/drivers/usb/gadget/configfs.c
    430     +++ b/drivers/usb/gadget/configfs.c
    431     @@ -108,21 +108,27 @@ struct gadget_config_name {
    432     struct list_head list;
    433     };
    434    
    435     +#define USB_MAX_STRING_WITH_NULL_LEN (USB_MAX_STRING_LEN+1)
    436     +
    437     static int usb_string_copy(const char *s, char **s_copy)
    438     {
    439     int ret;
    440     char *str;
    441     char *copy = *s_copy;
    442     ret = strlen(s);
    443     - if (ret > 126)
    444     + if (ret > USB_MAX_STRING_LEN)
    445     return -EOVERFLOW;
    446    
    447     - str = kstrdup(s, GFP_KERNEL);
    448     - if (!str)
    449     - return -ENOMEM;
    450     + if (copy) {
    451     + str = copy;
    452     + } else {
    453     + str = kmalloc(USB_MAX_STRING_WITH_NULL_LEN, GFP_KERNEL);
    454     + if (!str)
    455     + return -ENOMEM;
    456     + }
    457     + strcpy(str, s);
    458     if (str[ret - 1] == '\n')
    459     str[ret - 1] = '\0';
    460     - kfree(copy);
    461     *s_copy = str;
    462     return 0;
    463     }
    464     diff --git a/drivers/usb/gadget/usbstring.c b/drivers/usb/gadget/usbstring.c
    465     index 73a4dfba0edbf..0173a9969b9a0 100644
    466     --- a/drivers/usb/gadget/usbstring.c
    467     +++ b/drivers/usb/gadget/usbstring.c
    468     @@ -59,9 +59,9 @@ usb_gadget_get_string (struct usb_gadget_strings *table, int id, u8 *buf)
    469     return -EINVAL;
    470    
    471     /* string descriptors have length, tag, then UTF16-LE text */
    472     - len = min ((size_t) 126, strlen (s->s));
    473     + len = min((size_t)USB_MAX_STRING_LEN, strlen(s->s));
    474     len = utf8s_to_utf16s(s->s, len, UTF16_LITTLE_ENDIAN,
    475     - (wchar_t *) &buf[2], 126);
    476     + (wchar_t *) &buf[2], USB_MAX_STRING_LEN);
    477     if (len < 0)
    478     return -EINVAL;
    479     buf [0] = (len + 1) * 2;
    480     diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
    481     index 0eebd0bd6bc0e..cad06c60ad663 100644
    482     --- a/fs/btrfs/ctree.c
    483     +++ b/fs/btrfs/ctree.c
    484     @@ -1422,7 +1422,9 @@ get_old_root(struct btrfs_root *root, u64 time_seq)
    485     btrfs_warn(root->fs_info,
    486     "failed to read tree block %llu from get_old_root", logical);
    487     } else {
    488     + btrfs_tree_read_lock(old);
    489     eb = btrfs_clone_extent_buffer(old);
    490     + btrfs_tree_read_unlock(old);
    491     free_extent_buffer(old);
    492     }
    493     } else if (old_root) {
    494     diff --git a/fs/ext4/block_validity.c b/fs/ext4/block_validity.c
    495     index 45c7b0f9a8e3f..c50dcda7b708a 100644
    496     --- a/fs/ext4/block_validity.c
    497     +++ b/fs/ext4/block_validity.c
    498     @@ -23,6 +23,7 @@ struct ext4_system_zone {
    499     struct rb_node node;
    500     ext4_fsblk_t start_blk;
    501     unsigned int count;
    502     + u32 ino;
    503     };
    504    
    505     static struct kmem_cache *ext4_system_zone_cachep;
    506     @@ -43,7 +44,8 @@ void ext4_exit_system_zone(void)
    507     static inline int can_merge(struct ext4_system_zone *entry1,
    508     struct ext4_system_zone *entry2)
    509     {
    510     - if ((entry1->start_blk + entry1->count) == entry2->start_blk)
    511     + if ((entry1->start_blk + entry1->count) == entry2->start_blk &&
    512     + entry1->ino == entry2->ino)
    513     return 1;
    514     return 0;
    515     }
    516     @@ -55,9 +57,9 @@ static inline int can_merge(struct ext4_system_zone *entry1,
    517     */
    518     static int add_system_zone(struct ext4_sb_info *sbi,
    519     ext4_fsblk_t start_blk,
    520     - unsigned int count)
    521     + unsigned int count, u32 ino)
    522     {
    523     - struct ext4_system_zone *new_entry = NULL, *entry;
    524     + struct ext4_system_zone *new_entry, *entry;
    525     struct rb_node **n = &sbi->system_blks.rb_node, *node;
    526     struct rb_node *parent = NULL, *new_node = NULL;
    527    
    528     @@ -68,30 +70,21 @@ static int add_system_zone(struct ext4_sb_info *sbi,
    529     n = &(*n)->rb_left;
    530     else if (start_blk >= (entry->start_blk + entry->count))
    531     n = &(*n)->rb_right;
    532     - else {
    533     - if (start_blk + count > (entry->start_blk +
    534     - entry->count))
    535     - entry->count = (start_blk + count -
    536     - entry->start_blk);
    537     - new_node = *n;
    538     - new_entry = rb_entry(new_node, struct ext4_system_zone,
    539     - node);
    540     - break;
    541     - }
    542     + else /* Unexpected overlap of system zones. */
    543     + return -EFSCORRUPTED;
    544     }
    545    
    546     - if (!new_entry) {
    547     - new_entry = kmem_cache_alloc(ext4_system_zone_cachep,
    548     - GFP_KERNEL);
    549     - if (!new_entry)
    550     - return -ENOMEM;
    551     - new_entry->start_blk = start_blk;
    552     - new_entry->count = count;
    553     - new_node = &new_entry->node;
    554     + new_entry = kmem_cache_alloc(ext4_system_zone_cachep,
    555     + GFP_KERNEL);
    556     + if (!new_entry)
    557     + return -ENOMEM;
    558     + new_entry->start_blk = start_blk;
    559     + new_entry->count = count;
    560     + new_entry->ino = ino;
    561     + new_node = &new_entry->node;
    562    
    563     - rb_link_node(new_node, parent, n);
    564     - rb_insert_color(new_node, &sbi->system_blks);
    565     - }
    566     + rb_link_node(new_node, parent, n);
    567     + rb_insert_color(new_node, &sbi->system_blks);
    568    
    569     /* Can we merge to the left? */
    570     node = rb_prev(new_node);
    571     @@ -163,16 +156,16 @@ static int ext4_protect_reserved_inode(struct super_block *sb, u32 ino)
    572     if (n == 0) {
    573     i++;
    574     } else {
    575     - if (!ext4_data_block_valid(sbi, map.m_pblk, n)) {
    576     - ext4_error(sb, "blocks %llu-%llu from inode %u "
    577     + err = add_system_zone(sbi, map.m_pblk, n, ino);
    578     + if (err < 0) {
    579     + if (err == -EFSCORRUPTED) {
    580     + ext4_error(sb,
    581     + "blocks %llu-%llu from inode %u "
    582     "overlap system zone", map.m_pblk,
    583     map.m_pblk + map.m_len - 1, ino);
    584     - err = -EFSCORRUPTED;
    585     + }
    586     break;
    587     }
    588     - err = add_system_zone(sbi, map.m_pblk, n);
    589     - if (err < 0)
    590     - break;
    591     i += n;
    592     }
    593     }
    594     @@ -201,16 +194,16 @@ int ext4_setup_system_zone(struct super_block *sb)
    595     if (ext4_bg_has_super(sb, i) &&
    596     ((i < 5) || ((i % flex_size) == 0)))
    597     add_system_zone(sbi, ext4_group_first_block_no(sb, i),
    598     - ext4_bg_num_gdb(sb, i) + 1);
    599     + ext4_bg_num_gdb(sb, i) + 1, 0);
    600     gdp = ext4_get_group_desc(sb, i, NULL);
    601     - ret = add_system_zone(sbi, ext4_block_bitmap(sb, gdp), 1);
    602     + ret = add_system_zone(sbi, ext4_block_bitmap(sb, gdp), 1, 0);
    603     if (ret)
    604     return ret;
    605     - ret = add_system_zone(sbi, ext4_inode_bitmap(sb, gdp), 1);
    606     + ret = add_system_zone(sbi, ext4_inode_bitmap(sb, gdp), 1, 0);
    607     if (ret)
    608     return ret;
    609     ret = add_system_zone(sbi, ext4_inode_table(sb, gdp),
    610     - sbi->s_itb_per_group);
    611     + sbi->s_itb_per_group, 0);
    612     if (ret)
    613     return ret;
    614     }
    615     @@ -243,10 +236,11 @@ void ext4_release_system_zone(struct super_block *sb)
    616     * start_blk+count) is valid; 0 if some part of the block region
    617     * overlaps with filesystem metadata blocks.
    618     */
    619     -int ext4_data_block_valid(struct ext4_sb_info *sbi, ext4_fsblk_t start_blk,
    620     - unsigned int count)
    621     +int ext4_inode_block_valid(struct inode *inode, ext4_fsblk_t start_blk,
    622     + unsigned int count)
    623     {
    624     struct ext4_system_zone *entry;
    625     + struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
    626     struct rb_node *n = sbi->system_blks.rb_node;
    627    
    628     if ((start_blk <= le32_to_cpu(sbi->s_es->s_first_data_block)) ||
    629     @@ -262,6 +256,8 @@ int ext4_data_block_valid(struct ext4_sb_info *sbi, ext4_fsblk_t start_blk,
    630     else if (start_blk >= (entry->start_blk + entry->count))
    631     n = n->rb_right;
    632     else {
    633     + if (entry->ino == inode->i_ino)
    634     + return 1;
    635     sbi->s_es->s_last_error_block = cpu_to_le64(start_blk);
    636     return 0;
    637     }
    638     @@ -284,8 +280,7 @@ int ext4_check_blockref(const char *function, unsigned int line,
    639     while (bref < p+max) {
    640     blk = le32_to_cpu(*bref++);
    641     if (blk &&
    642     - unlikely(!ext4_data_block_valid(EXT4_SB(inode->i_sb),
    643     - blk, 1))) {
    644     + unlikely(!ext4_inode_block_valid(inode, blk, 1))) {
    645     es->s_last_error_block = cpu_to_le64(blk);
    646     ext4_error_inode(inode, function, line, blk,
    647     "invalid block");
    648     diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
    649     index 54a7f3b8b1bf3..1b62bd9e73125 100644
    650     --- a/fs/ext4/ext4.h
    651     +++ b/fs/ext4/ext4.h
    652     @@ -3136,9 +3136,9 @@ extern void ext4_release_system_zone(struct super_block *sb);
    653     extern int ext4_setup_system_zone(struct super_block *sb);
    654     extern int __init ext4_init_system_zone(void);
    655     extern void ext4_exit_system_zone(void);
    656     -extern int ext4_data_block_valid(struct ext4_sb_info *sbi,
    657     - ext4_fsblk_t start_blk,
    658     - unsigned int count);
    659     +extern int ext4_inode_block_valid(struct inode *inode,
    660     + ext4_fsblk_t start_blk,
    661     + unsigned int count);
    662     extern int ext4_check_blockref(const char *, unsigned int,
    663     struct inode *, __le32 *, unsigned int);
    664    
    665     diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
    666     index ab19f61bd04bc..7f291b7be7f3a 100644
    667     --- a/fs/ext4/extents.c
    668     +++ b/fs/ext4/extents.c
    669     @@ -389,7 +389,7 @@ static int ext4_valid_extent(struct inode *inode, struct ext4_extent *ext)
    670     */
    671     if (lblock + len <= lblock)
    672     return 0;
    673     - return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, len);
    674     + return ext4_inode_block_valid(inode, block, len);
    675     }
    676    
    677     static int ext4_valid_extent_idx(struct inode *inode,
    678     @@ -397,7 +397,7 @@ static int ext4_valid_extent_idx(struct inode *inode,
    679     {
    680     ext4_fsblk_t block = ext4_idx_pblock(ext_idx);
    681    
    682     - return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, 1);
    683     + return ext4_inode_block_valid(inode, block, 1);
    684     }
    685    
    686     static int ext4_valid_extent_entries(struct inode *inode,
    687     @@ -554,14 +554,10 @@ __read_extent_tree_block(const char *function, unsigned int line,
    688     }
    689     if (buffer_verified(bh) && !(flags & EXT4_EX_FORCE_CACHE))
    690     return bh;
    691     - if (!ext4_has_feature_journal(inode->i_sb) ||
    692     - (inode->i_ino !=
    693     - le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_journal_inum))) {
    694     - err = __ext4_ext_check(function, line, inode,
    695     - ext_block_hdr(bh), depth, pblk);
    696     - if (err)
    697     - goto errout;
    698     - }
    699     + err = __ext4_ext_check(function, line, inode,
    700     + ext_block_hdr(bh), depth, pblk);
    701     + if (err)
    702     + goto errout;
    703     set_buffer_verified(bh);
    704     /*
    705     * If this is a leaf block, cache all of its entries
    706     diff --git a/fs/ext4/indirect.c b/fs/ext4/indirect.c
    707     index d2844fe9040dd..ff7e1ac6ee530 100644
    708     --- a/fs/ext4/indirect.c
    709     +++ b/fs/ext4/indirect.c
    710     @@ -840,8 +840,7 @@ static int ext4_clear_blocks(handle_t *handle, struct inode *inode,
    711     else if (ext4_should_journal_data(inode))
    712     flags |= EXT4_FREE_BLOCKS_FORGET;
    713    
    714     - if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), block_to_free,
    715     - count)) {
    716     + if (!ext4_inode_block_valid(inode, block_to_free, count)) {
    717     EXT4_ERROR_INODE(inode, "attempt to clear invalid "
    718     "blocks %llu len %lu",
    719     (unsigned long long) block_to_free, count);
    720     @@ -1003,8 +1002,7 @@ static void ext4_free_branches(handle_t *handle, struct inode *inode,
    721     if (!nr)
    722     continue; /* A hole */
    723    
    724     - if (!ext4_data_block_valid(EXT4_SB(inode->i_sb),
    725     - nr, 1)) {
    726     + if (!ext4_inode_block_valid(inode, nr, 1)) {
    727     EXT4_ERROR_INODE(inode,
    728     "invalid indirect mapped "
    729     "block %lu (level %d)",
    730     diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
    731     index ccce89de6d7e3..aa97a3ed3d8f7 100644
    732     --- a/fs/ext4/inode.c
    733     +++ b/fs/ext4/inode.c
    734     @@ -378,8 +378,7 @@ static int __check_block_validity(struct inode *inode, const char *func,
    735     (inode->i_ino ==
    736     le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_journal_inum)))
    737     return 0;
    738     - if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), map->m_pblk,
    739     - map->m_len)) {
    740     + if (!ext4_inode_block_valid(inode, map->m_pblk, map->m_len)) {
    741     ext4_error_inode(inode, func, line, map->m_pblk,
    742     "lblock %lu mapped to illegal pblock %llu "
    743     "(length %d)", (unsigned long) map->m_lblk,
    744     @@ -4704,7 +4703,7 @@ struct inode *__ext4_iget(struct super_block *sb, unsigned long ino,
    745    
    746     ret = 0;
    747     if (ei->i_file_acl &&
    748     - !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) {
    749     + !ext4_inode_block_valid(inode, ei->i_file_acl, 1)) {
    750     ext4_error_inode(inode, function, line, 0,
    751     "iget: bad extended attribute block %llu",
    752     ei->i_file_acl);
    753     @@ -4894,7 +4893,7 @@ static int ext4_do_update_inode(handle_t *handle,
    754     struct ext4_inode_info *ei = EXT4_I(inode);
    755     struct buffer_head *bh = iloc->bh;
    756     struct super_block *sb = inode->i_sb;
    757     - int err = 0, rc, block;
    758     + int err = 0, block;
    759     int need_datasync = 0, set_large_file = 0;
    760     uid_t i_uid;
    761     gid_t i_gid;
    762     @@ -5004,9 +5003,9 @@ static int ext4_do_update_inode(handle_t *handle,
    763     bh->b_data);
    764    
    765     BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
    766     - rc = ext4_handle_dirty_metadata(handle, NULL, bh);
    767     - if (!err)
    768     - err = rc;
    769     + err = ext4_handle_dirty_metadata(handle, NULL, bh);
    770     + if (err)
    771     + goto out_brelse;
    772     ext4_clear_inode_state(inode, EXT4_STATE_NEW);
    773     if (set_large_file) {
    774     BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get write access");
    775     diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
    776     index 1d543f8b3814f..807331da9dfc1 100644
    777     --- a/fs/ext4/mballoc.c
    778     +++ b/fs/ext4/mballoc.c
    779     @@ -2963,7 +2963,7 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
    780     block = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);
    781    
    782     len = EXT4_C2B(sbi, ac->ac_b_ex.fe_len);
    783     - if (!ext4_data_block_valid(sbi, block, len)) {
    784     + if (!ext4_inode_block_valid(ac->ac_inode, block, len)) {
    785     ext4_error(sb, "Allocating blocks %llu-%llu which overlap "
    786     "fs metadata", block, block+len);
    787     /* File system mounted not to panic on error
    788     @@ -4725,7 +4725,7 @@ void ext4_free_blocks(handle_t *handle, struct inode *inode,
    789    
    790     sbi = EXT4_SB(sb);
    791     if (!(flags & EXT4_FREE_BLOCKS_VALIDATED) &&
    792     - !ext4_data_block_valid(sbi, block, count)) {
    793     + !ext4_inode_block_valid(inode, block, count)) {
    794     ext4_error(sb, "Freeing blocks not in datazone - "
    795     "block = %llu, count = %lu", block, count);
    796     goto error_return;
    797     diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
    798     index 6224b0e6fb643..e6e3eb8dd4d6c 100644
    799     --- a/fs/ext4/namei.c
    800     +++ b/fs/ext4/namei.c
    801     @@ -3425,6 +3425,31 @@ static int ext4_setent(handle_t *handle, struct ext4_renament *ent,
    802     return 0;
    803     }
    804    
    805     +static void ext4_resetent(handle_t *handle, struct ext4_renament *ent,
    806     + unsigned ino, unsigned file_type)
    807     +{
    808     + struct ext4_renament old = *ent;
    809     + int retval = 0;
    810     +
    811     + /*
    812     + * old->de could have moved from under us during make indexed dir,
    813     + * so the old->de may no longer valid and need to find it again
    814     + * before reset old inode info.
    815     + */
    816     + old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, NULL);
    817     + if (IS_ERR(old.bh))
    818     + retval = PTR_ERR(old.bh);
    819     + if (!old.bh)
    820     + retval = -ENOENT;
    821     + if (retval) {
    822     + ext4_std_error(old.dir->i_sb, retval);
    823     + return;
    824     + }
    825     +
    826     + ext4_setent(handle, &old, ino, file_type);
    827     + brelse(old.bh);
    828     +}
    829     +
    830     static int ext4_find_delete_entry(handle_t *handle, struct inode *dir,
    831     const struct qstr *d_name)
    832     {
    833     @@ -3734,8 +3759,8 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
    834     end_rename:
    835     if (whiteout) {
    836     if (retval) {
    837     - ext4_setent(handle, &old,
    838     - old.inode->i_ino, old_file_type);
    839     + ext4_resetent(handle, &old,
    840     + old.inode->i_ino, old_file_type);
    841     drop_nlink(whiteout);
    842     }
    843     unlock_new_inode(whiteout);
    844     diff --git a/fs/ext4/super.c b/fs/ext4/super.c
    845     index 84d28d3efc602..f70c5541d718d 100644
    846     --- a/fs/ext4/super.c
    847     +++ b/fs/ext4/super.c
    848     @@ -5148,7 +5148,10 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
    849     ext4_register_li_request(sb, first_not_zeroed);
    850     }
    851    
    852     - ext4_setup_system_zone(sb);
    853     + err = ext4_setup_system_zone(sb);
    854     + if (err)
    855     + goto restore_opts;
    856     +
    857     if (sbi->s_journal == NULL && !(old_sb_flags & MS_RDONLY))
    858     ext4_commit_super(sb, 1);
    859    
    860     diff --git a/fs/select.c b/fs/select.c
    861     index 3d4f85defeab0..de675c79f479d 100644
    862     --- a/fs/select.c
    863     +++ b/fs/select.c
    864     @@ -961,10 +961,9 @@ static long do_restart_poll(struct restart_block *restart_block)
    865    
    866     ret = do_sys_poll(ufds, nfds, to);
    867    
    868     - if (ret == -EINTR) {
    869     - restart_block->fn = do_restart_poll;
    870     - ret = -ERESTART_RESTARTBLOCK;
    871     - }
    872     + if (ret == -EINTR)
    873     + ret = set_restart_fn(restart_block, do_restart_poll);
    874     +
    875     return ret;
    876     }
    877    
    878     @@ -986,7 +985,6 @@ SYSCALL_DEFINE3(poll, struct pollfd __user *, ufds, unsigned int, nfds,
    879     struct restart_block *restart_block;
    880    
    881     restart_block = &current->restart_block;
    882     - restart_block->fn = do_restart_poll;
    883     restart_block->poll.ufds = ufds;
    884     restart_block->poll.nfds = nfds;
    885    
    886     @@ -997,7 +995,7 @@ SYSCALL_DEFINE3(poll, struct pollfd __user *, ufds, unsigned int, nfds,
    887     } else
    888     restart_block->poll.has_timeout = 0;
    889    
    890     - ret = -ERESTART_RESTARTBLOCK;
    891     + ret = set_restart_fn(restart_block, do_restart_poll);
    892     }
    893     return ret;
    894     }
    895     diff --git a/include/linux/thread_info.h b/include/linux/thread_info.h
    896     index 5e6436741f968..330794252270d 100644
    897     --- a/include/linux/thread_info.h
    898     +++ b/include/linux/thread_info.h
    899     @@ -9,6 +9,7 @@
    900    
    901     #include <linux/types.h>
    902     #include <linux/bug.h>
    903     +#include <linux/errno.h>
    904    
    905     struct timespec;
    906     struct compat_timespec;
    907     @@ -59,6 +60,18 @@ extern long do_no_restart_syscall(struct restart_block *parm);
    908    
    909     #ifdef __KERNEL__
    910    
    911     +#ifndef arch_set_restart_data
    912     +#define arch_set_restart_data(restart) do { } while (0)
    913     +#endif
    914     +
    915     +static inline long set_restart_fn(struct restart_block *restart,
    916     + long (*fn)(struct restart_block *))
    917     +{
    918     + restart->fn = fn;
    919     + arch_set_restart_data(restart);
    920     + return -ERESTART_RESTARTBLOCK;
    921     +}
    922     +
    923     #define THREADINFO_GFP (GFP_KERNEL_ACCOUNT | __GFP_NOTRACK | __GFP_ZERO)
    924    
    925     /*
    926     diff --git a/include/uapi/linux/usb/ch9.h b/include/uapi/linux/usb/ch9.h
    927     index 33c603dd7cd30..8e0e6d3091f19 100644
    928     --- a/include/uapi/linux/usb/ch9.h
    929     +++ b/include/uapi/linux/usb/ch9.h
    930     @@ -358,6 +358,9 @@ struct usb_config_descriptor {
    931    
    932     /*-------------------------------------------------------------------------*/
    933    
    934     +/* USB String descriptors can contain at most 126 characters. */
    935     +#define USB_MAX_STRING_LEN 126
    936     +
    937     /* USB_DT_STRING: String descriptor */
    938     struct usb_string_descriptor {
    939     __u8 bLength;
    940     diff --git a/kernel/futex.c b/kernel/futex.c
    941     index 0015c14ac2c04..796b1c8608397 100644
    942     --- a/kernel/futex.c
    943     +++ b/kernel/futex.c
    944     @@ -2822,14 +2822,13 @@ retry:
    945     goto out;
    946    
    947     restart = &current->restart_block;
    948     - restart->fn = futex_wait_restart;
    949     restart->futex.uaddr = uaddr;
    950     restart->futex.val = val;
    951     restart->futex.time = abs_time->tv64;
    952     restart->futex.bitset = bitset;
    953     restart->futex.flags = flags | FLAGS_HAS_TIMEOUT;
    954    
    955     - ret = -ERESTART_RESTARTBLOCK;
    956     + ret = set_restart_fn(restart, futex_wait_restart);
    957    
    958     out:
    959     if (to) {
    960     diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
    961     index b2fc2a581b861..33770ef64d219 100644
    962     --- a/kernel/irq/manage.c
    963     +++ b/kernel/irq/manage.c
    964     @@ -886,11 +886,15 @@ irq_forced_thread_fn(struct irq_desc *desc, struct irqaction *action)
    965     irqreturn_t ret;
    966    
    967     local_bh_disable();
    968     + if (!IS_ENABLED(CONFIG_PREEMPT_RT_BASE))
    969     + local_irq_disable();
    970     ret = action->thread_fn(action->irq, action->dev_id);
    971     if (ret == IRQ_HANDLED)
    972     atomic_inc(&desc->threads_handled);
    973    
    974     irq_finalize_oneshot(desc, action);
    975     + if (!IS_ENABLED(CONFIG_PREEMPT_RT_BASE))
    976     + local_irq_enable();
    977     local_bh_enable();
    978     return ret;
    979     }
    980     diff --git a/kernel/time/alarmtimer.c b/kernel/time/alarmtimer.c
    981     index 6aef4a0bed29e..d06c1d8dd4d27 100644
    982     --- a/kernel/time/alarmtimer.c
    983     +++ b/kernel/time/alarmtimer.c
    984     @@ -809,10 +809,10 @@ static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
    985     }
    986    
    987     restart = &current->restart_block;
    988     - restart->fn = alarm_timer_nsleep_restart;
    989     restart->nanosleep.clockid = type;
    990     restart->nanosleep.expires = exp.tv64;
    991     restart->nanosleep.rmtp = rmtp;
    992     + set_restart_fn(restart, alarm_timer_nsleep_restart);
    993     ret = -ERESTART_RESTARTBLOCK;
    994    
    995     out:
    996     diff --git a/kernel/time/hrtimer.c b/kernel/time/hrtimer.c
    997     index f31637ced7fac..df7750e032425 100644
    998     --- a/kernel/time/hrtimer.c
    999     +++ b/kernel/time/hrtimer.c
    1000     @@ -1582,10 +1582,10 @@ long hrtimer_nanosleep(struct timespec *rqtp, struct timespec __user *rmtp,
    1001     }
    1002    
    1003     restart = &current->restart_block;
    1004     - restart->fn = hrtimer_nanosleep_restart;
    1005     restart->nanosleep.clockid = t.timer.base->clockid;
    1006     restart->nanosleep.rmtp = rmtp;
    1007     restart->nanosleep.expires = hrtimer_get_expires_tv64(&t.timer);
    1008     + set_restart_fn(restart, hrtimer_nanosleep_restart);
    1009    
    1010     ret = -ERESTART_RESTARTBLOCK;
    1011     out:
    1012     diff --git a/kernel/time/posix-cpu-timers.c b/kernel/time/posix-cpu-timers.c
    1013     index 21a27bb735870..9fff077d0ffc4 100644
    1014     --- a/kernel/time/posix-cpu-timers.c
    1015     +++ b/kernel/time/posix-cpu-timers.c
    1016     @@ -1377,10 +1377,10 @@ static int posix_cpu_nsleep(const clockid_t which_clock, int flags,
    1017     if (rmtp && copy_to_user(rmtp, &it.it_value, sizeof *rmtp))
    1018     return -EFAULT;
    1019    
    1020     - restart_block->fn = posix_cpu_nsleep_restart;
    1021     restart_block->nanosleep.clockid = which_clock;
    1022     restart_block->nanosleep.rmtp = rmtp;
    1023     restart_block->nanosleep.expires = timespec_to_ns(rqtp);
    1024     + set_restart_fn(restart_block, posix_cpu_nsleep_restart);
    1025     }
    1026     return error;
    1027     }
    1028     diff --git a/net/qrtr/qrtr.c b/net/qrtr/qrtr.c
    1029     index a8253079902fb..d62b7a7f65bb0 100644
    1030     --- a/net/qrtr/qrtr.c
    1031     +++ b/net/qrtr/qrtr.c
    1032     @@ -232,7 +232,7 @@ int qrtr_endpoint_post(struct qrtr_endpoint *ep, const void *data, size_t len)
    1033     if (dst != QRTR_PORT_CTRL && type != QRTR_TYPE_DATA)
    1034     return -EINVAL;
    1035    
    1036     - skb = netdev_alloc_skb(NULL, len);
    1037     + skb = __netdev_alloc_skb(NULL, len, GFP_ATOMIC | __GFP_NOWARN);
    1038     if (!skb)
    1039     return -ENOMEM;
    1040    
    1041     diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
    1042     index eea18a124e4f7..ab6b7852a11cf 100644
    1043     --- a/net/sunrpc/svc.c
    1044     +++ b/net/sunrpc/svc.c
    1045     @@ -1306,7 +1306,7 @@ svc_process_common(struct svc_rqst *rqstp, struct kvec *argv, struct kvec *resv)
    1046    
    1047     sendit:
    1048     if (svc_authorise(rqstp))
    1049     - goto close;
    1050     + goto close_xprt;
    1051     return 1; /* Caller can now send it */
    1052    
    1053     dropit:
    1054     @@ -1315,6 +1315,8 @@ svc_process_common(struct svc_rqst *rqstp, struct kvec *argv, struct kvec *resv)
    1055     return 0;
    1056    
    1057     close:
    1058     + svc_authorise(rqstp);
    1059     +close_xprt:
    1060     if (rqstp->rq_xprt && test_bit(XPT_TEMP, &rqstp->rq_xprt->xpt_flags))
    1061     svc_close_xprt(rqstp->rq_xprt);
    1062     dprintk("svc: svc_process close\n");
    1063     @@ -1323,7 +1325,7 @@ svc_process_common(struct svc_rqst *rqstp, struct kvec *argv, struct kvec *resv)
    1064     err_short_len:
    1065     svc_printk(rqstp, "short len %Zd, dropping request\n",
    1066     argv->iov_len);
    1067     - goto close;
    1068     + goto close_xprt;
    1069    
    1070     err_bad_rpc:
    1071     serv->sv_stats->rpcbadfmt++;
    1072     diff --git a/net/sunrpc/svc_xprt.c b/net/sunrpc/svc_xprt.c
    1073     index 56e4ac8e2e994..7d366f6bef863 100644
    1074     --- a/net/sunrpc/svc_xprt.c
    1075     +++ b/net/sunrpc/svc_xprt.c
    1076     @@ -1104,7 +1104,7 @@ static int svc_close_list(struct svc_serv *serv, struct list_head *xprt_list, st
    1077     struct svc_xprt *xprt;
    1078     int ret = 0;
    1079    
    1080     - spin_lock(&serv->sv_lock);
    1081     + spin_lock_bh(&serv->sv_lock);
    1082     list_for_each_entry(xprt, xprt_list, xpt_list) {
    1083     if (xprt->xpt_net != net)
    1084     continue;
    1085     @@ -1112,7 +1112,7 @@ static int svc_close_list(struct svc_serv *serv, struct list_head *xprt_list, st
    1086     set_bit(XPT_CLOSE, &xprt->xpt_flags);
    1087     svc_xprt_enqueue(xprt);
    1088     }
    1089     - spin_unlock(&serv->sv_lock);
    1090     + spin_unlock_bh(&serv->sv_lock);
    1091     return ret;
    1092     }
    1093    
    1094     diff --git a/net/sunrpc/xprtrdma/svc_rdma_backchannel.c b/net/sunrpc/xprtrdma/svc_rdma_backchannel.c
    1095     index b3d48c6243c80..791072cd94920 100644
    1096     --- a/net/sunrpc/xprtrdma/svc_rdma_backchannel.c
    1097     +++ b/net/sunrpc/xprtrdma/svc_rdma_backchannel.c
    1098     @@ -328,9 +328,9 @@ xprt_setup_rdma_bc(struct xprt_create *args)
    1099     xprt->timeout = &xprt_rdma_bc_timeout;
    1100     xprt_set_bound(xprt);
    1101     xprt_set_connected(xprt);
    1102     - xprt->bind_timeout = RPCRDMA_BIND_TO;
    1103     - xprt->reestablish_timeout = RPCRDMA_INIT_REEST_TO;
    1104     - xprt->idle_timeout = RPCRDMA_IDLE_DISC_TO;
    1105     + xprt->bind_timeout = 0;
    1106     + xprt->reestablish_timeout = 0;
    1107     + xprt->idle_timeout = 0;
    1108    
    1109     xprt->prot = XPRT_TRANSPORT_BC_RDMA;
    1110     xprt->tsh_size = RPCRDMA_HDRLEN_MIN / sizeof(__be32);