Annotation of /trunk/kernel-alx/patches-3.18/0119-3.18.20-all-fixes.patch
Parent Directory | Revision Log
Revision 2690 -
(hide annotations)
(download)
Mon Aug 31 12:19:39 2015 UTC (9 years ago) by niro
File size: 60551 byte(s)
Mon Aug 31 12:19:39 2015 UTC (9 years ago) by niro
File size: 60551 byte(s)
-linux-3.18.20
1 | niro | 2690 | 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) { |