Improve credit handling when flushing a data block into the inode.

Both the credit and icredit need to be moved from the data block
to the inode data block (if needed)

make checkpointing more robust

As long as the root inode hasn't changed phase, we keep
looking for things to do.
If things got confused, this could livelock, which would be bad...

Simplify writeout rules for inode data block.

Previously we did not write an inode data block until the
InoIdx was ready.
This is not good if we need to sync an inode well before checkpoint
runs.
So just write an inde data block when we find it, but ensure not to
send an inode data block during checkpoint until the InoIdx block is
ready.

Note: it is now clear why an inode has two sets of credits, one on the
data block and one on the index block.  The first set may be needed to
sync the inode metadata.  The second may be need to update the
indexing information - they are copied across to the data block for
this purpose.

Simplify iolocking in get_flushable

The difference between data and index block is not really supportable,
and we cannot just avoid waiting for some blocks.

But we cannot always for a full iowait as block that have been
allocated to a cluster do not complete until the cluster is written
and we don't want to wait for a cluster to be written, especially as
we there thread that is supposed to do that.

So create an intermediate iowait which wait for iolock to be dropped
or the block to be placed on a list.  Once it is on a list we can be
sure not to lose it.

So we wait while incorporation or truncation happens, but not while
writeout happens.

Avoid races when processing blocks for checkpoint.

When doing a checkpoint we need to be sure that every
flushable block is accounted for.  So we need to be able
to wait for anything outstanding.

Currently a block can be removed from the leaflist by writepage
before it is placed on the cluster list.  During this window
the checkpoint thread cannot see it and so might progress without
waiting for and so will think it has completed prematurely.

So delay the removal from the leaflist until after we have the
writecluster lock.  This assures that every leaf block will be
either on the leaf list or on the cluster list when checkpoint is
looking for it.

When checkpoint calls cluster_done, this will release any blocks
from the cluster and, if needed, put them back on the leaf list where
they can be found again.

Remove dirtying of InoIdx in place of inode data block.

I don't remember why this was here, but until very recently
the code was wrong so it didn't do the "right" thing anyway.
And it doesn't seem to make sense.

When we dirty a dblock, we really want it to be dirty.
We might then write it and roll-forward will be able to pick
it all up except the index information which is always
calculated from addresses that are actually found.

Don't set Valid when setting Dirty.

While a block must be Valid to be Dirty, it is best to
only set Valid when actually putting data in the block,
and then check that it is Valid when marking it Dirty.
That can catch more bugs.

inode: Fix problems at inode creation.

- we need to pin the new inode dblock to ensure it gets written
- we don't need to dirty it in inode_map_new_commit as it is already
  dirtied in lafs_inode_init.

lafs_allocated_block: don't repeat so much for a new_parent

When we find that incorporation has pushed us to a new parent,
we don't need to repeat so much.... maybe not even very much at all

lafs_refile: only use ->inode pointer when we know it is valid.

->inode may be invalid if block is not pinned, or at least
has a parent.  So don't try to find 'fs' from it until we know
we will need it.

Don't insist on having UnincCredits for all Index blocks.

When an Index block has room for new addresses, it does not need to
have an UnincCredit because we know it will not split before more
credits are available.

temp_credits accounting.

Allow - in a totally smp-unsafe way - for credits which
aren't stored anywhere to be accounted when checking totals.

Be sure to remove all credits when releasing a block from a page.

As it has just become unlinked.

Make sure inodes don't get forgotten during cleaning.

During cleaning and other times when inodes might have dirty
index blocks we don't want the inode to be pushed out due to
apparently not being in use.

However there is a difficulty in holding a reference on the inode as
that cause the truncate following a final unlink to be delayed.

So to compromise, whenever the InoIdx block for an inode is pinned,
hold a reference to the inode as long as the link count is non-zero.

Once the link count becomes zero, we drop the extra ref and if this
leads to the inode being deleted, the current delaying of this
deletion (while the dblock is references) will keep the inode around
just long enough.

cleaner: hold ref on inode while preparing to clean blocks.

b->inode does not own a reference to the inode so we need to have some
other way to make sure it never goes invalid.
Normal filesystem references are safe as the VFS will truncate pages
before freeing the inode.   But cleaner accesses don't benefit from
that.

Once a block is Pinned (e.g. when B_Realloc) it owns a reference up to
the InoIdx and so the dblock is also referenced.   This ensures that
the inode won't go away even on destroy_inode.
However we hold a block for a short period before it is Pinned, so we
must hold a reference on the inode for that period as well.

cleaner: avoid blocks that are beyond the end of file.

This is a fairly half-hearted attempt which is more to
leave a reminder to get it right later.

