1 // SPDX-License-Identifier: GPL-2.0
5 * (c) 1996 Hans-Joachim Widmaier - Rewritten
7 * (C) 1993 Ray Burr - Modified for Amiga FFS filesystem.
9 * (C) 1992 Eric Youngdale Modified for ISO 9660 filesystem.
11 * (C) 1991 Linus Torvalds - minix filesystem
13 * affs regular file handling primitives
16 #include <linux/uio.h>
17 #include <linux/blkdev.h>
20 static struct buffer_head
*affs_get_extblock_slow(struct inode
*inode
, u32 ext
);
23 affs_file_open(struct inode
*inode
, struct file
*filp
)
25 pr_debug("open(%lu,%d)\n",
26 inode
->i_ino
, atomic_read(&AFFS_I(inode
)->i_opencnt
));
27 atomic_inc(&AFFS_I(inode
)->i_opencnt
);
32 affs_file_release(struct inode
*inode
, struct file
*filp
)
34 pr_debug("release(%lu, %d)\n",
35 inode
->i_ino
, atomic_read(&AFFS_I(inode
)->i_opencnt
));
37 if (atomic_dec_and_test(&AFFS_I(inode
)->i_opencnt
)) {
39 if (inode
->i_size
!= AFFS_I(inode
)->mmu_private
)
41 affs_free_prealloc(inode
);
49 affs_grow_extcache(struct inode
*inode
, u32 lc_idx
)
51 struct super_block
*sb
= inode
->i_sb
;
52 struct buffer_head
*bh
;
56 if (!AFFS_I(inode
)->i_lc
) {
57 char *ptr
= (char *)get_zeroed_page(GFP_NOFS
);
60 AFFS_I(inode
)->i_lc
= (u32
*)ptr
;
61 AFFS_I(inode
)->i_ac
= (struct affs_ext_key
*)(ptr
+ AFFS_CACHE_SIZE
/ 2);
64 lc_max
= AFFS_LC_SIZE
<< AFFS_I(inode
)->i_lc_shift
;
66 if (AFFS_I(inode
)->i_extcnt
> lc_max
) {
67 u32 lc_shift
, lc_mask
, tmp
, off
;
69 /* need to recalculate linear cache, start from old size */
70 lc_shift
= AFFS_I(inode
)->i_lc_shift
;
71 tmp
= (AFFS_I(inode
)->i_extcnt
/ AFFS_LC_SIZE
) >> lc_shift
;
72 for (; tmp
; tmp
>>= 1)
74 lc_mask
= (1 << lc_shift
) - 1;
76 /* fix idx and old size to new shift */
77 lc_idx
>>= (lc_shift
- AFFS_I(inode
)->i_lc_shift
);
78 AFFS_I(inode
)->i_lc_size
>>= (lc_shift
- AFFS_I(inode
)->i_lc_shift
);
80 /* first shrink old cache to make more space */
81 off
= 1 << (lc_shift
- AFFS_I(inode
)->i_lc_shift
);
82 for (i
= 1, j
= off
; j
< AFFS_LC_SIZE
; i
++, j
+= off
)
83 AFFS_I(inode
)->i_ac
[i
] = AFFS_I(inode
)->i_ac
[j
];
85 AFFS_I(inode
)->i_lc_shift
= lc_shift
;
86 AFFS_I(inode
)->i_lc_mask
= lc_mask
;
89 /* fill cache to the needed index */
90 i
= AFFS_I(inode
)->i_lc_size
;
91 AFFS_I(inode
)->i_lc_size
= lc_idx
+ 1;
92 for (; i
<= lc_idx
; i
++) {
94 AFFS_I(inode
)->i_lc
[0] = inode
->i_ino
;
97 key
= AFFS_I(inode
)->i_lc
[i
- 1];
98 j
= AFFS_I(inode
)->i_lc_mask
+ 1;
101 bh
= affs_bread(sb
, key
);
104 key
= be32_to_cpu(AFFS_TAIL(sb
, bh
)->extension
);
108 AFFS_I(inode
)->i_lc
[i
] = key
;
118 static struct buffer_head
*
119 affs_alloc_extblock(struct inode
*inode
, struct buffer_head
*bh
, u32 ext
)
121 struct super_block
*sb
= inode
->i_sb
;
122 struct buffer_head
*new_bh
;
125 blocknr
= affs_alloc_block(inode
, bh
->b_blocknr
);
127 return ERR_PTR(-ENOSPC
);
129 new_bh
= affs_getzeroblk(sb
, blocknr
);
131 affs_free_block(sb
, blocknr
);
132 return ERR_PTR(-EIO
);
135 AFFS_HEAD(new_bh
)->ptype
= cpu_to_be32(T_LIST
);
136 AFFS_HEAD(new_bh
)->key
= cpu_to_be32(blocknr
);
137 AFFS_TAIL(sb
, new_bh
)->stype
= cpu_to_be32(ST_FILE
);
138 AFFS_TAIL(sb
, new_bh
)->parent
= cpu_to_be32(inode
->i_ino
);
139 affs_fix_checksum(sb
, new_bh
);
141 mark_buffer_dirty_inode(new_bh
, inode
);
143 tmp
= be32_to_cpu(AFFS_TAIL(sb
, bh
)->extension
);
145 affs_warning(sb
, "alloc_ext", "previous extension set (%x)", tmp
);
146 AFFS_TAIL(sb
, bh
)->extension
= cpu_to_be32(blocknr
);
147 affs_adjust_checksum(bh
, blocknr
- tmp
);
148 mark_buffer_dirty_inode(bh
, inode
);
150 AFFS_I(inode
)->i_extcnt
++;
151 mark_inode_dirty(inode
);
156 static inline struct buffer_head
*
157 affs_get_extblock(struct inode
*inode
, u32 ext
)
159 /* inline the simplest case: same extended block as last time */
160 struct buffer_head
*bh
= AFFS_I(inode
)->i_ext_bh
;
161 if (ext
== AFFS_I(inode
)->i_ext_last
)
164 /* we have to do more (not inlined) */
165 bh
= affs_get_extblock_slow(inode
, ext
);
170 static struct buffer_head
*
171 affs_get_extblock_slow(struct inode
*inode
, u32 ext
)
173 struct super_block
*sb
= inode
->i_sb
;
174 struct buffer_head
*bh
;
176 u32 lc_idx
, lc_off
, ac_idx
;
179 if (ext
== AFFS_I(inode
)->i_ext_last
+ 1) {
180 /* read the next extended block from the current one */
181 bh
= AFFS_I(inode
)->i_ext_bh
;
182 ext_key
= be32_to_cpu(AFFS_TAIL(sb
, bh
)->extension
);
183 if (ext
< AFFS_I(inode
)->i_extcnt
)
185 BUG_ON(ext
> AFFS_I(inode
)->i_extcnt
);
186 bh
= affs_alloc_extblock(inode
, bh
, ext
);
193 /* we seek back to the file header block */
194 ext_key
= inode
->i_ino
;
198 if (ext
>= AFFS_I(inode
)->i_extcnt
) {
199 struct buffer_head
*prev_bh
;
201 /* allocate a new extended block */
202 BUG_ON(ext
> AFFS_I(inode
)->i_extcnt
);
204 /* get previous extended block */
205 prev_bh
= affs_get_extblock(inode
, ext
- 1);
208 bh
= affs_alloc_extblock(inode
, prev_bh
, ext
);
209 affs_brelse(prev_bh
);
216 /* check if there is an extended cache and whether it's large enough */
217 lc_idx
= ext
>> AFFS_I(inode
)->i_lc_shift
;
218 lc_off
= ext
& AFFS_I(inode
)->i_lc_mask
;
220 if (lc_idx
>= AFFS_I(inode
)->i_lc_size
) {
223 err
= affs_grow_extcache(inode
, lc_idx
);
229 /* every n'th key we find in the linear cache */
231 ext_key
= AFFS_I(inode
)->i_lc
[lc_idx
];
235 /* maybe it's still in the associative cache */
236 ac_idx
= (ext
- lc_idx
- 1) & AFFS_AC_MASK
;
237 if (AFFS_I(inode
)->i_ac
[ac_idx
].ext
== ext
) {
238 ext_key
= AFFS_I(inode
)->i_ac
[ac_idx
].key
;
242 /* try to find one of the previous extended blocks */
245 while (--tmp
, --lc_off
> 0) {
246 idx
= (idx
- 1) & AFFS_AC_MASK
;
247 if (AFFS_I(inode
)->i_ac
[idx
].ext
== tmp
) {
248 ext_key
= AFFS_I(inode
)->i_ac
[idx
].key
;
253 /* fall back to the linear cache */
254 ext_key
= AFFS_I(inode
)->i_lc
[lc_idx
];
256 /* read all extended blocks until we find the one we need */
259 bh
= affs_bread(sb
, ext_key
);
262 ext_key
= be32_to_cpu(AFFS_TAIL(sb
, bh
)->extension
);
268 /* store it in the associative cache */
269 // recalculate ac_idx?
270 AFFS_I(inode
)->i_ac
[ac_idx
].ext
= ext
;
271 AFFS_I(inode
)->i_ac
[ac_idx
].key
= ext_key
;
274 /* finally read the right extended block */
276 bh
= affs_bread(sb
, ext_key
);
282 /* release old cached extended block and store the new one */
283 affs_brelse(AFFS_I(inode
)->i_ext_bh
);
284 AFFS_I(inode
)->i_ext_last
= ext
;
285 AFFS_I(inode
)->i_ext_bh
= bh
;
292 return ERR_PTR(-EIO
);
296 affs_get_block(struct inode
*inode
, sector_t block
, struct buffer_head
*bh_result
, int create
)
298 struct super_block
*sb
= inode
->i_sb
;
299 struct buffer_head
*ext_bh
;
302 pr_debug("%s(%lu, %llu)\n", __func__
, inode
->i_ino
,
303 (unsigned long long)block
);
305 BUG_ON(block
> (sector_t
)0x7fffffffUL
);
307 if (block
>= AFFS_I(inode
)->i_blkcnt
) {
308 if (block
> AFFS_I(inode
)->i_blkcnt
|| !create
)
314 affs_lock_ext(inode
);
316 ext
= (u32
)block
/ AFFS_SB(sb
)->s_hashsize
;
317 block
-= ext
* AFFS_SB(sb
)->s_hashsize
;
318 ext_bh
= affs_get_extblock(inode
, ext
);
321 map_bh(bh_result
, sb
, (sector_t
)be32_to_cpu(AFFS_BLOCK(sb
, ext_bh
, block
)));
324 u32 blocknr
= affs_alloc_block(inode
, ext_bh
->b_blocknr
);
327 set_buffer_new(bh_result
);
328 AFFS_I(inode
)->mmu_private
+= AFFS_SB(sb
)->s_data_blksize
;
329 AFFS_I(inode
)->i_blkcnt
++;
331 /* store new block */
332 if (bh_result
->b_blocknr
)
333 affs_warning(sb
, "get_block",
334 "block already set (%llx)",
335 (unsigned long long)bh_result
->b_blocknr
);
336 AFFS_BLOCK(sb
, ext_bh
, block
) = cpu_to_be32(blocknr
);
337 AFFS_HEAD(ext_bh
)->block_count
= cpu_to_be32(block
+ 1);
338 affs_adjust_checksum(ext_bh
, blocknr
- bh_result
->b_blocknr
+ 1);
339 bh_result
->b_blocknr
= blocknr
;
342 /* insert first block into header block */
343 u32 tmp
= be32_to_cpu(AFFS_HEAD(ext_bh
)->first_data
);
345 affs_warning(sb
, "get_block", "first block already set (%d)", tmp
);
346 AFFS_HEAD(ext_bh
)->first_data
= cpu_to_be32(blocknr
);
347 affs_adjust_checksum(ext_bh
, blocknr
- tmp
);
353 affs_unlock_ext(inode
);
357 affs_error(inode
->i_sb
, "get_block", "strange block request %llu",
358 (unsigned long long)block
);
362 affs_unlock_ext(inode
);
363 return PTR_ERR(ext_bh
);
366 clear_buffer_mapped(bh_result
);
367 bh_result
->b_bdev
= NULL
;
369 affs_unlock_ext(inode
);
373 static int affs_writepage(struct page
*page
, struct writeback_control
*wbc
)
375 return block_write_full_page(page
, affs_get_block
, wbc
);
378 static int affs_readpage(struct file
*file
, struct page
*page
)
380 return block_read_full_page(page
, affs_get_block
);
383 static void affs_write_failed(struct address_space
*mapping
, loff_t to
)
385 struct inode
*inode
= mapping
->host
;
387 if (to
> inode
->i_size
) {
388 truncate_pagecache(inode
, inode
->i_size
);
389 affs_truncate(inode
);
394 affs_direct_IO(struct kiocb
*iocb
, struct iov_iter
*iter
)
396 struct file
*file
= iocb
->ki_filp
;
397 struct address_space
*mapping
= file
->f_mapping
;
398 struct inode
*inode
= mapping
->host
;
399 size_t count
= iov_iter_count(iter
);
400 loff_t offset
= iocb
->ki_pos
;
403 if (iov_iter_rw(iter
) == WRITE
) {
404 loff_t size
= offset
+ count
;
406 if (AFFS_I(inode
)->mmu_private
< size
)
410 ret
= blockdev_direct_IO(iocb
, inode
, iter
, affs_get_block
);
411 if (ret
< 0 && iov_iter_rw(iter
) == WRITE
)
412 affs_write_failed(mapping
, offset
+ count
);
416 static int affs_write_begin(struct file
*file
, struct address_space
*mapping
,
417 loff_t pos
, unsigned len
, unsigned flags
,
418 struct page
**pagep
, void **fsdata
)
423 ret
= cont_write_begin(file
, mapping
, pos
, len
, flags
, pagep
, fsdata
,
425 &AFFS_I(mapping
->host
)->mmu_private
);
427 affs_write_failed(mapping
, pos
+ len
);
432 static int affs_write_end(struct file
*file
, struct address_space
*mapping
,
433 loff_t pos
, unsigned int len
, unsigned int copied
,
434 struct page
*page
, void *fsdata
)
436 struct inode
*inode
= mapping
->host
;
439 ret
= generic_write_end(file
, mapping
, pos
, len
, copied
, page
, fsdata
);
441 /* Clear Archived bit on file writes, as AmigaOS would do */
442 if (AFFS_I(inode
)->i_protect
& FIBF_ARCHIVED
) {
443 AFFS_I(inode
)->i_protect
&= ~FIBF_ARCHIVED
;
444 mark_inode_dirty(inode
);
450 static sector_t
_affs_bmap(struct address_space
*mapping
, sector_t block
)
452 return generic_block_bmap(mapping
,block
,affs_get_block
);
455 const struct address_space_operations affs_aops
= {
456 .readpage
= affs_readpage
,
457 .writepage
= affs_writepage
,
458 .write_begin
= affs_write_begin
,
459 .write_end
= affs_write_end
,
460 .direct_IO
= affs_direct_IO
,
464 static inline struct buffer_head
*
465 affs_bread_ino(struct inode
*inode
, int block
, int create
)
467 struct buffer_head
*bh
, tmp_bh
;
471 err
= affs_get_block(inode
, block
, &tmp_bh
, create
);
473 bh
= affs_bread(inode
->i_sb
, tmp_bh
.b_blocknr
);
475 bh
->b_state
|= tmp_bh
.b_state
;
483 static inline struct buffer_head
*
484 affs_getzeroblk_ino(struct inode
*inode
, int block
)
486 struct buffer_head
*bh
, tmp_bh
;
490 err
= affs_get_block(inode
, block
, &tmp_bh
, 1);
492 bh
= affs_getzeroblk(inode
->i_sb
, tmp_bh
.b_blocknr
);
494 bh
->b_state
|= tmp_bh
.b_state
;
502 static inline struct buffer_head
*
503 affs_getemptyblk_ino(struct inode
*inode
, int block
)
505 struct buffer_head
*bh
, tmp_bh
;
509 err
= affs_get_block(inode
, block
, &tmp_bh
, 1);
511 bh
= affs_getemptyblk(inode
->i_sb
, tmp_bh
.b_blocknr
);
513 bh
->b_state
|= tmp_bh
.b_state
;
522 affs_do_readpage_ofs(struct page
*page
, unsigned to
, int create
)
524 struct inode
*inode
= page
->mapping
->host
;
525 struct super_block
*sb
= inode
->i_sb
;
526 struct buffer_head
*bh
;
529 u32 bidx
, boff
, bsize
;
532 pr_debug("%s(%lu, %ld, 0, %d)\n", __func__
, inode
->i_ino
,
534 BUG_ON(to
> PAGE_SIZE
);
535 bsize
= AFFS_SB(sb
)->s_data_blksize
;
536 tmp
= page
->index
<< PAGE_SHIFT
;
541 bh
= affs_bread_ino(inode
, bidx
, create
);
544 tmp
= min(bsize
- boff
, to
- pos
);
545 BUG_ON(pos
+ tmp
> to
|| tmp
> bsize
);
546 data
= kmap_atomic(page
);
547 memcpy(data
+ pos
, AFFS_DATA(bh
) + boff
, tmp
);
554 flush_dcache_page(page
);
559 affs_extent_file_ofs(struct inode
*inode
, u32 newsize
)
561 struct super_block
*sb
= inode
->i_sb
;
562 struct buffer_head
*bh
, *prev_bh
;
567 pr_debug("%s(%lu, %d)\n", __func__
, inode
->i_ino
, newsize
);
568 bsize
= AFFS_SB(sb
)->s_data_blksize
;
570 size
= AFFS_I(inode
)->mmu_private
;
574 bh
= affs_bread_ino(inode
, bidx
, 0);
577 tmp
= min(bsize
- boff
, newsize
- size
);
578 BUG_ON(boff
+ tmp
> bsize
|| tmp
> bsize
);
579 memset(AFFS_DATA(bh
) + boff
, 0, tmp
);
580 be32_add_cpu(&AFFS_DATA_HEAD(bh
)->size
, tmp
);
581 affs_fix_checksum(sb
, bh
);
582 mark_buffer_dirty_inode(bh
, inode
);
586 bh
= affs_bread_ino(inode
, bidx
- 1, 0);
591 while (size
< newsize
) {
593 bh
= affs_getzeroblk_ino(inode
, bidx
);
596 tmp
= min(bsize
, newsize
- size
);
598 AFFS_DATA_HEAD(bh
)->ptype
= cpu_to_be32(T_DATA
);
599 AFFS_DATA_HEAD(bh
)->key
= cpu_to_be32(inode
->i_ino
);
600 AFFS_DATA_HEAD(bh
)->sequence
= cpu_to_be32(bidx
);
601 AFFS_DATA_HEAD(bh
)->size
= cpu_to_be32(tmp
);
602 affs_fix_checksum(sb
, bh
);
603 bh
->b_state
&= ~(1UL << BH_New
);
604 mark_buffer_dirty_inode(bh
, inode
);
606 u32 tmp_next
= be32_to_cpu(AFFS_DATA_HEAD(prev_bh
)->next
);
609 affs_warning(sb
, "extent_file_ofs",
610 "next block already set for %d (%d)",
612 AFFS_DATA_HEAD(prev_bh
)->next
= cpu_to_be32(bh
->b_blocknr
);
613 affs_adjust_checksum(prev_bh
, bh
->b_blocknr
- tmp_next
);
614 mark_buffer_dirty_inode(prev_bh
, inode
);
615 affs_brelse(prev_bh
);
621 inode
->i_size
= AFFS_I(inode
)->mmu_private
= newsize
;
625 inode
->i_size
= AFFS_I(inode
)->mmu_private
= newsize
;
630 affs_readpage_ofs(struct file
*file
, struct page
*page
)
632 struct inode
*inode
= page
->mapping
->host
;
636 pr_debug("%s(%lu, %ld)\n", __func__
, inode
->i_ino
, page
->index
);
638 if (((page
->index
+ 1) << PAGE_SHIFT
) > inode
->i_size
) {
639 to
= inode
->i_size
& ~PAGE_MASK
;
640 memset(page_address(page
) + to
, 0, PAGE_SIZE
- to
);
643 err
= affs_do_readpage_ofs(page
, to
, 0);
645 SetPageUptodate(page
);
650 static int affs_write_begin_ofs(struct file
*file
, struct address_space
*mapping
,
651 loff_t pos
, unsigned len
, unsigned flags
,
652 struct page
**pagep
, void **fsdata
)
654 struct inode
*inode
= mapping
->host
;
659 pr_debug("%s(%lu, %llu, %llu)\n", __func__
, inode
->i_ino
, pos
,
661 if (pos
> AFFS_I(inode
)->mmu_private
) {
662 /* XXX: this probably leaves a too-big i_size in case of
663 * failure. Should really be updating i_size at write_end time
665 err
= affs_extent_file_ofs(inode
, pos
);
670 index
= pos
>> PAGE_SHIFT
;
671 page
= grab_cache_page_write_begin(mapping
, index
, flags
);
676 if (PageUptodate(page
))
679 /* XXX: inefficient but safe in the face of short writes */
680 err
= affs_do_readpage_ofs(page
, PAGE_SIZE
, 1);
688 static int affs_write_end_ofs(struct file
*file
, struct address_space
*mapping
,
689 loff_t pos
, unsigned len
, unsigned copied
,
690 struct page
*page
, void *fsdata
)
692 struct inode
*inode
= mapping
->host
;
693 struct super_block
*sb
= inode
->i_sb
;
694 struct buffer_head
*bh
, *prev_bh
;
696 u32 bidx
, boff
, bsize
;
701 from
= pos
& (PAGE_SIZE
- 1);
704 * XXX: not sure if this can handle short copies (len < copied), but
705 * we don't have to, because the page should always be uptodate here,
706 * due to write_begin.
709 pr_debug("%s(%lu, %llu, %llu)\n", __func__
, inode
->i_ino
, pos
,
711 bsize
= AFFS_SB(sb
)->s_data_blksize
;
712 data
= page_address(page
);
716 tmp
= (page
->index
<< PAGE_SHIFT
) + from
;
720 bh
= affs_bread_ino(inode
, bidx
, 0);
722 written
= PTR_ERR(bh
);
725 tmp
= min(bsize
- boff
, to
- from
);
726 BUG_ON(boff
+ tmp
> bsize
|| tmp
> bsize
);
727 memcpy(AFFS_DATA(bh
) + boff
, data
+ from
, tmp
);
728 be32_add_cpu(&AFFS_DATA_HEAD(bh
)->size
, tmp
);
729 affs_fix_checksum(sb
, bh
);
730 mark_buffer_dirty_inode(bh
, inode
);
735 bh
= affs_bread_ino(inode
, bidx
- 1, 0);
737 written
= PTR_ERR(bh
);
741 while (from
+ bsize
<= to
) {
743 bh
= affs_getemptyblk_ino(inode
, bidx
);
746 memcpy(AFFS_DATA(bh
), data
+ from
, bsize
);
747 if (buffer_new(bh
)) {
748 AFFS_DATA_HEAD(bh
)->ptype
= cpu_to_be32(T_DATA
);
749 AFFS_DATA_HEAD(bh
)->key
= cpu_to_be32(inode
->i_ino
);
750 AFFS_DATA_HEAD(bh
)->sequence
= cpu_to_be32(bidx
);
751 AFFS_DATA_HEAD(bh
)->size
= cpu_to_be32(bsize
);
752 AFFS_DATA_HEAD(bh
)->next
= 0;
753 bh
->b_state
&= ~(1UL << BH_New
);
755 u32 tmp_next
= be32_to_cpu(AFFS_DATA_HEAD(prev_bh
)->next
);
758 affs_warning(sb
, "commit_write_ofs",
759 "next block already set for %d (%d)",
761 AFFS_DATA_HEAD(prev_bh
)->next
= cpu_to_be32(bh
->b_blocknr
);
762 affs_adjust_checksum(prev_bh
, bh
->b_blocknr
- tmp_next
);
763 mark_buffer_dirty_inode(prev_bh
, inode
);
766 affs_brelse(prev_bh
);
767 affs_fix_checksum(sb
, bh
);
768 mark_buffer_dirty_inode(bh
, inode
);
775 bh
= affs_bread_ino(inode
, bidx
, 1);
778 tmp
= min(bsize
, to
- from
);
780 memcpy(AFFS_DATA(bh
), data
+ from
, tmp
);
781 if (buffer_new(bh
)) {
782 AFFS_DATA_HEAD(bh
)->ptype
= cpu_to_be32(T_DATA
);
783 AFFS_DATA_HEAD(bh
)->key
= cpu_to_be32(inode
->i_ino
);
784 AFFS_DATA_HEAD(bh
)->sequence
= cpu_to_be32(bidx
);
785 AFFS_DATA_HEAD(bh
)->size
= cpu_to_be32(tmp
);
786 AFFS_DATA_HEAD(bh
)->next
= 0;
787 bh
->b_state
&= ~(1UL << BH_New
);
789 u32 tmp_next
= be32_to_cpu(AFFS_DATA_HEAD(prev_bh
)->next
);
792 affs_warning(sb
, "commit_write_ofs",
793 "next block already set for %d (%d)",
795 AFFS_DATA_HEAD(prev_bh
)->next
= cpu_to_be32(bh
->b_blocknr
);
796 affs_adjust_checksum(prev_bh
, bh
->b_blocknr
- tmp_next
);
797 mark_buffer_dirty_inode(prev_bh
, inode
);
799 } else if (be32_to_cpu(AFFS_DATA_HEAD(bh
)->size
) < tmp
)
800 AFFS_DATA_HEAD(bh
)->size
= cpu_to_be32(tmp
);
801 affs_brelse(prev_bh
);
802 affs_fix_checksum(sb
, bh
);
803 mark_buffer_dirty_inode(bh
, inode
);
808 SetPageUptodate(page
);
812 tmp
= (page
->index
<< PAGE_SHIFT
) + from
;
813 if (tmp
> inode
->i_size
)
814 inode
->i_size
= AFFS_I(inode
)->mmu_private
= tmp
;
816 /* Clear Archived bit on file writes, as AmigaOS would do */
817 if (AFFS_I(inode
)->i_protect
& FIBF_ARCHIVED
) {
818 AFFS_I(inode
)->i_protect
&= ~FIBF_ARCHIVED
;
819 mark_inode_dirty(inode
);
831 written
= PTR_ERR(bh
);
835 const struct address_space_operations affs_aops_ofs
= {
836 .readpage
= affs_readpage_ofs
,
837 //.writepage = affs_writepage_ofs,
838 .write_begin
= affs_write_begin_ofs
,
839 .write_end
= affs_write_end_ofs
842 /* Free any preallocated blocks. */
845 affs_free_prealloc(struct inode
*inode
)
847 struct super_block
*sb
= inode
->i_sb
;
849 pr_debug("free_prealloc(ino=%lu)\n", inode
->i_ino
);
851 while (AFFS_I(inode
)->i_pa_cnt
) {
852 AFFS_I(inode
)->i_pa_cnt
--;
853 affs_free_block(sb
, ++AFFS_I(inode
)->i_lastalloc
);
857 /* Truncate (or enlarge) a file to the requested size. */
860 affs_truncate(struct inode
*inode
)
862 struct super_block
*sb
= inode
->i_sb
;
864 u32 last_blk
, blkcnt
, blk
;
866 struct buffer_head
*ext_bh
;
869 pr_debug("truncate(inode=%lu, oldsize=%llu, newsize=%llu)\n",
870 inode
->i_ino
, AFFS_I(inode
)->mmu_private
, inode
->i_size
);
875 last_blk
= ((u32
)inode
->i_size
- 1) / AFFS_SB(sb
)->s_data_blksize
;
876 ext
= last_blk
/ AFFS_SB(sb
)->s_hashsize
;
879 if (inode
->i_size
> AFFS_I(inode
)->mmu_private
) {
880 struct address_space
*mapping
= inode
->i_mapping
;
883 loff_t isize
= inode
->i_size
;
886 res
= mapping
->a_ops
->write_begin(NULL
, mapping
, isize
, 0, 0, &page
, &fsdata
);
888 res
= mapping
->a_ops
->write_end(NULL
, mapping
, isize
, 0, 0, page
, fsdata
);
890 inode
->i_size
= AFFS_I(inode
)->mmu_private
;
891 mark_inode_dirty(inode
);
893 } else if (inode
->i_size
== AFFS_I(inode
)->mmu_private
)
897 ext_bh
= affs_get_extblock(inode
, ext
);
898 if (IS_ERR(ext_bh
)) {
899 affs_warning(sb
, "truncate",
900 "unexpected read error for ext block %u (%ld)",
901 ext
, PTR_ERR(ext_bh
));
904 if (AFFS_I(inode
)->i_lc
) {
905 /* clear linear cache */
906 i
= (ext
+ 1) >> AFFS_I(inode
)->i_lc_shift
;
907 if (AFFS_I(inode
)->i_lc_size
> i
) {
908 AFFS_I(inode
)->i_lc_size
= i
;
909 for (; i
< AFFS_LC_SIZE
; i
++)
910 AFFS_I(inode
)->i_lc
[i
] = 0;
912 /* clear associative cache */
913 for (i
= 0; i
< AFFS_AC_SIZE
; i
++)
914 if (AFFS_I(inode
)->i_ac
[i
].ext
>= ext
)
915 AFFS_I(inode
)->i_ac
[i
].ext
= 0;
917 ext_key
= be32_to_cpu(AFFS_TAIL(sb
, ext_bh
)->extension
);
919 blkcnt
= AFFS_I(inode
)->i_blkcnt
;
923 i
= last_blk
% AFFS_SB(sb
)->s_hashsize
+ 1;
926 AFFS_HEAD(ext_bh
)->first_data
= 0;
927 AFFS_HEAD(ext_bh
)->block_count
= cpu_to_be32(i
);
928 size
= AFFS_SB(sb
)->s_hashsize
;
929 if (size
> blkcnt
- blk
+ i
)
930 size
= blkcnt
- blk
+ i
;
931 for (; i
< size
; i
++, blk
++) {
932 affs_free_block(sb
, be32_to_cpu(AFFS_BLOCK(sb
, ext_bh
, i
)));
933 AFFS_BLOCK(sb
, ext_bh
, i
) = 0;
935 AFFS_TAIL(sb
, ext_bh
)->extension
= 0;
936 affs_fix_checksum(sb
, ext_bh
);
937 mark_buffer_dirty_inode(ext_bh
, inode
);
941 AFFS_I(inode
)->i_blkcnt
= last_blk
+ 1;
942 AFFS_I(inode
)->i_extcnt
= ext
+ 1;
943 if (affs_test_opt(AFFS_SB(sb
)->s_flags
, SF_OFS
)) {
944 struct buffer_head
*bh
= affs_bread_ino(inode
, last_blk
, 0);
947 affs_warning(sb
, "truncate",
948 "unexpected read error for last block %u (%ld)",
952 tmp
= be32_to_cpu(AFFS_DATA_HEAD(bh
)->next
);
953 AFFS_DATA_HEAD(bh
)->next
= 0;
954 affs_adjust_checksum(bh
, -tmp
);
958 AFFS_I(inode
)->i_blkcnt
= 0;
959 AFFS_I(inode
)->i_extcnt
= 1;
961 AFFS_I(inode
)->mmu_private
= inode
->i_size
;
965 ext_bh
= affs_bread(sb
, ext_key
);
966 size
= AFFS_SB(sb
)->s_hashsize
;
967 if (size
> blkcnt
- blk
)
969 for (i
= 0; i
< size
; i
++, blk
++)
970 affs_free_block(sb
, be32_to_cpu(AFFS_BLOCK(sb
, ext_bh
, i
)));
971 affs_free_block(sb
, ext_key
);
972 ext_key
= be32_to_cpu(AFFS_TAIL(sb
, ext_bh
)->extension
);
975 affs_free_prealloc(inode
);
978 int affs_file_fsync(struct file
*filp
, loff_t start
, loff_t end
, int datasync
)
980 struct inode
*inode
= filp
->f_mapping
->host
;
983 err
= file_write_and_wait_range(filp
, start
, end
);
988 ret
= write_inode_now(inode
, 0);
989 err
= sync_blockdev(inode
->i_sb
->s_bdev
);
995 const struct file_operations affs_file_operations
= {
996 .llseek
= generic_file_llseek
,
997 .read_iter
= generic_file_read_iter
,
998 .write_iter
= generic_file_write_iter
,
999 .mmap
= generic_file_mmap
,
1000 .open
= affs_file_open
,
1001 .release
= affs_file_release
,
1002 .fsync
= affs_file_fsync
,
1003 .splice_read
= generic_file_splice_read
,
1006 const struct inode_operations affs_file_inode_operations
= {
1007 .setattr
= affs_notify_change
,