Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
ntfs: use zero_user_page
Use zero_user_page() instead of open-coding it.
[akpm@linux-foundation.org: kmap-type fixes]
Signed-off-by: Nate Diller <nate.diller@gmail.com>
Acked-by: Anton Altaparmakov <aia21@cantab.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
authored by
Nate Diller
and committed by
Linus Torvalds
e3bf460f
6d690dca
+26
-69
+9
-27
fs/ntfs/aops.c
+9
-27
fs/ntfs/aops.c
···
86
86
}
87
87
/* Check for the current buffer head overflowing. */
88
88
if (unlikely(file_ofs + bh->b_size > init_size)) {
89
-
u8 *kaddr;
90
89
int ofs;
91
90
92
91
ofs = 0;
93
92
if (file_ofs < init_size)
94
93
ofs = init_size - file_ofs;
95
94
local_irq_save(flags);
96
-
kaddr = kmap_atomic(page, KM_BIO_SRC_IRQ);
97
-
memset(kaddr + bh_offset(bh) + ofs, 0,
98
-
bh->b_size - ofs);
99
-
kunmap_atomic(kaddr, KM_BIO_SRC_IRQ);
95
+
zero_user_page(page, bh_offset(bh) + ofs,
96
+
bh->b_size - ofs, KM_BIO_SRC_IRQ);
100
97
local_irq_restore(flags);
101
-
flush_dcache_page(page);
102
98
}
103
99
} else {
104
100
clear_buffer_uptodate(bh);
···
241
245
rl = NULL;
242
246
nr = i = 0;
243
247
do {
244
-
u8 *kaddr;
245
-
int err;
248
+
int err = 0;
246
249
247
250
if (unlikely(buffer_uptodate(bh)))
248
251
continue;
···
249
254
arr[nr++] = bh;
250
255
continue;
251
256
}
252
-
err = 0;
253
257
bh->b_bdev = vol->sb->s_bdev;
254
258
/* Is the block within the allowed limits? */
255
259
if (iblock < lblock) {
···
334
340
bh->b_blocknr = -1UL;
335
341
clear_buffer_mapped(bh);
336
342
handle_zblock:
337
-
kaddr = kmap_atomic(page, KM_USER0);
338
-
memset(kaddr + i * blocksize, 0, blocksize);
339
-
kunmap_atomic(kaddr, KM_USER0);
340
-
flush_dcache_page(page);
343
+
zero_user_page(page, i * blocksize, blocksize, KM_USER0);
341
344
if (likely(!err))
342
345
set_buffer_uptodate(bh);
343
346
} while (i++, iblock++, (bh = bh->b_this_page) != head);
···
451
460
* ok to ignore the compressed flag here.
452
461
*/
453
462
if (unlikely(page->index > 0)) {
454
-
kaddr = kmap_atomic(page, KM_USER0);
455
-
memset(kaddr, 0, PAGE_CACHE_SIZE);
456
-
flush_dcache_page(page);
457
-
kunmap_atomic(kaddr, KM_USER0);
463
+
zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
458
464
goto done;
459
465
}
460
466
if (!NInoAttr(ni))
···
778
790
* uptodate so it can get discarded by the VM.
779
791
*/
780
792
if (err == -ENOENT || lcn == LCN_ENOENT) {
781
-
u8 *kaddr;
782
-
783
793
bh->b_blocknr = -1;
784
794
clear_buffer_dirty(bh);
785
-
kaddr = kmap_atomic(page, KM_USER0);
786
-
memset(kaddr + bh_offset(bh), 0, blocksize);
787
-
kunmap_atomic(kaddr, KM_USER0);
788
-
flush_dcache_page(page);
795
+
zero_user_page(page, bh_offset(bh), blocksize,
796
+
KM_USER0);
789
797
set_buffer_uptodate(bh);
790
798
err = 0;
791
799
continue;
···
1406
1422
if (page->index >= (i_size >> PAGE_CACHE_SHIFT)) {
1407
1423
/* The page straddles i_size. */
1408
1424
unsigned int ofs = i_size & ~PAGE_CACHE_MASK;
1409
-
kaddr = kmap_atomic(page, KM_USER0);
1410
-
memset(kaddr + ofs, 0, PAGE_CACHE_SIZE - ofs);
1411
-
kunmap_atomic(kaddr, KM_USER0);
1412
-
flush_dcache_page(page);
1425
+
zero_user_page(page, ofs, PAGE_CACHE_SIZE - ofs,
1426
+
KM_USER0);
1413
1427
}
1414
1428
/* Handle mst protected attributes. */
1415
1429
if (NInoMstProtected(ni))
+17
-42
fs/ntfs/file.c
+17
-42
fs/ntfs/file.c
···
606
606
ntfs_submit_bh_for_read(bh);
607
607
*wait_bh++ = bh;
608
608
} else {
609
-
u8 *kaddr = kmap_atomic(page, KM_USER0);
610
-
memset(kaddr + bh_offset(bh), 0,
611
-
blocksize);
612
-
kunmap_atomic(kaddr, KM_USER0);
613
-
flush_dcache_page(page);
609
+
zero_user_page(page, bh_offset(bh),
610
+
blocksize, KM_USER0);
614
611
set_buffer_uptodate(bh);
615
612
}
616
613
}
···
682
685
ntfs_submit_bh_for_read(bh);
683
686
*wait_bh++ = bh;
684
687
} else {
685
-
u8 *kaddr = kmap_atomic(page,
686
-
KM_USER0);
687
-
memset(kaddr + bh_offset(bh),
688
-
0, blocksize);
689
-
kunmap_atomic(kaddr, KM_USER0);
690
-
flush_dcache_page(page);
688
+
zero_user_page(page,
689
+
bh_offset(bh),
690
+
blocksize, KM_USER0);
691
691
set_buffer_uptodate(bh);
692
692
}
693
693
}
···
702
708
*/
703
709
if (bh_end <= pos || bh_pos >= end) {
704
710
if (!buffer_uptodate(bh)) {
705
-
u8 *kaddr = kmap_atomic(page, KM_USER0);
706
-
memset(kaddr + bh_offset(bh), 0,
707
-
blocksize);
708
-
kunmap_atomic(kaddr, KM_USER0);
709
-
flush_dcache_page(page);
711
+
zero_user_page(page, bh_offset(bh),
712
+
blocksize, KM_USER0);
710
713
set_buffer_uptodate(bh);
711
714
}
712
715
mark_buffer_dirty(bh);
···
742
751
if (!buffer_uptodate(bh))
743
752
set_buffer_uptodate(bh);
744
753
} else if (!buffer_uptodate(bh)) {
745
-
u8 *kaddr = kmap_atomic(page, KM_USER0);
746
-
memset(kaddr + bh_offset(bh), 0, blocksize);
747
-
kunmap_atomic(kaddr, KM_USER0);
748
-
flush_dcache_page(page);
754
+
zero_user_page(page, bh_offset(bh), blocksize,
755
+
KM_USER0);
749
756
set_buffer_uptodate(bh);
750
757
}
751
758
continue;
···
867
878
if (!buffer_uptodate(bh))
868
879
set_buffer_uptodate(bh);
869
880
} else if (!buffer_uptodate(bh)) {
870
-
u8 *kaddr = kmap_atomic(page, KM_USER0);
871
-
memset(kaddr + bh_offset(bh), 0,
872
-
blocksize);
873
-
kunmap_atomic(kaddr, KM_USER0);
874
-
flush_dcache_page(page);
881
+
zero_user_page(page, bh_offset(bh),
882
+
blocksize, KM_USER0);
875
883
set_buffer_uptodate(bh);
876
884
}
877
885
continue;
···
1123
1137
* to zero the overflowing region.
1124
1138
*/
1125
1139
if (unlikely(bh_pos + blocksize > initialized_size)) {
1126
-
u8 *kaddr;
1127
1140
int ofs = 0;
1128
1141
1129
1142
if (likely(bh_pos < initialized_size))
1130
1143
ofs = initialized_size - bh_pos;
1131
-
kaddr = kmap_atomic(page, KM_USER0);
1132
-
memset(kaddr + bh_offset(bh) + ofs, 0,
1133
-
blocksize - ofs);
1134
-
kunmap_atomic(kaddr, KM_USER0);
1135
-
flush_dcache_page(page);
1144
+
zero_user_page(page, bh_offset(bh) + ofs,
1145
+
blocksize - ofs, KM_USER0);
1136
1146
}
1137
1147
} else /* if (unlikely(!buffer_uptodate(bh))) */
1138
1148
err = -EIO;
···
1268
1286
if (PageUptodate(page))
1269
1287
set_buffer_uptodate(bh);
1270
1288
else {
1271
-
u8 *kaddr = kmap_atomic(page, KM_USER0);
1272
-
memset(kaddr + bh_offset(bh), 0,
1273
-
blocksize);
1274
-
kunmap_atomic(kaddr, KM_USER0);
1275
-
flush_dcache_page(page);
1289
+
zero_user_page(page, bh_offset(bh),
1290
+
blocksize, KM_USER0);
1276
1291
set_buffer_uptodate(bh);
1277
1292
}
1278
1293
}
···
1329
1350
len = PAGE_CACHE_SIZE;
1330
1351
if (len > bytes)
1331
1352
len = bytes;
1332
-
kaddr = kmap_atomic(*pages, KM_USER0);
1333
-
memset(kaddr, 0, len);
1334
-
kunmap_atomic(kaddr, KM_USER0);
1353
+
zero_user_page(*pages, 0, len, KM_USER0);
1335
1354
}
1336
1355
goto out;
1337
1356
}
···
1450
1473
len = PAGE_CACHE_SIZE;
1451
1474
if (len > bytes)
1452
1475
len = bytes;
1453
-
kaddr = kmap_atomic(*pages, KM_USER0);
1454
-
memset(kaddr, 0, len);
1455
-
kunmap_atomic(kaddr, KM_USER0);
1476
+
zero_user_page(*pages, 0, len, KM_USER0);
1456
1477
}
1457
1478
goto out;
1458
1479
}