1/*
2 *  linux/fs/hpfs/file.c
3 *
4 *  Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
5 *
6 *  file VFS functions
7 */
8
9#include <linux/smp_lock.h>
10#include "hpfs_fn.h"
11
12#define BLOCKS(size) (((size) + 511) >> 9)
13
14static int hpfs_file_release(struct inode *inode, struct file *file)
15{
16	lock_kernel();
17	hpfs_write_if_changed(inode);
18	unlock_kernel();
19	return 0;
20}
21
22int hpfs_file_fsync(struct file *file, int datasync)
23{
24	/*return file_fsync(file, datasync);*/
25	return 0; /* Don't fsync :-) */
26}
27
28/*
29 * generic_file_read often calls bmap with non-existing sector,
30 * so we must ignore such errors.
31 */
32
33static secno hpfs_bmap(struct inode *inode, unsigned file_secno)
34{
35	struct hpfs_inode_info *hpfs_inode = hpfs_i(inode);
36	unsigned n, disk_secno;
37	struct fnode *fnode;
38	struct buffer_head *bh;
39	if (BLOCKS(hpfs_i(inode)->mmu_private) <= file_secno) return 0;
40	n = file_secno - hpfs_inode->i_file_sec;
41	if (n < hpfs_inode->i_n_secs) return hpfs_inode->i_disk_sec + n;
42	if (!(fnode = hpfs_map_fnode(inode->i_sb, inode->i_ino, &bh))) return 0;
43	disk_secno = hpfs_bplus_lookup(inode->i_sb, inode, &fnode->btree, file_secno, bh);
44	if (disk_secno == -1) return 0;
45	if (hpfs_chk_sectors(inode->i_sb, disk_secno, 1, "bmap")) return 0;
46	return disk_secno;
47}
48
49static void hpfs_truncate(struct inode *i)
50{
51	if (IS_IMMUTABLE(i)) return /*-EPERM*/;
52	lock_kernel();
53	hpfs_i(i)->i_n_secs = 0;
54	i->i_blocks = 1 + ((i->i_size + 511) >> 9);
55	hpfs_i(i)->mmu_private = i->i_size;
56	hpfs_truncate_btree(i->i_sb, i->i_ino, 1, ((i->i_size + 511) >> 9));
57	hpfs_write_inode(i);
58	hpfs_i(i)->i_n_secs = 0;
59	unlock_kernel();
60}
61
62static int hpfs_get_block(struct inode *inode, sector_t iblock, struct buffer_head *bh_result, int create)
63{
64	secno s;
65	s = hpfs_bmap(inode, iblock);
66	if (s) {
67		map_bh(bh_result, inode->i_sb, s);
68		return 0;
69	}
70	if (!create) return 0;
71	if (iblock<<9 != hpfs_i(inode)->mmu_private) {
72		BUG();
73		return -EIO;
74	}
75	if ((s = hpfs_add_sector_to_btree(inode->i_sb, inode->i_ino, 1, inode->i_blocks - 1)) == -1) {
76		hpfs_truncate_btree(inode->i_sb, inode->i_ino, 1, inode->i_blocks - 1);
77		return -ENOSPC;
78	}
79	inode->i_blocks++;
80	hpfs_i(inode)->mmu_private += 512;
81	set_buffer_new(bh_result);
82	map_bh(bh_result, inode->i_sb, s);
83	return 0;
84}
85
86static int hpfs_writepage(struct page *page, struct writeback_control *wbc)
87{
88	return block_write_full_page(page,hpfs_get_block, wbc);
89}
90
91static int hpfs_readpage(struct file *file, struct page *page)
92{
93	return block_read_full_page(page,hpfs_get_block);
94}
95
96static int hpfs_write_begin(struct file *file, struct address_space *mapping,
97			loff_t pos, unsigned len, unsigned flags,
98			struct page **pagep, void **fsdata)
99{
100	int ret;
101
102	*pagep = NULL;
103	ret = cont_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
104				hpfs_get_block,
105				&hpfs_i(mapping->host)->mmu_private);
106	if (unlikely(ret)) {
107		loff_t isize = mapping->host->i_size;
108		if (pos + len > isize)
109			vmtruncate(mapping->host, isize);
110	}
111
112	return ret;
113}
114
115static sector_t _hpfs_bmap(struct address_space *mapping, sector_t block)
116{
117	return generic_block_bmap(mapping,block,hpfs_get_block);
118}
119
120const struct address_space_operations hpfs_aops = {
121	.readpage = hpfs_readpage,
122	.writepage = hpfs_writepage,
123	.sync_page = block_sync_page,
124	.write_begin = hpfs_write_begin,
125	.write_end = generic_write_end,
126	.bmap = _hpfs_bmap
127};
128
129static ssize_t hpfs_file_write(struct file *file, const char __user *buf,
130			size_t count, loff_t *ppos)
131{
132	ssize_t retval;
133
134	retval = do_sync_write(file, buf, count, ppos);
135	if (retval > 0)
136		hpfs_i(file->f_path.dentry->d_inode)->i_dirty = 1;
137	return retval;
138}
139
140const struct file_operations hpfs_file_ops =
141{
142	.llseek		= generic_file_llseek,
143	.read		= do_sync_read,
144	.aio_read	= generic_file_aio_read,
145	.write		= hpfs_file_write,
146	.aio_write	= generic_file_aio_write,
147	.mmap		= generic_file_mmap,
148	.release	= hpfs_file_release,
149	.fsync		= hpfs_file_fsync,
150	.splice_read	= generic_file_splice_read,
151};
152
153const struct inode_operations hpfs_file_iops =
154{
155	.truncate	= hpfs_truncate,
156	.setattr	= hpfs_setattr,
157};
158