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