kernel/git/stable/linux.git/fs/ufs/truncate.c, branch master

ufs: move truncate code into inode.c

2015-07-06T21:39:30+00:00

It is closely tied to block pointers handling there, can benefit from existing helpers, etc. - no point keeping them apart. Trimmed the trailing whitespaces in inode.c at the same time. Signed-off-by: Al Viro

ufs: no retries are needed on truncate

2015-07-06T21:39:29+00:00

Signed-off-by: Al Viro

ufs: ufs_trunc_...() has exclusion with everything that might cause allocations

2015-07-06T21:39:28+00:00

Currently - on lock_ufs(), eventually - on per-inode mutex. lock_ufs() used to be mere BKL, which is much weaker, so it needed those rechecks. BKL doesn't provide any exclusion once we lose CPU; its blind replacement, OTOH, _does_. Making that per-filesystem was an atrocity, but at least we can simplify life here. And yes, we certainly need to make that sucker per-inode - these days inode.c and truncate.c uses are needed only to protect the block pointers. Signed-off-by: Al Viro

ufs: ufs_trunc_direct() always returns 0

2015-07-06T21:39:27+00:00

make it return void Signed-off-by: Al Viro

ufs: don't use lock_ufs() for block pointers tree protection

2015-07-06T21:39:25+00:00

* stores to block pointers are under per-inode seqlock (meta_lock) and mutex (truncate_mutex) * fetches of block pointers are either under truncate_mutex, or wrapped into seqretry loop on meta_lock * all changes of ->i_size are under truncate_mutex and i_mutex * all changes of ->i_lastfrag are under truncate_mutex It's similar to what ext2 is doing; the main difference is that unlike ext2 we can't rely upon the atomicity of stores into block pointers - on UFS2 they are 64bit. So we can't cut the corner when switching a pointer from NULL to non-NULL as we could in ext2_splice_branch() and need to use meta_lock on all modifications. We use seqlock where ext2 uses rwlock; ext2 could probably also benefit from such change... Another non-trivial difference is that with UFS we *cannot* have reader grab truncate_mutex in case of race - it has to keep retrying. That might be possible to change, but not until we lift tail unpacking several levels up in call chain. After that commit we do *NOT* hold fs-wide serialization on accesses to block pointers anymore. Moreover, lock_ufs() can become a normal mutex now - it's only used on statfs, remount and sync_fs and none of those uses are recursive. As the matter of fact, *now* it can be collapsed with ->s_lock, and be eventually replaced with saner per-cylinder-group spinlocks, but that's a separate story. Signed-off-by: Al Viro

ufs: bforget() indirect blocks before freeing them

2015-07-06T21:39:24+00:00

right now it doesn't matter (lock_ufs() serializes everything), but when we switch to per-inode locking, it will be needed. Signed-off-by: Al Viro

ufs: move lock_ufs() down into __ufs_truncate_blocks()

2015-07-06T21:39:23+00:00

Signed-off-by: Al Viro

ufs: move truncate_setsize() down into ufs_truncate()

2015-07-06T21:39:22+00:00

just prior to __ufs_truncate_blocks(), with matching change of calling conventions Signed-off-by: Al Viro

ufs: switch ufs_evict_inode() to trimmed-down variant of ufs_truncate()

2015-07-06T21:39:20+00:00

Signed-off-by: Al Viro

ufs: kill more lock_ufs() calls

2015-07-06T21:39:19+00:00

a) move it inside ufs_truncate() b) ufs_free_inode() doesn't need it - it's serialized on ->s_lock c) ufs_write_inode() doesn't need it either (and can be called without it anyway). Signed-off-by: Al Viro