Don't clear B_Valid when index block is empty

This overloading just caused problem. Invent a new flag instead.

incorporate: handle empty block correctly.

When a block becomes empty, we need to remove it from the
indexing tree, causing the next block to take over the address
space if possible, else maybe the previous block.

FORMAT CHANGE - include start address explicitly in indirect blocks.

By storing the address of the first block in an indirect block,
that block can be relocated in the index tree with no adverse effects.
This makes it easier to handle blocks that have become empty.

So an indirect block now contains:
   u16 0x01   'indirect' indicator
   u32 addr   virtual address of first indexed block
   u48 paddr  physical address of first indexblock block
   u48 paddr2 next block ... etc

README notes for changes to index management.

Handle index blocks becoming empty better.

MORE TEXT HERE

Don't lose path to index blocks that haven't been incorporated

Before a new index block is incorporated, we can find it only by
finding a sibling and walking the sibling list.
If that primary sibling gets released, the new block becomes
unfindable.
So hold a reference to such primaries until incorporation,
and ensure that there is always a primary in the same parent
by incorporating more promptly after a split.

Group B_ flags by which sort of block they apply to.

This will allow us to overlap the 'Data' and 'Index' groups
later if that proves necessary.

dir: replace wrong constant with correct symbolic version.

Drop excess 'clean2' reference.

lafs_wait_block fixes

If the block is already Valid, there is no need to wait for
it to be unlocked.
This avoids extra async blocks lying around.

Avoid flushing inodes too soon.

I'm not 100% sure of this, but it seems write.  Inode data blocks
don't have PinPending, rather the inode block is Pinned.

Multiple improvements to inode dirtying

- in a few places we didn't called dirty_inode when we should have
  done.
- after inode_{inc,dec}_link_count we don't need to dirty the inode
  because it has already been done.
- handle I_Dirty properly rather than unpinning the block
- allocate NCredits for inodes so that I_Dirty can succeed.

README update

Fix clearing of PinPending

PinPending must be cleared after marking dirty, not before.

Add support for unattended testing.

Make sure the qemu exits when a test completes, and always
capture the kernel output.

unmount: push orphan handling along.

Just waiting for the thread to do it doesn't seem to be
enough.

lafs_find_orphan: always release the lock.

Forgot to unlock on the "not found" path.

Fixed to run_orphans.

We need to hold a reference to the db, as orphan_release
can drop it.
And an unclaimed inode block with no mx is always free to
be orphan_released.

Move unmap_dblock closer to map.

As this is an atomic region, keep it as short as possible.

Fix pruning of orphan file.

The test for "now beyond EOF" was all wrong.

Don't add Credits to Dirty blocks.

If the Credit has moved to Dirty, we don't need to add
another one during prealloc.
Doing so means that prealloc can fail on a block which is
already adequately allocated.

Add some more "temp_credits" assignment to improve credit-watch

Clear physaddr when growing an index tree.

The InoIdx block probably shouldn't have a phys address,
but we must be certainly it doesn't after a grow caused it to
not be an InoIdx block any more, else accounting will get
confused when we allocate it to another block.

Release the orphan status when finished deleting an inode.

and ensure that if the orphan_release fails, a subsequent attempt
has a chance of doing the right thing.

Be sure to alway unlock new inodes.

All error paths must unlock the new inode.
And make sure nlink is 0 so that it will not be cached.

correctly handle attempt to load inode that is being deleted.

Make sure to return ENOENT in this case.

Initialise empty index block during allocation.

I'm still not sure about this handling of empty index blocks,
but leaving it invalid certainly isn't correct.  I have to
initialise it and make it valid.

Avoid inadvertently flush blocks that are in middle of a transaction.

If a directory block has PinPending, then a transaction is in progress
and flushing the block (e.g. pdflush) would be a bad idea, as we could
lose the credit before the final update.

Complete proper pinning dir_handle_orphans.

If the orphan handler is going to dirty a block, it must
first pin it (and check for errors), and must afterwards remove
the PinPending.
One of the places which caused change did this.  The other didn't.

Fix orphan flushing in rmdir

lafs_dir_handle_orphan no longer requires drop_orphan,
and can drop the reference to the orphan block.
So we need to hold our own so we can test if it is still
and orphan after handling (in which case we must wait).

Fix beyond-eof check when cleaning

special files don't maintain i_size, so we must not compare against
that when cleaning them.

Remove incorrect BUG_ON in checkpoint.