Make sure cleaner doesn't start up after the FinalCheckpoint

We need to leave the cleaner thread running for checkpoint processing,
but don't want an really cleaning happening after the FinalCheckpoint.
So check and don't start anything new.

Don't use B_Credit to set B_Realloc

We need to keep B_Credit to possibly set B_Dirty (if a B_Realloc
block gets dirtied while being written to the 'clean' cluster we
still need to write it to a normal cluster).
So Find B_Realloc from elsewhere, use lafs_space_alloc if needed,
or as a last result setting B_Dirty.

Don't clear B_Realloc when setting B_Dirty

If the block has not yet been allocated to a cluster, then
B_Realloc will be cleared just before cluster allocation, and the
allocate won't happen.
If the block has already been allocated to a cluster for cleaning,
then we need the credit implied by B_Realloc so we shouldn't clear it.
The block will later be written to a normal cluster on the basis of
B_Dirty, so try to forget this cleaning, and in particular don't call
lafs_allocated_block as that will be a waste.....
Instead call lafs_pin_block to ensure that the block gets written out
in this phase, which is as good as cleaning.

README update and minor cosmetic changes.

Make sure segusage blocks are uptodate in seg_apply.

During roll-forward they can be not-read-yet.

Relax requirement for UnincCredit in lafs_allocated_block

A block that is being deleted and so has a new phys address of
0 does not need an UnincCredit.

clean: don't allow C or F to go negative.

As these are unsigned values, negatives are bad and confusing.

Fix use-wrong-variable bug in cluster_insert

I deleted the wrong thing from a list.

release iolock in lafs_phase_flip

The tail end of lafs_phase_flip needs the iolock to have been
dropped, so always drop it somewhere in lafs_phase_flip.

Add tracing to help find iolock deadlocks

i.e. record the place where the iolock was last claimed
on each block.

cluster_flush credit handling.

Combine calls to space_use and space_return as they do the same thing.
And move them up to immediately after the credits have been calculated
to avoid possibility of the credit-counter finding an incorrect count
that is only transient.

Clear uninc_credit when removing a data block from the tree.

We must drop this credit to keep the counts correct..

Improve prepare_checkpoint locking.

prepare_checkpoint currently takes wc[0].lock.
This is presumably to avoid races with ->checkpointing updates.
However it causes a deadlock if any code that holds the checkpoint
lock needs to flush a cluster or make other updates to a cluster,
which can happen.
So use fs->lock to protect ->checkpointing instead.

flush_data_to_inode fixes.

When flushing data to the inode, mark the dblock dirty
rather than the iblock.  We aren't allow to mark the iblock
dirty unless it is pinned, which it might not be....
It must be preallocated as the data is dirty, but the iblock doesn't
get pinned until the data is actually written.
As the inode data block is not pinned, it might not be written in
a particular phase, but that isn't a problem as long as it gets
written some time.

Add a BUG_ON if we ever try to dirty a non-Pinned index block again.
They are a problem because non-pinned InoIdx can lose their dblock
and then they fall out of the tree.

Also fix the space_return - we have already returned for the Dirty
flag.

fix max height for segment skiplist.

The max is defined as 8, but we use 9 !!!
Fix this and make sure it doesn't happen again.

count credits for debugging

Add code to count the number of credits in the tree
and make sure it matches the allocated_blocks number.
Call this at some useful places.

lafs_put_super - don't putref dblock

There is no need for this putref here - normal inode handling
gets it right.

lafs_shrinker fixes.

1/ only clear inode->iblock if the block we are about to
   free is the InoIdx block (i.e. is inode->iblock).
2/ Assume that unreffed iblocks are not pinned, they should
   never be.

lafs_release_index: free all index blocks when freeing an inode.

That than leaving the index blocks on the free list in an
to-be-freed state, actively free them when the inode is freed.

Fix freeing of inodes and ->dblock

The inode and the dblock each have a reference to the other.  Neither
are counted because:
   We don't want the inode to refcnt the dblock as that wastes space.
   We don't want the dblock to refcnt the inode as that stops it from
     being freed.

So when either is freed, it must remove the reference from the other.
To ease locking,  when the inode is freed it converts the reference,
if present, to a counted reference (using the same rule as
lafs_inode_dblock), then flags the inode for destruction and drops
the reference.

When the last reference to a dblock is dropped, it removes
both references and the calls destroy_inode again.

Notes that the dblock only exists while the inode exists - as soon
as the inode is destroyed, any dblock that might be around will
quickly get destroyed too, and the inode destruction is delayed until
this point.

Set I_Deleting on root inode during unmount

I don't remember exactly why I need this unfortunately....

