Merge branch 'kmap_atomic' of git://github.com/congwang/linux

Pull kmap_atomic cleanup from Cong Wang.

It's been in -next for a long time, and it gets rid of the (no longer
used) second argument to k[un]map_atomic().

Fix up a few trivial conflicts in various drivers, and do an "evil
merge" to catch some new uses that have come in since Cong's tree.

* 'kmap_atomic' of git://github.com/congwang/linux: (59 commits)
  feature-removal-schedule.txt: schedule the deprecated form of kmap_atomic() for removal
  highmem: kill all __kmap_atomic() [swarren@nvidia.com: highmem: Fix ARM build break due to __kmap_atomic rename]
  drbd: remove the second argument of k[un]map_atomic()
  zcache: remove the second argument of k[un]map_atomic()
  gma500: remove the second argument of k[un]map_atomic()
  dm: remove the second argument of k[un]map_atomic()
  tomoyo: remove the second argument of k[un]map_atomic()
  sunrpc: remove the second argument of k[un]map_atomic()
  rds: remove the second argument of k[un]map_atomic()
  net: remove the second argument of k[un]map_atomic()
  mm: remove the second argument of k[un]map_atomic()
  lib: remove the second argument of k[un]map_atomic()
  power: remove the second argument of k[un]map_atomic()
  kdb: remove the second argument of k[un]map_atomic()
  udf: remove the second argument of k[un]map_atomic()
  ubifs: remove the second argument of k[un]map_atomic()
  squashfs: remove the second argument of k[un]map_atomic()
  reiserfs: remove the second argument of k[un]map_atomic()
  ocfs2: remove the second argument of k[un]map_atomic()
  ntfs: remove the second argument of k[un]map_atomic()
  ...

2 files changed, 25 insertions, 25 deletions

diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index cdf36b1e9aa6..045e086144ad 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -457,7 +457,7 @@ void bitmap_update_sb(struct bitmap *bitmap)
                 return;
         }
         spin_unlock_irqrestore(&bitmap->lock, flags);
-        sb = kmap_atomic(bitmap->sb_page, KM_USER0);
+        sb = kmap_atomic(bitmap->sb_page);
         sb->events = cpu_to_le64(bitmap->mddev->events);
         if (bitmap->mddev->events < bitmap->events_cleared)
                 /* rocking back to read-only */
@@ -467,7 +467,7 @@ void bitmap_update_sb(struct bitmap *bitmap)
         /* Just in case these have been changed via sysfs: */
         sb->daemon_sleep = cpu_to_le32(bitmap->mddev->bitmap_info.daemon_sleep/HZ);
         sb->write_behind = cpu_to_le32(bitmap->mddev->bitmap_info.max_write_behind);
-        kunmap_atomic(sb, KM_USER0);
+        kunmap_atomic(sb);
         write_page(bitmap, bitmap->sb_page, 1);
 }
 
@@ -478,7 +478,7 @@ void bitmap_print_sb(struct bitmap *bitmap)
 
         if (!bitmap || !bitmap->sb_page)
                 return;
-        sb = kmap_atomic(bitmap->sb_page, KM_USER0);
+        sb = kmap_atomic(bitmap->sb_page);
         printk(KERN_DEBUG "%s: bitmap file superblock:\n", bmname(bitmap));
         printk(KERN_DEBUG "         magic: %08x\n", le32_to_cpu(sb->magic));
         printk(KERN_DEBUG "       version: %d\n", le32_to_cpu(sb->version));
@@ -497,7 +497,7 @@ void bitmap_print_sb(struct bitmap *bitmap)
         printk(KERN_DEBUG "     sync size: %llu KB\n",
                         (unsigned long long)le64_to_cpu(sb->sync_size)/2);
         printk(KERN_DEBUG "max write behind: %d\n", le32_to_cpu(sb->write_behind));