It seems that this list can be empty fairly often without
any problems caused - I was afraid of infinite loops as it appears
there is nothing to do.
Maybe it is just the waiting that is needed.

Remove incorrect assumption from erase_dblock

When erasing a pinned dblock, it might not be on the leaf list.
The fact that we have it locked can mean that it wasn't put there
yet.
So check leaf list membership explicitly.

Note that it cannot be in write-back, as we should have
waited for any writeback to finish, and won't have started any.

Add alloc_type to lafs_pin_dblock

This is particularly needed for make_orphan which needs
to allocate new blocks sometimes just to delete files.

Improve inode orphan handling.

And inode can be an orphan for an extended period of time and
should not be on the pending_orphans list all that time.
So we need to remove it if nothing needs doing for now, and
add it back on when it requires attention.

Improve lafs_run_orphans list handling.

Requiring the 'handle' routines to leave the orphan on the list and
then removing it if B_Orphan isn't set is not appropriate as we will
want to remove block while they still have B_Orphan set.
So do the list management differently to still ensure a single pass
through without needing the current block to hold our place.

Remove special handling for i_nlink when reading inodes.

This was never "right" and is confusing orphan handling.
We should not lose those blocks anymore but if we do we need a better
fix.

Flush orphans before failing rmdir due to not being empty.

Before we can be sure if a directory is empty, we need to
flush and orphans that might be holding space in the directory
in use.  Only then can a check on the file size be meaningful.

Run orphans from the cleaner thread, not immediately.

This involves:

 making dir_handle_orphans and inode_handle_orphans non-blocking.
 removing lots of explicit calls to handle_orphans.

make lafs_leaf_find properly async

The new iolock_block calls weren't honouring 'async'.
So fix that.

lafs_make_orphan_nb - non-blocking version.

We will need to in the 'dir' orphan handler which itself
needs to be non-blocking.

Further tidy up for make_orphan

Move the calls to orphan_abort and orphan_commit into make_orphan
to follow the pattern used elsewhere.
This requires moving the i_mutex lock out into make_orphan,
but otherwise seems to be a good improvement.

Split orphan_commit out from orphan_pin

It seems to work better as a separate function.

Use orphan_abort in lafs_orphan_release

lafs_orphan_release currently open-codes all of orphan_abort,
except the i_mutex locking is a bit different.  So change locking
rules for orphan_abort, then use that directly in lafs_orphan_release.

Get rid of orphan_info structure.

It no longer contains anything really useful...

Tidy up release_orphan

In particular it need to pin the dblocks, be async and get all the
references right.

Orphan:  simplify orphan creation.

We don't need to synchronise orphan creation with other parts of
direct ops etc.  We just make the block into an orphan if we
think that might be needed.  If this gets committed in a previous
checkpoint, there is no problem.

This simplifies things a lot and lets us get rid of some races.

Discard lafs_inode_prepare

This function has minimal content, and there is no matching
lafs_inode_pin, lafs_inode_commit etc.  So just remove it and
open-code instead.

Remove some outdated comments.

and some code that is pointless (dmap_dblock is identical to
map_dblock).

dir: fix use-after-put ordering error.

umount: wait for last cluster to be written.

checkpoint_unlock_wait only wait for the last cluster
to start.  We need to wait for all writes to be complete so
that no inodes remained pinned.

Account for some more temporary credits.

This might save us from a few check_credits warnings.

Documentation updates and some BUG_ON and tracing.

Slight improvement in tracing in orphan_pin

Rename  share_uninic to share_uninc

As the former is a typo.

Avoid confusion with ref name "orphans"

Two different places use the reference name "orphans", so change one
to avoid confusion.

Demote check_credits from BUG to WARNING.

Races and other things can cause inbalances.

Add tracing for seg_move

This turns out to be very useful for tracking segment usage.

simplify seg_apply

Just call seg_inc rather than open coding most of that
functionality.

lafs_print_tree: export and use in super.

This is for tracking an unmount bug, but print_tree seems
generally useful, so export it.

lafs_incorporate - don't clear a block with children.

If an index block has children, then erasing it is pointless
and confusing.  So don't.

Improve tracing for lafs_incorporate.

Show the uninc list as well, and do it before trying to
incorporate.

silly typo in do_incorporate_leaf.

The 'type' header is 2 bytes.

Accelerate walk_indirect.

