mksquashfs: remove "mutex_unlock" label in read_fs_bytes

Phread_cleanup_{push|pop} are implemented using a compound
statement in glibc.  This means an invisible `}` is inserted
immediately after the mutex_unlock label.

On PowerPC GCC 4.5.2 (and probably others) this causes a
label at end of compound statement compilation error.

So remove the label.

Signed-off-by: Phillip Lougher <phillip@squashfs.org.uk>
Makefile: update to give the links to LZ4 homepage and source repository

Signed-off-by: Phillip Lougher <phillip@squashfs.org.uk>
lz4_wrapper: update URL to LZ4 homepage

Signed-off-by: Phillip Lougher <phillip@squashfs.org.uk>
Makefile: update "no compressor selected" error message to include LZ4

Signed-off-by: Phillip Lougher <phillip@squashfs.org.uk>
Makefile: Make "COMP_DEFAULT isn't selected to be built" error more informative

Display the value that COMP_DEFAULT is set to.

Signed-off-by: Phillip Lougher <phillip@squashfs.org.uk>
lzo_wrapper: Remove current implementation!

There has been numerous complaints against the LZO implementation,
namely that it takes longer to compress than GZIP, but produces
worse compression.  As such for mksquashfs, it makes no sense
to use LZO compression to reduce build time when producing
experimental images.

The latest "complaint" is:
http://sourceforge.net/p/squashfs/support-requests/3

I produced an implementation of LZ4 for Squashfs, which as LZ4
is extremely fast at compression, I intended this to be used
as an extremely fast build time option for building experimental
images.  But, I have received unexpected resistance to adding
LZ4 support to Squashfs in the kernel, and so it's basically
back to the drawing board.

I have decided to re-write the LZO implementation, adding
support for different LZO compression algorithms, with the
addition of compressor command line options to select which
algorithm is used, together with all the other bits which
need to be added to support the "compression option" framework.

Note the original implementators of the LZO support can't be blamed for
not adding this support, because the "compression options" framework
didn't exist when the implementation was made!

The current LZO wrapper has an implemention for the lzo1x_999_compress
algorithm, this has to be completely rewritten to deal gracefully with the
ability to deal with multiple compression algorithms (a table of the
different compressors, and function pointers to the appropriate
function), and so the current implementation is not salvageable.

The LZ4 implementation incorporates the necessary support for the
compression options framework, and this code can be reused in the new
LZO wrapper, recouping some of the "wasted" effort in its implementation.

So, on the one-hand the current LZO implementation lacks salvageable code, and
on the other hand, the LZ4 implementation incorporates a compression
options framework which can be reused in the new LZO wrapper.

So, it makes sense to remove the current implementation, and base the
new implementation on the LZ4 wrapper.

Signed-off-by: Phillip Lougher <phillip@squashfs.rg.uk>
lzo_wrapper: new implementation

Add a new LZO implementation which supports multiple LZO
compression algorithms, with the addition of compressor
command line options to select which algorithm is used,
together with all the other bits which need to be added to
support the "compression option" framework.

Two new compressor options have been added:

1. -Xlzo_algo <algorithm>

Select LZO compression algorithm <algorithm>

Five LZO compression algorithms are now supported, these
algorithms are the ones supported by the kernel.

	lzo1x_1
	lzo1x_1_11
	lzo1x_1_12
	lzo1x_1_15
	lzo1x_999

 If no compression algorithm is specified, then default to
"lzo1x_999" which is the algorithm used by the previous LZO
implementation.

lzo1x_1 is faster than lzo1x_999, but it gives worse compression,
the lzo1x_1_xx algorithms are variants of lzo1x_1 with differing
memory requirements (at compress time), and varying compression levels.

2. -Xcompression_level <compression level>

Select compression level for the lzo1x_999 algorithm, this can
be between 1 and 9 (1 <= n <= 9).

If no compression level is specified, then default to 8, which
is the compression level used by the previous LZO implementation.

Note, -Xcompression_level is only applicable to the lzo1x_999
algorithm, as the other algorithms do not support compression
levels (the lzo1x_1_xx algorithms are in effect different
compression levels on the basic lzo1x_1 algorithm).

As mentioned above, if no -X compression options are used,
the new code defaults to the compression used by the original
LZO code.

Additionally, the new code now calls lzo1x_optimize() which
should be called to optimise the LZO compressed data after
compression.

Generally speaking, without -X compression options, the behaviour
should be the same as the original implementation.  If you wish
better compression, then you can bump the compression level up to 9.
If you wish quicker compression, then use one of the lzo1x_1
algorithms, or use a compression level less than 8 with the
lzo1x_999 algorithm.

Signed-off-by: Phillip Lougher <phillip@squashfs.org.uk>
unsquashfs: fix cache used count statistic

Fix cache used count statistic (only used in statistics dumping when
^\ is hit twice).

Occasionally when dumping the statistics I noticed the cache used
count was negative.  This proved to be because I forgot to
increment the cache used count in cache lookup when the block
was found unused on the free list.

Signed-off-by: Phillip Lougher <phillip@squashfs.org.uk>