-        kunmap_atomic(sb, KM_USER0);
+        kunmap_atomic(sb);
 }
 
 /*
@@ -525,7 +525,7 @@ static int bitmap_new_disk_sb(struct bitmap *bitmap)
         }
         bitmap->sb_page->index = 0;
 
-        sb = kmap_atomic(bitmap->sb_page, KM_USER0);
+        sb = kmap_atomic(bitmap->sb_page);
 
         sb->magic = cpu_to_le32(BITMAP_MAGIC);
         sb->version = cpu_to_le32(BITMAP_MAJOR_HI);
@@ -533,7 +533,7 @@ static int bitmap_new_disk_sb(struct bitmap *bitmap)
         chunksize = bitmap->mddev->bitmap_info.chunksize;
         BUG_ON(!chunksize);
         if (!is_power_of_2(chunksize)) {
-                kunmap_atomic(sb, KM_USER0);
+                kunmap_atomic(sb);
                 printk(KERN_ERR "bitmap chunksize not a power of 2\n");
                 return -EINVAL;
         }
@@ -571,7 +571,7 @@ static int bitmap_new_disk_sb(struct bitmap *bitmap)
         bitmap->flags |= BITMAP_HOSTENDIAN;
         sb->version = cpu_to_le32(BITMAP_MAJOR_HOSTENDIAN);
 
-        kunmap_atomic(sb, KM_USER0);
+        kunmap_atomic(sb);
 
         return 0;
 }
@@ -603,7 +603,7 @@ static int bitmap_read_sb(struct bitmap *bitmap)
                 return err;
         }
 
-        sb = kmap_atomic(bitmap->sb_page, KM_USER0);
+        sb = kmap_atomic(bitmap->sb_page);
 
         chunksize = le32_to_cpu(sb->chunksize);
         daemon_sleep = le32_to_cpu(sb->daemon_sleep) * HZ;
@@ -664,7 +664,7 @@ success:
                 bitmap->events_cleared = bitmap->mddev->events;
         err = 0;
 out:
-        kunmap_atomic(sb, KM_USER0);
+        kunmap_atomic(sb);
         if (err)
                 bitmap_print_sb(bitmap);
         return err;
@@ -689,7 +689,7 @@ static int bitmap_mask_state(struct bitmap *bitmap, enum bitmap_state bits,
                 return 0;
         }
         spin_unlock_irqrestore(&bitmap->lock, flags);
-        sb = kmap_atomic(bitmap->sb_page, KM_USER0);
+        sb = kmap_atomic(bitmap->sb_page);
         old = le32_to_cpu(sb->state) & bits;
         switch (op) {
         case MASK_SET:
@@ -703,7 +703,7 @@ static int bitmap_mask_state(struct bitmap *bitmap, enum bitmap_state bits,
         default:
                 BUG();
         }
-        kunmap_atomic(sb, KM_USER0);
+        kunmap_atomic(sb);
         return old;
 }
 
@@ -881,12 +881,12 @@ static void bitmap_file_set_bit(struct bitmap *bitmap, sector_t block)
         bit = file_page_offset(bitmap, chunk);
 
         /* set the bit */
-        kaddr = kmap_atomic(page, KM_USER0);
+        kaddr = kmap_atomic(page);
         if (bitmap->flags & BITMAP_HOSTENDIAN)
                 set_bit(bit, kaddr);
         else
                 __set_bit_le(bit, kaddr);
-        kunmap_atomic(kaddr, KM_USER0);
+        kunmap_atomic(kaddr);
         pr_debug("set file bit %lu page %lu\n", bit, page->index);
         /* record page number so it gets flushed to disk when unplug occurs */
         set_page_attr(bitmap, page, BITMAP_PAGE_DIRTY);
@@ -1050,10 +1050,10 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
                                  * if bitmap is out of date, dirty the
                                  * whole page and write it out
                                  */
-                                paddr = kmap_atomic(page, KM_USER0);
+                                paddr = kmap_atomic(page);
                                 memset(paddr + offset, 0xff,
                                        PAGE_SIZE - offset);
