Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq
authorLinus Torvalds <torvalds@linux-foundation.org>
Sat, 23 Oct 2010 00:13:10 +0000 (17:13 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Sat, 23 Oct 2010 00:13:10 +0000 (17:13 -0700)
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq:
  workqueue: remove in_workqueue_context()
  workqueue: Clarify that schedule_on_each_cpu is synchronous
  memory_hotplug: drop spurious calls to flush_scheduled_work()
  shpchp: update workqueue usage
  pciehp: update workqueue usage
  isdn/eicon: don't call flush_scheduled_work() from diva_os_remove_soft_isr()
  workqueue: add and use WQ_MEM_RECLAIM flag
  workqueue: fix HIGHPRI handling in keep_working()
  workqueue: add queue_work and activate_work trace points
  workqueue: prepare for more tracepoints
  workqueue: implement flush[_delayed]_work_sync()
  workqueue: factor out start_flush_work()
  workqueue: cleanup flush/cancel functions
  workqueue: implement alloc_ordered_workqueue()

Fix up trivial conflict in fs/gfs2/main.c as per Tejun

1  2 
drivers/ata/libata-sff.c
fs/gfs2/main.c
fs/xfs/linux-2.6/xfs_buf.c

diff --combined drivers/ata/libata-sff.c
@@@ -222,7 -222,7 +222,7 @@@ int ata_sff_busy_sleep(struct ata_port 
        timeout = ata_deadline(timer_start, tmout_pat);
        while (status != 0xff && (status & ATA_BUSY) &&
               time_before(jiffies, timeout)) {
 -              msleep(50);
 +              ata_msleep(ap, 50);
                status = ata_sff_busy_wait(ap, ATA_BUSY, 3);
        }
  
        timeout = ata_deadline(timer_start, tmout);
        while (status != 0xff && (status & ATA_BUSY) &&
               time_before(jiffies, timeout)) {
 -              msleep(50);
 +              ata_msleep(ap, 50);
                status = ap->ops->sff_check_status(ap);
        }
  
@@@ -360,7 -360,7 +360,7 @@@ static void ata_dev_select(struct ata_p
  
        if (wait) {
                if (can_sleep && ap->link.device[device].class == ATA_DEV_ATAPI)
 -                      msleep(150);
 +                      ata_msleep(ap, 150);
                ata_wait_idle(ap);
        }
  }
@@@ -1356,7 -1356,7 +1356,7 @@@ fsm_start
         */
        status = ata_sff_busy_wait(ap, ATA_BUSY, 5);
        if (status & ATA_BUSY) {
 -              msleep(2);
 +              ata_msleep(ap, 2);
                status = ata_sff_busy_wait(ap, ATA_BUSY, 10);
                if (status & ATA_BUSY) {
                        ata_sff_queue_pio_task(link, ATA_SHORT_PAUSE);
@@@ -1937,7 -1937,7 +1937,7 @@@ int ata_sff_wait_after_reset(struct ata
        unsigned int dev1 = devmask & (1 << 1);
        int rc, ret = 0;
  
 -      msleep(ATA_WAIT_AFTER_RESET);
 +      ata_msleep(ap, ATA_WAIT_AFTER_RESET);
  
        /* always check readiness of the master device */
        rc = ata_sff_wait_ready(link, deadline);
                        lbal = ioread8(ioaddr->lbal_addr);
                        if ((nsect == 1) && (lbal == 1))
                                break;
 -                      msleep(50);     /* give drive a breather */
 +                      ata_msleep(ap, 50);     /* give drive a breather */
                }
  
                rc = ata_sff_wait_ready(link, deadline);
@@@ -3335,14 -3335,14 +3335,14 @@@ void ata_sff_port_init(struct ata_port 
  
  int __init ata_sff_init(void)
  {
-       ata_sff_wq = alloc_workqueue("ata_sff", WQ_RESCUER, WQ_MAX_ACTIVE);
+       ata_sff_wq = alloc_workqueue("ata_sff", WQ_MEM_RECLAIM, WQ_MAX_ACTIVE);
        if (!ata_sff_wq)
                return -ENOMEM;
  
        return 0;
  }
  
 -void __exit ata_sff_exit(void)
 +void ata_sff_exit(void)
  {
        destroy_workqueue(ata_sff_wq);
  }
diff --combined fs/gfs2/main.c
@@@ -24,7 -24,6 +24,7 @@@
  #include "glock.h"
  #include "quota.h"
  #include "recovery.h"
 +#include "dir.h"
  
  static struct shrinker qd_shrinker = {
        .shrink = gfs2_shrink_qd_memory,
@@@ -79,9 -78,6 +79,9 @@@ static int __init init_gfs2_fs(void
  {
        int error;
  
 +      gfs2_str2qstr(&gfs2_qdot, ".");
 +      gfs2_str2qstr(&gfs2_qdotdot, "..");
 +
        error = gfs2_sys_init();
        if (error)
                return error;
  
        error = -ENOMEM;
        gfs_recovery_wq = alloc_workqueue("gfs_recovery",
-                                         WQ_RESCUER | WQ_FREEZEABLE, 0);
 -                                        WQ_NON_REENTRANT | WQ_MEM_RECLAIM, 0);
++                                        WQ_MEM_RECLAIM | WQ_FREEZEABLE, 0);
        if (!gfs_recovery_wq)
                goto fail_wq;
  
@@@ -924,7 -924,19 +924,7 @@@ xfs_buf_iodone_work
        xfs_buf_t               *bp =
                container_of(work, xfs_buf_t, b_iodone_work);
  
 -      /*
 -       * We can get an EOPNOTSUPP to ordered writes.  Here we clear the
 -       * ordered flag and reissue them.  Because we can't tell the higher
 -       * layers directly that they should not issue ordered I/O anymore, they
 -       * need to check if the _XFS_BARRIER_FAILED flag was set during I/O completion.
 -       */
 -      if ((bp->b_error == EOPNOTSUPP) &&
 -          (bp->b_flags & (XBF_ORDERED|XBF_ASYNC)) == (XBF_ORDERED|XBF_ASYNC)) {
 -              trace_xfs_buf_ordered_retry(bp, _RET_IP_);
 -              bp->b_flags &= ~XBF_ORDERED;
 -              bp->b_flags |= _XFS_BARRIER_FAILED;
 -              xfs_buf_iorequest(bp);
 -      } else if (bp->b_iodone)
 +      if (bp->b_iodone)
                (*(bp->b_iodone))(bp);
        else if (bp->b_flags & XBF_ASYNC)
                xfs_buf_relse(bp);
@@@ -1183,7 -1195,7 +1183,7 @@@ _xfs_buf_ioapply
  
        if (bp->b_flags & XBF_ORDERED) {
                ASSERT(!(bp->b_flags & XBF_READ));
 -              rw = WRITE_BARRIER;
 +              rw = WRITE_FLUSH_FUA;
        } else if (bp->b_flags & XBF_LOG_BUFFER) {
                ASSERT(!(bp->b_flags & XBF_READ_AHEAD));
                bp->b_flags &= ~_XBF_RUN_QUEUES;
@@@ -1921,7 -1933,7 +1921,7 @@@ xfs_buf_init(void
                goto out;
  
        xfslogd_workqueue = alloc_workqueue("xfslogd",
-                                       WQ_RESCUER | WQ_HIGHPRI, 1);
+                                       WQ_MEM_RECLAIM | WQ_HIGHPRI, 1);
        if (!xfslogd_workqueue)
                goto out_free_buf_zone;