getref_locked fixes.

When lafs_dirty_inode chooses to dirty the dblock, because there
is no iblock, we need to getref_locked that dblock because there
will be no implied reference.

And when doing that, don't dereference ->my_inode unless we are sure
it is valid - i.e. that this is a block in an inode file.

Use write_super to start checkpoint and sync_fs to wait for it.

There are always called in the right order and at the right place,
and this gives us a bit more control.

I don't remember why the cluster_flush was there, so I don't know
where to put it..

roll: use add_block_address rather than allocated block.

This avoids messing around with setting 'dirty' flags.

allocated_block: split out part of code for use in phase_flip.

When we flip phase, delayed incorporation needs to include addresses
in to the block.  But some of the lafs_allocated_block work has
already been done.  So split out the rest into a smaller function
for phase_flip to call.

put_super: release orphan and segsum files.

These files need to be released at unmount...

umount fixups - flush in the right place.

We really need to sync the filesystem before the
final checkpoint and other cleanups in lafs_release.
So move them to lafs_put_super so they get done after
the sync in generic_shutdown_super, but before the superblock
is completely destroyed.

refile: when clearing Pinned, remove from lru too

As only pinned blocks should be on leafs lru.

refile: blocks with B_IOLock are not on lru

so don't assume they are when checking refcounts.

cluster_allocate: remove from leafs list if needed.

When lafs_writepage called cluster_allocate, the block could
be on a leafs list.  In that case we need to cleanly remove it
from the list as lru is about to be used for a different purpose,
and it doesn't need to be on the list for a while.

dir orphans: always put orphans on the dirorphan list.

Once we call orphan_pin, we must put the block on the
dirorphans lists so that it can be checked and possibly
unorphaned.  Otherwise the B_Orphan flag which was set will
never be cleared.

cluster_allocate: handle credits better.

When moving credits from InoIdx to Inode data, allow for
the InoIdx not to have any if the Inode data already has enough.

Checkpoint: allocate InoIdx block if data block is dirty.

Sometimes the Inode data block can be dirty without the InoIdx
block being dirty.  We still need to write it out, so we move the
'pinning' across from the index to data blocks be calling
allocate here.

Set page dirty when a data block becomes dirty.

This is important to ensure that memory pressure or fsync writes
out directories and other internally-managed files.

lafs_get_block without page lock.

We need to be able to lafs_get_block an existing block even if
the page is locked.  So handle that case using ->private_lock.

Also release the page at the end..

MKREF(dblock) should have been MKREF(iblock)

The iblock holds a reference to the dblock, hence the
confusion...

Fix sort/splitting in add_cleanable.

When the cleanable list reaches a certain length, we sort it and
discard the half which are least ready to be cleaned.
That code was broken and is now fixed.

Empty the segsum cache at unmount

These all hold references to blocks which need to be released.

Clean out segment table at unmount time.

Each entry in the table holds a reference to some blocks,
so we need to clean them out to release all those references.

Clear I_Deleting when delayed-truncate finishes.

Otherwise if the delayed truncate completes before we try
to destroy, destruction never happens.

Perform a "Final Checkpoint" during unmount.

This checkpoint must leave everything clean, so we don't
flush out any segusage changes that will be picked up by
roll-forward anyway.

Wait correctly for checkpoint to finish.

We really need to wait for it to have started and finished,
else we might stop waiting before the real finish.

Put all intable references.

When segments are referenced by the free/clean segment table,
it implies a reference to the segusage blocks.
So when we remove things from the table, drop the reference.

Use strblk is more places.

Where we printed ino/fileaddr, just use strblk.

Print orphan_slot number of strblk

Use inode_{inc,dec}_link_count

as it is the approved way to change i_nlink.

Stop the cleaner at unmount

Various fixes...

more segusage refcount stuff.

(sorry, too long ago to remember)

Seg: add youthblk to segsum

and make sure it is cleaned up when appropriate.

Youth: dirty block when setting youth value, and other tidy ups.

When setting the youth for a newly allocated segment, make sure
to mark youth block 'dirty'.

Also reduce range of 'map_dblock' to where it is really needed.

README update

test: test for umount at the end of everything.

roll-forward:  handle segusage blocks better.

During roll-forward we mustn't load segusage blocks until we have
processed the checkpoint.  During that time segusage updates must be
delayed.
So make sure phase and qphase have suitable setting, and delay the
load where appropriate.
This allows us to remove 'in_checkpoint' as it can be determined from
qphase.

walk_leaf_index - use kmap, not kmap_atomic

When truncating a file, we need to update the segusage counts
for all relevant segments.  This can require reading segusage blocks
while walking a leaf index.  So we cannot use kmap_atomic in
lafs_walk_leaf_index.  So use kmap instead.