-                                kunmap_atomic(paddr, KM_USER0);
+                                kunmap_atomic(paddr);
                                 write_page(bitmap, page, 1);
 
                                 ret = -EIO;
@@ -1061,12 +1061,12 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
                                         goto err;
                         }
                 }
-                paddr = kmap_atomic(page, KM_USER0);
+                paddr = kmap_atomic(page);
                 if (bitmap->flags & BITMAP_HOSTENDIAN)
                         b = test_bit(bit, paddr);
                 else
                         b = test_bit_le(bit, paddr);
-                kunmap_atomic(paddr, KM_USER0);
+                kunmap_atomic(paddr);
                 if (b) {
                         /* if the disk bit is set, set the memory bit */
                         int needed = ((sector_t)(i+1) << (CHUNK_BLOCK_SHIFT(bitmap))
@@ -1209,10 +1209,10 @@ void bitmap_daemon_work(struct mddev *mddev)
                             mddev->bitmap_info.external == 0) {
                                 bitmap_super_t *sb;
                                 bitmap->need_sync = 0;
-                                sb = kmap_atomic(bitmap->sb_page, KM_USER0);
+                                sb = kmap_atomic(bitmap->sb_page);
                                 sb->events_cleared =
                                         cpu_to_le64(bitmap->events_cleared);
-                                kunmap_atomic(sb, KM_USER0);
+                                kunmap_atomic(sb);
                                 write_page(bitmap, bitmap->sb_page, 1);
                         }
                         spin_lock_irqsave(&bitmap->lock, flags);
@@ -1235,7 +1235,7 @@ void bitmap_daemon_work(struct mddev *mddev)
                                                   -1);
 
                                 /* clear the bit */
-                                paddr = kmap_atomic(page, KM_USER0);
+                                paddr = kmap_atomic(page);
                                 if (bitmap->flags & BITMAP_HOSTENDIAN)
                                         clear_bit(file_page_offset(bitmap, j),
                                                   paddr);
@@ -1244,7 +1244,7 @@ void bitmap_daemon_work(struct mddev *mddev)
                                                 file_page_offset(bitmap,
                                                                  j),
                                                 paddr);
-                                kunmap_atomic(paddr, KM_USER0);
+                                kunmap_atomic(paddr);
                         } else if (*bmc <= 2) {
                                 *bmc = 1; /* maybe clear the bit next time */
                                 set_page_attr(bitmap, page, BITMAP_PAGE_PENDING);
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 8c2a000cf3f5..db6b51639cee 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -590,9 +590,9 @@ static int crypt_iv_lmk_gen(struct crypt_config *cc, u8 *iv,
         int r = 0;
 
         if (bio_data_dir(dmreq->ctx->bio_in) == WRITE) {
-                src = kmap_atomic(sg_page(&dmreq->sg_in), KM_USER0);
+                src = kmap_atomic(sg_page(&dmreq->sg_in));
                 r = crypt_iv_lmk_one(cc, iv, dmreq, src + dmreq->sg_in.offset);
-                kunmap_atomic(src, KM_USER0);
+                kunmap_atomic(src);
         } else
                 memset(iv, 0, cc->iv_size);
 
@@ -608,14 +608,14 @@ static int crypt_iv_lmk_post(struct crypt_config *cc, u8 *iv,
         if (bio_data_dir(dmreq->ctx->bio_in) == WRITE)
                 return 0;
 
-        dst = kmap_atomic(sg_page(&dmreq->sg_out), KM_USER0);
+        dst = kmap_atomic(sg_page(&dmreq->sg_out));
         r = crypt_iv_lmk_one(cc, iv, dmreq, dst + dmreq->sg_out.offset);
 
         /* Tweak the first block of plaintext sector */
         if (!r)
                 crypto_xor(dst + dmreq->sg_out.offset, iv, cc->iv_size);
 
-        kunmap_atomic(dst, KM_USER0);
+        kunmap_atomic(dst);
         return r;
 }