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