iget - use symbolic error code, not number.

Fix dirty_block for inode data blocks.

When an inode block is to be marked dirty, make the
InoIdx block dirty instead.  When it gets written, the dirtiness
then gets moved to the data block and it gets written.

Also, don't unpin the InoIdx block while the data blocks
is dirty.  This probably shouldn't happen, but adding the test
is safest.

lafs_seg_deref - actually use it.

We never clear B_SegRef and drop the associated reference.
Also never drop the reference on the current writeout segment.
Fix that.

lafs_seg_ref - take all required references.

Every dirty or pinned block needs a reference to the segment usage
count for the segment holding that block.
This must be a writable reference so that when the block is written
the segusage can be decremented.

A writable reference requires a pinned block so the segusage block
must hold segref as well.  This can recurse a couple of levels.

So introduce lafs_seg_ref_block which walks through the recursion
and gets some seg references at the bottom of the recursion.
Then have lafs_reserve_block call seg_ref_block repeatedly until
everything required has a SegRef.

lafs_invalidate_page: don't erase blocks in special files.

Special internal files - particularly the inode file - does not
keep i_size up-to-date (it really isn't needed) so erasing
blocks beyond i_size is inappropriate.
All internal files do their own block erasure as needed without
depending in the setting of i_size, so simply ignore the
size on these files.

Clear CheckpointNeeded

This bit was previously set but never cleared.

Update segrefs when changing phys address.

When changing the ->physaddr of a block which holds a SegRef,
we must move the reference to the new segment.

So track whether a segref needs to be moved, and make the appropriate
refcount changes.

readpage: add missing putdref

segments.c: refcount fixes

orphan.c:  lots of refcount fixes.

Choose better ref names, and make sure were put them
appropriately.

inode.c refcount fixes.

I had forgotten serveral 'iput's and similar.

Cosmetic cleanups.

Mostly checkpatch.pl warnings, but also remove some old, uninteresting
printks and things like that.

Make sure all global functions have distinctive names.

All non-static functions should have names starting lafs_ or
_lafs_.  A few had slipped in that didn't so resolve them either
making them static or changing their name.

Cleanup timestamp handling.

 - register correct s_time_gran
 - remove useless lafs_timestamp
 - fix encode_time

Truncate from arbitrary offset in file.

When truncating a file, allow that we might not be truncating
from the beginning.

Another README update

Annotate getref depending on whether '0' is safe.

Any place where we might be getting the first reference on
a block, use get?ref_locked, and put appropriate checks in
getref and getref_locked to make sure they are used that way.

This required rearranging lafs_refile so that we didn't drop
the last ref if we were about to add a ref on _leafs.

Use 'enum' for B_* flags

Rather than listing the numbers.

Remove list_del from ihash_lookup

We don't want these list_dels.
 One removes from the global free list, which happens else where based
    on B_OnFree
 The other removes from the per-inode free list that happens else
 where base on ->parent.

make strblk safer

Check if ->inode is non-NULL before de-referencing it.

Minor fixes to lafs_leaf_find

It cannot be used during truncation, so make a note of that...

Don't erase inode dblock during incorporation.

When incorporation notices that the indexes are all gone
and the inode is ready to die, it should *not* erase the
dblock.  That gets things out of order.  The dblock gets
erased by the orphan handler which will still be overseeing
the operation.

Fix incorporate_index

While uninc->physaddr is unlikely to be zero, it is
possible and we must allow for it.

Further Truncate fixes.

In particular, don't use lafs_find_next to find the next place to
truncate.  This can instantiate data blocks past EOF which is confusing.
Just use lafs_leaf_find and only ever instantiate index blocks.

Remove need to hold i_mutex when flushing data into inode

Holding i_mutex while flush data into the inode is a problem because
it can triggered deadlocks if something hold i_mutex and waits for
checkpoint to finish - checkpoint might do the flush.

So check the i_size after clearing B_Dirty.  If it changes after this,
we will just do another write-out and fix things up.

clean up lafs_erase_dblock

- remove some dead code
- make it work for blocks that don't have a parent
- simplify the call from lafs_invalidate_page
- general clean up

Various incorporation and truncation fixes.

Various fixes for truncation (inode orphan handling).

- Don't update ->trunc_next until we do the truncation
   (it is possible to retry if reserve_block fails)
- Search down the index tree properly (ib2, not ib!)
- set 'adopt' for lafs_leaf_find - very important.
- general code tidy up.

Fixes for lafs_leaf_find

In particular, make sure 'next' gets the right value when we
find blocks on the siblings list.
Also add a useful comment.