xref: /openbmc/linux/fs/affs/file.c (revision 48c926cd)
1  /*
2   *  linux/fs/affs/file.c
3   *
4   *  (c) 1996  Hans-Joachim Widmaier - Rewritten
5   *
6   *  (C) 1993  Ray Burr - Modified for Amiga FFS filesystem.
7   *
8   *  (C) 1992  Eric Youngdale Modified for ISO 9660 filesystem.
9   *
10   *  (C) 1991  Linus Torvalds - minix filesystem
11   *
12   *  affs regular file handling primitives
13   */
14  
15  #include <linux/uio.h>
16  #include "affs.h"
17  
18  static struct buffer_head *affs_get_extblock_slow(struct inode *inode, u32 ext);
19  
20  static int
21  affs_file_open(struct inode *inode, struct file *filp)
22  {
23  	pr_debug("open(%lu,%d)\n",
24  		 inode->i_ino, atomic_read(&AFFS_I(inode)->i_opencnt));
25  	atomic_inc(&AFFS_I(inode)->i_opencnt);
26  	return 0;
27  }
28  
29  static int
30  affs_file_release(struct inode *inode, struct file *filp)
31  {
32  	pr_debug("release(%lu, %d)\n",
33  		 inode->i_ino, atomic_read(&AFFS_I(inode)->i_opencnt));
34  
35  	if (atomic_dec_and_test(&AFFS_I(inode)->i_opencnt)) {
36  		inode_lock(inode);
37  		if (inode->i_size != AFFS_I(inode)->mmu_private)
38  			affs_truncate(inode);
39  		affs_free_prealloc(inode);
40  		inode_unlock(inode);
41  	}
42  
43  	return 0;
44  }
45  
46  static int
47  affs_grow_extcache(struct inode *inode, u32 lc_idx)
48  {
49  	struct super_block	*sb = inode->i_sb;
50  	struct buffer_head	*bh;
51  	u32 lc_max;
52  	int i, j, key;
53  
54  	if (!AFFS_I(inode)->i_lc) {
55  		char *ptr = (char *)get_zeroed_page(GFP_NOFS);
56  		if (!ptr)
57  			return -ENOMEM;
58  		AFFS_I(inode)->i_lc = (u32 *)ptr;
59  		AFFS_I(inode)->i_ac = (struct affs_ext_key *)(ptr + AFFS_CACHE_SIZE / 2);
60  	}
61  
62  	lc_max = AFFS_LC_SIZE << AFFS_I(inode)->i_lc_shift;
63  
64  	if (AFFS_I(inode)->i_extcnt > lc_max) {
65  		u32 lc_shift, lc_mask, tmp, off;
66  
67  		/* need to recalculate linear cache, start from old size */
68  		lc_shift = AFFS_I(inode)->i_lc_shift;
69  		tmp = (AFFS_I(inode)->i_extcnt / AFFS_LC_SIZE) >> lc_shift;
70  		for (; tmp; tmp >>= 1)
71  			lc_shift++;
72  		lc_mask = (1 << lc_shift) - 1;
73  
74  		/* fix idx and old size to new shift */
75  		lc_idx >>= (lc_shift - AFFS_I(inode)->i_lc_shift);
76  		AFFS_I(inode)->i_lc_size >>= (lc_shift - AFFS_I(inode)->i_lc_shift);
77  
78  		/* first shrink old cache to make more space */
79  		off = 1 << (lc_shift - AFFS_I(inode)->i_lc_shift);
80  		for (i = 1, j = off; j < AFFS_LC_SIZE; i++, j += off)
81  			AFFS_I(inode)->i_ac[i] = AFFS_I(inode)->i_ac[j];
82  
83  		AFFS_I(inode)->i_lc_shift = lc_shift;
84  		AFFS_I(inode)->i_lc_mask = lc_mask;
85  	}
86  
87  	/* fill cache to the needed index */
88  	i = AFFS_I(inode)->i_lc_size;
89  	AFFS_I(inode)->i_lc_size = lc_idx + 1;
90  	for (; i <= lc_idx; i++) {
91  		if (!i) {
92  			AFFS_I(inode)->i_lc[0] = inode->i_ino;
93  			continue;
94  		}
95  		key = AFFS_I(inode)->i_lc[i - 1];
96  		j = AFFS_I(inode)->i_lc_mask + 1;
97  		// unlock cache
98  		for (; j > 0; j--) {
99  			bh = affs_bread(sb, key);
100  			if (!bh)
101  				goto err;
102  			key = be32_to_cpu(AFFS_TAIL(sb, bh)->extension);
103  			affs_brelse(bh);
104  		}
105  		// lock cache
106  		AFFS_I(inode)->i_lc[i] = key;
107  	}
108  
109  	return 0;
110  
111  err:
112  	// lock cache
113  	return -EIO;
114  }
115  
116  static struct buffer_head *
117  affs_alloc_extblock(struct inode *inode, struct buffer_head *bh, u32 ext)
118  {
119  	struct super_block *sb = inode->i_sb;
120  	struct buffer_head *new_bh;
121  	u32 blocknr, tmp;
122  
123  	blocknr = affs_alloc_block(inode, bh->b_blocknr);
124  	if (!blocknr)
125  		return ERR_PTR(-ENOSPC);
126  
127  	new_bh = affs_getzeroblk(sb, blocknr);
128  	if (!new_bh) {
129  		affs_free_block(sb, blocknr);
130  		return ERR_PTR(-EIO);
131  	}
132  
133  	AFFS_HEAD(new_bh)->ptype = cpu_to_be32(T_LIST);
134  	AFFS_HEAD(new_bh)->key = cpu_to_be32(blocknr);
135  	AFFS_TAIL(sb, new_bh)->stype = cpu_to_be32(ST_FILE);
136  	AFFS_TAIL(sb, new_bh)->parent = cpu_to_be32(inode->i_ino);
137  	affs_fix_checksum(sb, new_bh);
138  
139  	mark_buffer_dirty_inode(new_bh, inode);
140  
141  	tmp = be32_to_cpu(AFFS_TAIL(sb, bh)->extension);
142  	if (tmp)
143  		affs_warning(sb, "alloc_ext", "previous extension set (%x)", tmp);
144  	AFFS_TAIL(sb, bh)->extension = cpu_to_be32(blocknr);
145  	affs_adjust_checksum(bh, blocknr - tmp);
146  	mark_buffer_dirty_inode(bh, inode);
147  
148  	AFFS_I(inode)->i_extcnt++;
149  	mark_inode_dirty(inode);
150  
151  	return new_bh;
152  }
153  
154  static inline struct buffer_head *
155  affs_get_extblock(struct inode *inode, u32 ext)
156  {
157  	/* inline the simplest case: same extended block as last time */
158  	struct buffer_head *bh = AFFS_I(inode)->i_ext_bh;
159  	if (ext == AFFS_I(inode)->i_ext_last)
160  		get_bh(bh);
161  	else
162  		/* we have to do more (not inlined) */
163  		bh = affs_get_extblock_slow(inode, ext);
164  
165  	return bh;
166  }
167  
168  static struct buffer_head *
169  affs_get_extblock_slow(struct inode *inode, u32 ext)
170  {
171  	struct super_block *sb = inode->i_sb;
172  	struct buffer_head *bh;
173  	u32 ext_key;
174  	u32 lc_idx, lc_off, ac_idx;
175  	u32 tmp, idx;
176  
177  	if (ext == AFFS_I(inode)->i_ext_last + 1) {
178  		/* read the next extended block from the current one */
179  		bh = AFFS_I(inode)->i_ext_bh;
180  		ext_key = be32_to_cpu(AFFS_TAIL(sb, bh)->extension);
181  		if (ext < AFFS_I(inode)->i_extcnt)
182  			goto read_ext;
183  		BUG_ON(ext > AFFS_I(inode)->i_extcnt);
184  		bh = affs_alloc_extblock(inode, bh, ext);
185  		if (IS_ERR(bh))
186  			return bh;
187  		goto store_ext;
188  	}
189  
190  	if (ext == 0) {
191  		/* we seek back to the file header block */
192  		ext_key = inode->i_ino;
193  		goto read_ext;
194  	}
195  
196  	if (ext >= AFFS_I(inode)->i_extcnt) {
197  		struct buffer_head *prev_bh;
198  
199  		/* allocate a new extended block */
200  		BUG_ON(ext > AFFS_I(inode)->i_extcnt);
201  
202  		/* get previous extended block */
203  		prev_bh = affs_get_extblock(inode, ext - 1);
204  		if (IS_ERR(prev_bh))
205  			return prev_bh;
206  		bh = affs_alloc_extblock(inode, prev_bh, ext);
207  		affs_brelse(prev_bh);
208  		if (IS_ERR(bh))
209  			return bh;
210  		goto store_ext;
211  	}
212  
213  again:
214  	/* check if there is an extended cache and whether it's large enough */
215  	lc_idx = ext >> AFFS_I(inode)->i_lc_shift;
216  	lc_off = ext & AFFS_I(inode)->i_lc_mask;
217  
218  	if (lc_idx >= AFFS_I(inode)->i_lc_size) {
219  		int err;
220  
221  		err = affs_grow_extcache(inode, lc_idx);
222  		if (err)
223  			return ERR_PTR(err);
224  		goto again;
225  	}
226  
227  	/* every n'th key we find in the linear cache */
228  	if (!lc_off) {
229  		ext_key = AFFS_I(inode)->i_lc[lc_idx];
230  		goto read_ext;
231  	}
232  
233  	/* maybe it's still in the associative cache */
234  	ac_idx = (ext - lc_idx - 1) & AFFS_AC_MASK;
235  	if (AFFS_I(inode)->i_ac[ac_idx].ext == ext) {
236  		ext_key = AFFS_I(inode)->i_ac[ac_idx].key;
237  		goto read_ext;
238  	}
239  
240  	/* try to find one of the previous extended blocks */
241  	tmp = ext;
242  	idx = ac_idx;
243  	while (--tmp, --lc_off > 0) {
244  		idx = (idx - 1) & AFFS_AC_MASK;
245  		if (AFFS_I(inode)->i_ac[idx].ext == tmp) {
246  			ext_key = AFFS_I(inode)->i_ac[idx].key;
247  			goto find_ext;
248  		}
249  	}
250  
251  	/* fall back to the linear cache */
252  	ext_key = AFFS_I(inode)->i_lc[lc_idx];
253  find_ext:
254  	/* read all extended blocks until we find the one we need */
255  	//unlock cache
256  	do {
257  		bh = affs_bread(sb, ext_key);
258  		if (!bh)
259  			goto err_bread;
260  		ext_key = be32_to_cpu(AFFS_TAIL(sb, bh)->extension);
261  		affs_brelse(bh);
262  		tmp++;
263  	} while (tmp < ext);
264  	//lock cache
265  
266  	/* store it in the associative cache */
267  	// recalculate ac_idx?
268  	AFFS_I(inode)->i_ac[ac_idx].ext = ext;
269  	AFFS_I(inode)->i_ac[ac_idx].key = ext_key;
270  
271  read_ext:
272  	/* finally read the right extended block */
273  	//unlock cache
274  	bh = affs_bread(sb, ext_key);
275  	if (!bh)
276  		goto err_bread;
277  	//lock cache
278  
279  store_ext:
280  	/* release old cached extended block and store the new one */
281  	affs_brelse(AFFS_I(inode)->i_ext_bh);
282  	AFFS_I(inode)->i_ext_last = ext;
283  	AFFS_I(inode)->i_ext_bh = bh;
284  	get_bh(bh);
285  
286  	return bh;
287  
288  err_bread:
289  	affs_brelse(bh);
290  	return ERR_PTR(-EIO);
291  }
292  
293  static int
294  affs_get_block(struct inode *inode, sector_t block, struct buffer_head *bh_result, int create)
295  {
296  	struct super_block	*sb = inode->i_sb;
297  	struct buffer_head	*ext_bh;
298  	u32			 ext;
299  
300  	pr_debug("%s(%lu, %llu)\n", __func__, inode->i_ino,
301  		 (unsigned long long)block);
302  
303  	BUG_ON(block > (sector_t)0x7fffffffUL);
304  
305  	if (block >= AFFS_I(inode)->i_blkcnt) {
306  		if (block > AFFS_I(inode)->i_blkcnt || !create)
307  			goto err_big;
308  	} else
309  		create = 0;
310  
311  	//lock cache
312  	affs_lock_ext(inode);
313  
314  	ext = (u32)block / AFFS_SB(sb)->s_hashsize;
315  	block -= ext * AFFS_SB(sb)->s_hashsize;
316  	ext_bh = affs_get_extblock(inode, ext);
317  	if (IS_ERR(ext_bh))
318  		goto err_ext;
319  	map_bh(bh_result, sb, (sector_t)be32_to_cpu(AFFS_BLOCK(sb, ext_bh, block)));
320  
321  	if (create) {
322  		u32 blocknr = affs_alloc_block(inode, ext_bh->b_blocknr);
323  		if (!blocknr)
324  			goto err_alloc;
325  		set_buffer_new(bh_result);
326  		AFFS_I(inode)->mmu_private += AFFS_SB(sb)->s_data_blksize;
327  		AFFS_I(inode)->i_blkcnt++;
328  
329  		/* store new block */
330  		if (bh_result->b_blocknr)
331  			affs_warning(sb, "get_block",
332  				     "block already set (%llx)",
333  				     (unsigned long long)bh_result->b_blocknr);
334  		AFFS_BLOCK(sb, ext_bh, block) = cpu_to_be32(blocknr);
335  		AFFS_HEAD(ext_bh)->block_count = cpu_to_be32(block + 1);
336  		affs_adjust_checksum(ext_bh, blocknr - bh_result->b_blocknr + 1);
337  		bh_result->b_blocknr = blocknr;
338  
339  		if (!block) {
340  			/* insert first block into header block */
341  			u32 tmp = be32_to_cpu(AFFS_HEAD(ext_bh)->first_data);
342  			if (tmp)
343  				affs_warning(sb, "get_block", "first block already set (%d)", tmp);
344  			AFFS_HEAD(ext_bh)->first_data = cpu_to_be32(blocknr);
345  			affs_adjust_checksum(ext_bh, blocknr - tmp);
346  		}
347  	}
348  
349  	affs_brelse(ext_bh);
350  	//unlock cache
351  	affs_unlock_ext(inode);
352  	return 0;
353  
354  err_big:
355  	affs_error(inode->i_sb, "get_block", "strange block request %llu",
356  		   (unsigned long long)block);
357  	return -EIO;
358  err_ext:
359  	// unlock cache
360  	affs_unlock_ext(inode);
361  	return PTR_ERR(ext_bh);
362  err_alloc:
363  	brelse(ext_bh);
364  	clear_buffer_mapped(bh_result);
365  	bh_result->b_bdev = NULL;
366  	// unlock cache
367  	affs_unlock_ext(inode);
368  	return -ENOSPC;
369  }
370  
371  static int affs_writepage(struct page *page, struct writeback_control *wbc)
372  {
373  	return block_write_full_page(page, affs_get_block, wbc);
374  }
375  
376  static int affs_readpage(struct file *file, struct page *page)
377  {
378  	return block_read_full_page(page, affs_get_block);
379  }
380  
381  static void affs_write_failed(struct address_space *mapping, loff_t to)
382  {
383  	struct inode *inode = mapping->host;
384  
385  	if (to > inode->i_size) {
386  		truncate_pagecache(inode, inode->i_size);
387  		affs_truncate(inode);
388  	}
389  }
390  
391  static ssize_t
392  affs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
393  {
394  	struct file *file = iocb->ki_filp;
395  	struct address_space *mapping = file->f_mapping;
396  	struct inode *inode = mapping->host;
397  	size_t count = iov_iter_count(iter);
398  	loff_t offset = iocb->ki_pos;
399  	ssize_t ret;
400  
401  	if (iov_iter_rw(iter) == WRITE) {
402  		loff_t size = offset + count;
403  
404  		if (AFFS_I(inode)->mmu_private < size)
405  			return 0;
406  	}
407  
408  	ret = blockdev_direct_IO(iocb, inode, iter, affs_get_block);
409  	if (ret < 0 && iov_iter_rw(iter) == WRITE)
410  		affs_write_failed(mapping, offset + count);
411  	return ret;
412  }
413  
414  static int affs_write_begin(struct file *file, struct address_space *mapping,
415  			loff_t pos, unsigned len, unsigned flags,
416  			struct page **pagep, void **fsdata)
417  {
418  	int ret;
419  
420  	*pagep = NULL;
421  	ret = cont_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
422  				affs_get_block,
423  				&AFFS_I(mapping->host)->mmu_private);
424  	if (unlikely(ret))
425  		affs_write_failed(mapping, pos + len);
426  
427  	return ret;
428  }
429  
430  static sector_t _affs_bmap(struct address_space *mapping, sector_t block)
431  {
432  	return generic_block_bmap(mapping,block,affs_get_block);
433  }
434  
435  const struct address_space_operations affs_aops = {
436  	.readpage = affs_readpage,
437  	.writepage = affs_writepage,
438  	.write_begin = affs_write_begin,
439  	.write_end = generic_write_end,
440  	.direct_IO = affs_direct_IO,
441  	.bmap = _affs_bmap
442  };
443  
444  static inline struct buffer_head *
445  affs_bread_ino(struct inode *inode, int block, int create)
446  {
447  	struct buffer_head *bh, tmp_bh;
448  	int err;
449  
450  	tmp_bh.b_state = 0;
451  	err = affs_get_block(inode, block, &tmp_bh, create);
452  	if (!err) {
453  		bh = affs_bread(inode->i_sb, tmp_bh.b_blocknr);
454  		if (bh) {
455  			bh->b_state |= tmp_bh.b_state;
456  			return bh;
457  		}
458  		err = -EIO;
459  	}
460  	return ERR_PTR(err);
461  }
462  
463  static inline struct buffer_head *
464  affs_getzeroblk_ino(struct inode *inode, int block)
465  {
466  	struct buffer_head *bh, tmp_bh;
467  	int err;
468  
469  	tmp_bh.b_state = 0;
470  	err = affs_get_block(inode, block, &tmp_bh, 1);
471  	if (!err) {
472  		bh = affs_getzeroblk(inode->i_sb, tmp_bh.b_blocknr);
473  		if (bh) {
474  			bh->b_state |= tmp_bh.b_state;
475  			return bh;
476  		}
477  		err = -EIO;
478  	}
479  	return ERR_PTR(err);
480  }
481  
482  static inline struct buffer_head *
483  affs_getemptyblk_ino(struct inode *inode, int block)
484  {
485  	struct buffer_head *bh, tmp_bh;
486  	int err;
487  
488  	tmp_bh.b_state = 0;
489  	err = affs_get_block(inode, block, &tmp_bh, 1);
490  	if (!err) {
491  		bh = affs_getemptyblk(inode->i_sb, tmp_bh.b_blocknr);
492  		if (bh) {
493  			bh->b_state |= tmp_bh.b_state;
494  			return bh;
495  		}
496  		err = -EIO;
497  	}
498  	return ERR_PTR(err);
499  }
500  
501  static int
502  affs_do_readpage_ofs(struct page *page, unsigned to, int create)
503  {
504  	struct inode *inode = page->mapping->host;
505  	struct super_block *sb = inode->i_sb;
506  	struct buffer_head *bh;
507  	char *data;
508  	unsigned pos = 0;
509  	u32 bidx, boff, bsize;
510  	u32 tmp;
511  
512  	pr_debug("%s(%lu, %ld, 0, %d)\n", __func__, inode->i_ino,
513  		 page->index, to);
514  	BUG_ON(to > PAGE_SIZE);
515  	bsize = AFFS_SB(sb)->s_data_blksize;
516  	tmp = page->index << PAGE_SHIFT;
517  	bidx = tmp / bsize;
518  	boff = tmp % bsize;
519  
520  	while (pos < to) {
521  		bh = affs_bread_ino(inode, bidx, create);
522  		if (IS_ERR(bh))
523  			return PTR_ERR(bh);
524  		tmp = min(bsize - boff, to - pos);
525  		BUG_ON(pos + tmp > to || tmp > bsize);
526  		data = kmap_atomic(page);
527  		memcpy(data + pos, AFFS_DATA(bh) + boff, tmp);
528  		kunmap_atomic(data);
529  		affs_brelse(bh);
530  		bidx++;
531  		pos += tmp;
532  		boff = 0;
533  	}
534  	flush_dcache_page(page);
535  	return 0;
536  }
537  
538  static int
539  affs_extent_file_ofs(struct inode *inode, u32 newsize)
540  {
541  	struct super_block *sb = inode->i_sb;
542  	struct buffer_head *bh, *prev_bh;
543  	u32 bidx, boff;
544  	u32 size, bsize;
545  	u32 tmp;
546  
547  	pr_debug("%s(%lu, %d)\n", __func__, inode->i_ino, newsize);
548  	bsize = AFFS_SB(sb)->s_data_blksize;
549  	bh = NULL;
550  	size = AFFS_I(inode)->mmu_private;
551  	bidx = size / bsize;
552  	boff = size % bsize;
553  	if (boff) {
554  		bh = affs_bread_ino(inode, bidx, 0);
555  		if (IS_ERR(bh))
556  			return PTR_ERR(bh);
557  		tmp = min(bsize - boff, newsize - size);
558  		BUG_ON(boff + tmp > bsize || tmp > bsize);
559  		memset(AFFS_DATA(bh) + boff, 0, tmp);
560  		be32_add_cpu(&AFFS_DATA_HEAD(bh)->size, tmp);
561  		affs_fix_checksum(sb, bh);
562  		mark_buffer_dirty_inode(bh, inode);
563  		size += tmp;
564  		bidx++;
565  	} else if (bidx) {
566  		bh = affs_bread_ino(inode, bidx - 1, 0);
567  		if (IS_ERR(bh))
568  			return PTR_ERR(bh);
569  	}
570  
571  	while (size < newsize) {
572  		prev_bh = bh;
573  		bh = affs_getzeroblk_ino(inode, bidx);
574  		if (IS_ERR(bh))
575  			goto out;
576  		tmp = min(bsize, newsize - size);
577  		BUG_ON(tmp > bsize);
578  		AFFS_DATA_HEAD(bh)->ptype = cpu_to_be32(T_DATA);
579  		AFFS_DATA_HEAD(bh)->key = cpu_to_be32(inode->i_ino);
580  		AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx);
581  		AFFS_DATA_HEAD(bh)->size = cpu_to_be32(tmp);
582  		affs_fix_checksum(sb, bh);
583  		bh->b_state &= ~(1UL << BH_New);
584  		mark_buffer_dirty_inode(bh, inode);
585  		if (prev_bh) {
586  			u32 tmp_next = be32_to_cpu(AFFS_DATA_HEAD(prev_bh)->next);
587  
588  			if (tmp_next)
589  				affs_warning(sb, "extent_file_ofs",
590  					     "next block already set for %d (%d)",
591  					     bidx, tmp_next);
592  			AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr);
593  			affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp_next);
594  			mark_buffer_dirty_inode(prev_bh, inode);
595  			affs_brelse(prev_bh);
596  		}
597  		size += bsize;
598  		bidx++;
599  	}
600  	affs_brelse(bh);
601  	inode->i_size = AFFS_I(inode)->mmu_private = newsize;
602  	return 0;
603  
604  out:
605  	inode->i_size = AFFS_I(inode)->mmu_private = newsize;
606  	return PTR_ERR(bh);
607  }
608  
609  static int
610  affs_readpage_ofs(struct file *file, struct page *page)
611  {
612  	struct inode *inode = page->mapping->host;
613  	u32 to;
614  	int err;
615  
616  	pr_debug("%s(%lu, %ld)\n", __func__, inode->i_ino, page->index);
617  	to = PAGE_SIZE;
618  	if (((page->index + 1) << PAGE_SHIFT) > inode->i_size) {
619  		to = inode->i_size & ~PAGE_MASK;
620  		memset(page_address(page) + to, 0, PAGE_SIZE - to);
621  	}
622  
623  	err = affs_do_readpage_ofs(page, to, 0);
624  	if (!err)
625  		SetPageUptodate(page);
626  	unlock_page(page);
627  	return err;
628  }
629  
630  static int affs_write_begin_ofs(struct file *file, struct address_space *mapping,
631  				loff_t pos, unsigned len, unsigned flags,
632  				struct page **pagep, void **fsdata)
633  {
634  	struct inode *inode = mapping->host;
635  	struct page *page;
636  	pgoff_t index;
637  	int err = 0;
638  
639  	pr_debug("%s(%lu, %llu, %llu)\n", __func__, inode->i_ino, pos,
640  		 pos + len);
641  	if (pos > AFFS_I(inode)->mmu_private) {
642  		/* XXX: this probably leaves a too-big i_size in case of
643  		 * failure. Should really be updating i_size at write_end time
644  		 */
645  		err = affs_extent_file_ofs(inode, pos);
646  		if (err)
647  			return err;
648  	}
649  
650  	index = pos >> PAGE_SHIFT;
651  	page = grab_cache_page_write_begin(mapping, index, flags);
652  	if (!page)
653  		return -ENOMEM;
654  	*pagep = page;
655  
656  	if (PageUptodate(page))
657  		return 0;
658  
659  	/* XXX: inefficient but safe in the face of short writes */
660  	err = affs_do_readpage_ofs(page, PAGE_SIZE, 1);
661  	if (err) {
662  		unlock_page(page);
663  		put_page(page);
664  	}
665  	return err;
666  }
667  
668  static int affs_write_end_ofs(struct file *file, struct address_space *mapping,
669  				loff_t pos, unsigned len, unsigned copied,
670  				struct page *page, void *fsdata)
671  {
672  	struct inode *inode = mapping->host;
673  	struct super_block *sb = inode->i_sb;
674  	struct buffer_head *bh, *prev_bh;
675  	char *data;
676  	u32 bidx, boff, bsize;
677  	unsigned from, to;
678  	u32 tmp;
679  	int written;
680  
681  	from = pos & (PAGE_SIZE - 1);
682  	to = from + len;
683  	/*
684  	 * XXX: not sure if this can handle short copies (len < copied), but
685  	 * we don't have to, because the page should always be uptodate here,
686  	 * due to write_begin.
687  	 */
688  
689  	pr_debug("%s(%lu, %llu, %llu)\n", __func__, inode->i_ino, pos,
690  		 pos + len);
691  	bsize = AFFS_SB(sb)->s_data_blksize;
692  	data = page_address(page);
693  
694  	bh = NULL;
695  	written = 0;
696  	tmp = (page->index << PAGE_SHIFT) + from;
697  	bidx = tmp / bsize;
698  	boff = tmp % bsize;
699  	if (boff) {
700  		bh = affs_bread_ino(inode, bidx, 0);
701  		if (IS_ERR(bh)) {
702  			written = PTR_ERR(bh);
703  			goto err_first_bh;
704  		}
705  		tmp = min(bsize - boff, to - from);
706  		BUG_ON(boff + tmp > bsize || tmp > bsize);
707  		memcpy(AFFS_DATA(bh) + boff, data + from, tmp);
708  		be32_add_cpu(&AFFS_DATA_HEAD(bh)->size, tmp);
709  		affs_fix_checksum(sb, bh);
710  		mark_buffer_dirty_inode(bh, inode);
711  		written += tmp;
712  		from += tmp;
713  		bidx++;
714  	} else if (bidx) {
715  		bh = affs_bread_ino(inode, bidx - 1, 0);
716  		if (IS_ERR(bh)) {
717  			written = PTR_ERR(bh);
718  			goto err_first_bh;
719  		}
720  	}
721  	while (from + bsize <= to) {
722  		prev_bh = bh;
723  		bh = affs_getemptyblk_ino(inode, bidx);
724  		if (IS_ERR(bh))
725  			goto err_bh;
726  		memcpy(AFFS_DATA(bh), data + from, bsize);
727  		if (buffer_new(bh)) {
728  			AFFS_DATA_HEAD(bh)->ptype = cpu_to_be32(T_DATA);
729  			AFFS_DATA_HEAD(bh)->key = cpu_to_be32(inode->i_ino);
730  			AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx);
731  			AFFS_DATA_HEAD(bh)->size = cpu_to_be32(bsize);
732  			AFFS_DATA_HEAD(bh)->next = 0;
733  			bh->b_state &= ~(1UL << BH_New);
734  			if (prev_bh) {
735  				u32 tmp_next = be32_to_cpu(AFFS_DATA_HEAD(prev_bh)->next);
736  
737  				if (tmp_next)
738  					affs_warning(sb, "commit_write_ofs",
739  						     "next block already set for %d (%d)",
740  						     bidx, tmp_next);
741  				AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr);
742  				affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp_next);
743  				mark_buffer_dirty_inode(prev_bh, inode);
744  			}
745  		}
746  		affs_brelse(prev_bh);
747  		affs_fix_checksum(sb, bh);
748  		mark_buffer_dirty_inode(bh, inode);
749  		written += bsize;
750  		from += bsize;
751  		bidx++;
752  	}
753  	if (from < to) {
754  		prev_bh = bh;
755  		bh = affs_bread_ino(inode, bidx, 1);
756  		if (IS_ERR(bh))
757  			goto err_bh;
758  		tmp = min(bsize, to - from);
759  		BUG_ON(tmp > bsize);
760  		memcpy(AFFS_DATA(bh), data + from, tmp);
761  		if (buffer_new(bh)) {
762  			AFFS_DATA_HEAD(bh)->ptype = cpu_to_be32(T_DATA);
763  			AFFS_DATA_HEAD(bh)->key = cpu_to_be32(inode->i_ino);
764  			AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx);
765  			AFFS_DATA_HEAD(bh)->size = cpu_to_be32(tmp);
766  			AFFS_DATA_HEAD(bh)->next = 0;
767  			bh->b_state &= ~(1UL << BH_New);
768  			if (prev_bh) {
769  				u32 tmp_next = be32_to_cpu(AFFS_DATA_HEAD(prev_bh)->next);
770  
771  				if (tmp_next)
772  					affs_warning(sb, "commit_write_ofs",
773  						     "next block already set for %d (%d)",
774  						     bidx, tmp_next);
775  				AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr);
776  				affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp_next);
777  				mark_buffer_dirty_inode(prev_bh, inode);
778  			}
779  		} else if (be32_to_cpu(AFFS_DATA_HEAD(bh)->size) < tmp)
780  			AFFS_DATA_HEAD(bh)->size = cpu_to_be32(tmp);
781  		affs_brelse(prev_bh);
782  		affs_fix_checksum(sb, bh);
783  		mark_buffer_dirty_inode(bh, inode);
784  		written += tmp;
785  		from += tmp;
786  		bidx++;
787  	}
788  	SetPageUptodate(page);
789  
790  done:
791  	affs_brelse(bh);
792  	tmp = (page->index << PAGE_SHIFT) + from;
793  	if (tmp > inode->i_size)
794  		inode->i_size = AFFS_I(inode)->mmu_private = tmp;
795  
796  err_first_bh:
797  	unlock_page(page);
798  	put_page(page);
799  
800  	return written;
801  
802  err_bh:
803  	bh = prev_bh;
804  	if (!written)
805  		written = PTR_ERR(bh);
806  	goto done;
807  }
808  
809  const struct address_space_operations affs_aops_ofs = {
810  	.readpage = affs_readpage_ofs,
811  	//.writepage = affs_writepage_ofs,
812  	.write_begin = affs_write_begin_ofs,
813  	.write_end = affs_write_end_ofs
814  };
815  
816  /* Free any preallocated blocks. */
817  
818  void
819  affs_free_prealloc(struct inode *inode)
820  {
821  	struct super_block *sb = inode->i_sb;
822  
823  	pr_debug("free_prealloc(ino=%lu)\n", inode->i_ino);
824  
825  	while (AFFS_I(inode)->i_pa_cnt) {
826  		AFFS_I(inode)->i_pa_cnt--;
827  		affs_free_block(sb, ++AFFS_I(inode)->i_lastalloc);
828  	}
829  }
830  
831  /* Truncate (or enlarge) a file to the requested size. */
832  
833  void
834  affs_truncate(struct inode *inode)
835  {
836  	struct super_block *sb = inode->i_sb;
837  	u32 ext, ext_key;
838  	u32 last_blk, blkcnt, blk;
839  	u32 size;
840  	struct buffer_head *ext_bh;
841  	int i;
842  
843  	pr_debug("truncate(inode=%lu, oldsize=%llu, newsize=%llu)\n",
844  		 inode->i_ino, AFFS_I(inode)->mmu_private, inode->i_size);
845  
846  	last_blk = 0;
847  	ext = 0;
848  	if (inode->i_size) {
849  		last_blk = ((u32)inode->i_size - 1) / AFFS_SB(sb)->s_data_blksize;
850  		ext = last_blk / AFFS_SB(sb)->s_hashsize;
851  	}
852  
853  	if (inode->i_size > AFFS_I(inode)->mmu_private) {
854  		struct address_space *mapping = inode->i_mapping;
855  		struct page *page;
856  		void *fsdata;
857  		loff_t isize = inode->i_size;
858  		int res;
859  
860  		res = mapping->a_ops->write_begin(NULL, mapping, isize, 0, 0, &page, &fsdata);
861  		if (!res)
862  			res = mapping->a_ops->write_end(NULL, mapping, isize, 0, 0, page, fsdata);
863  		else
864  			inode->i_size = AFFS_I(inode)->mmu_private;
865  		mark_inode_dirty(inode);
866  		return;
867  	} else if (inode->i_size == AFFS_I(inode)->mmu_private)
868  		return;
869  
870  	// lock cache
871  	ext_bh = affs_get_extblock(inode, ext);
872  	if (IS_ERR(ext_bh)) {
873  		affs_warning(sb, "truncate",
874  			     "unexpected read error for ext block %u (%ld)",
875  			     ext, PTR_ERR(ext_bh));
876  		return;
877  	}
878  	if (AFFS_I(inode)->i_lc) {
879  		/* clear linear cache */
880  		i = (ext + 1) >> AFFS_I(inode)->i_lc_shift;
881  		if (AFFS_I(inode)->i_lc_size > i) {
882  			AFFS_I(inode)->i_lc_size = i;
883  			for (; i < AFFS_LC_SIZE; i++)
884  				AFFS_I(inode)->i_lc[i] = 0;
885  		}
886  		/* clear associative cache */
887  		for (i = 0; i < AFFS_AC_SIZE; i++)
888  			if (AFFS_I(inode)->i_ac[i].ext >= ext)
889  				AFFS_I(inode)->i_ac[i].ext = 0;
890  	}
891  	ext_key = be32_to_cpu(AFFS_TAIL(sb, ext_bh)->extension);
892  
893  	blkcnt = AFFS_I(inode)->i_blkcnt;
894  	i = 0;
895  	blk = last_blk;
896  	if (inode->i_size) {
897  		i = last_blk % AFFS_SB(sb)->s_hashsize + 1;
898  		blk++;
899  	} else
900  		AFFS_HEAD(ext_bh)->first_data = 0;
901  	AFFS_HEAD(ext_bh)->block_count = cpu_to_be32(i);
902  	size = AFFS_SB(sb)->s_hashsize;
903  	if (size > blkcnt - blk + i)
904  		size = blkcnt - blk + i;
905  	for (; i < size; i++, blk++) {
906  		affs_free_block(sb, be32_to_cpu(AFFS_BLOCK(sb, ext_bh, i)));
907  		AFFS_BLOCK(sb, ext_bh, i) = 0;
908  	}
909  	AFFS_TAIL(sb, ext_bh)->extension = 0;
910  	affs_fix_checksum(sb, ext_bh);
911  	mark_buffer_dirty_inode(ext_bh, inode);
912  	affs_brelse(ext_bh);
913  
914  	if (inode->i_size) {
915  		AFFS_I(inode)->i_blkcnt = last_blk + 1;
916  		AFFS_I(inode)->i_extcnt = ext + 1;
917  		if (affs_test_opt(AFFS_SB(sb)->s_flags, SF_OFS)) {
918  			struct buffer_head *bh = affs_bread_ino(inode, last_blk, 0);
919  			u32 tmp;
920  			if (IS_ERR(bh)) {
921  				affs_warning(sb, "truncate",
922  					     "unexpected read error for last block %u (%ld)",
923  					     ext, PTR_ERR(bh));
924  				return;
925  			}
926  			tmp = be32_to_cpu(AFFS_DATA_HEAD(bh)->next);
927  			AFFS_DATA_HEAD(bh)->next = 0;
928  			affs_adjust_checksum(bh, -tmp);
929  			affs_brelse(bh);
930  		}
931  	} else {
932  		AFFS_I(inode)->i_blkcnt = 0;
933  		AFFS_I(inode)->i_extcnt = 1;
934  	}
935  	AFFS_I(inode)->mmu_private = inode->i_size;
936  	// unlock cache
937  
938  	while (ext_key) {
939  		ext_bh = affs_bread(sb, ext_key);
940  		size = AFFS_SB(sb)->s_hashsize;
941  		if (size > blkcnt - blk)
942  			size = blkcnt - blk;
943  		for (i = 0; i < size; i++, blk++)
944  			affs_free_block(sb, be32_to_cpu(AFFS_BLOCK(sb, ext_bh, i)));
945  		affs_free_block(sb, ext_key);
946  		ext_key = be32_to_cpu(AFFS_TAIL(sb, ext_bh)->extension);
947  		affs_brelse(ext_bh);
948  	}
949  	affs_free_prealloc(inode);
950  }
951  
952  int affs_file_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
953  {
954  	struct inode *inode = filp->f_mapping->host;
955  	int ret, err;
956  
957  	err = file_write_and_wait_range(filp, start, end);
958  	if (err)
959  		return err;
960  
961  	inode_lock(inode);
962  	ret = write_inode_now(inode, 0);
963  	err = sync_blockdev(inode->i_sb->s_bdev);
964  	if (!ret)
965  		ret = err;
966  	inode_unlock(inode);
967  	return ret;
968  }
969  const struct file_operations affs_file_operations = {
970  	.llseek		= generic_file_llseek,
971  	.read_iter	= generic_file_read_iter,
972  	.write_iter	= generic_file_write_iter,
973  	.mmap		= generic_file_mmap,
974  	.open		= affs_file_open,
975  	.release	= affs_file_release,
976  	.fsync		= affs_file_fsync,
977  	.splice_read	= generic_file_splice_read,
978  };
979  
980  const struct inode_operations affs_file_inode_operations = {
981  	.setattr	= affs_notify_change,
982  };
983