aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--fs/hpfs/buffer.c33
-rw-r--r--fs/hpfs/file.c40
-rw-r--r--fs/hpfs/hpfs_fn.h7
-rw-r--r--fs/hpfs/map.c22
-rw-r--r--fs/hpfs/super.c17
5 files changed, 106 insertions, 13 deletions
diff --git a/fs/hpfs/buffer.c b/fs/hpfs/buffer.c
index f49d1498aa2e..4d0a1afa058c 100644
--- a/fs/hpfs/buffer.c
+++ b/fs/hpfs/buffer.c
@@ -7,8 +7,37 @@
7 */ 7 */
8#include <linux/sched.h> 8#include <linux/sched.h>
9#include <linux/slab.h> 9#include <linux/slab.h>
10#include <linux/blkdev.h>
10#include "hpfs_fn.h" 11#include "hpfs_fn.h"
11 12
13void hpfs_prefetch_sectors(struct super_block *s, unsigned secno, int n)
14{
15 struct buffer_head *bh;
16 struct blk_plug plug;
17
18 if (n <= 0 || unlikely(secno >= hpfs_sb(s)->sb_fs_size))
19 return;
20
21 bh = sb_find_get_block(s, secno);
22 if (bh) {
23 if (buffer_uptodate(bh)) {
24 brelse(bh);
25 return;
26 }
27 brelse(bh);
28 };
29
30 blk_start_plug(&plug);
31 while (n > 0) {
32 if (unlikely(secno >= hpfs_sb(s)->sb_fs_size))
33 break;
34 sb_breadahead(s, secno);
35 secno++;
36 n--;
37 }
38 blk_finish_plug(&plug);
39}
40
12/* Map a sector into a buffer and return pointers to it and to the buffer. */ 41/* Map a sector into a buffer and return pointers to it and to the buffer. */
13 42
14void *hpfs_map_sector(struct super_block *s, unsigned secno, struct buffer_head **bhp, 43void *hpfs_map_sector(struct super_block *s, unsigned secno, struct buffer_head **bhp,
@@ -18,6 +47,8 @@ void *hpfs_map_sector(struct super_block *s, unsigned secno, struct buffer_head
18 47
19 hpfs_lock_assert(s); 48 hpfs_lock_assert(s);
20 49
50 hpfs_prefetch_sectors(s, secno, ahead);
51
21 cond_resched(); 52 cond_resched();
22 53
23 *bhp = bh = sb_bread(s, secno); 54 *bhp = bh = sb_bread(s, secno);
@@ -67,6 +98,8 @@ void *hpfs_map_4sectors(struct super_block *s, unsigned secno, struct quad_buffe
67 return NULL; 98 return NULL;
68 } 99 }
69 100
101 hpfs_prefetch_sectors(s, secno, 4 + ahead);
102
70 qbh->data = data = kmalloc(2048, GFP_NOFS); 103 qbh->data = data = kmalloc(2048, GFP_NOFS);
71 if (!data) { 104 if (!data) {
72 printk("HPFS: hpfs_map_4sectors: out of memory\n"); 105 printk("HPFS: hpfs_map_4sectors: out of memory\n");
diff --git a/fs/hpfs/file.c b/fs/hpfs/file.c
index e4ba5fe4c3b5..4e9dabcf1f4c 100644
--- a/fs/hpfs/file.c
+++ b/fs/hpfs/file.c
@@ -7,6 +7,7 @@
7 */ 7 */
8 8
9#include "hpfs_fn.h" 9#include "hpfs_fn.h"
10#include <linux/mpage.h>
10 11
11#define BLOCKS(size) (((size) + 511) >> 9) 12#define BLOCKS(size) (((size) + 511) >> 9)
12 13
@@ -34,7 +35,7 @@ int hpfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
34 * so we must ignore such errors. 35 * so we must ignore such errors.
35 */ 36 */
36 37
37static secno hpfs_bmap(struct inode *inode, unsigned file_secno) 38static secno hpfs_bmap(struct inode *inode, unsigned file_secno, unsigned *n_secs)
38{ 39{
39 struct hpfs_inode_info *hpfs_inode = hpfs_i(inode); 40 struct hpfs_inode_info *hpfs_inode = hpfs_i(inode);
40 unsigned n, disk_secno; 41 unsigned n, disk_secno;
@@ -42,11 +43,20 @@ static secno hpfs_bmap(struct inode *inode, unsigned file_secno)
42 struct buffer_head *bh; 43 struct buffer_head *bh;
43 if (BLOCKS(hpfs_i(inode)->mmu_private) <= file_secno) return 0; 44 if (BLOCKS(hpfs_i(inode)->mmu_private) <= file_secno) return 0;
44 n = file_secno - hpfs_inode->i_file_sec; 45 n = file_secno - hpfs_inode->i_file_sec;
45 if (n < hpfs_inode->i_n_secs) return hpfs_inode->i_disk_sec + n; 46 if (n < hpfs_inode->i_n_secs) {
47 *n_secs = hpfs_inode->i_n_secs - n;
48 return hpfs_inode->i_disk_sec + n;
49 }
46 if (!(fnode = hpfs_map_fnode(inode->i_sb, inode->i_ino, &bh))) return 0; 50 if (!(fnode = hpfs_map_fnode(inode->i_sb, inode->i_ino, &bh))) return 0;
47 disk_secno = hpfs_bplus_lookup(inode->i_sb, inode, &fnode->btree, file_secno, bh); 51 disk_secno = hpfs_bplus_lookup(inode->i_sb, inode, &fnode->btree, file_secno, bh);
48 if (disk_secno == -1) return 0; 52 if (disk_secno == -1) return 0;
49 if (hpfs_chk_sectors(inode->i_sb, disk_secno, 1, "bmap")) return 0; 53 if (hpfs_chk_sectors(inode->i_sb, disk_secno, 1, "bmap")) return 0;
54 n = file_secno - hpfs_inode->i_file_sec;
55 if (n < hpfs_inode->i_n_secs) {
56 *n_secs = hpfs_inode->i_n_secs - n;
57 return hpfs_inode->i_disk_sec + n;
58 }
59 *n_secs = 1;
50 return disk_secno; 60 return disk_secno;
51} 61}
52 62
@@ -67,10 +77,14 @@ static int hpfs_get_block(struct inode *inode, sector_t iblock, struct buffer_he
67{ 77{
68 int r; 78 int r;
69 secno s; 79 secno s;
80 unsigned n_secs;
70 hpfs_lock(inode->i_sb); 81 hpfs_lock(inode->i_sb);
71 s = hpfs_bmap(inode, iblock); 82 s = hpfs_bmap(inode, iblock, &n_secs);
72 if (s) { 83 if (s) {
84 if (bh_result->b_size >> 9 < n_secs)
85 n_secs = bh_result->b_size >> 9;
73 map_bh(bh_result, inode->i_sb, s); 86 map_bh(bh_result, inode->i_sb, s);
87 bh_result->b_size = n_secs << 9;
74 goto ret_0; 88 goto ret_0;
75 } 89 }
76 if (!create) goto ret_0; 90 if (!create) goto ret_0;
@@ -95,14 +109,26 @@ static int hpfs_get_block(struct inode *inode, sector_t iblock, struct buffer_he
95 return r; 109 return r;
96} 110}
97 111
112static int hpfs_readpage(struct file *file, struct page *page)
113{
114 return mpage_readpage(page, hpfs_get_block);
115}
116
98static int hpfs_writepage(struct page *page, struct writeback_control *wbc) 117static int hpfs_writepage(struct page *page, struct writeback_control *wbc)
99{ 118{
100 return block_write_full_page(page,hpfs_get_block, wbc); 119 return block_write_full_page(page, hpfs_get_block, wbc);
101} 120}
102 121
103static int hpfs_readpage(struct file *file, struct page *page) 122static int hpfs_readpages(struct file *file, struct address_space *mapping,
123 struct list_head *pages, unsigned nr_pages)
124{
125 return mpage_readpages(mapping, pages, nr_pages, hpfs_get_block);
126}
127
128static int hpfs_writepages(struct address_space *mapping,
129 struct writeback_control *wbc)
104{ 130{
105 return block_read_full_page(page,hpfs_get_block); 131 return mpage_writepages(mapping, wbc, hpfs_get_block);
106} 132}
107 133
108static void hpfs_write_failed(struct address_space *mapping, loff_t to) 134static void hpfs_write_failed(struct address_space *mapping, loff_t to)
@@ -161,6 +187,8 @@ static sector_t _hpfs_bmap(struct address_space *mapping, sector_t block)
161const struct address_space_operations hpfs_aops = { 187const struct address_space_operations hpfs_aops = {
162 .readpage = hpfs_readpage, 188 .readpage = hpfs_readpage,
163 .writepage = hpfs_writepage, 189 .writepage = hpfs_writepage,
190 .readpages = hpfs_readpages,
191 .writepages = hpfs_writepages,
164 .write_begin = hpfs_write_begin, 192 .write_begin = hpfs_write_begin,
165 .write_end = hpfs_write_end, 193 .write_end = hpfs_write_end,
166 .bmap = _hpfs_bmap 194 .bmap = _hpfs_bmap
diff --git a/fs/hpfs/hpfs_fn.h b/fs/hpfs/hpfs_fn.h
index b7ae286646b5..1b398636e990 100644
--- a/fs/hpfs/hpfs_fn.h
+++ b/fs/hpfs/hpfs_fn.h
@@ -27,8 +27,9 @@
27#define ALLOC_FWD_MAX 128 27#define ALLOC_FWD_MAX 128
28#define ALLOC_M 1 28#define ALLOC_M 1
29#define FNODE_RD_AHEAD 16 29#define FNODE_RD_AHEAD 16
30#define ANODE_RD_AHEAD 16 30#define ANODE_RD_AHEAD 0
31#define DNODE_RD_AHEAD 4 31#define DNODE_RD_AHEAD 72
32#define COUNT_RD_AHEAD 62
32 33
33#define FREE_DNODES_ADD 58 34#define FREE_DNODES_ADD 58
34#define FREE_DNODES_DEL 29 35#define FREE_DNODES_DEL 29
@@ -207,6 +208,7 @@ void hpfs_remove_fnode(struct super_block *, fnode_secno fno);
207 208
208/* buffer.c */ 209/* buffer.c */
209 210
211void hpfs_prefetch_sectors(struct super_block *, unsigned, int);
210void *hpfs_map_sector(struct super_block *, unsigned, struct buffer_head **, int); 212void *hpfs_map_sector(struct super_block *, unsigned, struct buffer_head **, int);
211void *hpfs_get_sector(struct super_block *, unsigned, struct buffer_head **); 213void *hpfs_get_sector(struct super_block *, unsigned, struct buffer_head **);
212void *hpfs_map_4sectors(struct super_block *, unsigned, struct quad_buffer_head *, int); 214void *hpfs_map_4sectors(struct super_block *, unsigned, struct quad_buffer_head *, int);
@@ -271,6 +273,7 @@ void hpfs_evict_inode(struct inode *);
271 273
272__le32 *hpfs_map_dnode_bitmap(struct super_block *, struct quad_buffer_head *); 274__le32 *hpfs_map_dnode_bitmap(struct super_block *, struct quad_buffer_head *);
273__le32 *hpfs_map_bitmap(struct super_block *, unsigned, struct quad_buffer_head *, char *); 275__le32 *hpfs_map_bitmap(struct super_block *, unsigned, struct quad_buffer_head *, char *);
276void hpfs_prefetch_bitmap(struct super_block *, unsigned);
274unsigned char *hpfs_load_code_page(struct super_block *, secno); 277unsigned char *hpfs_load_code_page(struct super_block *, secno);
275__le32 *hpfs_load_bitmap_directory(struct super_block *, secno bmp); 278__le32 *hpfs_load_bitmap_directory(struct super_block *, secno bmp);
276struct fnode *hpfs_map_fnode(struct super_block *s, ino_t, struct buffer_head **); 279struct fnode *hpfs_map_fnode(struct super_block *s, ino_t, struct buffer_head **);
diff --git a/fs/hpfs/map.c b/fs/hpfs/map.c
index 4acb19d78359..3aa66ae1031e 100644
--- a/fs/hpfs/map.c
+++ b/fs/hpfs/map.c
@@ -17,7 +17,9 @@ __le32 *hpfs_map_bitmap(struct super_block *s, unsigned bmp_block,
17 struct quad_buffer_head *qbh, char *id) 17 struct quad_buffer_head *qbh, char *id)
18{ 18{
19 secno sec; 19 secno sec;
20 if (hpfs_sb(s)->sb_chk) if (bmp_block * 16384 > hpfs_sb(s)->sb_fs_size) { 20 __le32 *ret;
21 unsigned n_bands = (hpfs_sb(s)->sb_fs_size + 0x3fff) >> 14;
22 if (hpfs_sb(s)->sb_chk) if (bmp_block >= n_bands) {
21 hpfs_error(s, "hpfs_map_bitmap called with bad parameter: %08x at %s", bmp_block, id); 23 hpfs_error(s, "hpfs_map_bitmap called with bad parameter: %08x at %s", bmp_block, id);
22 return NULL; 24 return NULL;
23 } 25 }
@@ -26,7 +28,23 @@ __le32 *hpfs_map_bitmap(struct super_block *s, unsigned bmp_block,
26 hpfs_error(s, "invalid bitmap block pointer %08x -> %08x at %s", bmp_block, sec, id); 28 hpfs_error(s, "invalid bitmap block pointer %08x -> %08x at %s", bmp_block, sec, id);
27 return NULL; 29 return NULL;
28 } 30 }
29 return hpfs_map_4sectors(s, sec, qbh, 4); 31 ret = hpfs_map_4sectors(s, sec, qbh, 4);
32 if (ret) hpfs_prefetch_bitmap(s, bmp_block + 1);
33 return ret;
34}
35
36void hpfs_prefetch_bitmap(struct super_block *s, unsigned bmp_block)
37{
38 unsigned to_prefetch, next_prefetch;
39 unsigned n_bands = (hpfs_sb(s)->sb_fs_size + 0x3fff) >> 14;
40 if (unlikely(bmp_block >= n_bands))
41 return;
42 to_prefetch = le32_to_cpu(hpfs_sb(s)->sb_bmp_dir[bmp_block]);
43 if (unlikely(bmp_block + 1 >= n_bands))
44 next_prefetch = 0;
45 else
46 next_prefetch = le32_to_cpu(hpfs_sb(s)->sb_bmp_dir[bmp_block + 1]);
47 hpfs_prefetch_sectors(s, to_prefetch, 4 + 4 * (to_prefetch + 4 == next_prefetch));
30} 48}
31 49
32/* 50/*
diff --git a/fs/hpfs/super.c b/fs/hpfs/super.c
index a0617e706957..4334cda8dba1 100644
--- a/fs/hpfs/super.c
+++ b/fs/hpfs/super.c
@@ -121,7 +121,7 @@ unsigned hpfs_count_one_bitmap(struct super_block *s, secno secno)
121 unsigned long *bits; 121 unsigned long *bits;
122 unsigned count; 122 unsigned count;
123 123
124 bits = hpfs_map_4sectors(s, secno, &qbh, 4); 124 bits = hpfs_map_4sectors(s, secno, &qbh, 0);
125 if (!bits) 125 if (!bits)
126 return 0; 126 return 0;
127 count = bitmap_weight(bits, 2048 * BITS_PER_BYTE); 127 count = bitmap_weight(bits, 2048 * BITS_PER_BYTE);
@@ -134,8 +134,13 @@ static unsigned count_bitmaps(struct super_block *s)
134 unsigned n, count, n_bands; 134 unsigned n, count, n_bands;
135 n_bands = (hpfs_sb(s)->sb_fs_size + 0x3fff) >> 14; 135 n_bands = (hpfs_sb(s)->sb_fs_size + 0x3fff) >> 14;
136 count = 0; 136 count = 0;
137 for (n = 0; n < n_bands; n++) 137 for (n = 0; n < COUNT_RD_AHEAD; n++) {
138 hpfs_prefetch_bitmap(s, n);
139 }
140 for (n = 0; n < n_bands; n++) {
141 hpfs_prefetch_bitmap(s, n + COUNT_RD_AHEAD);
138 count += hpfs_count_one_bitmap(s, le32_to_cpu(hpfs_sb(s)->sb_bmp_dir[n])); 142 count += hpfs_count_one_bitmap(s, le32_to_cpu(hpfs_sb(s)->sb_bmp_dir[n]));
143 }
139 return count; 144 return count;
140} 145}
141 146
@@ -558,7 +563,13 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
558 sbi->sb_cp_table = NULL; 563 sbi->sb_cp_table = NULL;
559 sbi->sb_c_bitmap = -1; 564 sbi->sb_c_bitmap = -1;
560 sbi->sb_max_fwd_alloc = 0xffffff; 565 sbi->sb_max_fwd_alloc = 0xffffff;
561 566
567 if (sbi->sb_fs_size >= 0x80000000) {
568 hpfs_error(s, "invalid size in superblock: %08x",
569 (unsigned)sbi->sb_fs_size);
570 goto bail4;
571 }
572
562 /* Load bitmap directory */ 573 /* Load bitmap directory */
563 if (!(sbi->sb_bmp_dir = hpfs_load_bitmap_directory(s, le32_to_cpu(superblock->bitmaps)))) 574 if (!(sbi->sb_bmp_dir = hpfs_load_bitmap_directory(s, le32_to_cpu(superblock->bitmaps))))
564 goto bail4; 575 goto bail4;