4 * Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
11 #define BLOCKS(size) (((size) + 511) >> 9)
13 static int hpfs_file_release(struct inode
*inode
, struct file
*file
)
15 hpfs_lock(inode
->i_sb
);
16 hpfs_write_if_changed(inode
);
17 hpfs_unlock(inode
->i_sb
);
21 int hpfs_file_fsync(struct file
*file
, int datasync
)
23 /*return file_fsync(file, datasync);*/
24 return 0; /* Don't fsync :-) */
28 * generic_file_read often calls bmap with non-existing sector,
29 * so we must ignore such errors.
32 static secno
hpfs_bmap(struct inode
*inode
, unsigned file_secno
)
34 struct hpfs_inode_info
*hpfs_inode
= hpfs_i(inode
);
35 unsigned n
, disk_secno
;
37 struct buffer_head
*bh
;
38 if (BLOCKS(hpfs_i(inode
)->mmu_private
) <= file_secno
) return 0;
39 n
= file_secno
- hpfs_inode
->i_file_sec
;
40 if (n
< hpfs_inode
->i_n_secs
) return hpfs_inode
->i_disk_sec
+ n
;
41 if (!(fnode
= hpfs_map_fnode(inode
->i_sb
, inode
->i_ino
, &bh
))) return 0;
42 disk_secno
= hpfs_bplus_lookup(inode
->i_sb
, inode
, &fnode
->btree
, file_secno
, bh
);
43 if (disk_secno
== -1) return 0;
44 if (hpfs_chk_sectors(inode
->i_sb
, disk_secno
, 1, "bmap")) return 0;
48 static void hpfs_truncate(struct inode
*i
)
50 if (IS_IMMUTABLE(i
)) return /*-EPERM*/;
52 hpfs_i(i
)->i_n_secs
= 0;
53 i
->i_blocks
= 1 + ((i
->i_size
+ 511) >> 9);
54 hpfs_i(i
)->mmu_private
= i
->i_size
;
55 hpfs_truncate_btree(i
->i_sb
, i
->i_ino
, 1, ((i
->i_size
+ 511) >> 9));
57 hpfs_i(i
)->i_n_secs
= 0;
61 static int hpfs_get_block(struct inode
*inode
, sector_t iblock
, struct buffer_head
*bh_result
, int create
)
64 s
= hpfs_bmap(inode
, iblock
);
66 map_bh(bh_result
, inode
->i_sb
, s
);
69 if (!create
) return 0;
70 if (iblock
<<9 != hpfs_i(inode
)->mmu_private
) {
74 if ((s
= hpfs_add_sector_to_btree(inode
->i_sb
, inode
->i_ino
, 1, inode
->i_blocks
- 1)) == -1) {
75 hpfs_truncate_btree(inode
->i_sb
, inode
->i_ino
, 1, inode
->i_blocks
- 1);
79 hpfs_i(inode
)->mmu_private
+= 512;
80 set_buffer_new(bh_result
);
81 map_bh(bh_result
, inode
->i_sb
, s
);
85 static int hpfs_writepage(struct page
*page
, struct writeback_control
*wbc
)
87 return block_write_full_page(page
,hpfs_get_block
, wbc
);
90 static int hpfs_readpage(struct file
*file
, struct page
*page
)
92 return block_read_full_page(page
,hpfs_get_block
);
95 static int hpfs_write_begin(struct file
*file
, struct address_space
*mapping
,
96 loff_t pos
, unsigned len
, unsigned flags
,
97 struct page
**pagep
, void **fsdata
)
102 ret
= cont_write_begin(file
, mapping
, pos
, len
, flags
, pagep
, fsdata
,
104 &hpfs_i(mapping
->host
)->mmu_private
);
106 loff_t isize
= mapping
->host
->i_size
;
107 if (pos
+ len
> isize
)
108 vmtruncate(mapping
->host
, isize
);
114 static sector_t
_hpfs_bmap(struct address_space
*mapping
, sector_t block
)
116 return generic_block_bmap(mapping
,block
,hpfs_get_block
);
119 const struct address_space_operations hpfs_aops
= {
120 .readpage
= hpfs_readpage
,
121 .writepage
= hpfs_writepage
,
122 .write_begin
= hpfs_write_begin
,
123 .write_end
= generic_write_end
,
127 static ssize_t
hpfs_file_write(struct file
*file
, const char __user
*buf
,
128 size_t count
, loff_t
*ppos
)
132 retval
= do_sync_write(file
, buf
, count
, ppos
);
134 hpfs_i(file
->f_path
.dentry
->d_inode
)->i_dirty
= 1;
138 const struct file_operations hpfs_file_ops
=
140 .llseek
= generic_file_llseek
,
141 .read
= do_sync_read
,
142 .aio_read
= generic_file_aio_read
,
143 .write
= hpfs_file_write
,
144 .aio_write
= generic_file_aio_write
,
145 .mmap
= generic_file_mmap
,
146 .release
= hpfs_file_release
,
147 .fsync
= hpfs_file_fsync
,
148 .splice_read
= generic_file_splice_read
,
151 const struct inode_operations hpfs_file_iops
=
153 .truncate
= hpfs_truncate
,
154 .setattr
= hpfs_setattr
,