If an indirect block is being asked to incorporate an address that
is very must after the address of the block, it has to count all
the way up to that number, which is a waste of time.
So if there is an opportunity to jump forward, take it.

incorporate: always call sort_blocks on the uninc list.

Were were not calling it when trying the 'simple' incorporation.

Fix add_extent

We weren't updating the lastaddr/lastphys at all!!

correct some comments in lafs.h

I was spelling the idtag wrongly.

IO: support loading of an index block from addr 0.

This can happen when adding blocks to a prevously truncated
file, or even when continuing with a slow truncate.

phys==0 just means the index block is empty, so honour that.

truncate: make sure index block is pinned and dirty when we prune it.

truncate: make sure index changes get incorporated.

When we have used lafs_incorporate to clear and unpin
an index block we need to incorporate the parent so that
the unpinned block gets fully released.

Fix prune_some.

We need to put phys==0 into the uninc_table, not the current phys.
This might end up not being very efficient... might need to rethink
it.

Move a dprintk in delete_inode

We very often enter delete_inode (when cleaning) on an inode that
doesn't really exist.  So only print a message if this is a real
inode needing to be deleted.

Remove useless test in lafs_add_block_address

If it is an Index block, we never get to this test, so there is
no point testing it again.

leaf_find: make sure returned block is IOLocked.

If we had to return a sibling of the found block, we weren't
getting an IOLock on it, which is bad.

Don't accept failure from lafs_add_block_address

If this returns 0, it didn't add the address, so we need to
call it repeatedly.

incorporate_index - minor cleanups.

Improve robustness and remove a LAFS_BUG that only ever for
a NULL block.

Initialise inode->update_cluster

Introduce lafs_index_empty.

We currently use lafs_leaf_next to test if an index block is empty,
but that doesn't work on internal nodes of course.
So create lafs_index_empty for that purpose.

Updates summaries when flushing a block into the inode.

If the block previously had a real address, we need to
release that address for reuse.

cleaner: recognise end of segment properly.

If we find an incorrect cluster header, then abort cleaning
for that segment.  This should not normally happen as we
shouldn't clean a segment until it has been completely written.
But we need to protect against it anyway.

segments: don't lose delayed updates.

We need to keep ss if it has negative updates as well as
positive.

Split B_Writeback out from B_IOLock

It is best to have Writeback separate from Lock, just like pages
do.  Then readonly accesses don't have to wait for writeback to
finish.

Fix iolock semantics.

There are some races with IOlock and page unlock due to bad
assumption.
So make things more explicit with a flag to say if we own
the lock, or the 'Writeback' flag.

This allows us to remove the extra flag to iounlock_block
which is really nice because it always confused me.

A significant but subtle part of the locking involved the
fact that one a page has been read, it will not be read
again, so when readpage calls lafs_iocheck_block it is not
possible that it will unlock incorrectly.
It could conceivably unwriteback incorrectly, but next patch
should fix that.

Correctly handle Dirty index blocks during truncate

IOLock all accesses to index blocks.

We really don't need them to change while being read.
This creates a possibly unpleasant conflict with writeout,
so maybe we need a IOWriteback flag for writeout...

Use i_data rather than i_mapping

For this filesystem, i_mapping always points to i_data,
so dereferencing the pointer is a total waste of a memory
access.

Revise dirty/valid rules for Index blocks.

An Index block is 'Valid' if it contains any index.
So an InoIdx block for a depth=0 inode is never Valid
(as there is data rather than indexes there).

When it comes time to cluster_allocate an Index block,
if it is not Valid, we simple allocated_block it to 0.

An index block is Dirty if there are any children that need incorporation
as well was when incorporate has happened but has not yet been
written.
So an Index block can be Dirty but not Valid (unlike data blocks).

Make sure inode dblock stayed pinned in checkpoint.

In order for a dblock to stay pinned, we need PinPending to be set.

Make sure orphans are cleaned up when inode creation fails.

Release ino when file creation fails.

Due to a hack elsewhere, we need to explicitly set
nlink to 0 when creation fail.  The hack needs to be
fixed but for now, just set nlink to 0.

LAFS_BUG add new debug macro that prints block information.

Cleaner: make sure we finish the job.

If there might be blocks in the ->cleaning list even after
we have read all of the cluster headers.  So make sure we continue
cleaning until all of those are dealt with.

make sure blocks are always refiled after Pinned is set.

This is important to ensure they go on the leaf lru.
There was one place we weren't doing the right thing.

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.