Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel-alx/patches-3.18/0119-3.18.20-all-fixes.patch

    Contents of /trunk/kernel-alx/patches-3.18/0119-3.18.20-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 2690 - (show annotations) (download)
    Mon Aug 31 12:19:39 2015 UTC (8 years, 8 months ago) by niro
    File size: 60551 byte(s) 
    -linux-3.18.20
    1 diff --git a/Documentation/devicetree/bindings/spi/spi_pl022.txt b/Documentation/devicetree/bindings/spi/spi_pl022.txt
    2 index 22ed6797216d..4d1673ca8cf8 100644
    3 --- a/Documentation/devicetree/bindings/spi/spi_pl022.txt
    4 +++ b/Documentation/devicetree/bindings/spi/spi_pl022.txt
    5 @@ -4,9 +4,9 @@ Required properties:
    6 - compatible : "arm,pl022", "arm,primecell"
    7 - reg : Offset and length of the register set for the device
    8 - interrupts : Should contain SPI controller interrupt
    9 +- num-cs : total number of chipselects
    10
    11 Optional properties:
    12 -- num-cs : total number of chipselects
    13 - cs-gpios : should specify GPIOs used for chipselects.
    14 The gpios will be referred to as reg = <index> in the SPI child nodes.
    15 If unspecified, a single SPI device without a chip select can be used.
    16 diff --git a/Makefile b/Makefile
    17 index eab97c3d462d..3ef589539cca 100644
    18 --- a/Makefile
    19 +++ b/Makefile
    20 @@ -1,6 +1,6 @@
    21 VERSION = 3
    22 PATCHLEVEL = 18
    23 -SUBLEVEL = 19
    24 +SUBLEVEL = 20
    25 EXTRAVERSION =
    26 NAME = Diseased Newt
    27
    28 diff --git a/arch/arm64/mm/hugetlbpage.c b/arch/arm64/mm/hugetlbpage.c
    29 index 2de9d2e59d96..0eeb4f0930a0 100644
    30 --- a/arch/arm64/mm/hugetlbpage.c
    31 +++ b/arch/arm64/mm/hugetlbpage.c
    32 @@ -40,13 +40,13 @@ int huge_pmd_unshare(struct mm_struct *mm, unsigned long *addr, pte_t *ptep)
    33
    34 int pmd_huge(pmd_t pmd)
    35 {
    36 - return !(pmd_val(pmd) & PMD_TABLE_BIT);
    37 + return pmd_val(pmd) && !(pmd_val(pmd) & PMD_TABLE_BIT);
    38 }
    39
    40 int pud_huge(pud_t pud)
    41 {
    42 #ifndef __PAGETABLE_PMD_FOLDED
    43 - return !(pud_val(pud) & PUD_TABLE_BIT);
    44 + return pud_val(pud) && !(pud_val(pud) & PUD_TABLE_BIT);
    45 #else
    46 return 0;
    47 #endif
    48 diff --git a/block/blk-mq.c b/block/blk-mq.c
    49 index 849479debac3..691959ecb80f 100644
    50 --- a/block/blk-mq.c
    51 +++ b/block/blk-mq.c
    52 @@ -1473,22 +1473,6 @@ static int blk_mq_hctx_cpu_offline(struct blk_mq_hw_ctx *hctx, int cpu)
    53 return NOTIFY_OK;
    54 }
    55
    56 -static int blk_mq_hctx_cpu_online(struct blk_mq_hw_ctx *hctx, int cpu)
    57 -{
    58 - struct request_queue *q = hctx->queue;
    59 - struct blk_mq_tag_set *set = q->tag_set;
    60 -
    61 - if (set->tags[hctx->queue_num])
    62 - return NOTIFY_OK;
    63 -
    64 - set->tags[hctx->queue_num] = blk_mq_init_rq_map(set, hctx->queue_num);
    65 - if (!set->tags[hctx->queue_num])
    66 - return NOTIFY_STOP;
    67 -
    68 - hctx->tags = set->tags[hctx->queue_num];
    69 - return NOTIFY_OK;
    70 -}
    71 -
    72 static int blk_mq_hctx_notify(void *data, unsigned long action,
    73 unsigned int cpu)
    74 {
    75 @@ -1496,8 +1480,11 @@ static int blk_mq_hctx_notify(void *data, unsigned long action,
    76
    77 if (action == CPU_DEAD || action == CPU_DEAD_FROZEN)
    78 return blk_mq_hctx_cpu_offline(hctx, cpu);
    79 - else if (action == CPU_ONLINE || action == CPU_ONLINE_FROZEN)
    80 - return blk_mq_hctx_cpu_online(hctx, cpu);
    81 +
    82 + /*
    83 + * In case of CPU online, tags may be reallocated
    84 + * in blk_mq_map_swqueue() after mapping is updated.
    85 + */
    86
    87 return NOTIFY_OK;
    88 }
    89 @@ -1682,6 +1669,7 @@ static void blk_mq_map_swqueue(struct request_queue *q)
    90 unsigned int i;
    91 struct blk_mq_hw_ctx *hctx;
    92 struct blk_mq_ctx *ctx;
    93 + struct blk_mq_tag_set *set = q->tag_set;
    94
    95 queue_for_each_hw_ctx(q, hctx, i) {
    96 cpumask_clear(hctx->cpumask);
    97 @@ -1708,16 +1696,20 @@ static void blk_mq_map_swqueue(struct request_queue *q)
    98 * disable it and free the request entries.
    99 */
    100 if (!hctx->nr_ctx) {
    101 - struct blk_mq_tag_set *set = q->tag_set;
    102 -
    103 if (set->tags[i]) {
    104 blk_mq_free_rq_map(set, set->tags[i], i);
    105 set->tags[i] = NULL;
    106 - hctx->tags = NULL;
    107 }
    108 + hctx->tags = NULL;
    109 continue;
    110 }
    111
    112 + /* unmapped hw queue can be remapped after CPU topo changed */
    113 + if (!set->tags[i])
    114 + set->tags[i] = blk_mq_init_rq_map(set, i);
    115 + hctx->tags = set->tags[i];
    116 + WARN_ON(!hctx->tags);
    117 +
    118 /*
    119 * Initialize batch roundrobin counts
    120 */
    121 diff --git a/drivers/acpi/acpica/utxfinit.c b/drivers/acpi/acpica/utxfinit.c
    122 index 13380d818462..64f8f307243b 100644
    123 --- a/drivers/acpi/acpica/utxfinit.c
    124 +++ b/drivers/acpi/acpica/utxfinit.c
    125 @@ -175,10 +175,12 @@ acpi_status __init acpi_enable_subsystem(u32 flags)
    126 * Obtain a permanent mapping for the FACS. This is required for the
    127 * Global Lock and the Firmware Waking Vector
    128 */
    129 - status = acpi_tb_initialize_facs();
    130 - if (ACPI_FAILURE(status)) {
    131 - ACPI_WARNING((AE_INFO, "Could not map the FACS table"));
    132 - return_ACPI_STATUS(status);
    133 + if (!(flags & ACPI_NO_FACS_INIT)) {
    134 + status = acpi_tb_initialize_facs();
    135 + if (ACPI_FAILURE(status)) {
    136 + ACPI_WARNING((AE_INFO, "Could not map the FACS table"));
    137 + return_ACPI_STATUS(status);
    138 + }
    139 }
    140 #endif /* !ACPI_REDUCED_HARDWARE */
    141
    142 diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
    143 index 64af3bf2b4c7..98dc0dc605bc 100644
    144 --- a/drivers/ata/libata-core.c
    145 +++ b/drivers/ata/libata-core.c
    146 @@ -4174,9 +4174,10 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
    147 { "ST3320[68]13AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
    148 ATA_HORKAGE_FIRMWARE_WARN },
    149
    150 - /* Seagate Momentus SpinPoint M8 seem to have FPMDA_AA issues */
    151 + /* drives which fail FPDMA_AA activation (some may freeze afterwards) */
    152 { "ST1000LM024 HN-M101MBB", "2AR10001", ATA_HORKAGE_BROKEN_FPDMA_AA },
    153 { "ST1000LM024 HN-M101MBB", "2BA30001", ATA_HORKAGE_BROKEN_FPDMA_AA },
    154 + { "VB0250EAVER", "HPG7", ATA_HORKAGE_BROKEN_FPDMA_AA },
    155
    156 /* Blacklist entries taken from Silicon Image 3124/3132
    157 Windows driver .inf file - also several Linux problem reports */
    158 @@ -4230,6 +4231,9 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
    159 { "Micron_M550*", NULL, ATA_HORKAGE_NO_NCQ_TRIM, },
    160 { "Crucial_CT*M550SSD*", NULL, ATA_HORKAGE_NO_NCQ_TRIM, },
    161
    162 + /* devices that don't properly handle TRIM commands */
    163 + { "SuperSSpeed S238*", NULL, ATA_HORKAGE_NOTRIM, },
    164 +
    165 /*
    166 * Some WD SATA-I drives spin up and down erratically when the link
    167 * is put into the slumber mode. We don't have full list of the
    168 @@ -4467,7 +4471,8 @@ static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
    169 else /* In the ancient relic department - skip all of this */
    170 return 0;
    171
    172 - err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
    173 + /* On some disks, this command causes spin-up, so we need longer timeout */
    174 + err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 15000);
    175
    176 DPRINTK("EXIT, err_mask=%x\n", err_mask);
    177 return err_mask;
    178 diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
    179 index 0586f66d70fa..d6ff64248c23 100644
    180 --- a/drivers/ata/libata-scsi.c
    181 +++ b/drivers/ata/libata-scsi.c
    182 @@ -2514,7 +2514,8 @@ static unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf)
    183 rbuf[14] = (lowest_aligned >> 8) & 0x3f;
    184 rbuf[15] = lowest_aligned;
    185
    186 - if (ata_id_has_trim(args->id)) {
    187 + if (ata_id_has_trim(args->id) &&
    188 + !(dev->horkage & ATA_HORKAGE_NOTRIM)) {
    189 rbuf[14] |= 0x80; /* TPE */
    190
    191 if (ata_id_has_zero_after_trim(args->id))
    192 diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
    193 index 3d785ebb48d3..50e8bd00e431 100644
    194 --- a/drivers/base/firmware_class.c
    195 +++ b/drivers/base/firmware_class.c
    196 @@ -545,10 +545,8 @@ static void fw_dev_release(struct device *dev)
    197 kfree(fw_priv);
    198 }
    199
    200 -static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
    201 +static int do_firmware_uevent(struct firmware_priv *fw_priv, struct kobj_uevent_env *env)
    202 {
    203 - struct firmware_priv *fw_priv = to_firmware_priv(dev);
    204 -
    205 if (add_uevent_var(env, "FIRMWARE=%s", fw_priv->buf->fw_id))
    206 return -ENOMEM;
    207 if (add_uevent_var(env, "TIMEOUT=%i", loading_timeout))
    208 @@ -559,6 +557,18 @@ static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
    209 return 0;
    210 }
    211
    212 +static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
    213 +{
    214 + struct firmware_priv *fw_priv = to_firmware_priv(dev);
    215 + int err = 0;
    216 +
    217 + mutex_lock(&fw_lock);
    218 + if (fw_priv->buf)
    219 + err = do_firmware_uevent(fw_priv, env);
    220 + mutex_unlock(&fw_lock);
    221 + return err;
    222 +}
    223 +
    224 static struct class firmware_class = {
    225 .name = "firmware",
    226 .class_attrs = firmware_class_attrs,
    227 diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
    228 index b7f101b52d81..0cd6e0d7dd1a 100644
    229 --- a/drivers/gpu/drm/drm_crtc.c
    230 +++ b/drivers/gpu/drm/drm_crtc.c
    231 @@ -2555,8 +2555,11 @@ int drm_mode_setcrtc(struct drm_device *dev, void *data,
    232 if (!drm_core_check_feature(dev, DRIVER_MODESET))
    233 return -EINVAL;
    234
    235 - /* For some reason crtc x/y offsets are signed internally. */
    236 - if (crtc_req->x > INT_MAX || crtc_req->y > INT_MAX)
    237 + /*
    238 + * Universal plane src offsets are only 16.16, prevent havoc for
    239 + * drivers using universal plane code internally.
    240 + */
    241 + if (crtc_req->x & 0xffff0000 || crtc_req->y & 0xffff0000)
    242 return -ERANGE;
    243
    244 drm_modeset_lock_all(dev);
    245 diff --git a/drivers/gpu/drm/radeon/si_dpm.c b/drivers/gpu/drm/radeon/si_dpm.c
    246 index 534edaa77940..c6ad8a9f1452 100644
    247 --- a/drivers/gpu/drm/radeon/si_dpm.c
    248 +++ b/drivers/gpu/drm/radeon/si_dpm.c
    249 @@ -2922,6 +2922,7 @@ static struct si_dpm_quirk si_dpm_quirk_list[] = {
    250 /* PITCAIRN - https://bugs.freedesktop.org/show_bug.cgi?id=76490 */
    251 { PCI_VENDOR_ID_ATI, 0x6810, 0x1462, 0x3036, 0, 120000 },
    252 { PCI_VENDOR_ID_ATI, 0x6811, 0x174b, 0xe271, 0, 120000 },
    253 + { PCI_VENDOR_ID_ATI, 0x6810, 0x174b, 0xe271, 85000, 90000 },
    254 { 0, 0, 0, 0 },
    255 };
    256
    257 diff --git a/drivers/iio/adc/at91_adc.c b/drivers/iio/adc/at91_adc.c
    258 index ff61ae55dd3f..0047db49ee5e 100644
    259 --- a/drivers/iio/adc/at91_adc.c
    260 +++ b/drivers/iio/adc/at91_adc.c
    261 @@ -182,7 +182,7 @@ struct at91_adc_caps {
    262 u8 ts_pen_detect_sensitivity;
    263
    264 /* startup time calculate function */
    265 - u32 (*calc_startup_ticks)(u8 startup_time, u32 adc_clk_khz);
    266 + u32 (*calc_startup_ticks)(u32 startup_time, u32 adc_clk_khz);
    267
    268 u8 num_channels;
    269 struct at91_adc_reg_desc registers;
    270 @@ -201,7 +201,7 @@ struct at91_adc_state {
    271 u8 num_channels;
    272 void __iomem *reg_base;
    273 struct at91_adc_reg_desc *registers;
    274 - u8 startup_time;
    275 + u32 startup_time;
    276 u8 sample_hold_time;
    277 bool sleep_mode;
    278 struct iio_trigger **trig;
    279 @@ -780,7 +780,7 @@ ret:
    280 return ret;
    281 }
    282
    283 -static u32 calc_startup_ticks_9260(u8 startup_time, u32 adc_clk_khz)
    284 +static u32 calc_startup_ticks_9260(u32 startup_time, u32 adc_clk_khz)
    285 {
    286 /*
    287 * Number of ticks needed to cover the startup time of the ADC
    288 @@ -791,7 +791,7 @@ static u32 calc_startup_ticks_9260(u8 startup_time, u32 adc_clk_khz)
    289 return round_up((startup_time * adc_clk_khz / 1000) - 1, 8) / 8;
    290 }
    291
    292 -static u32 calc_startup_ticks_9x5(u8 startup_time, u32 adc_clk_khz)
    293 +static u32 calc_startup_ticks_9x5(u32 startup_time, u32 adc_clk_khz)
    294 {
    295 /*
    296 * For sama5d3x and at91sam9x5, the formula changes to:
    297 diff --git a/drivers/iio/dac/ad5624r_spi.c b/drivers/iio/dac/ad5624r_spi.c
    298 index 61bb9d4239ea..e98428df0d44 100644
    299 --- a/drivers/iio/dac/ad5624r_spi.c
    300 +++ b/drivers/iio/dac/ad5624r_spi.c
    301 @@ -22,7 +22,7 @@
    302 #include "ad5624r.h"
    303
    304 static int ad5624r_spi_write(struct spi_device *spi,
    305 - u8 cmd, u8 addr, u16 val, u8 len)
    306 + u8 cmd, u8 addr, u16 val, u8 shift)
    307 {
    308 u32 data;
    309 u8 msg[3];
    310 @@ -35,7 +35,7 @@ static int ad5624r_spi_write(struct spi_device *spi,
    311 * 14-, 12-bit input code followed by 0, 2, or 4 don't care bits,
    312 * for the AD5664R, AD5644R, and AD5624R, respectively.
    313 */
    314 - data = (0 << 22) | (cmd << 19) | (addr << 16) | (val << (16 - len));
    315 + data = (0 << 22) | (cmd << 19) | (addr << 16) | (val << shift);
    316 msg[0] = data >> 16;
    317 msg[1] = data >> 8;
    318 msg[2] = data;
    319 diff --git a/drivers/iio/temperature/tmp006.c b/drivers/iio/temperature/tmp006.c
    320 index 84a0789c3d96..7a8050996b4e 100644
    321 --- a/drivers/iio/temperature/tmp006.c
    322 +++ b/drivers/iio/temperature/tmp006.c
    323 @@ -132,6 +132,9 @@ static int tmp006_write_raw(struct iio_dev *indio_dev,
    324 struct tmp006_data *data = iio_priv(indio_dev);
    325 int i;
    326
    327 + if (mask != IIO_CHAN_INFO_SAMP_FREQ)
    328 + return -EINVAL;
    329 +
    330 for (i = 0; i < ARRAY_SIZE(tmp006_freqs); i++)
    331 if ((val == tmp006_freqs[i][0]) &&
    332 (val2 == tmp006_freqs[i][1])) {
    333 diff --git a/drivers/infiniband/ulp/isert/ib_isert.c b/drivers/infiniband/ulp/isert/ib_isert.c
    334 index 02c494a8d111..7b8c29b295ac 100644
    335 --- a/drivers/infiniband/ulp/isert/ib_isert.c
    336 +++ b/drivers/infiniband/ulp/isert/ib_isert.c
    337 @@ -220,7 +220,7 @@ fail:
    338 static void
    339 isert_free_rx_descriptors(struct isert_conn *isert_conn)
    340 {
    341 - struct ib_device *ib_dev = isert_conn->conn_cm_id->device;
    342 + struct ib_device *ib_dev = isert_conn->conn_device->ib_device;
    343 struct iser_rx_desc *rx_desc;
    344 int i;
    345
    346 @@ -742,9 +742,9 @@ out:
    347 static void
    348 isert_connect_release(struct isert_conn *isert_conn)
    349 {
    350 - struct ib_device *ib_dev = isert_conn->conn_cm_id->device;
    351 struct isert_device *device = isert_conn->conn_device;
    352 int cq_index;
    353 + struct ib_device *ib_dev = device->ib_device;
    354
    355 pr_debug("Entering isert_connect_release(): >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
    356
    357 @@ -752,7 +752,8 @@ isert_connect_release(struct isert_conn *isert_conn)
    358 isert_conn_free_fastreg_pool(isert_conn);
    359
    360 isert_free_rx_descriptors(isert_conn);
    361 - rdma_destroy_id(isert_conn->conn_cm_id);
    362 + if (isert_conn->conn_cm_id)
    363 + rdma_destroy_id(isert_conn->conn_cm_id);
    364
    365 if (isert_conn->conn_qp) {
    366 cq_index = ((struct isert_cq_desc *)
    367 @@ -924,12 +925,15 @@ out:
    368 return 0;
    369 }
    370
    371 -static void
    372 +static int
    373 isert_connect_error(struct rdma_cm_id *cma_id)
    374 {
    375 struct isert_conn *isert_conn = cma_id->qp->qp_context;
    376
    377 + isert_conn->conn_cm_id = NULL;
    378 isert_put_conn(isert_conn);
    379 +
    380 + return -1;
    381 }
    382
    383 static int
    384 @@ -959,7 +963,7 @@ isert_cma_handler(struct rdma_cm_id *cma_id, struct rdma_cm_event *event)
    385 case RDMA_CM_EVENT_REJECTED: /* FALLTHRU */
    386 case RDMA_CM_EVENT_UNREACHABLE: /* FALLTHRU */
    387 case RDMA_CM_EVENT_CONNECT_ERROR:
    388 - isert_connect_error(cma_id);
    389 + ret = isert_connect_error(cma_id);
    390 break;
    391 default:
    392 pr_err("Unhandled RDMA CMA event: %d\n", event->event);
    393 diff --git a/drivers/md/md.c b/drivers/md/md.c
    394 index 9233c71138f1..43390353d62f 100644
    395 --- a/drivers/md/md.c
    396 +++ b/drivers/md/md.c
    397 @@ -6031,7 +6031,7 @@ static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
    398 mddev->ctime != info->ctime ||
    399 mddev->level != info->level ||
    400 /* mddev->layout != info->layout || */
    401 - !mddev->persistent != info->not_persistent||
    402 + mddev->persistent != !info->not_persistent ||
    403 mddev->chunk_sectors != info->chunk_size >> 9 ||
    404 /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
    405 ((state^info->state) & 0xfffffe00)
    406 diff --git a/drivers/md/persistent-data/dm-btree-remove.c b/drivers/md/persistent-data/dm-btree-remove.c
    407 index b88757cd0d1d..a03178e91a79 100644
    408 --- a/drivers/md/persistent-data/dm-btree-remove.c
    409 +++ b/drivers/md/persistent-data/dm-btree-remove.c
    410 @@ -309,8 +309,8 @@ static void redistribute3(struct dm_btree_info *info, struct btree_node *parent,
    411
    412 if (s < 0 && nr_center < -s) {
    413 /* not enough in central node */
    414 - shift(left, center, nr_center);
    415 - s = nr_center - target;
    416 + shift(left, center, -nr_center);
    417 + s += nr_center;
    418 shift(left, right, s);
    419 nr_right += s;
    420 } else
    421 @@ -323,7 +323,7 @@ static void redistribute3(struct dm_btree_info *info, struct btree_node *parent,
    422 if (s > 0 && nr_center < s) {
    423 /* not enough in central node */
    424 shift(center, right, nr_center);
    425 - s = target - nr_center;
    426 + s -= nr_center;
    427 shift(left, right, s);
    428 nr_left -= s;
    429 } else
    430 diff --git a/drivers/md/persistent-data/dm-btree.c b/drivers/md/persistent-data/dm-btree.c
    431 index 200ac12a1d40..fdd3793e22f9 100644
    432 --- a/drivers/md/persistent-data/dm-btree.c
    433 +++ b/drivers/md/persistent-data/dm-btree.c
    434 @@ -255,7 +255,7 @@ int dm_btree_del(struct dm_btree_info *info, dm_block_t root)
    435 int r;
    436 struct del_stack *s;
    437
    438 - s = kmalloc(sizeof(*s), GFP_KERNEL);
    439 + s = kmalloc(sizeof(*s), GFP_NOIO);
    440 if (!s)
    441 return -ENOMEM;
    442 s->info = info;
    443 diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
    444 index a19a18f0058a..10ecc0a0112b 100644
    445 --- a/drivers/mmc/card/block.c
    446 +++ b/drivers/mmc/card/block.c
    447 @@ -205,6 +205,8 @@ static ssize_t power_ro_lock_show(struct device *dev,
    448
    449 ret = snprintf(buf, PAGE_SIZE, "%d\n", locked);
    450
    451 + mmc_blk_put(md);
    452 +
    453 return ret;
    454 }
    455
    456 @@ -1915,9 +1917,11 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
    457 break;
    458 case MMC_BLK_CMD_ERR:
    459 ret = mmc_blk_cmd_err(md, card, brq, req, ret);
    460 - if (!mmc_blk_reset(md, card->host, type))
    461 - break;
    462 - goto cmd_abort;
    463 + if (mmc_blk_reset(md, card->host, type))
    464 + goto cmd_abort;
    465 + if (!ret)
    466 + goto start_new_req;
    467 + break;
    468 case MMC_BLK_RETRY:
    469 if (retry++ < 5)
    470 break;
    471 diff --git a/drivers/net/can/dev.c b/drivers/net/can/dev.c
    472 index bb686e15102c..573b53b38af4 100644
    473 --- a/drivers/net/can/dev.c
    474 +++ b/drivers/net/can/dev.c
    475 @@ -360,9 +360,6 @@ unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx)
    476 struct can_frame *cf = (struct can_frame *)skb->data;
    477 u8 dlc = cf->can_dlc;
    478
    479 - if (!(skb->tstamp.tv64))
    480 - __net_timestamp(skb);
    481 -
    482 netif_rx(priv->echo_skb[idx]);
    483 priv->echo_skb[idx] = NULL;
    484
    485 @@ -499,7 +496,6 @@ struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf)
    486 if (unlikely(!skb))
    487 return NULL;
    488
    489 - __net_timestamp(skb);
    490 skb->protocol = htons(ETH_P_CAN);
    491 skb->pkt_type = PACKET_BROADCAST;
    492 skb->ip_summed = CHECKSUM_UNNECESSARY;
    493 @@ -528,7 +524,6 @@ struct sk_buff *alloc_canfd_skb(struct net_device *dev,
    494 if (unlikely(!skb))
    495 return NULL;
    496
    497 - __net_timestamp(skb);
    498 skb->protocol = htons(ETH_P_CANFD);
    499 skb->pkt_type = PACKET_BROADCAST;
    500 skb->ip_summed = CHECKSUM_UNNECESSARY;
    501 diff --git a/drivers/net/can/slcan.c b/drivers/net/can/slcan.c
    502 index cb6b4723af4a..acb5b92ace92 100644
    503 --- a/drivers/net/can/slcan.c
    504 +++ b/drivers/net/can/slcan.c
    505 @@ -210,7 +210,6 @@ static void slc_bump(struct slcan *sl)
    506 if (!skb)
    507 return;
    508
    509 - __net_timestamp(skb);
    510 skb->dev = sl->dev;
    511 skb->protocol = htons(ETH_P_CAN);
    512 skb->pkt_type = PACKET_BROADCAST;
    513 diff --git a/drivers/net/can/vcan.c b/drivers/net/can/vcan.c
    514 index 30e4627a0c01..4e94057ef5cf 100644
    515 --- a/drivers/net/can/vcan.c
    516 +++ b/drivers/net/can/vcan.c
    517 @@ -81,9 +81,6 @@ static void vcan_rx(struct sk_buff *skb, struct net_device *dev)
    518 skb->dev = dev;
    519 skb->ip_summed = CHECKSUM_UNNECESSARY;
    520
    521 - if (!(skb->tstamp.tv64))
    522 - __net_timestamp(skb);
    523 -
    524 netif_rx_ni(skb);
    525 }
    526
    527 diff --git a/drivers/of/base.c b/drivers/of/base.c
    528 index 4c2ccde42427..469d2b7f47eb 100644
    529 --- a/drivers/of/base.c
    530 +++ b/drivers/of/base.c
    531 @@ -88,7 +88,7 @@ EXPORT_SYMBOL(of_n_size_cells);
    532 #ifdef CONFIG_NUMA
    533 int __weak of_node_to_nid(struct device_node *np)
    534 {
    535 - return numa_node_id();
    536 + return NUMA_NO_NODE;
    537 }
    538 #endif
    539
    540 diff --git a/drivers/platform/x86/dell-laptop.c b/drivers/platform/x86/dell-laptop.c
    541 index 233d2ee598a6..be945fff61c3 100644
    542 --- a/drivers/platform/x86/dell-laptop.c
    543 +++ b/drivers/platform/x86/dell-laptop.c
    544 @@ -272,7 +272,6 @@ static const struct dmi_system_id dell_quirks[] __initconst = {
    545 };
    546
    547 static struct calling_interface_buffer *buffer;
    548 -static struct page *bufferpage;
    549 static DEFINE_MUTEX(buffer_mutex);
    550
    551 static int hwswitch_state;
    552 @@ -825,12 +824,11 @@ static int __init dell_init(void)
    553 * Allocate buffer below 4GB for SMI data--only 32-bit physical addr
    554 * is passed to SMI handler.
    555 */
    556 - bufferpage = alloc_page(GFP_KERNEL | GFP_DMA32);
    557 - if (!bufferpage) {
    558 + buffer = (void *)__get_free_page(GFP_KERNEL | GFP_DMA32);
    559 + if (!buffer) {
    560 ret = -ENOMEM;
    561 goto fail_buffer;
    562 }
    563 - buffer = page_address(bufferpage);
    564
    565 ret = dell_setup_rfkill();
    566
    567 @@ -892,7 +890,7 @@ fail_backlight:
    568 cancel_delayed_work_sync(&dell_rfkill_work);
    569 dell_cleanup_rfkill();
    570 fail_rfkill:
    571 - free_page((unsigned long)bufferpage);
    572 + free_page((unsigned long)buffer);
    573 fail_buffer:
    574 platform_device_del(platform_device);
    575 fail_platform_device2:
    576 diff --git a/drivers/scsi/scsi_devinfo.c b/drivers/scsi/scsi_devinfo.c
    577 index 262ab837a704..9f77d23239a2 100644
    578 --- a/drivers/scsi/scsi_devinfo.c
    579 +++ b/drivers/scsi/scsi_devinfo.c
    580 @@ -226,6 +226,7 @@ static struct {
    581 {"PIONEER", "CD-ROM DRM-624X", NULL, BLIST_FORCELUN | BLIST_SINGLELUN},
    582 {"Promise", "VTrak E610f", NULL, BLIST_SPARSELUN | BLIST_NO_RSOC},
    583 {"Promise", "", NULL, BLIST_SPARSELUN},
    584 + {"QNAP", "iSCSI Storage", NULL, BLIST_MAX_1024},
    585 {"QUANTUM", "XP34301", "1071", BLIST_NOTQ},
    586 {"REGAL", "CDC-4X", NULL, BLIST_MAX5LUN | BLIST_SINGLELUN},
    587 {"SanDisk", "ImageMate CF-SD1", NULL, BLIST_FORCELUN},
    588 diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
    589 index ba3f1e8d0d57..f49cb534a829 100644
    590 --- a/drivers/scsi/scsi_scan.c
    591 +++ b/drivers/scsi/scsi_scan.c
    592 @@ -901,6 +901,12 @@ static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
    593 */
    594 if (*bflags & BLIST_MAX_512)
    595 blk_queue_max_hw_sectors(sdev->request_queue, 512);
    596 + /*
    597 + * Max 1024 sector transfer length for targets that report incorrect
    598 + * max/optimal lengths and relied on the old block layer safe default
    599 + */
    600 + else if (*bflags & BLIST_MAX_1024)
    601 + blk_queue_max_hw_sectors(sdev->request_queue, 1024);
    602
    603 /*
    604 * Some devices may not want to have a start command automatically
    605 diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
    606 index 2eb6fa8e645e..3c5dd9762476 100644
    607 --- a/drivers/target/iscsi/iscsi_target.c
    608 +++ b/drivers/target/iscsi/iscsi_target.c
    609 @@ -537,7 +537,7 @@ static struct iscsit_transport iscsi_target_transport = {
    610
    611 static int __init iscsi_target_init_module(void)
    612 {
    613 - int ret = 0;
    614 + int ret = 0, size;
    615
    616 pr_debug("iSCSI-Target "ISCSIT_VERSION"\n");
    617
    618 @@ -546,6 +546,7 @@ static int __init iscsi_target_init_module(void)
    619 pr_err("Unable to allocate memory for iscsit_global\n");
    620 return -1;
    621 }
    622 + spin_lock_init(&iscsit_global->ts_bitmap_lock);
    623 mutex_init(&auth_id_lock);
    624 spin_lock_init(&sess_idr_lock);
    625 idr_init(&tiqn_idr);
    626 @@ -555,15 +556,11 @@ static int __init iscsi_target_init_module(void)
    627 if (ret < 0)
    628 goto out;
    629
    630 - ret = iscsi_thread_set_init();
    631 - if (ret < 0)
    632 + size = BITS_TO_LONGS(ISCSIT_BITMAP_BITS) * sizeof(long);
    633 + iscsit_global->ts_bitmap = vzalloc(size);
    634 + if (!iscsit_global->ts_bitmap) {
    635 + pr_err("Unable to allocate iscsit_global->ts_bitmap\n");
    636 goto configfs_out;
    637 -
    638 - if (iscsi_allocate_thread_sets(TARGET_THREAD_SET_COUNT) !=
    639 - TARGET_THREAD_SET_COUNT) {
    640 - pr_err("iscsi_allocate_thread_sets() returned"
    641 - " unexpected value!\n");
    642 - goto ts_out1;
    643 }
    644
    645 lio_qr_cache = kmem_cache_create("lio_qr_cache",
    646 @@ -572,7 +569,7 @@ static int __init iscsi_target_init_module(void)
    647 if (!lio_qr_cache) {
    648 pr_err("nable to kmem_cache_create() for"
    649 " lio_qr_cache\n");
    650 - goto ts_out2;
    651 + goto bitmap_out;
    652 }
    653
    654 lio_dr_cache = kmem_cache_create("lio_dr_cache",
    655 @@ -616,10 +613,8 @@ dr_out:
    656 kmem_cache_destroy(lio_dr_cache);
    657 qr_out:
    658 kmem_cache_destroy(lio_qr_cache);
    659 -ts_out2:
    660 - iscsi_deallocate_thread_sets();
    661 -ts_out1:
    662 - iscsi_thread_set_free();
    663 +bitmap_out:
    664 + vfree(iscsit_global->ts_bitmap);
    665 configfs_out:
    666 iscsi_target_deregister_configfs();
    667 out:
    668 @@ -629,8 +624,6 @@ out:
    669
    670 static void __exit iscsi_target_cleanup_module(void)
    671 {
    672 - iscsi_deallocate_thread_sets();
    673 - iscsi_thread_set_free();
    674 iscsit_release_discovery_tpg();
    675 iscsit_unregister_transport(&iscsi_target_transport);
    676 kmem_cache_destroy(lio_qr_cache);
    677 @@ -640,6 +633,7 @@ static void __exit iscsi_target_cleanup_module(void)
    678
    679 iscsi_target_deregister_configfs();
    680
    681 + vfree(iscsit_global->ts_bitmap);
    682 kfree(iscsit_global);
    683 }
    684
    685 @@ -3680,17 +3674,16 @@ static int iscsit_send_reject(
    686
    687 void iscsit_thread_get_cpumask(struct iscsi_conn *conn)
    688 {
    689 - struct iscsi_thread_set *ts = conn->thread_set;
    690 int ord, cpu;
    691 /*
    692 - * thread_id is assigned from iscsit_global->ts_bitmap from
    693 - * within iscsi_thread_set.c:iscsi_allocate_thread_sets()
    694 + * bitmap_id is assigned from iscsit_global->ts_bitmap from
    695 + * within iscsit_start_kthreads()
    696 *
    697 - * Here we use thread_id to determine which CPU that this
    698 - * iSCSI connection's iscsi_thread_set will be scheduled to
    699 + * Here we use bitmap_id to determine which CPU that this
    700 + * iSCSI connection's RX/TX threads will be scheduled to
    701 * execute upon.
    702 */
    703 - ord = ts->thread_id % cpumask_weight(cpu_online_mask);
    704 + ord = conn->bitmap_id % cpumask_weight(cpu_online_mask);
    705 for_each_online_cpu(cpu) {
    706 if (ord-- == 0) {
    707 cpumask_set_cpu(cpu, conn->conn_cpumask);
    708 @@ -3879,7 +3872,7 @@ check_rsp_state:
    709 switch (state) {
    710 case ISTATE_SEND_LOGOUTRSP:
    711 if (!iscsit_logout_post_handler(cmd, conn))
    712 - goto restart;
    713 + return -ECONNRESET;
    714 /* fall through */
    715 case ISTATE_SEND_STATUS:
    716 case ISTATE_SEND_ASYNCMSG:
    717 @@ -3907,8 +3900,6 @@ check_rsp_state:
    718
    719 err:
    720 return -1;
    721 -restart:
    722 - return -EAGAIN;
    723 }
    724
    725 static int iscsit_handle_response_queue(struct iscsi_conn *conn)
    726 @@ -3935,21 +3926,13 @@ static int iscsit_handle_response_queue(struct iscsi_conn *conn)
    727 int iscsi_target_tx_thread(void *arg)
    728 {
    729 int ret = 0;
    730 - struct iscsi_conn *conn;
    731 - struct iscsi_thread_set *ts = arg;
    732 + struct iscsi_conn *conn = arg;
    733 /*
    734 * Allow ourselves to be interrupted by SIGINT so that a
    735 * connection recovery / failure event can be triggered externally.
    736 */
    737 allow_signal(SIGINT);
    738
    739 -restart:
    740 - conn = iscsi_tx_thread_pre_handler(ts);
    741 - if (!conn)
    742 - goto out;
    743 -
    744 - ret = 0;
    745 -
    746 while (!kthread_should_stop()) {
    747 /*
    748 * Ensure that both TX and RX per connection kthreads
    749 @@ -3958,11 +3941,9 @@ restart:
    750 iscsit_thread_check_cpumask(conn, current, 1);
    751
    752 wait_event_interruptible(conn->queues_wq,
    753 - !iscsit_conn_all_queues_empty(conn) ||
    754 - ts->status == ISCSI_THREAD_SET_RESET);
    755 + !iscsit_conn_all_queues_empty(conn));
    756
    757 - if ((ts->status == ISCSI_THREAD_SET_RESET) ||
    758 - signal_pending(current))
    759 + if (signal_pending(current))
    760 goto transport_err;
    761
    762 get_immediate:
    763 @@ -3973,15 +3954,14 @@ get_immediate:
    764 ret = iscsit_handle_response_queue(conn);
    765 if (ret == 1)
    766 goto get_immediate;
    767 - else if (ret == -EAGAIN)
    768 - goto restart;
    769 + else if (ret == -ECONNRESET)
    770 + goto out;
    771 else if (ret < 0)
    772 goto transport_err;
    773 }
    774
    775 transport_err:
    776 iscsit_take_action_for_connection_exit(conn);
    777 - goto restart;
    778 out:
    779 return 0;
    780 }
    781 @@ -4070,8 +4050,7 @@ int iscsi_target_rx_thread(void *arg)
    782 int ret;
    783 u8 buffer[ISCSI_HDR_LEN], opcode;
    784 u32 checksum = 0, digest = 0;
    785 - struct iscsi_conn *conn = NULL;
    786 - struct iscsi_thread_set *ts = arg;
    787 + struct iscsi_conn *conn = arg;
    788 struct kvec iov;
    789 /*
    790 * Allow ourselves to be interrupted by SIGINT so that a
    791 @@ -4079,11 +4058,6 @@ int iscsi_target_rx_thread(void *arg)
    792 */
    793 allow_signal(SIGINT);
    794
    795 -restart:
    796 - conn = iscsi_rx_thread_pre_handler(ts);
    797 - if (!conn)
    798 - goto out;
    799 -
    800 if (conn->conn_transport->transport_type == ISCSI_INFINIBAND) {
    801 struct completion comp;
    802 int rc;
    803 @@ -4093,7 +4067,7 @@ restart:
    804 if (rc < 0)
    805 goto transport_err;
    806
    807 - goto out;
    808 + goto transport_err;
    809 }
    810
    811 while (!kthread_should_stop()) {
    812 @@ -4169,8 +4143,6 @@ transport_err:
    813 if (!signal_pending(current))
    814 atomic_set(&conn->transport_failed, 1);
    815 iscsit_take_action_for_connection_exit(conn);
    816 - goto restart;
    817 -out:
    818 return 0;
    819 }
    820
    821 @@ -4232,7 +4204,24 @@ int iscsit_close_connection(
    822 if (conn->conn_transport->transport_type == ISCSI_TCP)
    823 complete(&conn->conn_logout_comp);
    824
    825 - iscsi_release_thread_set(conn);
    826 + if (!strcmp(current->comm, ISCSI_RX_THREAD_NAME)) {
    827 + if (conn->tx_thread &&
    828 + cmpxchg(&conn->tx_thread_active, true, false)) {
    829 + send_sig(SIGINT, conn->tx_thread, 1);
    830 + kthread_stop(conn->tx_thread);
    831 + }
    832 + } else if (!strcmp(current->comm, ISCSI_TX_THREAD_NAME)) {
    833 + if (conn->rx_thread &&
    834 + cmpxchg(&conn->rx_thread_active, true, false)) {
    835 + send_sig(SIGINT, conn->rx_thread, 1);
    836 + kthread_stop(conn->rx_thread);
    837 + }
    838 + }
    839 +
    840 + spin_lock(&iscsit_global->ts_bitmap_lock);
    841 + bitmap_release_region(iscsit_global->ts_bitmap, conn->bitmap_id,
    842 + get_order(1));
    843 + spin_unlock(&iscsit_global->ts_bitmap_lock);
    844
    845 iscsit_stop_timers_for_cmds(conn);
    846 iscsit_stop_nopin_response_timer(conn);
    847 @@ -4510,15 +4499,13 @@ static void iscsit_logout_post_handler_closesession(
    848 struct iscsi_conn *conn)
    849 {
    850 struct iscsi_session *sess = conn->sess;
    851 -
    852 - iscsi_set_thread_clear(conn, ISCSI_CLEAR_TX_THREAD);
    853 - iscsi_set_thread_set_signal(conn, ISCSI_SIGNAL_TX_THREAD);
    854 + int sleep = cmpxchg(&conn->tx_thread_active, true, false);
    855
    856 atomic_set(&conn->conn_logout_remove, 0);
    857 complete(&conn->conn_logout_comp);
    858
    859 iscsit_dec_conn_usage_count(conn);
    860 - iscsit_stop_session(sess, 1, 1);
    861 + iscsit_stop_session(sess, sleep, sleep);
    862 iscsit_dec_session_usage_count(sess);
    863 target_put_session(sess->se_sess);
    864 }
    865 @@ -4526,13 +4513,12 @@ static void iscsit_logout_post_handler_closesession(
    866 static void iscsit_logout_post_handler_samecid(
    867 struct iscsi_conn *conn)
    868 {
    869 - iscsi_set_thread_clear(conn, ISCSI_CLEAR_TX_THREAD);
    870 - iscsi_set_thread_set_signal(conn, ISCSI_SIGNAL_TX_THREAD);
    871 + int sleep = cmpxchg(&conn->tx_thread_active, true, false);
    872
    873 atomic_set(&conn->conn_logout_remove, 0);
    874 complete(&conn->conn_logout_comp);
    875
    876 - iscsit_cause_connection_reinstatement(conn, 1);
    877 + iscsit_cause_connection_reinstatement(conn, sleep);
    878 iscsit_dec_conn_usage_count(conn);
    879 }
    880
    881 diff --git a/drivers/target/iscsi/iscsi_target_core.h b/drivers/target/iscsi/iscsi_target_core.h
    882 index 302eb3b78715..2423f27e4670 100644
    883 --- a/drivers/target/iscsi/iscsi_target_core.h
    884 +++ b/drivers/target/iscsi/iscsi_target_core.h
    885 @@ -602,6 +602,11 @@ struct iscsi_conn {
    886 struct iscsi_session *sess;
    887 /* Pointer to thread_set in use for this conn's threads */
    888 struct iscsi_thread_set *thread_set;
    889 + int bitmap_id;
    890 + int rx_thread_active;
    891 + struct task_struct *rx_thread;
    892 + int tx_thread_active;
    893 + struct task_struct *tx_thread;
    894 /* list_head for session connection list */
    895 struct list_head conn_list;
    896 } ____cacheline_aligned;
    897 @@ -872,10 +877,12 @@ struct iscsit_global {
    898 /* Unique identifier used for the authentication daemon */
    899 u32 auth_id;
    900 u32 inactive_ts;
    901 +#define ISCSIT_BITMAP_BITS 262144
    902 /* Thread Set bitmap count */
    903 int ts_bitmap_count;
    904 /* Thread Set bitmap pointer */
    905 unsigned long *ts_bitmap;
    906 + spinlock_t ts_bitmap_lock;
    907 /* Used for iSCSI discovery session authentication */
    908 struct iscsi_node_acl discovery_acl;
    909 struct iscsi_portal_group *discovery_tpg;
    910 diff --git a/drivers/target/iscsi/iscsi_target_erl0.c b/drivers/target/iscsi/iscsi_target_erl0.c
    911 index a0ae5fc0ad75..87f687258729 100644
    912 --- a/drivers/target/iscsi/iscsi_target_erl0.c
    913 +++ b/drivers/target/iscsi/iscsi_target_erl0.c
    914 @@ -860,7 +860,10 @@ void iscsit_connection_reinstatement_rcfr(struct iscsi_conn *conn)
    915 }
    916 spin_unlock_bh(&conn->state_lock);
    917
    918 - iscsi_thread_set_force_reinstatement(conn);
    919 + if (conn->tx_thread && conn->tx_thread_active)
    920 + send_sig(SIGINT, conn->tx_thread, 1);
    921 + if (conn->rx_thread && conn->rx_thread_active)
    922 + send_sig(SIGINT, conn->rx_thread, 1);
    923
    924 sleep:
    925 wait_for_completion(&conn->conn_wait_rcfr_comp);
    926 @@ -885,10 +888,10 @@ void iscsit_cause_connection_reinstatement(struct iscsi_conn *conn, int sleep)
    927 return;
    928 }
    929
    930 - if (iscsi_thread_set_force_reinstatement(conn) < 0) {
    931 - spin_unlock_bh(&conn->state_lock);
    932 - return;
    933 - }
    934 + if (conn->tx_thread && conn->tx_thread_active)
    935 + send_sig(SIGINT, conn->tx_thread, 1);
    936 + if (conn->rx_thread && conn->rx_thread_active)
    937 + send_sig(SIGINT, conn->rx_thread, 1);
    938
    939 atomic_set(&conn->connection_reinstatement, 1);
    940 if (!sleep) {
    941 diff --git a/drivers/target/iscsi/iscsi_target_login.c b/drivers/target/iscsi/iscsi_target_login.c
    942 index 18e2601527df..2d87abc6b38c 100644
    943 --- a/drivers/target/iscsi/iscsi_target_login.c
    944 +++ b/drivers/target/iscsi/iscsi_target_login.c
    945 @@ -699,6 +699,51 @@ static void iscsi_post_login_start_timers(struct iscsi_conn *conn)
    946 iscsit_start_nopin_timer(conn);
    947 }
    948
    949 +int iscsit_start_kthreads(struct iscsi_conn *conn)
    950 +{
    951 + int ret = 0;
    952 +
    953 + spin_lock(&iscsit_global->ts_bitmap_lock);
    954 + conn->bitmap_id = bitmap_find_free_region(iscsit_global->ts_bitmap,
    955 + ISCSIT_BITMAP_BITS, get_order(1));
    956 + spin_unlock(&iscsit_global->ts_bitmap_lock);
    957 +
    958 + if (conn->bitmap_id < 0) {
    959 + pr_err("bitmap_find_free_region() failed for"
    960 + " iscsit_start_kthreads()\n");
    961 + return -ENOMEM;
    962 + }
    963 +
    964 + conn->tx_thread = kthread_run(iscsi_target_tx_thread, conn,
    965 + "%s", ISCSI_TX_THREAD_NAME);
    966 + if (IS_ERR(conn->tx_thread)) {
    967 + pr_err("Unable to start iscsi_target_tx_thread\n");
    968 + ret = PTR_ERR(conn->tx_thread);
    969 + goto out_bitmap;
    970 + }
    971 + conn->tx_thread_active = true;
    972 +
    973 + conn->rx_thread = kthread_run(iscsi_target_rx_thread, conn,
    974 + "%s", ISCSI_RX_THREAD_NAME);
    975 + if (IS_ERR(conn->rx_thread)) {
    976 + pr_err("Unable to start iscsi_target_rx_thread\n");
    977 + ret = PTR_ERR(conn->rx_thread);
    978 + goto out_tx;
    979 + }
    980 + conn->rx_thread_active = true;
    981 +
    982 + return 0;
    983 +out_tx:
    984 + kthread_stop(conn->tx_thread);
    985 + conn->tx_thread_active = false;
    986 +out_bitmap:
    987 + spin_lock(&iscsit_global->ts_bitmap_lock);
    988 + bitmap_release_region(iscsit_global->ts_bitmap, conn->bitmap_id,
    989 + get_order(1));
    990 + spin_unlock(&iscsit_global->ts_bitmap_lock);
    991 + return ret;
    992 +}
    993 +
    994 int iscsi_post_login_handler(
    995 struct iscsi_np *np,
    996 struct iscsi_conn *conn,
    997 @@ -709,7 +754,7 @@ int iscsi_post_login_handler(
    998 struct se_session *se_sess = sess->se_sess;
    999 struct iscsi_portal_group *tpg = sess->tpg;
    1000 struct se_portal_group *se_tpg = &tpg->tpg_se_tpg;
    1001 - struct iscsi_thread_set *ts;
    1002 + int rc;
    1003
    1004 iscsit_inc_conn_usage_count(conn);
    1005
    1006 @@ -724,7 +769,6 @@ int iscsi_post_login_handler(
    1007 /*
    1008 * SCSI Initiator -> SCSI Target Port Mapping
    1009 */
    1010 - ts = iscsi_get_thread_set();
    1011 if (!zero_tsih) {
    1012 iscsi_set_session_parameters(sess->sess_ops,
    1013 conn->param_list, 0);
    1014 @@ -751,9 +795,11 @@ int iscsi_post_login_handler(
    1015 sess->sess_ops->InitiatorName);
    1016 spin_unlock_bh(&sess->conn_lock);
    1017
    1018 - iscsi_post_login_start_timers(conn);
    1019 + rc = iscsit_start_kthreads(conn);
    1020 + if (rc)
    1021 + return rc;
    1022
    1023 - iscsi_activate_thread_set(conn, ts);
    1024 + iscsi_post_login_start_timers(conn);
    1025 /*
    1026 * Determine CPU mask to ensure connection's RX and TX kthreads
    1027 * are scheduled on the same CPU.
    1028 @@ -810,8 +856,11 @@ int iscsi_post_login_handler(
    1029 " iSCSI Target Portal Group: %hu\n", tpg->nsessions, tpg->tpgt);
    1030 spin_unlock_bh(&se_tpg->session_lock);
    1031
    1032 + rc = iscsit_start_kthreads(conn);
    1033 + if (rc)
    1034 + return rc;
    1035 +
    1036 iscsi_post_login_start_timers(conn);
    1037 - iscsi_activate_thread_set(conn, ts);
    1038 /*
    1039 * Determine CPU mask to ensure connection's RX and TX kthreads
    1040 * are scheduled on the same CPU.
    1041 diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
    1042 index e500243803d8..a85eadff6bea 100644
    1043 --- a/drivers/usb/core/devio.c
    1044 +++ b/drivers/usb/core/devio.c
    1045 @@ -513,7 +513,7 @@ static void async_completed(struct urb *urb)
    1046 snoop(&urb->dev->dev, "urb complete\n");
    1047 snoop_urb(urb->dev, as->userurb, urb->pipe, urb->actual_length,
    1048 as->status, COMPLETE, NULL, 0);
    1049 - if ((urb->transfer_flags & URB_DIR_MASK) == USB_DIR_IN)
    1050 + if ((urb->transfer_flags & URB_DIR_MASK) == URB_DIR_IN)
    1051 snoop_urb_data(urb, urb->actual_length);
    1052
    1053 if (as->status < 0 && as->bulk_addr && as->status != -ECONNRESET &&
    1054 @@ -1690,7 +1690,7 @@ static struct async *reap_as(struct usb_dev_state *ps)
    1055 for (;;) {
    1056 __set_current_state(TASK_INTERRUPTIBLE);
    1057 as = async_getcompleted(ps);
    1058 - if (as)
    1059 + if (as || !connected(ps))
    1060 break;
    1061 if (signal_pending(current))
    1062 break;
    1063 @@ -1713,7 +1713,7 @@ static int proc_reapurb(struct usb_dev_state *ps, void __user *arg)
    1064 }
    1065 if (signal_pending(current))
    1066 return -EINTR;
    1067 - return -EIO;
    1068 + return -ENODEV;
    1069 }
    1070
    1071 static int proc_reapurbnonblock(struct usb_dev_state *ps, void __user *arg)
    1072 @@ -1722,10 +1722,11 @@ static int proc_reapurbnonblock(struct usb_dev_state *ps, void __user *arg)
    1073 struct async *as;
    1074
    1075 as = async_getcompleted(ps);
    1076 - retval = -EAGAIN;
    1077 if (as) {
    1078 retval = processcompl(as, (void __user * __user *)arg);
    1079 free_async(as);
    1080 + } else {
    1081 + retval = (connected(ps) ? -EAGAIN : -ENODEV);
    1082 }
    1083 return retval;
    1084 }
    1085 @@ -1855,7 +1856,7 @@ static int proc_reapurb_compat(struct usb_dev_state *ps, void __user *arg)
    1086 }
    1087 if (signal_pending(current))
    1088 return -EINTR;
    1089 - return -EIO;
    1090 + return -ENODEV;
    1091 }
    1092
    1093 static int proc_reapurbnonblock_compat(struct usb_dev_state *ps, void __user *arg)
    1094 @@ -1863,11 +1864,12 @@ static int proc_reapurbnonblock_compat(struct usb_dev_state *ps, void __user *ar
    1095 int retval;
    1096 struct async *as;
    1097
    1098 - retval = -EAGAIN;
    1099 as = async_getcompleted(ps);
    1100 if (as) {
    1101 retval = processcompl_compat(as, (void __user * __user *)arg);
    1102 free_async(as);
    1103 + } else {
    1104 + retval = (connected(ps) ? -EAGAIN : -ENODEV);
    1105 }
    1106 return retval;
    1107 }
    1108 @@ -2039,7 +2041,8 @@ static int proc_get_capabilities(struct usb_dev_state *ps, void __user *arg)
    1109 {
    1110 __u32 caps;
    1111
    1112 - caps = USBDEVFS_CAP_ZERO_PACKET | USBDEVFS_CAP_NO_PACKET_SIZE_LIM;
    1113 + caps = USBDEVFS_CAP_ZERO_PACKET | USBDEVFS_CAP_NO_PACKET_SIZE_LIM |
    1114 + USBDEVFS_CAP_REAP_AFTER_DISCONNECT;
    1115 if (!ps->dev->bus->no_stop_on_short)
    1116 caps |= USBDEVFS_CAP_BULK_CONTINUATION;
    1117 if (ps->dev->bus->sg_tablesize)
    1118 @@ -2139,6 +2142,32 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
    1119 return -EPERM;
    1120
    1121 usb_lock_device(dev);
    1122 +
    1123 + /* Reap operations are allowed even after disconnection */
    1124 + switch (cmd) {
    1125 + case USBDEVFS_REAPURB:
    1126 + snoop(&dev->dev, "%s: REAPURB\n", __func__);
    1127 + ret = proc_reapurb(ps, p);
    1128 + goto done;
    1129 +
    1130 + case USBDEVFS_REAPURBNDELAY:
    1131 + snoop(&dev->dev, "%s: REAPURBNDELAY\n", __func__);
    1132 + ret = proc_reapurbnonblock(ps, p);
    1133 + goto done;
    1134 +
    1135 +#ifdef CONFIG_COMPAT
    1136 + case USBDEVFS_REAPURB32:
    1137 + snoop(&dev->dev, "%s: REAPURB32\n", __func__);
    1138 + ret = proc_reapurb_compat(ps, p);
    1139 + goto done;
    1140 +
    1141 + case USBDEVFS_REAPURBNDELAY32:
    1142 + snoop(&dev->dev, "%s: REAPURBNDELAY32\n", __func__);
    1143 + ret = proc_reapurbnonblock_compat(ps, p);
    1144 + goto done;
    1145 +#endif
    1146 + }
    1147 +
    1148 if (!connected(ps)) {
    1149 usb_unlock_device(dev);
    1150 return -ENODEV;
    1151 @@ -2232,16 +2261,6 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
    1152 inode->i_mtime = CURRENT_TIME;
    1153 break;
    1154
    1155 - case USBDEVFS_REAPURB32:
    1156 - snoop(&dev->dev, "%s: REAPURB32\n", __func__);
    1157 - ret = proc_reapurb_compat(ps, p);
    1158 - break;
    1159 -
    1160 - case USBDEVFS_REAPURBNDELAY32:
    1161 - snoop(&dev->dev, "%s: REAPURBNDELAY32\n", __func__);
    1162 - ret = proc_reapurbnonblock_compat(ps, p);
    1163 - break;
    1164 -
    1165 case USBDEVFS_IOCTL32:
    1166 snoop(&dev->dev, "%s: IOCTL32\n", __func__);
    1167 ret = proc_ioctl_compat(ps, ptr_to_compat(p));
    1168 @@ -2253,16 +2272,6 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
    1169 ret = proc_unlinkurb(ps, p);
    1170 break;
    1171
    1172 - case USBDEVFS_REAPURB:
    1173 - snoop(&dev->dev, "%s: REAPURB\n", __func__);
    1174 - ret = proc_reapurb(ps, p);
    1175 - break;
    1176 -
    1177 - case USBDEVFS_REAPURBNDELAY:
    1178 - snoop(&dev->dev, "%s: REAPURBNDELAY\n", __func__);
    1179 - ret = proc_reapurbnonblock(ps, p);
    1180 - break;
    1181 -
    1182 case USBDEVFS_DISCSIGNAL:
    1183 snoop(&dev->dev, "%s: DISCSIGNAL\n", __func__);
    1184 ret = proc_disconnectsignal(ps, p);
    1185 @@ -2305,6 +2314,8 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
    1186 ret = proc_free_streams(ps, p);
    1187 break;
    1188 }
    1189 +
    1190 + done:
    1191 usb_unlock_device(dev);
    1192 if (ret >= 0)
    1193 inode->i_atime = CURRENT_TIME;
    1194 diff --git a/drivers/usb/dwc3/ep0.c b/drivers/usb/dwc3/ep0.c
    1195 index df38e7ef4976..bdc995da3420 100644
    1196 --- a/drivers/usb/dwc3/ep0.c
    1197 +++ b/drivers/usb/dwc3/ep0.c
    1198 @@ -727,6 +727,10 @@ static int dwc3_ep0_std_request(struct dwc3 *dwc, struct usb_ctrlrequest *ctrl)
    1199 dwc3_trace(trace_dwc3_ep0, "USB_REQ_SET_ISOCH_DELAY\n");
    1200 ret = dwc3_ep0_set_isoch_delay(dwc, ctrl);
    1201 break;
    1202 + case USB_REQ_SET_INTERFACE:
    1203 + dev_vdbg(dwc->dev, "USB_REQ_SET_INTERFACE\n");
    1204 + dwc->start_config_issued = false;
    1205 + /* Fall through */
    1206 default:
    1207 dwc3_trace(trace_dwc3_ep0, "Forwarding to gadget driver\n");
    1208 ret = dwc3_ep0_delegate_req(dwc, ctrl);
    1209 diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
    1210 index 5cb3d7a10017..a67018eddf41 100644
    1211 --- a/drivers/usb/host/xhci-mem.c
    1212 +++ b/drivers/usb/host/xhci-mem.c
    1213 @@ -1431,10 +1431,10 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
    1214 /* Attempt to use the ring cache */
    1215 if (virt_dev->num_rings_cached == 0)
    1216 return -ENOMEM;
    1217 + virt_dev->num_rings_cached--;
    1218 virt_dev->eps[ep_index].new_ring =
    1219 virt_dev->ring_cache[virt_dev->num_rings_cached];
    1220 virt_dev->ring_cache[virt_dev->num_rings_cached] = NULL;
    1221 - virt_dev->num_rings_cached--;
    1222 xhci_reinit_cached_ring(xhci, virt_dev->eps[ep_index].new_ring,
    1223 1, type);
    1224 }
    1225 diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c
    1226 index 0241a3a0d63e..1e9bde4fe785 100644
    1227 --- a/drivers/usb/musb/musb_virthub.c
    1228 +++ b/drivers/usb/musb/musb_virthub.c
    1229 @@ -273,9 +273,7 @@ static int musb_has_gadget(struct musb *musb)
    1230 #ifdef CONFIG_USB_MUSB_HOST
    1231 return 1;
    1232 #else
    1233 - if (musb->port_mode == MUSB_PORT_MODE_HOST)
    1234 - return 1;
    1235 - return musb->g.dev.driver != NULL;
    1236 + return musb->port_mode == MUSB_PORT_MODE_HOST;
    1237 #endif
    1238 }
    1239
    1240 diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c
    1241 index ffd739e31bfc..eac7ccaa3c85 100644
    1242 --- a/drivers/usb/serial/cp210x.c
    1243 +++ b/drivers/usb/serial/cp210x.c
    1244 @@ -187,6 +187,7 @@ static const struct usb_device_id id_table[] = {
    1245 { USB_DEVICE(0x1FB9, 0x0602) }, /* Lake Shore Model 648 Magnet Power Supply */
    1246 { USB_DEVICE(0x1FB9, 0x0700) }, /* Lake Shore Model 737 VSM Controller */
    1247 { USB_DEVICE(0x1FB9, 0x0701) }, /* Lake Shore Model 776 Hall Matrix */
    1248 + { USB_DEVICE(0x2626, 0xEA60) }, /* Aruba Networks 7xxx USB Serial Console */
    1249 { USB_DEVICE(0x3195, 0xF190) }, /* Link Instruments MSO-19 */
    1250 { USB_DEVICE(0x3195, 0xF280) }, /* Link Instruments MSO-28 */
    1251 { USB_DEVICE(0x3195, 0xF281) }, /* Link Instruments MSO-28 */
    1252 diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
    1253 index efdcee15b520..c8c4e50ffee1 100644
    1254 --- a/drivers/usb/serial/option.c
    1255 +++ b/drivers/usb/serial/option.c
    1256 @@ -1773,6 +1773,7 @@ static const struct usb_device_id option_ids[] = {
    1257 { USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x7d03, 0xff, 0x00, 0x00) },
    1258 { USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x3e01, 0xff, 0xff, 0xff) }, /* D-Link DWM-152/C1 */
    1259 { USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x3e02, 0xff, 0xff, 0xff) }, /* D-Link DWM-156/C1 */
    1260 + { USB_DEVICE_INTERFACE_CLASS(0x2020, 0x4000, 0xff) }, /* OLICARD300 - MT6225 */
    1261 { USB_DEVICE(INOVIA_VENDOR_ID, INOVIA_SEW858) },
    1262 { USB_DEVICE(VIATELECOM_VENDOR_ID, VIATELECOM_PRODUCT_CDS7) },
    1263 { } /* Terminating entry */
    1264 diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
    1265 index 19842370a07f..6fbfc8fc2f5d 100644
    1266 --- a/drivers/usb/serial/usb-serial.c
    1267 +++ b/drivers/usb/serial/usb-serial.c
    1268 @@ -1290,6 +1290,7 @@ static void __exit usb_serial_exit(void)
    1269 tty_unregister_driver(usb_serial_tty_driver);
    1270 put_tty_driver(usb_serial_tty_driver);
    1271 bus_unregister(&usb_serial_bus_type);
    1272 + idr_destroy(&serial_minors);
    1273 }
    1274
    1275
    1276 diff --git a/drivers/watchdog/omap_wdt.c b/drivers/watchdog/omap_wdt.c
    1277 index 3691b157516a..0c8868eceb4d 100644
    1278 --- a/drivers/watchdog/omap_wdt.c
    1279 +++ b/drivers/watchdog/omap_wdt.c
    1280 @@ -132,6 +132,13 @@ static int omap_wdt_start(struct watchdog_device *wdog)
    1281
    1282 pm_runtime_get_sync(wdev->dev);
    1283
    1284 + /*
    1285 + * Make sure the watchdog is disabled. This is unfortunately required
    1286 + * because writing to various registers with the watchdog running has no
    1287 + * effect.
    1288 + */
    1289 + omap_wdt_disable(wdev);
    1290 +
    1291 /* initialize prescaler */
    1292 while (readl_relaxed(base + OMAP_WATCHDOG_WPS) & 0x01)
    1293 cpu_relax();
    1294 diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
    1295 index 296482fc77a9..a2f6e9ae1a98 100644
    1296 --- a/fs/9p/vfs_inode.c
    1297 +++ b/fs/9p/vfs_inode.c
    1298 @@ -540,8 +540,7 @@ static struct inode *v9fs_qid_iget(struct super_block *sb,
    1299 unlock_new_inode(inode);
    1300 return inode;
    1301 error:
    1302 - unlock_new_inode(inode);
    1303 - iput(inode);
    1304 + iget_failed(inode);
    1305 return ERR_PTR(retval);
    1306
    1307 }
    1308 diff --git a/fs/9p/vfs_inode_dotl.c b/fs/9p/vfs_inode_dotl.c
    1309 index 02b64f4e576a..092d20c643e5 100644
    1310 --- a/fs/9p/vfs_inode_dotl.c
    1311 +++ b/fs/9p/vfs_inode_dotl.c
    1312 @@ -149,8 +149,7 @@ static struct inode *v9fs_qid_iget_dotl(struct super_block *sb,
    1313 unlock_new_inode(inode);
    1314 return inode;
    1315 error:
    1316 - unlock_new_inode(inode);
    1317 - iput(inode);
    1318 + iget_failed(inode);
    1319 return ERR_PTR(retval);
    1320
    1321 }
    1322 diff --git a/fs/btrfs/inode-map.c b/fs/btrfs/inode-map.c
    1323 index 83d646bd2e4b..ed2de833dd18 100644
    1324 --- a/fs/btrfs/inode-map.c
    1325 +++ b/fs/btrfs/inode-map.c
    1326 @@ -271,7 +271,7 @@ void btrfs_unpin_free_ino(struct btrfs_root *root)
    1327 __btrfs_add_free_space(ctl, info->offset, count);
    1328 free:
    1329 rb_erase(&info->offset_index, rbroot);
    1330 - kfree(info);
    1331 + kmem_cache_free(btrfs_free_space_cachep, info);
    1332 }
    1333 }
    1334
    1335 diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
    1336 index 1cecf25fa14f..3d50f1ee51ba 100644
    1337 --- a/fs/btrfs/ioctl.c
    1338 +++ b/fs/btrfs/ioctl.c
    1339 @@ -2959,7 +2959,7 @@ out_unlock:
    1340 static long btrfs_ioctl_file_extent_same(struct file *file,
    1341 struct btrfs_ioctl_same_args __user *argp)
    1342 {
    1343 - struct btrfs_ioctl_same_args *same;
    1344 + struct btrfs_ioctl_same_args *same = NULL;
    1345 struct btrfs_ioctl_same_extent_info *info;
    1346 struct inode *src = file_inode(file);
    1347 u64 off;
    1348 @@ -2989,6 +2989,7 @@ static long btrfs_ioctl_file_extent_same(struct file *file,
    1349
    1350 if (IS_ERR(same)) {
    1351 ret = PTR_ERR(same);
    1352 + same = NULL;
    1353 goto out;
    1354 }
    1355
    1356 @@ -3059,6 +3060,7 @@ static long btrfs_ioctl_file_extent_same(struct file *file,
    1357
    1358 out:
    1359 mnt_drop_write_file(file);
    1360 + kfree(same);
    1361 return ret;
    1362 }
    1363
    1364 diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
    1365 index 120824664d32..777f74370143 100644
    1366 --- a/fs/ext4/inode.c
    1367 +++ b/fs/ext4/inode.c
    1368 @@ -1230,7 +1230,7 @@ static void ext4_da_page_release_reservation(struct page *page,
    1369 unsigned int offset,
    1370 unsigned int length)
    1371 {
    1372 - int to_release = 0;
    1373 + int to_release = 0, contiguous_blks = 0;
    1374 struct buffer_head *head, *bh;
    1375 unsigned int curr_off = 0;
    1376 struct inode *inode = page->mapping->host;
    1377 @@ -1251,14 +1251,23 @@ static void ext4_da_page_release_reservation(struct page *page,
    1378
    1379 if ((offset <= curr_off) && (buffer_delay(bh))) {
    1380 to_release++;
    1381 + contiguous_blks++;
    1382 clear_buffer_delay(bh);
    1383 + } else if (contiguous_blks) {
    1384 + lblk = page->index <<
    1385 + (PAGE_CACHE_SHIFT - inode->i_blkbits);
    1386 + lblk += (curr_off >> inode->i_blkbits) -
    1387 + contiguous_blks;
    1388 + ext4_es_remove_extent(inode, lblk, contiguous_blks);
    1389 + contiguous_blks = 0;
    1390 }
    1391 curr_off = next_off;
    1392 } while ((bh = bh->b_this_page) != head);
    1393
    1394 - if (to_release) {
    1395 + if (contiguous_blks) {
    1396 lblk = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
    1397 - ext4_es_remove_extent(inode, lblk, to_release);
    1398 + lblk += (curr_off >> inode->i_blkbits) - contiguous_blks;
    1399 + ext4_es_remove_extent(inode, lblk, contiguous_blks);
    1400 }
    1401
    1402 /* If we have released all the blocks belonging to a cluster, then we
    1403 diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
    1404 index dbfe15c2533c..99c8e38ffb7b 100644
    1405 --- a/fs/ext4/mballoc.c
    1406 +++ b/fs/ext4/mballoc.c
    1407 @@ -4801,18 +4801,12 @@ do_more:
    1408 /*
    1409 * blocks being freed are metadata. these blocks shouldn't
    1410 * be used until this transaction is committed
    1411 + *
    1412 + * We use __GFP_NOFAIL because ext4_free_blocks() is not allowed
    1413 + * to fail.
    1414 */
    1415 - retry:
    1416 - new_entry = kmem_cache_alloc(ext4_free_data_cachep, GFP_NOFS);
    1417 - if (!new_entry) {
    1418 - /*
    1419 - * We use a retry loop because
    1420 - * ext4_free_blocks() is not allowed to fail.
    1421 - */
    1422 - cond_resched();
    1423 - congestion_wait(BLK_RW_ASYNC, HZ/50);
    1424 - goto retry;
    1425 - }
    1426 + new_entry = kmem_cache_alloc(ext4_free_data_cachep,
    1427 + GFP_NOFS|__GFP_NOFAIL);
    1428 new_entry->efd_start_cluster = bit;
    1429 new_entry->efd_group = block_group;
    1430 new_entry->efd_count = count_clusters;
    1431 diff --git a/fs/ext4/migrate.c b/fs/ext4/migrate.c
    1432 index a432634f2e6a..876b984f1a75 100644
    1433 --- a/fs/ext4/migrate.c
    1434 +++ b/fs/ext4/migrate.c
    1435 @@ -620,6 +620,7 @@ int ext4_ind_migrate(struct inode *inode)
    1436 struct ext4_inode_info *ei = EXT4_I(inode);
    1437 struct ext4_extent *ex;
    1438 unsigned int i, len;
    1439 + ext4_lblk_t start, end;
    1440 ext4_fsblk_t blk;
    1441 handle_t *handle;
    1442 int ret;
    1443 @@ -633,6 +634,14 @@ int ext4_ind_migrate(struct inode *inode)
    1444 EXT4_FEATURE_RO_COMPAT_BIGALLOC))
    1445 return -EOPNOTSUPP;
    1446
    1447 + /*
    1448 + * In order to get correct extent info, force all delayed allocation
    1449 + * blocks to be allocated, otherwise delayed allocation blocks may not
    1450 + * be reflected and bypass the checks on extent header.
    1451 + */
    1452 + if (test_opt(inode->i_sb, DELALLOC))
    1453 + ext4_alloc_da_blocks(inode);
    1454 +
    1455 handle = ext4_journal_start(inode, EXT4_HT_MIGRATE, 1);
    1456 if (IS_ERR(handle))
    1457 return PTR_ERR(handle);
    1458 @@ -650,11 +659,13 @@ int ext4_ind_migrate(struct inode *inode)
    1459 goto errout;
    1460 }
    1461 if (eh->eh_entries == 0)
    1462 - blk = len = 0;
    1463 + blk = len = start = end = 0;
    1464 else {
    1465 len = le16_to_cpu(ex->ee_len);
    1466 blk = ext4_ext_pblock(ex);
    1467 - if (len > EXT4_NDIR_BLOCKS) {
    1468 + start = le32_to_cpu(ex->ee_block);
    1469 + end = start + len - 1;
    1470 + if (end >= EXT4_NDIR_BLOCKS) {
    1471 ret = -EOPNOTSUPP;
    1472 goto errout;
    1473 }
    1474 @@ -662,7 +673,7 @@ int ext4_ind_migrate(struct inode *inode)
    1475
    1476 ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS);
    1477 memset(ei->i_data, 0, sizeof(ei->i_data));
    1478 - for (i=0; i < len; i++)
    1479 + for (i = start; i <= end; i++)
    1480 ei->i_data[i] = cpu_to_le32(blk++);
    1481 ext4_mark_inode_dirty(handle, inode);
    1482 errout:
    1483 diff --git a/fs/nfs/nfs3xdr.c b/fs/nfs/nfs3xdr.c
    1484 index 8f4cbe7f4aa8..53853ca134e5 100644
    1485 --- a/fs/nfs/nfs3xdr.c
    1486 +++ b/fs/nfs/nfs3xdr.c
    1487 @@ -1342,7 +1342,7 @@ static void nfs3_xdr_enc_setacl3args(struct rpc_rqst *req,
    1488 if (args->npages != 0)
    1489 xdr_write_pages(xdr, args->pages, 0, args->len);
    1490 else
    1491 - xdr_reserve_space(xdr, NFS_ACL_INLINE_BUFSIZE);
    1492 + xdr_reserve_space(xdr, args->len);
    1493
    1494 error = nfsacl_encode(xdr->buf, base, args->inode,
    1495 (args->mask & NFS_ACL) ?
    1496 diff --git a/include/acpi/actypes.h b/include/acpi/actypes.h
    1497 index 93ef42245647..f6406e70ea4a 100644
    1498 --- a/include/acpi/actypes.h
    1499 +++ b/include/acpi/actypes.h
    1500 @@ -573,6 +573,7 @@ typedef u64 acpi_integer;
    1501 #define ACPI_NO_ACPI_ENABLE 0x10
    1502 #define ACPI_NO_DEVICE_INIT 0x20
    1503 #define ACPI_NO_OBJECT_INIT 0x40
    1504 +#define ACPI_NO_FACS_INIT 0x80
    1505
    1506 /*
    1507 * Initialization state
    1508 diff --git a/include/linux/libata.h b/include/linux/libata.h
    1509 index b3a816f4c0c4..8f6a07441b85 100644
    1510 --- a/include/linux/libata.h
    1511 +++ b/include/linux/libata.h
    1512 @@ -429,6 +429,7 @@ enum {
    1513 ATA_HORKAGE_NO_NCQ_TRIM = (1 << 19), /* don't use queued TRIM */
    1514 ATA_HORKAGE_NOLPM = (1 << 20), /* don't use LPM */
    1515 ATA_HORKAGE_WD_BROKEN_LPM = (1 << 21), /* some WDs have broken LPM */
    1516 + ATA_HORKAGE_NOTRIM = (1 << 24), /* don't use TRIM */
    1517
    1518 /* DMA mask for user DMA control: User visible values; DO NOT
    1519 renumber */
    1520 diff --git a/include/linux/of.h b/include/linux/of.h
    1521 index ce9f6a2b3532..4a6a489a7506 100644
    1522 --- a/include/linux/of.h
    1523 +++ b/include/linux/of.h
    1524 @@ -593,7 +593,10 @@ static inline const char *of_prop_next_string(struct property *prop,
    1525 #if defined(CONFIG_OF) && defined(CONFIG_NUMA)
    1526 extern int of_node_to_nid(struct device_node *np);
    1527 #else
    1528 -static inline int of_node_to_nid(struct device_node *device) { return 0; }
    1529 +static inline int of_node_to_nid(struct device_node *device)
    1530 +{
    1531 + return NUMA_NO_NODE;
    1532 +}
    1533 #endif
    1534
    1535 static inline struct device_node *of_find_matching_node(
    1536 diff --git a/include/scsi/scsi_devinfo.h b/include/scsi/scsi_devinfo.h
    1537 index 183eaab7c380..96e3f56519e7 100644
    1538 --- a/include/scsi/scsi_devinfo.h
    1539 +++ b/include/scsi/scsi_devinfo.h
    1540 @@ -36,5 +36,6 @@
    1541 for sequential scan */
    1542 #define BLIST_TRY_VPD_PAGES 0x10000000 /* Attempt to read VPD pages */
    1543 #define BLIST_NO_RSOC 0x20000000 /* don't try to issue RSOC */
    1544 +#define BLIST_MAX_1024 0x40000000 /* maximum 1024 sector cdb length */
    1545
    1546 #endif
    1547 diff --git a/include/uapi/linux/usbdevice_fs.h b/include/uapi/linux/usbdevice_fs.h
    1548 index abe5f4bd4d82..019ba1e0799a 100644
    1549 --- a/include/uapi/linux/usbdevice_fs.h
    1550 +++ b/include/uapi/linux/usbdevice_fs.h
    1551 @@ -128,11 +128,12 @@ struct usbdevfs_hub_portinfo {
    1552 char port [127]; /* e.g. port 3 connects to device 27 */
    1553 };
    1554
    1555 -/* Device capability flags */
    1556 +/* System and bus capability flags */
    1557 #define USBDEVFS_CAP_ZERO_PACKET 0x01
    1558 #define USBDEVFS_CAP_BULK_CONTINUATION 0x02
    1559 #define USBDEVFS_CAP_NO_PACKET_SIZE_LIM 0x04
    1560 #define USBDEVFS_CAP_BULK_SCATTER_GATHER 0x08
    1561 +#define USBDEVFS_CAP_REAP_AFTER_DISCONNECT 0x10
    1562
    1563 /* USBDEVFS_DISCONNECT_CLAIM flags & struct */
    1564
    1565 diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
    1566 index bf95fdad4d96..3b9f01ba363a 100644
    1567 --- a/kernel/printk/printk.c
    1568 +++ b/kernel/printk/printk.c
    1569 @@ -487,11 +487,11 @@ static int check_syslog_permissions(int type, bool from_file)
    1570 * already done the capabilities checks at open time.
    1571 */
    1572 if (from_file && type != SYSLOG_ACTION_OPEN)
    1573 - return 0;
    1574 + goto ok;
    1575
    1576 if (syslog_action_restricted(type)) {
    1577 if (capable(CAP_SYSLOG))
    1578 - return 0;
    1579 + goto ok;
    1580 /*
    1581 * For historical reasons, accept CAP_SYS_ADMIN too, with
    1582 * a warning.
    1583 @@ -501,10 +501,11 @@ static int check_syslog_permissions(int type, bool from_file)
    1584 "CAP_SYS_ADMIN but no CAP_SYSLOG "
    1585 "(deprecated).\n",
    1586 current->comm, task_pid_nr(current));
    1587 - return 0;
    1588 + goto ok;
    1589 }
    1590 return -EPERM;
    1591 }
    1592 +ok:
    1593 return security_syslog(type);
    1594 }
    1595
    1596 @@ -1266,10 +1267,6 @@ int do_syslog(int type, char __user *buf, int len, bool from_file)
    1597 if (error)
    1598 goto out;
    1599
    1600 - error = security_syslog(type);
    1601 - if (error)
    1602 - return error;
    1603 -
    1604 switch (type) {
    1605 case SYSLOG_ACTION_CLOSE: /* Close log */
    1606 break;
    1607 diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
    1608 index 385391fb1d3b..5642436bf97e 100644
    1609 --- a/kernel/trace/trace.h
    1610 +++ b/kernel/trace/trace.h
    1611 @@ -442,6 +442,7 @@ enum {
    1612
    1613 TRACE_CONTROL_BIT,
    1614
    1615 + TRACE_BRANCH_BIT,
    1616 /*
    1617 * Abuse of the trace_recursion.
    1618 * As we need a way to maintain state if we are tracing the function
    1619 diff --git a/kernel/trace/trace_branch.c b/kernel/trace/trace_branch.c
    1620 index 697fb9bac8f0..60850b4fcb04 100644
    1621 --- a/kernel/trace/trace_branch.c
    1622 +++ b/kernel/trace/trace_branch.c
    1623 @@ -37,9 +37,12 @@ probe_likely_condition(struct ftrace_branch_data *f, int val, int expect)
    1624 struct trace_branch *entry;
    1625 struct ring_buffer *buffer;
    1626 unsigned long flags;
    1627 - int cpu, pc;
    1628 + int pc;
    1629 const char *p;
    1630
    1631 + if (current->trace_recursion & TRACE_BRANCH_BIT)
    1632 + return;
    1633 +
    1634 /*
    1635 * I would love to save just the ftrace_likely_data pointer, but
    1636 * this code can also be used by modules. Ugly things can happen
    1637 @@ -50,10 +53,10 @@ probe_likely_condition(struct ftrace_branch_data *f, int val, int expect)
    1638 if (unlikely(!tr))
    1639 return;
    1640
    1641 - local_irq_save(flags);
    1642 - cpu = raw_smp_processor_id();
    1643 - data = per_cpu_ptr(tr->trace_buffer.data, cpu);
    1644 - if (atomic_inc_return(&data->disabled) != 1)
    1645 + raw_local_irq_save(flags);
    1646 + current->trace_recursion |= TRACE_BRANCH_BIT;
    1647 + data = this_cpu_ptr(tr->trace_buffer.data);
    1648 + if (atomic_read(&data->disabled))
    1649 goto out;
    1650
    1651 pc = preempt_count();
    1652 @@ -82,8 +85,8 @@ probe_likely_condition(struct ftrace_branch_data *f, int val, int expect)
    1653 __buffer_unlock_commit(buffer, event);
    1654
    1655 out:
    1656 - atomic_dec(&data->disabled);
    1657 - local_irq_restore(flags);
    1658 + current->trace_recursion &= ~TRACE_BRANCH_BIT;
    1659 + raw_local_irq_restore(flags);
    1660 }
    1661
    1662 static inline
    1663 diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
    1664 index 51afcb76d32b..357b1ddf088b 100644
    1665 --- a/kernel/trace/trace_events_filter.c
    1666 +++ b/kernel/trace/trace_events_filter.c
    1667 @@ -1383,7 +1383,9 @@ static int check_preds(struct filter_parse_state *ps)
    1668 continue;
    1669 }
    1670 n_normal_preds++;
    1671 - WARN_ON_ONCE(cnt < 0);
    1672 + /* all ops should have operands */
    1673 + if (cnt < 0)
    1674 + break;
    1675 }
    1676
    1677 if (cnt != 1 || !n_normal_preds || n_logical_preds >= n_normal_preds) {
    1678 diff --git a/lib/bitmap.c b/lib/bitmap.c
    1679 index b499ab6ada29..2ed91904e806 100644
    1680 --- a/lib/bitmap.c
    1681 +++ b/lib/bitmap.c
    1682 @@ -610,12 +610,12 @@ static int __bitmap_parselist(const char *buf, unsigned int buflen,
    1683 unsigned a, b;
    1684 int c, old_c, totaldigits;
    1685 const char __user __force *ubuf = (const char __user __force *)buf;
    1686 - int exp_digit, in_range;
    1687 + int at_start, in_range;
    1688
    1689 totaldigits = c = 0;
    1690 bitmap_zero(maskp, nmaskbits);
    1691 do {
    1692 - exp_digit = 1;
    1693 + at_start = 1;
    1694 in_range = 0;
    1695 a = b = 0;
    1696
    1697 @@ -644,11 +644,10 @@ static int __bitmap_parselist(const char *buf, unsigned int buflen,
    1698 break;
    1699
    1700 if (c == '-') {
    1701 - if (exp_digit || in_range)
    1702 + if (at_start || in_range)
    1703 return -EINVAL;
    1704 b = 0;
    1705 in_range = 1;
    1706 - exp_digit = 1;
    1707 continue;
    1708 }
    1709
    1710 @@ -658,16 +657,18 @@ static int __bitmap_parselist(const char *buf, unsigned int buflen,
    1711 b = b * 10 + (c - '0');
    1712 if (!in_range)
    1713 a = b;
    1714 - exp_digit = 0;
    1715 + at_start = 0;
    1716 totaldigits++;
    1717 }
    1718 if (!(a <= b))
    1719 return -EINVAL;
    1720 if (b >= nmaskbits)
    1721 return -ERANGE;
    1722 - while (a <= b) {
    1723 - set_bit(a, maskp);
    1724 - a++;
    1725 + if (!at_start) {
    1726 + while (a <= b) {
    1727 + set_bit(a, maskp);
    1728 + a++;
    1729 + }
    1730 }
    1731 } while (buflen && c == ',');
    1732 return 0;
    1733 diff --git a/net/9p/client.c b/net/9p/client.c
    1734 index e86a9bea1d16..53fe98ee8a55 100644
    1735 --- a/net/9p/client.c
    1736 +++ b/net/9p/client.c
    1737 @@ -850,7 +850,8 @@ static struct p9_req_t *p9_client_zc_rpc(struct p9_client *c, int8_t type,
    1738 if (err < 0) {
    1739 if (err == -EIO)
    1740 c->status = Disconnected;
    1741 - goto reterr;
    1742 + if (err != -ERESTARTSYS)
    1743 + goto reterr;
    1744 }
    1745 if (req->status == REQ_STATUS_ERROR) {
    1746 p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
    1747 diff --git a/net/can/af_can.c b/net/can/af_can.c
    1748 index 9a3244941a5c..d6030d6949df 100644
    1749 --- a/net/can/af_can.c
    1750 +++ b/net/can/af_can.c
    1751 @@ -313,12 +313,8 @@ int can_send(struct sk_buff *skb, int loop)
    1752 return err;
    1753 }
    1754
    1755 - if (newskb) {
    1756 - if (!(newskb->tstamp.tv64))
    1757 - __net_timestamp(newskb);
    1758 -
    1759 + if (newskb)
    1760 netif_rx_ni(newskb);
    1761 - }
    1762
    1763 /* update statistics */
    1764 can_stats.tx_frames++;
    1765 diff --git a/net/mac80211/main.c b/net/mac80211/main.c
    1766 index 0de7c93bf62b..67943cb5df8a 100644
    1767 --- a/net/mac80211/main.c
    1768 +++ b/net/mac80211/main.c
    1769 @@ -249,6 +249,7 @@ static void ieee80211_restart_work(struct work_struct *work)
    1770 {
    1771 struct ieee80211_local *local =
    1772 container_of(work, struct ieee80211_local, restart_work);
    1773 + struct ieee80211_sub_if_data *sdata;
    1774
    1775 /* wait for scan work complete */
    1776 flush_workqueue(local->workqueue);
    1777 @@ -257,6 +258,8 @@ static void ieee80211_restart_work(struct work_struct *work)
    1778 "%s called with hardware scan in progress\n", __func__);
    1779
    1780 rtnl_lock();
    1781 + list_for_each_entry(sdata, &local->interfaces, list)
    1782 + flush_delayed_work(&sdata->dec_tailroom_needed_wk);
    1783 ieee80211_scan_cancel(local);
    1784 ieee80211_reconfig(local);
    1785 rtnl_unlock();
    1786 diff --git a/security/integrity/evm/evm_main.c b/security/integrity/evm/evm_main.c
    1787 index c5ee1a7c5e8a..4ada1a97a60b 100644
    1788 --- a/security/integrity/evm/evm_main.c
    1789 +++ b/security/integrity/evm/evm_main.c
    1790 @@ -22,6 +22,7 @@
    1791 #include <linux/xattr.h>
    1792 #include <linux/integrity.h>
    1793 #include <linux/evm.h>
    1794 +#include <linux/magic.h>
    1795 #include <crypto/hash.h>
    1796 #include "evm.h"
    1797
    1798 @@ -291,6 +292,17 @@ static int evm_protect_xattr(struct dentry *dentry, const char *xattr_name,
    1799 iint = integrity_iint_find(dentry->d_inode);
    1800 if (iint && (iint->flags & IMA_NEW_FILE))
    1801 return 0;
    1802 +
    1803 + /* exception for pseudo filesystems */
    1804 + if (dentry->d_inode->i_sb->s_magic == TMPFS_MAGIC
    1805 + || dentry->d_inode->i_sb->s_magic == SYSFS_MAGIC)
    1806 + return 0;
    1807 +
    1808 + integrity_audit_msg(AUDIT_INTEGRITY_METADATA,
    1809 + dentry->d_inode, dentry->d_name.name,
    1810 + "update_metadata",
    1811 + integrity_status_msg[evm_status],
    1812 + -EPERM, 0);
    1813 }
    1814 out:
    1815 if (evm_status != INTEGRITY_PASS)
    1816 diff --git a/security/keys/keyring.c b/security/keys/keyring.c
    1817 index e72548b5897e..d33437007ad2 100644
    1818 --- a/security/keys/keyring.c
    1819 +++ b/security/keys/keyring.c
    1820 @@ -1181,9 +1181,11 @@ void __key_link_end(struct key *keyring,
    1821 if (index_key->type == &key_type_keyring)
    1822 up_write(&keyring_serialise_link_sem);
    1823
    1824 - if (edit && !edit->dead_leaf) {
    1825 - key_payload_reserve(keyring,
    1826 - keyring->datalen - KEYQUOTA_LINK_BYTES);
    1827 + if (edit) {
    1828 + if (!edit->dead_leaf) {
    1829 + key_payload_reserve(keyring,
    1830 + keyring->datalen - KEYQUOTA_LINK_BYTES);
    1831 + }
    1832 assoc_array_cancel_edit(edit);
    1833 }
    1834 up_write(&keyring->sem);
    1835 diff --git a/sound/soc/fsl/imx-wm8962.c b/sound/soc/fsl/imx-wm8962.c
    1836 index 3a3d17ce6ba4..664452599497 100644
    1837 --- a/sound/soc/fsl/imx-wm8962.c
    1838 +++ b/sound/soc/fsl/imx-wm8962.c
    1839 @@ -190,7 +190,7 @@ static int imx_wm8962_probe(struct platform_device *pdev)
    1840 dev_err(&pdev->dev, "audmux internal port setup failed\n");
    1841 return ret;
    1842 }
    1843 - imx_audmux_v2_configure_port(ext_port,
    1844 + ret = imx_audmux_v2_configure_port(ext_port,
    1845 IMX_AUDMUX_V2_PTCR_SYN,
    1846 IMX_AUDMUX_V2_PDCR_RXDSEL(int_port));
    1847 if (ret) {