Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel-lts/patches-3.4/0159-3.4.60-all-fixes.patch

    Contents of /trunk/kernel-lts/patches-3.4/0159-3.4.60-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 2276 - (show annotations) (download)
    Mon Sep 2 08:10:14 2013 UTC (10 years, 8 months ago) by niro
    File size: 20355 byte(s) 
    -linux-3.4.60
    1 diff --git a/arch/x86/xen/setup.c b/arch/x86/xen/setup.c
    2 index 017d48a..f8b0260 100644
    3 --- a/arch/x86/xen/setup.c
    4 +++ b/arch/x86/xen/setup.c
    5 @@ -213,6 +213,17 @@ static void xen_align_and_add_e820_region(u64 start, u64 size, int type)
    6 e820_add_region(start, end - start, type);
    7 }
    8
    9 +void xen_ignore_unusable(struct e820entry *list, size_t map_size)
    10 +{
    11 + struct e820entry *entry;
    12 + unsigned int i;
    13 +
    14 + for (i = 0, entry = list; i < map_size; i++, entry++) {
    15 + if (entry->type == E820_UNUSABLE)
    16 + entry->type = E820_RAM;
    17 + }
    18 +}
    19 +
    20 /**
    21 * machine_specific_memory_setup - Hook for machine specific memory setup.
    22 **/
    23 @@ -251,6 +262,17 @@ char * __init xen_memory_setup(void)
    24 }
    25 BUG_ON(rc);
    26
    27 + /*
    28 + * Xen won't allow a 1:1 mapping to be created to UNUSABLE
    29 + * regions, so if we're using the machine memory map leave the
    30 + * region as RAM as it is in the pseudo-physical map.
    31 + *
    32 + * UNUSABLE regions in domUs are not handled and will need
    33 + * a patch in the future.
    34 + */
    35 + if (xen_initial_domain())
    36 + xen_ignore_unusable(map, memmap.nr_entries);
    37 +
    38 /* Make sure the Xen-supplied memory map is well-ordered. */
    39 sanitize_e820_map(map, memmap.nr_entries, &memmap.nr_entries);
    40
    41 diff --git a/drivers/ata/libata-pmp.c b/drivers/ata/libata-pmp.c
    42 index f63a588..f5c35be 100644
    43 --- a/drivers/ata/libata-pmp.c
    44 +++ b/drivers/ata/libata-pmp.c
    45 @@ -289,24 +289,24 @@ static int sata_pmp_configure(struct ata_device *dev, int print_info)
    46
    47 /* Disable sending Early R_OK.
    48 * With "cached read" HDD testing and multiple ports busy on a SATA
    49 - * host controller, 3726 PMP will very rarely drop a deferred
    50 + * host controller, 3x26 PMP will very rarely drop a deferred
    51 * R_OK that was intended for the host. Symptom will be all
    52 * 5 drives under test will timeout, get reset, and recover.
    53 */
    54 - if (vendor == 0x1095 && devid == 0x3726) {
    55 + if (vendor == 0x1095 && (devid == 0x3726 || devid == 0x3826)) {
    56 u32 reg;
    57
    58 err_mask = sata_pmp_read(&ap->link, PMP_GSCR_SII_POL, &reg);
    59 if (err_mask) {
    60 rc = -EIO;
    61 - reason = "failed to read Sil3726 Private Register";
    62 + reason = "failed to read Sil3x26 Private Register";
    63 goto fail;
    64 }
    65 reg &= ~0x1;
    66 err_mask = sata_pmp_write(&ap->link, PMP_GSCR_SII_POL, reg);
    67 if (err_mask) {
    68 rc = -EIO;
    69 - reason = "failed to write Sil3726 Private Register";
    70 + reason = "failed to write Sil3x26 Private Register";
    71 goto fail;
    72 }
    73 }
    74 @@ -383,8 +383,8 @@ static void sata_pmp_quirks(struct ata_port *ap)
    75 u16 devid = sata_pmp_gscr_devid(gscr);
    76 struct ata_link *link;
    77
    78 - if (vendor == 0x1095 && devid == 0x3726) {
    79 - /* sil3726 quirks */
    80 + if (vendor == 0x1095 && (devid == 0x3726 || devid == 0x3826)) {
    81 + /* sil3x26 quirks */
    82 ata_for_each_link(link, ap, EDGE) {
    83 /* link reports offline after LPM */
    84 link->flags |= ATA_LFLAG_NO_LPM;
    85 diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h
    86 index dde62bf..d031932 100644
    87 --- a/drivers/gpu/drm/i915/i915_reg.h
    88 +++ b/drivers/gpu/drm/i915/i915_reg.h
    89 @@ -502,6 +502,8 @@
    90 will not assert AGPBUSY# and will only
    91 be delivered when out of C3. */
    92 #define INSTPM_FORCE_ORDERING (1<<7) /* GEN6+ */
    93 +#define INSTPM_TLB_INVALIDATE (1<<9)
    94 +#define INSTPM_SYNC_FLUSH (1<<5)
    95 #define ACTHD 0x020c8
    96 #define FW_BLC 0x020d8
    97 #define FW_BLC2 0x020dc
    98 diff --git a/drivers/gpu/drm/i915/intel_ringbuffer.c b/drivers/gpu/drm/i915/intel_ringbuffer.c
    99 index c17325c..99a9df8 100644
    100 --- a/drivers/gpu/drm/i915/intel_ringbuffer.c
    101 +++ b/drivers/gpu/drm/i915/intel_ringbuffer.c
    102 @@ -767,6 +767,18 @@ void intel_ring_setup_status_page(struct intel_ring_buffer *ring)
    103
    104 I915_WRITE(mmio, (u32)ring->status_page.gfx_addr);
    105 POSTING_READ(mmio);
    106 +
    107 + /* Flush the TLB for this page */
    108 + if (INTEL_INFO(dev)->gen >= 6) {
    109 + u32 reg = RING_INSTPM(ring->mmio_base);
    110 + I915_WRITE(reg,
    111 + _MASKED_BIT_ENABLE(INSTPM_TLB_INVALIDATE |
    112 + INSTPM_SYNC_FLUSH));
    113 + if (wait_for((I915_READ(reg) & INSTPM_SYNC_FLUSH) == 0,
    114 + 1000))
    115 + DRM_ERROR("%s: wait for SyncFlush to complete for TLB invalidation timed out\n",
    116 + ring->name);
    117 + }
    118 }
    119
    120 static int
    121 diff --git a/drivers/net/wireless/hostap/hostap_ioctl.c b/drivers/net/wireless/hostap/hostap_ioctl.c
    122 index 18054d9..dbec2ff 100644
    123 --- a/drivers/net/wireless/hostap/hostap_ioctl.c
    124 +++ b/drivers/net/wireless/hostap/hostap_ioctl.c
    125 @@ -522,9 +522,9 @@ static int prism2_ioctl_giwaplist(struct net_device *dev,
    126
    127 data->length = prism2_ap_get_sta_qual(local, addr, qual, IW_MAX_AP, 1);
    128
    129 - memcpy(extra, &addr, sizeof(struct sockaddr) * data->length);
    130 + memcpy(extra, addr, sizeof(struct sockaddr) * data->length);
    131 data->flags = 1; /* has quality information */
    132 - memcpy(extra + sizeof(struct sockaddr) * data->length, &qual,
    133 + memcpy(extra + sizeof(struct sockaddr) * data->length, qual,
    134 sizeof(struct iw_quality) * data->length);
    135
    136 kfree(addr);
    137 diff --git a/drivers/net/wireless/zd1201.c b/drivers/net/wireless/zd1201.c
    138 index a66b93b..1662fcc 100644
    139 --- a/drivers/net/wireless/zd1201.c
    140 +++ b/drivers/net/wireless/zd1201.c
    141 @@ -98,10 +98,12 @@ static int zd1201_fw_upload(struct usb_device *dev, int apfw)
    142 goto exit;
    143
    144 err = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 0x4,
    145 - USB_DIR_IN | 0x40, 0,0, &ret, sizeof(ret), ZD1201_FW_TIMEOUT);
    146 + USB_DIR_IN | 0x40, 0, 0, buf, sizeof(ret), ZD1201_FW_TIMEOUT);
    147 if (err < 0)
    148 goto exit;
    149
    150 + memcpy(&ret, buf, sizeof(ret));
    151 +
    152 if (ret & 0x80) {
    153 err = -EIO;
    154 goto exit;
    155 diff --git a/drivers/of/fdt.c b/drivers/of/fdt.c
    156 index 91a375f..17fad3b 100644
    157 --- a/drivers/of/fdt.c
    158 +++ b/drivers/of/fdt.c
    159 @@ -390,6 +390,8 @@ static void __unflatten_device_tree(struct boot_param_header *blob,
    160 mem = (unsigned long)
    161 dt_alloc(size + 4, __alignof__(struct device_node));
    162
    163 + memset((void *)mem, 0, size);
    164 +
    165 ((__be32 *)mem)[size / 4] = cpu_to_be32(0xdeadbeef);
    166
    167 pr_debug(" unflattening %lx...\n", mem);
    168 diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c
    169 index e1b4f80..5c87270 100644
    170 --- a/drivers/s390/scsi/zfcp_erp.c
    171 +++ b/drivers/s390/scsi/zfcp_erp.c
    172 @@ -102,10 +102,13 @@ static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
    173
    174 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
    175 zfcp_erp_action_dismiss(&port->erp_action);
    176 - else
    177 - shost_for_each_device(sdev, port->adapter->scsi_host)
    178 + else {
    179 + spin_lock(port->adapter->scsi_host->host_lock);
    180 + __shost_for_each_device(sdev, port->adapter->scsi_host)
    181 if (sdev_to_zfcp(sdev)->port == port)
    182 zfcp_erp_action_dismiss_lun(sdev);
    183 + spin_unlock(port->adapter->scsi_host->host_lock);
    184 + }
    185 }
    186
    187 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
    188 @@ -592,9 +595,11 @@ static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,
    189 {
    190 struct scsi_device *sdev;
    191
    192 - shost_for_each_device(sdev, port->adapter->scsi_host)
    193 + spin_lock(port->adapter->scsi_host->host_lock);
    194 + __shost_for_each_device(sdev, port->adapter->scsi_host)
    195 if (sdev_to_zfcp(sdev)->port == port)
    196 _zfcp_erp_lun_reopen(sdev, clear, id, 0);
    197 + spin_unlock(port->adapter->scsi_host->host_lock);
    198 }
    199
    200 static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
    201 @@ -1435,8 +1440,10 @@ void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask)
    202 atomic_set_mask(common_mask, &port->status);
    203 read_unlock_irqrestore(&adapter->port_list_lock, flags);
    204
    205 - shost_for_each_device(sdev, adapter->scsi_host)
    206 + spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
    207 + __shost_for_each_device(sdev, adapter->scsi_host)
    208 atomic_set_mask(common_mask, &sdev_to_zfcp(sdev)->status);
    209 + spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
    210 }
    211
    212 /**
    213 @@ -1470,11 +1477,13 @@ void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask)
    214 }
    215 read_unlock_irqrestore(&adapter->port_list_lock, flags);
    216
    217 - shost_for_each_device(sdev, adapter->scsi_host) {
    218 + spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
    219 + __shost_for_each_device(sdev, adapter->scsi_host) {
    220 atomic_clear_mask(common_mask, &sdev_to_zfcp(sdev)->status);
    221 if (clear_counter)
    222 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
    223 }
    224 + spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
    225 }
    226
    227 /**
    228 @@ -1488,16 +1497,19 @@ void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask)
    229 {
    230 struct scsi_device *sdev;
    231 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
    232 + unsigned long flags;
    233
    234 atomic_set_mask(mask, &port->status);
    235
    236 if (!common_mask)
    237 return;
    238
    239 - shost_for_each_device(sdev, port->adapter->scsi_host)
    240 + spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
    241 + __shost_for_each_device(sdev, port->adapter->scsi_host)
    242 if (sdev_to_zfcp(sdev)->port == port)
    243 atomic_set_mask(common_mask,
    244 &sdev_to_zfcp(sdev)->status);
    245 + spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
    246 }
    247
    248 /**
    249 @@ -1512,6 +1524,7 @@ void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
    250 struct scsi_device *sdev;
    251 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
    252 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
    253 + unsigned long flags;
    254
    255 atomic_clear_mask(mask, &port->status);
    256
    257 @@ -1521,13 +1534,15 @@ void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
    258 if (clear_counter)
    259 atomic_set(&port->erp_counter, 0);
    260
    261 - shost_for_each_device(sdev, port->adapter->scsi_host)
    262 + spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
    263 + __shost_for_each_device(sdev, port->adapter->scsi_host)
    264 if (sdev_to_zfcp(sdev)->port == port) {
    265 atomic_clear_mask(common_mask,
    266 &sdev_to_zfcp(sdev)->status);
    267 if (clear_counter)
    268 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
    269 }
    270 + spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
    271 }
    272
    273 /**
    274 diff --git a/drivers/s390/scsi/zfcp_qdio.c b/drivers/s390/scsi/zfcp_qdio.c
    275 index e76d003..52c6b59 100644
    276 --- a/drivers/s390/scsi/zfcp_qdio.c
    277 +++ b/drivers/s390/scsi/zfcp_qdio.c
    278 @@ -224,11 +224,9 @@ int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req,
    279
    280 static int zfcp_qdio_sbal_check(struct zfcp_qdio *qdio)
    281 {
    282 - spin_lock_irq(&qdio->req_q_lock);
    283 if (atomic_read(&qdio->req_q_free) ||
    284 !(atomic_read(&qdio->adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP))
    285 return 1;
    286 - spin_unlock_irq(&qdio->req_q_lock);
    287 return 0;
    288 }
    289
    290 @@ -246,9 +244,8 @@ int zfcp_qdio_sbal_get(struct zfcp_qdio *qdio)
    291 {
    292 long ret;
    293
    294 - spin_unlock_irq(&qdio->req_q_lock);
    295 - ret = wait_event_interruptible_timeout(qdio->req_q_wq,
    296 - zfcp_qdio_sbal_check(qdio), 5 * HZ);
    297 + ret = wait_event_interruptible_lock_irq_timeout(qdio->req_q_wq,
    298 + zfcp_qdio_sbal_check(qdio), qdio->req_q_lock, 5 * HZ);
    299
    300 if (!(atomic_read(&qdio->adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP))
    301 return -EIO;
    302 @@ -262,7 +259,6 @@ int zfcp_qdio_sbal_get(struct zfcp_qdio *qdio)
    303 zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdsbg_1");
    304 }
    305
    306 - spin_lock_irq(&qdio->req_q_lock);
    307 return -EIO;
    308 }
    309
    310 diff --git a/drivers/xen/events.c b/drivers/xen/events.c
    311 index 417c133..33dcad6 100644
    312 --- a/drivers/xen/events.c
    313 +++ b/drivers/xen/events.c
    314 @@ -324,7 +324,7 @@ static void init_evtchn_cpu_bindings(void)
    315
    316 for_each_possible_cpu(i)
    317 memset(per_cpu(cpu_evtchn_mask, i),
    318 - (i == 0) ? ~0 : 0, sizeof(*per_cpu(cpu_evtchn_mask, i)));
    319 + (i == 0) ? ~0 : 0, NR_EVENT_CHANNELS/8);
    320 }
    321
    322 static inline void clear_evtchn(int port)
    323 diff --git a/fs/nilfs2/segbuf.c b/fs/nilfs2/segbuf.c
    324 index dc9a913..2d8be51 100644
    325 --- a/fs/nilfs2/segbuf.c
    326 +++ b/fs/nilfs2/segbuf.c
    327 @@ -345,8 +345,7 @@ static void nilfs_end_bio_write(struct bio *bio, int err)
    328
    329 if (err == -EOPNOTSUPP) {
    330 set_bit(BIO_EOPNOTSUPP, &bio->bi_flags);
    331 - bio_put(bio);
    332 - /* to be detected by submit_seg_bio() */
    333 + /* to be detected by nilfs_segbuf_submit_bio() */
    334 }
    335
    336 if (!uptodate)
    337 @@ -377,12 +376,12 @@ static int nilfs_segbuf_submit_bio(struct nilfs_segment_buffer *segbuf,
    338 bio->bi_private = segbuf;
    339 bio_get(bio);
    340 submit_bio(mode, bio);
    341 + segbuf->sb_nbio++;
    342 if (bio_flagged(bio, BIO_EOPNOTSUPP)) {
    343 bio_put(bio);
    344 err = -EOPNOTSUPP;
    345 goto failed;
    346 }
    347 - segbuf->sb_nbio++;
    348 bio_put(bio);
    349
    350 wi->bio = NULL;
    351 diff --git a/include/linux/wait.h b/include/linux/wait.h
    352 index 6c6c20e..b305b31 100644
    353 --- a/include/linux/wait.h
    354 +++ b/include/linux/wait.h
    355 @@ -530,6 +530,63 @@ do { \
    356 ? 0 : __wait_event_interruptible_locked(wq, condition, 1, 1))
    357
    358
    359 +#define __wait_event_interruptible_lock_irq_timeout(wq, condition, \
    360 + lock, ret) \
    361 +do { \
    362 + DEFINE_WAIT(__wait); \
    363 + \
    364 + for (;;) { \
    365 + prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE); \
    366 + if (condition) \
    367 + break; \
    368 + if (signal_pending(current)) { \
    369 + ret = -ERESTARTSYS; \
    370 + break; \
    371 + } \
    372 + spin_unlock_irq(&lock); \
    373 + ret = schedule_timeout(ret); \
    374 + spin_lock_irq(&lock); \
    375 + if (!ret) \
    376 + break; \
    377 + } \
    378 + finish_wait(&wq, &__wait); \
    379 +} while (0)
    380 +
    381 +/**
    382 + * wait_event_interruptible_lock_irq_timeout - sleep until a condition gets true or a timeout elapses.
    383 + * The condition is checked under the lock. This is expected
    384 + * to be called with the lock taken.
    385 + * @wq: the waitqueue to wait on
    386 + * @condition: a C expression for the event to wait for
    387 + * @lock: a locked spinlock_t, which will be released before schedule()
    388 + * and reacquired afterwards.
    389 + * @timeout: timeout, in jiffies
    390 + *
    391 + * The process is put to sleep (TASK_INTERRUPTIBLE) until the
    392 + * @condition evaluates to true or signal is received. The @condition is
    393 + * checked each time the waitqueue @wq is woken up.
    394 + *
    395 + * wake_up() has to be called after changing any variable that could
    396 + * change the result of the wait condition.
    397 + *
    398 + * This is supposed to be called while holding the lock. The lock is
    399 + * dropped before going to sleep and is reacquired afterwards.
    400 + *
    401 + * The function returns 0 if the @timeout elapsed, -ERESTARTSYS if it
    402 + * was interrupted by a signal, and the remaining jiffies otherwise
    403 + * if the condition evaluated to true before the timeout elapsed.
    404 + */
    405 +#define wait_event_interruptible_lock_irq_timeout(wq, condition, lock, \
    406 + timeout) \
    407 +({ \
    408 + int __ret = timeout; \
    409 + \
    410 + if (!(condition)) \
    411 + __wait_event_interruptible_lock_irq_timeout( \
    412 + wq, condition, lock, __ret); \
    413 + __ret; \
    414 +})
    415 +
    416
    417 #define __wait_event_killable(wq, condition, ret) \
    418 do { \
    419 diff --git a/kernel/workqueue.c b/kernel/workqueue.c
    420 index a64b94e..575d092 100644
    421 --- a/kernel/workqueue.c
    422 +++ b/kernel/workqueue.c
    423 @@ -128,6 +128,7 @@ struct worker {
    424 };
    425
    426 struct work_struct *current_work; /* L: work being processed */
    427 + work_func_t current_func; /* L: current_work's fn */
    428 struct cpu_workqueue_struct *current_cwq; /* L: current_work's cwq */
    429 struct list_head scheduled; /* L: scheduled works */
    430 struct task_struct *task; /* I: worker task */
    431 @@ -838,7 +839,8 @@ static struct worker *__find_worker_executing_work(struct global_cwq *gcwq,
    432 struct hlist_node *tmp;
    433
    434 hlist_for_each_entry(worker, tmp, bwh, hentry)
    435 - if (worker->current_work == work)
    436 + if (worker->current_work == work &&
    437 + worker->current_func == work->func)
    438 return worker;
    439 return NULL;
    440 }
    441 @@ -848,9 +850,27 @@ static struct worker *__find_worker_executing_work(struct global_cwq *gcwq,
    442 * @gcwq: gcwq of interest
    443 * @work: work to find worker for
    444 *
    445 - * Find a worker which is executing @work on @gcwq. This function is
    446 - * identical to __find_worker_executing_work() except that this
    447 - * function calculates @bwh itself.
    448 + * Find a worker which is executing @work on @gcwq by searching
    449 + * @gcwq->busy_hash which is keyed by the address of @work. For a worker
    450 + * to match, its current execution should match the address of @work and
    451 + * its work function. This is to avoid unwanted dependency between
    452 + * unrelated work executions through a work item being recycled while still
    453 + * being executed.
    454 + *
    455 + * This is a bit tricky. A work item may be freed once its execution
    456 + * starts and nothing prevents the freed area from being recycled for
    457 + * another work item. If the same work item address ends up being reused
    458 + * before the original execution finishes, workqueue will identify the
    459 + * recycled work item as currently executing and make it wait until the
    460 + * current execution finishes, introducing an unwanted dependency.
    461 + *
    462 + * This function checks the work item address, work function and workqueue
    463 + * to avoid false positives. Note that this isn't complete as one may
    464 + * construct a work function which can introduce dependency onto itself
    465 + * through a recycled work item. Well, if somebody wants to shoot oneself
    466 + * in the foot that badly, there's only so much we can do, and if such
    467 + * deadlock actually occurs, it should be easy to locate the culprit work
    468 + * function.
    469 *
    470 * CONTEXT:
    471 * spin_lock_irq(gcwq->lock).
    472 @@ -1721,10 +1741,9 @@ static void move_linked_works(struct work_struct *work, struct list_head *head,
    473 *nextp = n;
    474 }
    475
    476 -static void cwq_activate_first_delayed(struct cpu_workqueue_struct *cwq)
    477 +static void cwq_activate_delayed_work(struct work_struct *work)
    478 {
    479 - struct work_struct *work = list_first_entry(&cwq->delayed_works,
    480 - struct work_struct, entry);
    481 + struct cpu_workqueue_struct *cwq = get_work_cwq(work);
    482 struct list_head *pos = gcwq_determine_ins_pos(cwq->gcwq, cwq);
    483
    484 trace_workqueue_activate_work(work);
    485 @@ -1733,6 +1752,14 @@ static void cwq_activate_first_delayed(struct cpu_workqueue_struct *cwq)
    486 cwq->nr_active++;
    487 }
    488
    489 +static void cwq_activate_first_delayed(struct cpu_workqueue_struct *cwq)
    490 +{
    491 + struct work_struct *work = list_first_entry(&cwq->delayed_works,
    492 + struct work_struct, entry);
    493 +
    494 + cwq_activate_delayed_work(work);
    495 +}
    496 +
    497 /**
    498 * cwq_dec_nr_in_flight - decrement cwq's nr_in_flight
    499 * @cwq: cwq of interest
    500 @@ -1804,7 +1831,6 @@ __acquires(&gcwq->lock)
    501 struct global_cwq *gcwq = cwq->gcwq;
    502 struct hlist_head *bwh = busy_worker_head(gcwq, work);
    503 bool cpu_intensive = cwq->wq->flags & WQ_CPU_INTENSIVE;
    504 - work_func_t f = work->func;
    505 int work_color;
    506 struct worker *collision;
    507 #ifdef CONFIG_LOCKDEP
    508 @@ -1833,6 +1859,7 @@ __acquires(&gcwq->lock)
    509 debug_work_deactivate(work);
    510 hlist_add_head(&worker->hentry, bwh);
    511 worker->current_work = work;
    512 + worker->current_func = work->func;
    513 worker->current_cwq = cwq;
    514 work_color = get_work_color(work);
    515
    516 @@ -1870,7 +1897,7 @@ __acquires(&gcwq->lock)
    517 lock_map_acquire_read(&cwq->wq->lockdep_map);
    518 lock_map_acquire(&lockdep_map);
    519 trace_workqueue_execute_start(work);
    520 - f(work);
    521 + worker->current_func(work);
    522 /*
    523 * While we must be careful to not use "work" after this, the trace
    524 * point will only record its address.
    525 @@ -1880,11 +1907,10 @@ __acquires(&gcwq->lock)
    526 lock_map_release(&cwq->wq->lockdep_map);
    527
    528 if (unlikely(in_atomic() || lockdep_depth(current) > 0)) {
    529 - printk(KERN_ERR "BUG: workqueue leaked lock or atomic: "
    530 - "%s/0x%08x/%d\n",
    531 - current->comm, preempt_count(), task_pid_nr(current));
    532 - printk(KERN_ERR " last function: ");
    533 - print_symbol("%s\n", (unsigned long)f);
    534 + pr_err("BUG: workqueue leaked lock or atomic: %s/0x%08x/%d\n"
    535 + " last function: %pf\n",
    536 + current->comm, preempt_count(), task_pid_nr(current),
    537 + worker->current_func);
    538 debug_show_held_locks(current);
    539 dump_stack();
    540 }
    541 @@ -1898,6 +1924,7 @@ __acquires(&gcwq->lock)
    542 /* we're done with it, release */
    543 hlist_del_init(&worker->hentry);
    544 worker->current_work = NULL;
    545 + worker->current_func = NULL;
    546 worker->current_cwq = NULL;
    547 cwq_dec_nr_in_flight(cwq, work_color, false);
    548 }
    549 @@ -2625,6 +2652,18 @@ static int try_to_grab_pending(struct work_struct *work)
    550 smp_rmb();
    551 if (gcwq == get_work_gcwq(work)) {
    552 debug_work_deactivate(work);
    553 +
    554 + /*
    555 + * A delayed work item cannot be grabbed directly
    556 + * because it might have linked NO_COLOR work items
    557 + * which, if left on the delayed_list, will confuse
    558 + * cwq->nr_active management later on and cause
    559 + * stall. Make sure the work item is activated
    560 + * before grabbing.
    561 + */
    562 + if (*work_data_bits(work) & WORK_STRUCT_DELAYED)
    563 + cwq_activate_delayed_work(work);
    564 +
    565 list_del_init(&work->entry);
    566 cwq_dec_nr_in_flight(get_work_cwq(work),
    567 get_work_color(work),